diff --git a/.cargo/config b/.cargo/config
deleted file mode 100644
index a4dc4b423fe..00000000000
--- a/.cargo/config
+++ /dev/null
@@ -1,13 +0,0 @@
-[target.x86_64-unknown-redox]
-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::if_not_else",
-]
-
diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 00000000000..c6aa207614f
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,5 @@
+[target.x86_64-unknown-redox]
+linker = "x86_64-unknown-redox-gcc"
+
+[env]
+PROJECT_NAME_FOR_VERSION_STRING = "uutils coreutils"
diff --git a/.clippy.toml b/.clippy.toml
index bee70857bd1..b6f9a360f69 100644
--- a/.clippy.toml
+++ b/.clippy.toml
@@ -1,2 +1,5 @@
-msrv = "1.64.0"
-cognitive-complexity-threshold = 10
+msrv = "1.85.0"
+avoid-breaking-exported-api = false
+check-private-items = true
+cognitive-complexity-threshold = 24
+missing-docs-in-crate-items = true
diff --git a/.config/nextest.toml b/.config/nextest.toml
index 3ba8bb393a4..473c461402a 100644
--- a/.config/nextest.toml
+++ b/.config/nextest.toml
@@ -4,3 +4,10 @@ status-level = "all"
 final-status-level = "skip"
 failure-output = "immediate-final"
 fail-fast = false
+
+[profile.coverage]
+retries = 0
+status-level = "all"
+final-status-level = "skip"
+failure-output = "immediate-final"
+fail-fast = false
diff --git a/.editorconfig b/.editorconfig
index 53ccc4f9a15..9df8cbbbf98 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,4 +1,5 @@
 # EditorConfig (is awesome!; ref: http://EditorConfig.org; v2022.02.11 [rivy])
+# spell-checker:ignore akefile shellcheck vcproj
 
 # * top-most EditorConfig file
 root = true
@@ -52,7 +53,7 @@ indent_style = space
 switch_case_indent = true
 
 [*.{sln,vc{,x}proj{,.*},[Ss][Ln][Nn],[Vv][Cc]{,[Xx]}[Pp][Rr][Oo][Jj]{,.*}}]
-# MSVC sln/vcproj/vcxproj files, when used, will persistantly revert to CRLF EOLNs and eat final EOLs
+# MSVC sln/vcproj/vcxproj files, when used, will persistently revert to CRLF EOLNs and eat final EOLs
 end_of_line = crlf
 insert_final_newline = false
 
diff --git a/.envrc b/.envrc
new file mode 100644
index 00000000000..cbf4a76e2de
--- /dev/null
+++ b/.envrc
@@ -0,0 +1,7 @@
+# spell-checker:ignore direnv
+
+if ! has nix_direnv_version || ! nix_direnv_version 3.0.6; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.0.6/direnvrc" "sha256-RYcUJaRMf8oF5LznDrlCXbkOQrywm0HDv1VjYGaJGdM="
+fi
+
+use flake
diff --git a/.github/workflows/CICD.yml b/.github/workflows/CICD.yml
index fe72de11067..c9dcb2e3552 100644
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -2,20 +2,26 @@ name: CICD
 
 # 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
+# spell-checker:ignore (jargon) SHAs deps dequote softprops subshell toolchain fuzzers dedupe devel profdata
+# spell-checker:ignore (people) Peltoche rivy dtolnay Anson dawidd
+# spell-checker:ignore (shell/tools) binutils choco clippy dmake dpkg esac fakeroot fdesc fdescfs gmake grcov halium lcov libclang libfuse libssl limactl mkdir nextest nocross pacman popd printf pushd redoxer rsync rustc rustfmt rustup shopt sccache utmpdump xargs
+# spell-checker:ignore (misc) aarch alnum armhf bindir busytest coreutils defconfig DESTDIR gecos getenforce gnueabihf issuecomment maint manpages msys multisize noconfirm nullglob onexitbegin onexitend pell runtest Swatinem tempfile testsuite toybox uutils
 
 env:
   PROJECT_NAME: coreutils
   PROJECT_DESC: "Core universal (cross-platform) utilities"
   PROJECT_AUTH: "uutils"
-  RUST_MIN_SRV: "1.64.0"
+  RUST_MIN_SRV: "1.85.0"
   # * 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]
+on:
+  pull_request:
+  push:
+    tags:
+      - '*'
+    branches:
+      - '*'
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -30,8 +36,10 @@ jobs:
     name: Style/cargo-deny
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: EmbarkStudios/cargo-deny-action@v1
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: EmbarkStudios/cargo-deny-action@v2
 
   style_deps:
     ## ToDO: [2021-11-10; rivy] 'Style/deps' needs more informative output and better integration of results into the GHA dashboard
@@ -47,7 +55,9 @@ jobs:
           - { os: macos-latest   , features: "feat_Tier1,feat_require_unix,feat_require_unix_utmpx" }
           - { os: windows-latest , features: feat_os_windows }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - 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>
@@ -82,199 +92,6 @@ jobs:
         grep --ignore-case "all deps seem to have been used" udeps.log || { printf "%s\n" "::${fault_type} ::${fault_prefix}: \`cargo udeps\`: style violation (unused dependency found)" ; fault=true ; }
         if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
 
-  style_format:
-    name: Style/format
-    runs-on: ${{ matrix.job.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        job:
-          - { 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
-      run: |
-        ## VARs setup
-        outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        # failure mode
-        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;
-        outputs FAIL_ON_FAULT FAULT_TYPE
-        # target-specific options
-        # * CARGO_FEATURES_OPTION
-        CARGO_FEATURES_OPTION='' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
-        outputs CARGO_FEATURES_OPTION
-    - name: "`cargo fmt` testing"
-      shell: bash
-      run: |
-        ## `cargo fmt` testing
-        unset fault
-        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
-        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
-        # * 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 ; }
-        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_test for XX seconds
-      continue-on-error: true
-      shell: bash
-      run: |
-        ## Run it
-        cd fuzz
-        cargo +nightly fuzz run fuzz_test -- -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:
-      SCCACHE_GHA_ENABLED: "true"
-      RUSTC_WRAPPER: "sccache"
-    strategy:
-      fail-fast: false
-      matrix:
-        job:
-          - { os: ubuntu-latest  , features: feat_os_unix }
-          - { os: macos-latest   , features: feat_os_macos }
-          - { 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
-      run: |
-        ## VARs setup
-        outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        # failure mode
-        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;
-        outputs FAIL_ON_FAULT FAULT_TYPE
-        # 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
-        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/setup prerequisites
-      shell: bash
-      run: |
-        ## Install/setup prerequisites
-        case '${{ matrix.job.os }}' in
-          macos-latest) brew install coreutils ;; # needed for show-utils.sh
-        esac
-    - name: "`cargo clippy` lint testing"
-      shell: bash
-      run: |
-        ## `cargo clippy` lint testing
-        unset fault
-        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_UTILITY_LIST_OPTIONS }} -- -W clippy::default_trait_access -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 }}
-    strategy:
-      matrix:
-        job:
-          - { os: ubuntu-latest , features: feat_os_unix }
-    steps:
-    - uses: actions/checkout@v3
-    - name: Initialize workflow variables
-      id: vars
-      shell: bash
-      run: |
-        ## VARs setup
-        outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        # failure mode
-        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;
-        outputs FAIL_ON_FAULT FAULT_TYPE
-    - name: Install/setup prerequisites
-      shell: bash
-      run: |
-        ## Install/setup prerequisites
-        # * pin installed cspell to v4.2.8 (cspell v5+ is broken for NodeJS < v12)
-        ## maint: [2021-11-10; rivy] `cspell` version may be advanced to v5 when used with NodeJS >= v12
-        sudo apt-get -y update ; sudo apt-get -y install npm ; sudo npm install cspell@4.2.8 -g ;
-    - name: Run `cspell`
-      shell: bash
-      run: |
-        ## Run `cspell`
-        unset fault
-        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
-        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
-        # * find cspell configuration ; note: avoid quotes around ${cfg_file} b/c `cspell` (v4) doesn't correctly dequote the config argument (or perhaps a subshell expansion issue?)
-        cfg_files=($(shopt -s nullglob ; echo {.vscode,.}/{,.}c[sS]pell{.json,.config{.js,.cjs,.json,.yaml,.yml},.yaml,.yml} ;))
-        cfg_file=${cfg_files[0]}
-        unset CSPELL_CFG_OPTION ; if [ -n "$cfg_file" ]; then CSPELL_CFG_OPTION="--config $cfg_file" ; fi
-        # * `cspell`
-        ## maint: [2021-11-10; rivy] the `--no-progress` option for `cspell` is a `cspell` v5+ option
-        # S=$(cspell ${CSPELL_CFG_OPTION} --no-summary --no-progress "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
-        S=$(cspell ${CSPELL_CFG_OPTION} --no-summary "**/*") && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
-        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
-
   doc_warnings:
     name: Documentation/warnings
     runs-on: ${{ matrix.job.os }}
@@ -292,14 +109,20 @@ jobs:
 #          - { os: macos-latest   , features: feat_os_macos }
 #          - { os: windows-latest , features: feat_os_windows }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - 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
+      uses: mozilla-actions/sccache-action@v0.0.9
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        sudo apt-get -y update ; sudo apt-get -y install libselinux1-dev
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -326,9 +149,9 @@ jobs:
       shell: bash
       run: |
         RUSTDOCFLAGS="-Dwarnings" cargo doc  ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --no-deps --workspace --document-private-items
-    - uses: DavidAnson/markdownlint-cli2-action@v12
+    - uses: DavidAnson/markdownlint-cli2-action@v20
       with:
-        command: fix
+        fix: "true"
         globs: |
           *.md
           docs/src/*.md
@@ -345,7 +168,9 @@ jobs:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@master
       with:
         toolchain: ${{ env.RUST_MIN_SRV }}
@@ -353,7 +178,7 @@ jobs:
     - uses: taiki-e/install-action@nextest
     - uses: Swatinem/rust-cache@v2
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -365,19 +190,19 @@ jobs:
         unset CARGO_FEATURES_OPTION
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
         outputs CARGO_FEATURES_OPTION
-    - name: Confirm MinSRV compatible 'Cargo.lock'
+    - name: Confirm MinSRV compatible '*/Cargo.lock'
       shell: bash
       run: |
-        ## Confirm MinSRV compatible 'Cargo.lock'
-        # * 'Cargo.lock' is required to be in a format that `cargo` of MinSRV can interpret (eg, v1-format for MinSRV < v1.38)
-        cargo fetch --locked --quiet || { echo "::error file=Cargo.lock::Incompatible (or out-of-date) 'Cargo.lock' file; update using \`cargo +${{ env.RUST_MIN_SRV }} update\`" ; exit 1 ; }
-    - name: Confirm MinSRV equivalence for '.clippy.toml'
+        ## Confirm MinSRV compatible '*/Cargo.lock'
+        # * '*/Cargo.lock' is required to be in a format that `cargo` of MinSRV can interpret (eg, v1-format for MinSRV < v1.38)
+        for dir in "." "fuzz"; do
+          ( cd "$dir" && cargo fetch --locked --quiet ) || { echo "::error file=$dir/Cargo.lock::Incompatible (or out-of-date) '$dir/Cargo.lock' file; update using \`cd '$dir' && cargo +${{ env.RUST_MIN_SRV }} update\`" ; exit 1 ; }
+        done
+    - name: Install/setup prerequisites
       shell: bash
       run: |
-        ## Confirm MinSRV equivalence for '.clippy.toml'
-        # * ensure '.clippy.toml' MSRV configuration setting is equal to ${{ env.RUST_MIN_SRV }}
-        CLIPPY_MSRV=$(grep -P "(?i)^\s*msrv\s*=\s*" .clippy.toml | grep -oP "\d+([.]\d+)+")
-        if [ "${CLIPPY_MSRV}" != "${{ env.RUST_MIN_SRV }}" ]; then { echo "::error file=.clippy.toml::Incorrect MSRV configuration for clippy (found '${CLIPPY_MSRV}'; should be '${{ env.RUST_MIN_SRV }}'); update '.clippy.toml' with 'msrv = \"${{ env.RUST_MIN_SRV }}\"'" ; exit 1 ; } ; fi
+        # Install a package for one of the tests
+        sudo apt-get -y update ; sudo apt-get -y install attr
     - name: Info
       shell: bash
       run: |
@@ -397,7 +222,7 @@ jobs:
         echo "## dependency list"
         ## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
         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
+        RUSTUP_TOOLCHAIN=stable cargo tree --no-dedupe --locked -e=no-dev --prefix=none ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} | grep -vE "$PWD" | sort --unique
     - name: Test
       run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -p uucore -p coreutils
       env:
@@ -413,7 +238,9 @@ jobs:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@stable
     - uses: Swatinem/rust-cache@v2
     - name: "`cargo update` testing"
@@ -421,7 +248,9 @@ jobs:
       run: |
         ## `cargo update` 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>
-        cargo fetch --locked --quiet || { echo "::error file=Cargo.lock::'Cargo.lock' file requires update (use \`cargo +${{ env.RUST_MIN_SRV }} update\`)" ; exit 1 ; }
+        for dir in "." "fuzz"; do
+          ( cd "$dir" && cargo fetch --locked --quiet ) || { echo "::error file=$dir/Cargo.lock::'$dir/Cargo.lock' file requires update (use \`cd '$dir' && cargo +${{ env.RUST_MIN_SRV }} update\`)" ; exit 1 ; }
+        done
 
   build_makefile:
     name: Build/Makefile
@@ -436,12 +265,18 @@ jobs:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@stable
     - uses: taiki-e/install-action@nextest
     - uses: Swatinem/rust-cache@v2
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        sudo apt-get -y update ; sudo apt-get -y install libselinux1-dev
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: "`make build`"
       shell: bash
       run: |
@@ -451,10 +286,26 @@ jobs:
       run: make nextest CARGOFLAGS="--profile ci --hide-progress-bar"
       env:
         RUST_BACKTRACE: "1"
+    - name: "`make install COMPLETIONS=n MANPAGES=n`"
+      shell: bash
+      run: |
+        DESTDIR=/tmp/ make PROFILE=release COMPLETIONS=n MANPAGES=n install
+        # Check that the utils are present
+        test -f /tmp/usr/local/bin/tty
+        # Check that the manpage is not present
+        ! test -f /tmp/usr/local/share/man/man1/whoami.1
+        # Check that the completion is not present
+        ! test -f /tmp/usr/local/share/zsh/site-functions/_install
+        ! test -f /tmp/usr/local/share/bash-completion/completions/head
+        ! test -f /tmp/usr/local/share/fish/vendor_completions.d/cat.fish
+      env:
+        RUST_BACKTRACE: "1"
     - name: "`make install`"
       shell: bash
       run: |
         DESTDIR=/tmp/ make PROFILE=release install
+        # Check that the utils are present
+        test -f /tmp/usr/local/bin/tty
         # Check that the manpage is present
         test -f /tmp/usr/local/share/man/man1/whoami.1
         # Check that the completion is present
@@ -467,6 +318,8 @@ jobs:
       shell: bash
       run: |
         DESTDIR=/tmp/ make uninstall
+        # Check that the utils are not present
+        ! test -f /tmp/usr/local/bin/tty
         # Check that the manpage is not present
         ! test -f /tmp/usr/local/share/man/man1/whoami.1
         # Check that the completion is not present
@@ -490,14 +343,16 @@ jobs:
           - { os: macos-latest   , features: feat_os_macos }
           - { os: windows-latest , features: feat_os_windows }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - 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
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Test
-      run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+      run: cargo nextest run --hide-progress-bar --profile ci --features ${{ matrix.job.features }}
       env:
         RUST_BACKTRACE: "1"
 
@@ -517,14 +372,16 @@ jobs:
           - { os: macos-latest   , features: feat_os_macos }
           - { os: windows-latest , features: feat_os_windows }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - 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
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Test
-      run: cargo nextest run --hide-progress-bar --profile ci ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+      run: cargo nextest run --hide-progress-bar --profile ci --features ${{ matrix.job.features }}
       env:
         RUST_BACKTRACE: "1"
 
@@ -541,17 +398,19 @@ jobs:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@stable
     - uses: Swatinem/rust-cache@v2
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Install dependencies
       shell: bash
       run: |
         ## Install dependencies
         sudo apt-get update
-        sudo apt-get install jq
+        sudo apt-get install jq libselinux1-dev
     - name: "`make install`"
       shell: bash
       run: |
@@ -584,14 +443,14 @@ jobs:
               --arg multisize "$SIZE_MULTI" \
               '{($date): { sha: $sha, size: $size, multisize: $multisize, }}' > size-result.json
     - name: Download the previous individual size result
-      uses: dawidd6/action-download-artifact@v2
+      uses: dawidd6/action-download-artifact@v9
       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
+      uses: dawidd6/action-download-artifact@v9
       with:
         workflow: CICD.yml
         name: size-result
@@ -603,6 +462,12 @@ jobs:
         check() {
           # Warn if the size increases by more than 5%
           threshold='1.05'
+
+          if [[ "$2" -eq 0 || "$3" -eq 0 ]]; then
+              echo "::warning file=$4::Invalid size for $1. Sizes cannot be 0."
+              return
+          fi
+
           ratio=$(jq -n "$2 / $3")
           echo "$1: size=$2, previous_size=$3, ratio=$ratio, threshold=$threshold"
           if [[ "$(jq -n "$ratio > $threshold")" == 'true' ]]; then
@@ -622,12 +487,12 @@ jobs:
         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
+      uses: actions/upload-artifact@v4
       with:
         name: individual-size-result
         path: individual-size-result.json
     - name: Upload the size result
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: size-result
         path: size-result.json
@@ -648,20 +513,28 @@ jobs:
       fail-fast: false
       matrix:
         job:
-          # { 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 , target , cargo-options , default-features,  features , use-cross , toolchain, skip-tests, workspace-tests, skip-package, skip-publish }
+          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , features: feat_os_unix_gnueabihf , use-cross: use-cross , skip-tests: true }
+          - { os: ubuntu-24.04-arm  , target: aarch64-unknown-linux-gnu   , features: feat_os_unix_gnueabihf }
+          - { os: ubuntu-latest  , target: aarch64-unknown-linux-musl  , features: feat_os_unix      , use-cross: use-cross , skip-tests: true }
           # - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: feat_selinux           , use-cross: use-cross }
-          - { 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 }
-          - { os: macos-latest   , target: x86_64-apple-darwin         , features: feat_os_macos }
+          - { os: ubuntu-latest  , target: i686-unknown-linux-gnu      , features: "feat_os_unix,test_risky_names", use-cross: use-cross }
+          - { os: ubuntu-latest  , target: i686-unknown-linux-musl     , features: feat_os_unix      , use-cross: use-cross }
+          - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: "feat_os_unix,test_risky_names", use-cross: use-cross }
+          - { os: ubuntu-latest  , target: x86_64-unknown-linux-gnu    , features: "feat_os_unix,uudoc"   , use-cross: no, workspace-tests: true }
+          - { os: ubuntu-latest  , target: x86_64-unknown-linux-musl   , features: feat_os_unix      , use-cross: use-cross }
+          - { os: ubuntu-latest  , target: x86_64-unknown-redox        , features: feat_os_unix_redox     , use-cross: redoxer , skip-tests: true }
+          - { os: ubuntu-latest  , target: wasm32-unknown-unknown      , default-features: false, features: uucore/format, skip-tests: true, skip-package: true, skip-publish: true }
+          - { os: macos-latest   , target: aarch64-apple-darwin        , features: feat_os_macos, workspace-tests: true } # M1 CPU
+          - { os: macos-13       , target: x86_64-apple-darwin         , features: feat_os_macos, workspace-tests: true }
           - { 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-gnu       , features: feat_os_windows }
           - { os: windows-latest , target: x86_64-pc-windows-msvc      , features: feat_os_windows }
+          - { os: windows-latest , target: aarch64-pc-windows-msvc     , features: feat_os_windows, use-cross: use-cross , skip-tests: true }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@master
       with:
         toolchain: ${{ env.RUST_MIN_SRV }}
@@ -670,7 +543,7 @@ jobs:
       with:
         key: "${{ matrix.job.os }}_${{ matrix.job.target }}"
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Initialize workflow variables
       id: vars
       shell: bash
@@ -707,7 +580,13 @@ jobs:
           i686-*) TARGET_ARCH=i686 ;;
           x86_64-*) TARGET_ARCH=x86_64 ;;
         esac;
-        unset TARGET_OS ; case '${{ matrix.job.target }}' in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
+        unset TARGET_OS
+        case '${{ matrix.job.target }}' in
+          *-linux-*) TARGET_OS=linux ;;
+          *-apple-*) TARGET_OS=macos ;;
+          *-windows-*) TARGET_OS=windows ;;
+          *-redox*) TARGET_OS=redox ;;
+        esac
         outputs TARGET_ARCH TARGET_OS
         # package name
         PKG_suffix=".tar.gz" ; case '${{ matrix.job.target }}' in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
@@ -741,20 +620,47 @@ jobs:
         CARGO_FEATURES_OPTION='' ;
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features=${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
+        # * CARGO_DEFAULT_FEATURES_OPTION
+        CARGO_DEFAULT_FEATURES_OPTION='' ;
+        if [ "${{ matrix.job.default-features }}" == "false" ]; then CARGO_DEFAULT_FEATURES_OPTION='--no-default-features' ; fi
+        outputs CARGO_DEFAULT_FEATURES_OPTION
         # * CARGO_CMD
-        CARGO_CMD='cross' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) CARGO_CMD='cargo' ;; esac;
+        CARGO_CMD='cross'
+        CARGO_CMD_OPTIONS='+${{ env.RUST_MIN_SRV }}'
+        # Added suffix for artifacts, needed when multiple jobs use the same target.
+        ARTIFACTS_SUFFIX=''
+        case '${{ matrix.job.use-cross }}' in
+          ''|0|f|false|n|no)
+            CARGO_CMD='cargo'
+            ARTIFACTS_SUFFIX='-nocross'
+            ;;
+          redoxer)
+            CARGO_CMD='redoxer'
+            CARGO_CMD_OPTIONS=''
+            ;;
+        esac
         outputs CARGO_CMD
+        outputs CARGO_CMD_OPTIONS
+        outputs ARTIFACTS_SUFFIX
+        CARGO_TEST_OPTIONS=''
+        case '${{ matrix.job.workspace-tests }}' in
+          1|t|true|y|yes)
+            # This also runs tests in other packages in the source directory (e.g. uucore).
+            # We cannot enable this everywhere as some platforms are currently broken, and
+            # we cannot use `cross` as its Docker image is ancient (Ubuntu 16.04) and is
+            # missing required system dependencies (e.g. recent libclang-dev).
+            CARGO_TEST_OPTIONS='--workspace'
+            ;;
+        esac
+        outputs CARGO_TEST_OPTIONS
         # ** pass needed environment into `cross` container (iff `cross` not already configured via "Cross.toml")
         if [ "${CARGO_CMD}" = 'cross' ] && [ ! -e "Cross.toml" ] ; then
           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;
-        outputs CARGO_TEST_OPTIONS
         # * executable for `strip`?
         STRIP="strip"
         case ${{ matrix.job.target }} in
-          aarch64-*-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
+          aarch64-*-linux-*) STRIP="aarch64-linux-gnu-strip" ;;
           arm-*-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;;
           *-pc-windows-msvc) STRIP="" ;;
         esac;
@@ -762,7 +668,7 @@ jobs:
     - uses: taiki-e/install-action@v2
       if: steps.vars.outputs.CARGO_CMD == 'cross'
       with:
-        tool: cross@0.2.1
+        tool: cross@0.2.5
     - name: Create all needed build/work directories
       shell: bash
       run: |
@@ -775,14 +681,27 @@ jobs:
       run: |
         ## Install/setup prerequisites
         case '${{ matrix.job.target }}' in
-          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
-          aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
+          arm-unknown-linux-gnueabihf)
+            sudo apt-get -y update
+            sudo apt-get -y install gcc-arm-linux-gnueabihf
+          ;;
+          aarch64-unknown-linux-*)
+            sudo apt-get -y update
+            sudo apt-get -y install gcc-aarch64-linux-gnu
+          ;;
+          *-redox*)
+            sudo apt-get -y update
+            sudo apt-get -y install fuse3 libfuse-dev
+          ;;
         esac
         case '${{ matrix.job.os }}' in
           macos-latest) brew install coreutils ;; # needed for testing
         esac
         case '${{ matrix.job.os }}' in
           ubuntu-*)
+            # selinux headers needed to build tests
+            sudo apt-get -y update
+            sudo apt-get -y install libselinux1-dev
             # pinky is a tool to show logged-in users from utmp, and gecos fields from /etc/passwd.
             # In GitHub Action *nix VMs, no accounts log in, even the "runner" account that runs the commands. The account also has empty gecos fields.
             # To work around this for pinky tests, we create a fake login entry for the GH runner account...
@@ -796,6 +715,10 @@ jobs:
             echo "foo" > /home/runner/.plan
             ;;
         esac
+    - uses: taiki-e/install-action@v2
+      if: steps.vars.outputs.CARGO_CMD == 'redoxer'
+      with:
+        tool: redoxer@0.2.37
     - name: Initialize toolchain-dependent workflow variables
       id: dep_vars
       shell: bash
@@ -829,35 +752,38 @@ jobs:
         # dependencies
         echo "## dependency list"
         cargo fetch --locked --quiet
-        cargo tree --locked --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} --all --no-dev-dependencies --no-indent | grep -vE "$PWD" | sort --unique
+        cargo tree --locked --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.vars.outputs.CARGO_DEFAULT_FEATURES_OPTION }} --no-dedupe -e=no-dev --prefix=none | grep -vE "$PWD" | sort --unique
     - name: Build
       shell: bash
       run: |
         ## Build
-        ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} build --release \
-        --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+        ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} build --release \
+        --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.vars.outputs.CARGO_DEFAULT_FEATURES_OPTION }}
     - name: Test
+      if: matrix.job.skip-tests != true
       shell: bash
       run: |
         ## Test
-        ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} test --target=${{ matrix.job.target }} \
-        ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+        ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} test --target=${{ matrix.job.target }} \
+        ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} ${{ steps.vars.outputs.CARGO_DEFAULT_FEATURES_OPTION }}
       env:
         RUST_BACKTRACE: "1"
     - name: Test individual utilities
+      if: matrix.job.skip-tests != true
       shell: bash
       run: |
         ## Test individual utilities
-        ${{ steps.vars.outputs.CARGO_CMD }} +${{ env.RUST_MIN_SRV }} test --target=${{ matrix.job.target }} \
-        ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
+        ${{ steps.vars.outputs.CARGO_CMD }} ${{ steps.vars.outputs.CARGO_CMD_OPTIONS }} test --target=${{ matrix.job.target }} \
+        ${{ matrix.job.cargo-options }} ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
       env:
         RUST_BACKTRACE: "1"
     - name: Archive executable artifacts
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
+        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}${{ steps.vars.outputs.ARTIFACTS_SUFFIX }}
         path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
     - name: Package
+      if: matrix.job.skip-package != true
       shell: bash
       run: |
         ## Package artifact(s)
@@ -892,9 +818,10 @@ jobs:
           fakeroot dpkg-deb --build "${DPKG_DIR}" "${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}"
         fi
     - name: Publish
-      uses: softprops/action-gh-release@v1
-      if: steps.vars.outputs.DEPLOY
+      uses: softprops/action-gh-release@v2
+      if: steps.vars.outputs.DEPLOY && matrix.job.skip-publish != true
       with:
+        draft: true
         files: |
           ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
           ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}
@@ -920,13 +847,16 @@ jobs:
       run: |
         ## VARs setup
         echo "TEST_SUMMARY_FILE=busybox-result.json" >> $GITHUB_OUTPUT
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: Swatinem/rust-cache@v2
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Install/setup prerequisites
       shell: bash
       run: |
+        sudo apt-get -y update ; sudo apt-get -y install libselinux1-dev
         ## Install/setup prerequisites
         make prepare-busytest
     - name: Run BusyBox test suite
@@ -964,17 +894,17 @@ jobs:
           HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
           echo "HASH=${HASH}" >> $GITHUB_OUTPUT
     - name: Reserve SHA1/ID of 'test-summary'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "${{ steps.summary.outputs.HASH }}"
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test results summary
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: test-summary
+        name: busybox-test-summary
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Upload json results
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: busybox-result.json
         path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
@@ -1000,24 +930,29 @@ jobs:
         outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
         TEST_SUMMARY_FILE="toybox-result.json"
         outputs TEST_SUMMARY_FILE
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@master
       with:
         toolchain: ${{ env.RUST_MIN_SRV }}
         components: rustfmt
     - uses: Swatinem/rust-cache@v2
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        sudo apt-get -y update ; sudo apt-get -y install libselinux1-dev
     - name: Build coreutils as multiple binaries
       shell: bash
       run: |
         ## Build individual uutil binaries
         set -v
         make
-    - name: Install/setup prerequisites
+    - name: Run toybox src
       shell: bash
       run: |
-        ## Install/setup prerequisites
         make toybox-src
     - name: Run Toybox test suite
       id: summary
@@ -1052,30 +987,21 @@ jobs:
         HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
           echo "HASH=${HASH}" >> $GITHUB_OUTPUT
     - name: Reserve SHA1/ID of 'test-summary'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "${{ steps.summary.outputs.HASH }}"
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test results summary
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: test-summary
+        name: toybox-test-summary
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Upload json results
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: toybox-result.json
         path: ${{ steps.vars.outputs.TEST_SUMMARY_FILE }}
 
-  toml_format:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Clone repository
-        uses: actions/checkout@v3
-
-      - name: Check
-        run: npx --yes @taplo/cli fmt --check
-
   coverage:
     name: Code Coverage
     runs-on: ${{ matrix.job.os }}
@@ -1088,45 +1014,55 @@ jobs:
       matrix:
         job:
           - { 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 }
+          # FIXME: Re-enable macos code coverage
+          # - { os: macos-latest   , features: macos, toolchain: nightly }
+          # FIXME: Re-enable Code Coverage on windows, which currently fails due to "profiler_builtins". See #6686.
+          # - { os: windows-latest , features: windows, toolchain: nightly-x86_64-pc-windows-gnu }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - 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: taiki-e/install-action@v2
+      with:
+        tool: nextest,grcov@0.8.24
     - uses: Swatinem/rust-cache@v2
+
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
+
     # - name: Reattach HEAD ## may be needed for accurate code coverage info
     #   run: git checkout ${{ github.head_ref }}
+
     - name: Initialize workflow variables
       id: vars
       shell: bash
       run: |
         ## VARs setup
         outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+
         # toolchain
         TOOLCHAIN="nightly" ## default to "nightly" toolchain (required for certain required unstable compiler flags) ## !maint: refactor when stable channel has needed support
+
         # * specify gnu-type TOOLCHAIN for windows; `grcov` requires gnu-style code coverage data files
         case ${{ matrix.job.os }} in windows-*) TOOLCHAIN="$TOOLCHAIN-x86_64-pc-windows-gnu" ;; esac;
+
         # * use requested TOOLCHAIN if specified
         if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
         outputs TOOLCHAIN
-        # staging directory
-        STAGING='_staging'
-        outputs STAGING
+
         # target-specific options
+
         # * CARGO_FEATURES_OPTION
         CARGO_FEATURES_OPTION='--all-features' ;  ## default to '--all-features' for code coverage
         if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features=${{ matrix.job.features }}' ; fi
         outputs CARGO_FEATURES_OPTION
+
         # * CODECOV_FLAGS
         CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
         outputs CODECOV_FLAGS
+
     - name: Install/setup prerequisites
       shell: bash
       run: |
@@ -1134,8 +1070,10 @@ jobs:
         case '${{ matrix.job.os }}' in
           macos-latest) brew install coreutils ;; # needed for testing
         esac
+
         case '${{ matrix.job.os }}' in
           ubuntu-latest)
+            sudo apt-get -y update ; sudo apt-get -y install libselinux1-dev
             # pinky is a tool to show logged-in users from utmp, and gecos fields from /etc/passwd.
             # In GitHub Action *nix VMs, no accounts log in, even the "runner" account that runs the commands. The account also has empty gecos fields.
             # To work around this for pinky tests, we create a fake login entry for the GH runner account...
@@ -1149,63 +1087,118 @@ jobs:
             echo "foo" > /home/runner/.plan
             ;;
         esac
-    - name: Initialize toolchain-dependent workflow variables
-      id: dep_vars
-      shell: bash
+
+        case '${{ matrix.job.os }}' in
+          # Update binutils if MinGW due to https://github.com/rust-lang/rust/issues/112368
+          windows-latest) C:/msys64/usr/bin/pacman.exe -Sy --needed mingw-w64-x86_64-gcc --noconfirm ; echo "C:\msys64\mingw64\bin" >> $GITHUB_PATH ;;
+        esac
+
+        ## Install the llvm-tools component to get access to `llvm-profdata`
+        rustup component add llvm-tools
+
+    - name: Run test and coverage
+      id: run_test_cov
       run: |
-        ## Dependent VARs setup
         outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        # * determine sub-crate utility list
-        UTILITY_LIST="$(./util/show-utils.sh ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }})"
-        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 nextest run --profile ci --hide-progress-bar -p uucore
-      env:
-        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 nextest run --profile ci --hide-progress-bar ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
-      env:
-        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 nextest run --profile ci --hide-progress-bar ${{ steps.dep_vars.outputs.CARGO_UTILITY_LIST_OPTIONS }}
+
+        # Run the coverage script
+        ./util/build-run-test-coverage-linux.sh
+
+        outputs REPORT_FILE
       env:
-        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"
+        COVERAGE_DIR: ${{ github.workspace }}/coverage
+        FEATURES_OPTION: ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
         # RUSTUP_TOOLCHAIN: ${{ steps.vars.outputs.TOOLCHAIN }}
-    - name: Generate coverage data (via `grcov`)
-      id: coverage
-      shell: bash
-      run: |
-        ## Generate coverage data
-        COVERAGE_REPORT_DIR="target/debug"
-        COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
-        # GRCOV_IGNORE_OPTION='--ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*"' ## `grcov` ignores these params when passed as an environment variable (why?)
-        # GRCOV_EXCLUDE_OPTION='--excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"' ## `grcov` ignores these params when passed as an environment variable (why?)
-        mkdir -p "${COVERAGE_REPORT_DIR}"
-        # display coverage files
-        ~/.cargo/bin/grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
-        # generate coverage report
-        ~/.cargo/bin/grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
-        echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
+
     - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v3
-      # if: steps.vars.outputs.HAS_CODECOV_TOKEN
+      uses: codecov/codecov-action@v5
       with:
-        # token: ${{ secrets.CODECOV_TOKEN }}
-        file: ${{ steps.coverage.outputs.report }}
+        token: ${{ secrets.CODECOV_TOKEN }}
+        files: ${{ steps.run_test_cov.outputs.report }}
         ## flags: IntegrationTests, UnitTests, ${{ steps.vars.outputs.CODECOV_FLAGS }}
         flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
         name: codecov-umbrella
         fail_ci_if_error: false
 
+  test_separately:
+    name: Separate Builds
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: Swatinem/rust-cache@v2
+    - name: build and test all programs individually
+      shell: bash
+      run: |
+        for f in $(util/show-utils.sh)
+        do
+          echo "Building and testing $f"
+          cargo test -p "uu_$f" || exit 1
+        done
+
+  test_all_features:
+    name: Test all features separately
+    needs: [ min_version, deps ]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        # windows-latest - https://github.com/uutils/coreutils/issues/7044
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@stable
+    - uses: Swatinem/rust-cache@v2
+    - name: build and test all features individually
+      shell: bash
+      run: |
+        for f in $(util/show-utils.sh)
+        do
+          echo "Running tests with --features=$f and --no-default-features"
+          cargo test --features=$f --no-default-features
+        done
+
+  test_selinux:
+    name: Build/SELinux
+    needs: [ min_version, deps ]
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@stable
+    - name: Setup Lima
+      uses: lima-vm/lima-actions/setup@v1
+      id: lima-actions-setup
+    - name: Cache ~/.cache/lima
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/lima
+        key: lima-${{ steps.lima-actions-setup.outputs.version }}
+    - name: Start Fedora VM with SELinux
+      run: limactl start --plain --name=default --cpus=1 --disk=30 --memory=4 --network=lima:user-v2 template://fedora
+    - name: Setup SSH
+      uses: lima-vm/lima-actions/ssh@v1
+    - run: rsync -v -a -e ssh . lima-default:~/work/
+    - name: Setup Rust and other build deps in VM
+      run: |
+        lima sudo dnf install gcc g++ git rustup libselinux-devel clang-devel attr -y
+        lima rustup-init -y --default-toolchain stable
+    - name: Verify SELinux Status
+      run: |
+        lima getenforce
+        lima ls -laZ /etc/selinux
+    - name: Build and Test with SELinux
+      run: |
+        lima ls
+        lima bash -c "cd work && cargo test --features 'feat_selinux'"
+    - name: Lint with SELinux
+      run: lima bash -c "cd work && cargo clippy --all-targets --features 'feat_selinux' -- -D warnings"
diff --git a/.github/workflows/CheckScripts.yml b/.github/workflows/CheckScripts.yml
index e1b3b24d205..78a4656fcde 100644
--- a/.github/workflows/CheckScripts.yml
+++ b/.github/workflows/CheckScripts.yml
@@ -1,6 +1,6 @@
 name: CheckScripts
 
-# spell-checker:ignore ludeeus mfinelli
+# spell-checker:ignore ludeeus mfinelli shellcheck scandir shfmt
 
 env:
   SCRIPT_DIR: 'util'
@@ -8,7 +8,7 @@ env:
 on:
   push:
     branches:
-      - main
+      - '*'
     paths:
       - 'util/**/*.sh'
   pull_request:
@@ -29,7 +29,9 @@ jobs:
     permissions:
       contents: read
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: Run ShellCheck
         uses: ludeeus/action-shellcheck@master
         env:
@@ -41,34 +43,18 @@ jobs:
 
   shell_fmt:
     name: ShellScript/Format
-    # no need to run in pr events
-    # shfmt will be performed on main branch when the PR is merged
-    if: github.event_name != 'pull_request'
     runs-on: ubuntu-latest
-    needs: [ shell_check ]
     permissions:
-      contents: write
-      pull-requests: write
+      contents: read
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
       - name: Setup shfmt
-        uses: mfinelli/setup-shfmt@v2
+        uses: mfinelli/setup-shfmt@v3
       - name: Run shfmt
         shell: bash
         run: |
-          # show differs first for every files that need to be formatted
           # fmt options: bash syntax, 4 spaces indent, indent for switch-case
           echo "## show the differences between formatted and original scripts..."
           find ${{ env.SCRIPT_DIR }} -name "*.sh" -print0 | xargs -0 shfmt -ln=bash -i 4 -ci -d || true
-          # perform a shell format
-          echo "## perform a shell format..."
-          # ignore the error code because `-d` will always return false when the file has difference
-          find ${{ env.SCRIPT_DIR }} -name "*.sh" -print0 | xargs -0 shfmt -ln=bash -i 4 -ci -w
-      - name: Commit any changes
-        uses: EndBug/add-and-commit@v9
-        with:
-          default_author: github_actions
-          message: "style: auto format by CI (shfmt)"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          
diff --git a/.github/workflows/FixPR.yml b/.github/workflows/FixPR.yml
index 97b0be34afa..bbdf50b30b5 100644
--- a/.github/workflows/FixPR.yml
+++ b/.github/workflows/FixPR.yml
@@ -1,6 +1,6 @@
 name: FixPR
 
-# spell-checker:ignore Swatinem dtolnay
+# spell-checker:ignore Swatinem dtolnay dedupe
 
 # Trigger automated fixes for PRs being merged (with associated commits)
 
@@ -26,7 +26,9 @@ jobs:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - name: Initialize job variables
       id: vars
       shell: bash
@@ -41,9 +43,11 @@ jobs:
     - name: Ensure updated 'Cargo.lock'
       shell: bash
       run: |
-        # Ensure updated 'Cargo.lock'
-        # * 'Cargo.lock' is required to be in a format that `cargo` of MinSRV can interpret (eg, v1-format for MinSRV < v1.38)
-        cargo fetch --locked --quiet || cargo +${{ steps.vars.outputs.RUST_MIN_SRV }} update
+        # Ensure updated '*/Cargo.lock'
+        # * '*/Cargo.lock' is required to be in a format that `cargo` of MinSRV can interpret (eg, v1-format for MinSRV < v1.38)
+        for dir in "." "fuzz"; do
+          ( cd "$dir" && (cargo fetch --locked --quiet || cargo +${{ steps.vars.outputs.RUST_MIN_SRV }} update) )
+        done
     - name: Info
       shell: bash
       run: |
@@ -63,14 +67,14 @@ jobs:
         echo "## dependency list"
         cargo fetch --locked --quiet
         ## * using the 'stable' toolchain is necessary to avoid "unexpected '--filter-platform'" errors
-        RUSTUP_TOOLCHAIN=stable cargo tree --locked --all --no-dev-dependencies --no-indent --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
+        RUSTUP_TOOLCHAIN=stable cargo tree --locked --no-dedupe -e=no-dev --prefix=none --features ${{ matrix.job.features }} | grep -vE "$PWD" | sort --unique
     - name: Commit any changes (to '${{ env.BRANCH_TARGET }}')
       uses: EndBug/add-and-commit@v9
       with:
         new_branch: ${{ env.BRANCH_TARGET }}
         default_author: github_actions
-        message: "maint ~ refresh 'Cargo.lock'"
-        add: Cargo.lock
+        message: "maint ~ refresh 'Cargo.lock' 'fuzz/Cargo.lock'"
+        add: Cargo.lock fuzz/Cargo.lock
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -85,7 +89,9 @@ jobs:
         job:
           - { os: ubuntu-latest , features: feat_os_unix }
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - name: Initialize job variables
       id: vars
       shell: bash
diff --git a/.github/workflows/GnuComment.yml b/.github/workflows/GnuComment.yml
index bb64232a99a..7fe42070e82 100644
--- a/.github/workflows/GnuComment.yml
+++ b/.github/workflows/GnuComment.yml
@@ -1,10 +1,12 @@
 name: GnuComment
 
+# spell-checker:ignore zizmor backquote
+
 on:
   workflow_run:
     workflows: ["GnuTests"]
     types:
-      - completed
+      - completed  # zizmor: ignore[dangerous-triggers]
 
 permissions: {}
 jobs:
@@ -18,7 +20,7 @@ jobs:
       github.event.workflow_run.event == 'pull_request'
     steps:
       - name: 'Download artifact'
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         with:
           script: |
             // List all artifacts from GnuTests
@@ -43,7 +45,7 @@ jobs:
       - run: unzip comment.zip
 
       - name: 'Comment on PR'
-        uses: actions/github-script@v6
+        uses: actions/github-script@v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
diff --git a/.github/workflows/GnuTests.yml b/.github/workflows/GnuTests.yml
index ccb5a6f7495..fc40fc91f5f 100644
--- a/.github/workflows/GnuTests.yml
+++ b/.github/workflows/GnuTests.yml
@@ -1,15 +1,19 @@
 name: 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 libattr libcap taiki-e
+# spell-checker:ignore (jargon) submodules devel
+# spell-checker:ignore (libs/utils) autopoint chksum getenforce gperf lcov libexpect limactl pyinotify setenforce shopt texinfo valgrind libattr libcap taiki-e
 # spell-checker:ignore (options) Ccodegen Coverflow Cpanic Zpanic
 # 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`
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - '*'
 
 permissions:
   contents: read
@@ -19,6 +23,9 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
+env:
+  DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+
 jobs:
   gnu:
     permissions:
@@ -26,7 +33,7 @@ jobs:
       contents: read  # for actions/checkout to fetch code
       pull-requests: read  # for dawidd6/action-download-artifact to query commit hash
     name: Run GNU tests
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
     - name: Initialize workflow variables
       id: vars
@@ -41,23 +48,31 @@ jobs:
         path_reference="reference"
         outputs path_GNU path_GNU_tests path_reference path_UUTILS
         #
-        repo_default_branch="${{ github.event.repository.default_branch }}"
-        repo_GNU_ref="v9.4"
-        repo_reference_branch="${{ github.event.repository.default_branch }}"
+        repo_default_branch="$DEFAULT_BRANCH"
+        repo_GNU_ref="v9.7"
+        repo_reference_branch="$DEFAULT_BRANCH"
         outputs repo_default_branch repo_GNU_ref repo_reference_branch
         #
         SUITE_LOG_FILE="${path_GNU_tests}/test-suite.log"
         ROOT_SUITE_LOG_FILE="${path_GNU_tests}/test-suite-root.log"
+        SELINUX_SUITE_LOG_FILE="${path_GNU_tests}/selinux-test-suite.log"
+        SELINUX_ROOT_SUITE_LOG_FILE="${path_GNU_tests}/selinux-test-suite-root.log"
         TEST_LOGS_GLOB="${path_GNU_tests}/**/*.log" ## note: not usable at bash CLI; [why] double globstar not enabled by default b/c MacOS includes only bash v3 which doesn't have double globstar support
         TEST_FILESET_PREFIX='test-fileset-IDs.sha1#'
         TEST_FILESET_SUFFIX='.txt'
         TEST_SUMMARY_FILE='gnu-result.json'
         TEST_FULL_SUMMARY_FILE='gnu-full-result.json'
-        outputs SUITE_LOG_FILE ROOT_SUITE_LOG_FILE TEST_FILESET_PREFIX TEST_FILESET_SUFFIX TEST_LOGS_GLOB TEST_SUMMARY_FILE TEST_FULL_SUMMARY_FILE
+        TEST_ROOT_FULL_SUMMARY_FILE='gnu-root-full-result.json'
+        TEST_SELINUX_FULL_SUMMARY_FILE='selinux-gnu-full-result.json'
+        TEST_SELINUX_ROOT_FULL_SUMMARY_FILE='selinux-root-gnu-full-result.json'
+        AGGREGATED_SUMMARY_FILE='aggregated-result.json'
+
+        outputs SUITE_LOG_FILE ROOT_SUITE_LOG_FILE SELINUX_SUITE_LOG_FILE SELINUX_ROOT_SUITE_LOG_FILE TEST_FILESET_PREFIX TEST_FILESET_SUFFIX TEST_LOGS_GLOB TEST_SUMMARY_FILE TEST_FULL_SUMMARY_FILE TEST_ROOT_FULL_SUMMARY_FILE TEST_SELINUX_FULL_SUMMARY_FILE TEST_SELINUX_ROOT_FULL_SUMMARY_FILE AGGREGATED_SUMMARY_FILE
     - name: Checkout code (uutil)
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         path: '${{ steps.vars.outputs.path_UUTILS }}'
+        persist-credentials: false
     - uses: dtolnay/rust-toolchain@master
       with:
         toolchain: stable
@@ -66,14 +81,62 @@ jobs:
       with:
         workspaces: "./${{ steps.vars.outputs.path_UUTILS }} -> target"
     - name: Checkout code (GNU coreutils)
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         repository: 'coreutils/coreutils'
         path: '${{ steps.vars.outputs.path_GNU }}'
         ref: ${{ steps.vars.outputs.repo_GNU_ref }}
-        submodules: recursive
+        submodules: false
+        persist-credentials: false
+
+    - name: Selinux - Setup Lima
+      uses: lima-vm/lima-actions/setup@v1
+      id: lima-actions-setup
+
+    - name: Selinux - Cache ~/.cache/lima
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/lima
+        key: lima-${{ steps.lima-actions-setup.outputs.version }}
+
+    - name: Selinux - Start Fedora VM with SELinux
+      run: limactl start --plain --name=default --cpus=4 --disk=40 --memory=8 --network=lima:user-v2 template://fedora
+
+    - name: Selinux - Setup SSH
+      uses: lima-vm/lima-actions/ssh@v1
+
+    - name: Selinux - Verify SELinux Status and Configuration
+      run: |
+        lima getenforce
+        lima ls -laZ /etc/selinux
+        lima sudo sestatus
+
+        # Ensure we're running in enforcing mode
+        lima sudo setenforce 1
+        lima getenforce
+
+        # Create test files with SELinux contexts for testing
+        lima sudo mkdir -p /var/test_selinux
+        lima sudo touch /var/test_selinux/test_file
+        lima sudo chcon -t etc_t /var/test_selinux/test_file
+        lima ls -Z /var/test_selinux/test_file  # Verify context
+
+    - name: Selinux - Install dependencies in VM
+      run: |
+        lima sudo dnf -y update
+        lima sudo dnf -y install git autoconf autopoint bison texinfo gperf gcc g++ gdb jq libacl-devel libattr-devel libcap-devel libselinux-devel attr rustup clang-devel texinfo-tex wget automake patch quilt
+        lima rustup-init -y --default-toolchain stable
+
+    - name: Override submodule URL and initialize submodules
+      # Use github instead of upstream git server
+      run: |
+        git submodule sync --recursive
+        git config submodule.gnulib.url https://github.com/coreutils/gnulib.git
+        git submodule update --init --recursive --depth 1
+      working-directory: ${{ steps.vars.outputs.path_GNU }}
+
     - name: Retrieve reference artifacts
-      uses: dawidd6/action-download-artifact@v2
+      uses: dawidd6/action-download-artifact@v9
       # ref: <https://github.com/dawidd6/action-download-artifact>
       continue-on-error: true ## don't break the build for missing reference artifacts (may be expired or just not generated yet)
       with:
@@ -87,7 +150,7 @@ jobs:
       run: |
         ## Install dependencies
         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
+        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 libselinux1-dev attr quilt
     - name: Add various locales
       shell: bash
       run: |
@@ -99,6 +162,7 @@ jobs:
         sudo locale-gen
         sudo locale-gen --keep-existing fr_FR
         sudo locale-gen --keep-existing fr_FR.UTF-8
+        sudo locale-gen --keep-existing es_ES.UTF-8
         sudo locale-gen --keep-existing sv_SE
         sudo locale-gen --keep-existing sv_SE.UTF-8
         sudo locale-gen --keep-existing en_US
@@ -107,12 +171,68 @@ jobs:
         sudo update-locale
         echo "After:"
         locale -a
+
+    - name: Selinux - Copy the sources to VM
+      run: |
+        rsync -a -e ssh . lima-default:~/work/
+
     - name: Build binaries
       shell: bash
       run: |
         ## Build binaries
         cd '${{ steps.vars.outputs.path_UUTILS }}'
-        bash util/build-gnu.sh
+        bash util/build-gnu.sh --release-build
+
+    - name: Selinux - Generate selinux tests list
+      run: |
+        # Find and list all tests that require SELinux
+        lima bash -c "cd ~/work/gnu/ && grep -l 'require_selinux_' -r tests/ > ~/work/uutils/selinux-tests.txt"
+        lima bash -c "cd ~/work/uutils/ && cat selinux-tests.txt"
+
+        # Count the tests
+        lima bash -c "cd ~/work/uutils/ && echo 'Found SELinux tests:'; wc -l selinux-tests.txt"
+
+    - name: Selinux - Build for selinux tests
+      run: |
+        lima bash -c "cd ~/work/uutils/ && bash util/build-gnu.sh"
+        lima bash -c "mkdir -p ~/work/gnu/tests-selinux/"
+
+    - name: Selinux - Run selinux tests
+      run: |
+        lima sudo setenforce 1
+        lima getenforce
+        lima cat /proc/filesystems
+        lima bash -c "cd ~/work/uutils/ && bash util/run-gnu-test.sh \$(cat selinux-tests.txt)"
+
+    - name: Selinux - Extract testing info from individual logs into JSON
+      shell: bash
+      run : |
+        lima bash -c "cd ~/work/gnu/ && python3 ../uutils/util/gnu-json-result.py tests > ~/work/gnu/tests-selinux/${{ steps.vars.outputs.TEST_SELINUX_FULL_SUMMARY_FILE }}"
+
+    - name: Selinux/root - Run selinux tests
+      run: |
+        lima bash -c "cd ~/work/uutils/ && CI=1 bash util/run-gnu-test.sh run-root \$(cat selinux-tests.txt)"
+
+    - name: Selinux/root - Extract testing info from individual logs into JSON
+      shell: bash
+      run : |
+        lima bash -c "cd ~/work/gnu/ && python3 ../uutils/util/gnu-json-result.py tests > ~/work/gnu/tests-selinux/${{ steps.vars.outputs.TEST_SELINUX_ROOT_FULL_SUMMARY_FILE }}"
+
+    - name: Selinux - Collect test logs and test results
+      run: |
+        mkdir -p ${{ steps.vars.outputs.path_GNU_tests }}-selinux
+
+        # Copy the test logs from the Lima VM to the host
+        lima bash -c "cp ~/work/gnu/tests/test-suite.log ~/work/gnu/tests-selinux/ || echo 'No test-suite.log found'"
+        lima bash -c "cp ~/work/gnu/tests/test-suite-root.log ~/work/gnu/tests-selinux/ || echo 'No test-suite-root.log found'"
+        rsync -v -a -e ssh lima-default:~/work/gnu/tests-selinux/ ./${{ steps.vars.outputs.path_GNU_tests }}-selinux/
+
+        # Copy SELinux logs to the main test directory for integrated processing
+        cp -f ${{ steps.vars.outputs.path_GNU_tests }}-selinux/test-suite.log ${{ steps.vars.outputs.path_GNU_tests }}/selinux-test-suite.log
+        cp -f ${{ steps.vars.outputs.path_GNU_tests }}-selinux/test-suite-root.log ${{ steps.vars.outputs.path_GNU_tests }}/selinux-test-suite-root.log
+        cp -f ${{ steps.vars.outputs.path_GNU_tests }}-selinux/${{ steps.vars.outputs.TEST_SELINUX_FULL_SUMMARY_FILE }} .
+        cp -f ${{ steps.vars.outputs.path_GNU_tests }}-selinux/${{ steps.vars.outputs.TEST_SELINUX_ROOT_FULL_SUMMARY_FILE }} .
+
     - name: Run GNU tests
       shell: bash
       run: |
@@ -120,6 +240,13 @@ jobs:
         path_GNU='${{ steps.vars.outputs.path_GNU }}'
         path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
         bash "${path_UUTILS}/util/run-gnu-test.sh"
+
+    - name: Extract testing info from individual logs into JSON
+      shell: bash
+      run : |
+        path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
+        python ${path_UUTILS}/util/gnu-json-result.py ${{ steps.vars.outputs.path_GNU_tests }} > ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
+
     - name: Run GNU root tests
       shell: bash
       run: |
@@ -127,35 +254,40 @@ jobs:
         path_GNU='${{ steps.vars.outputs.path_GNU }}'
         path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
         bash "${path_UUTILS}/util/run-gnu-test.sh" run-root
-    - name: Extract testing info into JSON
+
+    - name: Extract testing info from individual logs (run as root) into JSON
       shell: bash
       run : |
-        ## Extract testing info into JSON
         path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
-        python ${path_UUTILS}/util/gnu-json-result.py ${{ steps.vars.outputs.path_GNU_tests }} > ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
+        python ${path_UUTILS}/util/gnu-json-result.py ${{ steps.vars.outputs.path_GNU_tests }} > ${{ steps.vars.outputs.TEST_ROOT_FULL_SUMMARY_FILE }}
+
     - name: Extract/summarize testing info
       id: summary
       shell: bash
       run: |
         ## Extract/summarize testing info
         outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
-        #
+
         path_UUTILS='${{ steps.vars.outputs.path_UUTILS }}'
-        #
-        SUITE_LOG_FILE='${{ steps.vars.outputs.SUITE_LOG_FILE }}'
-        ROOT_SUITE_LOG_FILE='${{ steps.vars.outputs.ROOT_SUITE_LOG_FILE }}'
-        ls -al ${SUITE_LOG_FILE} ${ROOT_SUITE_LOG_FILE}
 
-        if test -f "${SUITE_LOG_FILE}"
+        # Check if the file exists
+        if test -f "${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}"
         then
-            source ${path_UUTILS}/util/analyze-gnu-results.sh ${SUITE_LOG_FILE} ${ROOT_SUITE_LOG_FILE}
+            # Look at all individual results and summarize
+            eval $(python3 ${path_UUTILS}/util/analyze-gnu-results.py -o=${{ steps.vars.outputs.AGGREGATED_SUMMARY_FILE }} ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }} ${{ steps.vars.outputs.TEST_ROOT_FULL_SUMMARY_FILE }} ${{ steps.vars.outputs.TEST_SELINUX_FULL_SUMMARY_FILE }} ${{ steps.vars.outputs.TEST_SELINUX_ROOT_FULL_SUMMARY_FILE }})
+
             if [[ "$TOTAL" -eq 0 || "$TOTAL" -eq 1 ]]; then
-              echo "::error ::Failed to parse test results from '${SUITE_LOG_FILE}'; failing early"
+              echo "::error ::Failed to parse test results from '${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}'; failing early"
               exit 1
             fi
+
             output="GNU tests summary = TOTAL: $TOTAL / PASS: $PASS / FAIL: $FAIL / ERROR: $ERROR / SKIP: $SKIP"
             echo "${output}"
-            if [[ "$FAIL" -gt 0 || "$ERROR" -gt 0 ]]; then echo "::warning ::${output}" ; fi
+
+            if [[ "$FAIL" -gt 0 || "$ERROR" -gt 0 ]]; then
+              echo "::warning ::${output}"
+            fi
+
             jq -n \
                   --arg date "$(date --rfc-email)" \
                   --arg sha "$GITHUB_SHA" \
@@ -169,122 +301,101 @@ jobs:
             HASH=$(sha1sum '${{ steps.vars.outputs.TEST_SUMMARY_FILE }}' | cut --delim=" " -f 1)
             outputs HASH
           else
-            echo "::error ::Failed to find summary of test results (missing '${SUITE_LOG_FILE}'); failing early"
+            echo "::error ::Failed to find summary of test results (missing '${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}'); failing early"
             exit 1
           fi
+
           # Compress logs before upload (fails otherwise)
           gzip ${{ steps.vars.outputs.TEST_LOGS_GLOB }}
     - name: Reserve SHA1/ID of 'test-summary'
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "${{ steps.summary.outputs.HASH }}"
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test results summary
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: test-summary
         path: "${{ steps.vars.outputs.TEST_SUMMARY_FILE }}"
     - name: Reserve test logs
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: test-logs
         path: "${{ steps.vars.outputs.TEST_LOGS_GLOB }}"
     - name: Upload full json results
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
-        name: gnu-full-result.json
+        name: gnu-full-result
         path: ${{ steps.vars.outputs.TEST_FULL_SUMMARY_FILE }}
+    - name: Upload root json results
+      uses: actions/upload-artifact@v4
+      with:
+        name: gnu-root-full-result
+        path: ${{ steps.vars.outputs.TEST_ROOT_FULL_SUMMARY_FILE }}
+    - name: Upload selinux json results
+      uses: actions/upload-artifact@v4
+      with:
+        name: selinux-gnu-full-result
+        path: ${{ steps.vars.outputs.TEST_SELINUX_FULL_SUMMARY_FILE }}
+    - name: Upload selinux root json results
+      uses: actions/upload-artifact@v4
+      with:
+        name: selinux-root-gnu-full-result.json
+        path: ${{ steps.vars.outputs.TEST_SELINUX_ROOT_FULL_SUMMARY_FILE }}
+    - name: Upload aggregated json results
+      uses: actions/upload-artifact@v4
+      with:
+        name: aggregated-result
+        path: ${{ steps.vars.outputs.AGGREGATED_SUMMARY_FILE }}
     - name: Compare test failures VS reference
       shell: bash
       run: |
-        ## Compare test failures VS reference
-        have_new_failures=""
-        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'
+        ## Compare test failures VS reference using JSON files
+        REF_SUMMARY_FILE='${{ steps.vars.outputs.path_reference }}/aggregated-result/aggregated-result.json'
+        CURRENT_SUMMARY_FILE='${{ steps.vars.outputs.AGGREGATED_SUMMARY_FILE }}'
         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="${path_UUTILS}/.github/workflows/ignore-intermittent.txt"
 
-        mkdir -p ${{ steps.vars.outputs.path_reference }}
+        # Path to ignore file for intermittent issues
+        IGNORE_INTERMITTENT="${path_UUTILS}/.github/workflows/ignore-intermittent.txt"
 
+        # Set up comment directory
         COMMENT_DIR="${{ steps.vars.outputs.path_reference }}/comment"
         mkdir -p ${COMMENT_DIR}
         echo ${{ github.event.number }} > ${COMMENT_DIR}/NR
         COMMENT_LOG="${COMMENT_DIR}/result.txt"
 
-        # The comment log might be downloaded from a previous run
-        # We only want the new changes, so remove it if it exists.
-        rm -f ${COMMENT_LOG}
-        touch ${COMMENT_LOG}
+        COMPARISON_RESULT=0
+        if test -f "${CURRENT_SUMMARY_FILE}"; then
+          if test -f "${REF_SUMMARY_FILE}"; then
+            echo "Reference summary SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
+            echo "Current summary SHA1/ID: $(sha1sum -- "${CURRENT_SUMMARY_FILE}")"
 
-        if test -f "${REF_LOG_FILE}"; then
-          echo "Reference SHA1/ID: $(sha1sum -- "${REF_SUMMARY_FILE}")"
-          REF_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" "${REF_LOG_FILE}" | sort)
-          NEW_ERROR=$(sed -n "s/^ERROR: \([[:print:]]\+\).*/\1/p" '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' | sort)
-          REF_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" "${REF_LOG_FILE}" | sort)
-          NEW_FAILING=$(sed -n "s/^FAIL: \([[:print:]]\+\).*/\1/p" '${{ steps.vars.outputs.path_GNU_tests }}/test-suite.log' | sort)
-          for LINE in ${REF_FAILING}
-          do
-            if ! grep -Fxq ${LINE}<<<"${NEW_FAILING}"; then
-              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}
-          do
-            if ! grep -Fxq ${LINE}<<<"${REF_FAILING}"
-            then
-              if ! grep ${LINE} ${IGNORE_INTERMITTENT}
-              then
-                MSG="GNU test failed: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
-                echo "::error ::$MSG"
-                echo $MSG >> ${COMMENT_LOG}
-                have_new_failures="true"
-              else
-                MSG="Skip an intermittent issue ${LINE}"
-                echo "::warning ::$MSG"
-                echo $MSG >> ${COMMENT_LOG}
-                echo ""
-              fi
-            fi
-          done
-          for LINE in ${REF_ERROR}
-          do
-            if ! grep -Fxq ${LINE}<<<"${NEW_ERROR}"; then
-              MSG="Congrats! The gnu test ${LINE} is no longer ERROR!"
-              echo "::warning ::$MSG"
-              echo $MSG >> ${COMMENT_LOG}
-            fi
-          done
-          for LINE in ${NEW_ERROR}
-          do
-            if ! grep -Fxq ${LINE}<<<"${REF_ERROR}"
-            then
-              MSG="GNU test error: ${LINE}. ${LINE} is passing on '${{ steps.vars.outputs.repo_default_branch }}'. Maybe you have to rebase?"
-              echo "::error ::$MSG"
-              echo $MSG >> ${COMMENT_LOG}
-              have_new_failures="true"
-            fi
-          done
+            python3 ${path_UUTILS}/util/compare_test_results.py \
+              --ignore-file "${IGNORE_INTERMITTENT}" \
+              --output "${COMMENT_LOG}" \
+              "${CURRENT_SUMMARY_FILE}" "${REF_SUMMARY_FILE}"
 
+            COMPARISON_RESULT=$?
+          else
+            echo "::warning ::Skipping test comparison; no prior reference summary is available at '${REF_SUMMARY_FILE}'."
+          fi
         else
-          echo "::warning ::Skipping test failure comparison; no prior reference test logs are available."
+          echo "::error ::Failed to find summary of test results (missing '${CURRENT_SUMMARY_FILE}'); failing early"
+          exit 1
+        fi
+
+        if [ ${COMPARISON_RESULT} -eq 1 ]; then
+          echo "ONLY_INTERMITTENT=false" >> $GITHUB_ENV
+          echo "::error ::Found new non-intermittent test failures"
+          exit 1
+        else
+          echo "ONLY_INTERMITTENT=true" >> $GITHUB_ENV
+          echo "::notice ::No new test failures detected"
         fi
-        if test -n "${have_new_failures}" ; then exit -1 ; fi
     - name: Upload comparison log (for GnuComment workflow)
       if: success() || failure() # run regardless of prior step success/failure
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: comment
         path: ${{ steps.vars.outputs.path_reference }}/comment/
@@ -301,76 +412,3 @@ jobs:
         else
           echo "::warning ::Skipping test summary comparison; no prior reference summary is available."
         fi
-
-  gnu_coverage:
-    name: Run GNU tests with coverage
-    runs-on: ubuntu-20.04
-    steps:
-    - name: Checkout code uutil
-      uses: actions/checkout@v3
-      with:
-        path: 'uutils'
-    - name: Checkout GNU coreutils
-      uses: actions/checkout@v3
-      with:
-        repository: 'coreutils/coreutils'
-        path: 'gnu'
-        ref: 'v9.4'
-        submodules: recursive
-    - 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-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
-        echo "Before:"
-        locale -a
-        ## Some tests fail with 'cannot change locale (en_US.ISO-8859-1): No such file or directory'
-        ## Some others need a French locale
-        sudo locale-gen
-        sudo locale-gen --keep-existing fr_FR
-        sudo locale-gen --keep-existing fr_FR.UTF-8
-        sudo update-locale
-        echo "After:"
-        locale -a
-    - name: Build binaries
-      env:
-        RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
-        RUSTDOCFLAGS: "-Cpanic=abort"
-      run: |
-        ## Build binaries
-        cd uutils
-        UU_MAKE_PROFILE=debug bash util/build-gnu.sh
-    - name: Run GNU tests
-      run: bash uutils/util/run-gnu-test.sh
-    - name: Generate coverage data (via `grcov`)
-      id: coverage
-      run: |
-        ## Generate coverage data
-        cd uutils
-        COVERAGE_REPORT_DIR="target/debug"
-        COVERAGE_REPORT_FILE="${COVERAGE_REPORT_DIR}/lcov.info"
-        mkdir -p "${COVERAGE_REPORT_DIR}"
-        sudo chown -R "$(whoami)" "${COVERAGE_REPORT_DIR}"
-        # display coverage files
-        grcov . --output-type files --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()" | sort --unique
-        # generate coverage report
-        grcov . --output-type lcov --output-path "${COVERAGE_REPORT_FILE}" --branch --ignore build.rs --ignore "vendor/*" --ignore "/*" --ignore "[a-zA-Z]:/*" --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
-        echo "report=${COVERAGE_REPORT_FILE}" >> $GITHUB_OUTPUT
-    - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v3
-      with:
-        file: ${{ steps.coverage.outputs.report }}
-        flags: gnutests
-        name: gnutests
-        working-directory: uutils
diff --git a/.github/workflows/android.yml b/.github/workflows/android.yml
index a6929b171cc..4f8edea3085 100644
--- a/.github/workflows/android.yml
+++ b/.github/workflows/android.yml
@@ -1,8 +1,15 @@
 name: Android
 
-# spell-checker:ignore TERMUX reactivecircus Swatinem  noaudio pkill swiftshader dtolnay juliangruber
+# spell-checker:ignore (people) reactivecircus Swatinem dtolnay juliangruber
+# spell-checker:ignore (shell/tools) TERMUX nextest udevadm pkill
+# spell-checker:ignore (misc) swiftshader playstore DATALOSS noaudio
+
+on:
+  pull_request:
+  push:
+    branches:
+      - '*'
 
-on: [push, pull_request]
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -12,78 +19,160 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
 
+env:
+  TERMUX: v0.118.0
+  KEY_POSTFIX: nextest+rustc-hash+adb+sshd+upgrade+XGB+inc18
+  COMMON_EMULATOR_OPTIONS: -no-window -noaudio -no-boot-anim -camera-back none -gpu swiftshader_indirect -metrics-collection
+  EMULATOR_DISK_SIZE: 12GB
+  EMULATOR_HEAP_SIZE: 2048M
+  EMULATOR_BOOT_TIMEOUT: 1200 # 20min
+
 jobs:
   test_android:
     name: Test builds
-    runs-on: macos-latest
     timeout-minutes: 90
     strategy:
       fail-fast: false
       matrix:
+        os: [ubuntu-latest] # , macos-latest
+        cores: [4] # , 6
+        ram: [4096, 8192]
         api-level: [28]
-        target: [default]
-        arch: [x86] # , arm64-v8a
+        target: [google_apis_playstore]
+        arch: [x86, x86_64] # , arm64-v8a
+        exclude:
+          - ram: 8192
+            arch: x86
+          - ram: 4096
+            arch: x86_64
+    runs-on: ${{ matrix.os }}
     env:
-      TERMUX: v0.118.0
+      EMULATOR_RAM_SIZE: ${{ matrix.ram }}
+      EMULATOR_CORES: ${{ matrix.cores }}
+      RUNNER_OS: ${{ matrix.os }}
+      AVD_CACHE_KEY: "set later due to limitations of github actions not able to concatenate env variables"
     steps:
-    - uses: actions/checkout@v3
+    - name: Concatenate values to environment file
+      run: |
+        echo "AVD_CACHE_KEY=${{ matrix.os }}-${{ matrix.cores }}-${{ matrix.ram }}-${{ matrix.api-level }}-${{ matrix.target }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}+${{ env.KEY_POSTFIX }}" >> $GITHUB_ENV
+    - name: Collect information about runner
+      if: always()
+      continue-on-error: true
+      run: |
+        hostname
+        uname -a
+        free -mh
+        df -Th
+        cat /proc/cpuinfo
+    - name: (Linux) create links from home to data partition
+      if: ${{ runner.os == 'Linux' }}
+      continue-on-error: true
+      run: |
+        ls -lah /mnt/
+        cat /mnt/DATALOSS_WARNING_README.txt
+        sudo mkdir /mnt/data
+        sudo chmod a+rwx /mnt/data
+        mkdir /mnt/data/.android && ln -s /mnt/data/.android ~/.android
+        mkdir /mnt/data/work && ln -s /mnt/data/work ~/work
+    - name: Enable KVM group perms (linux hardware acceleration)
+      if: ${{ runner.os == 'Linux' }}
+      run: |
+        echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+        sudo udevadm control --reload-rules
+        sudo udevadm trigger --name-match=kvm
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Collect information about runner
+      if: always()
+      continue-on-error: true
+      run: |
+        free -mh
+        df -Th
     - name: Restore AVD cache
-      uses: actions/cache/restore@v3
+      uses: actions/cache/restore@v4
       id: avd-cache
+      continue-on-error: true
       with:
         path: |
           ~/.android/avd/*
           ~/.android/avd/*/snapshots/*
           ~/.android/adb*
           ~/__rustc_hash__
-        key: avd-${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}+nextest+rustc-hash
+        key: avd-${{ env.AVD_CACHE_KEY }}
+    - name: Collect information about runner after AVD cache
+      if: always()
+      continue-on-error: true
+      run: |
+        free -mh
+        df -Th
+        ls -lah /mnt/data
+        du -sch /mnt/data
+    - name: Delete AVD Lockfile when run from cache
+      if: steps.avd-cache.outputs.cache-hit == 'true'
+      run: |
+        rm -f \
+          ~/.android/avd/*.avd/*.lock \
+          ~/.android/avd/*/*.lock
     - name: Create and cache emulator image
       if: steps.avd-cache.outputs.cache-hit != 'true'
-      uses: reactivecircus/android-emulator-runner@v2
+      uses: reactivecircus/android-emulator-runner@v2.34.0
       with:
         api-level: ${{ matrix.api-level }}
         target: ${{ matrix.target }}
         arch: ${{ matrix.arch }}
-        ram-size: 2048M
-        disk-size: 7GB
+        ram-size: ${{ env.EMULATOR_RAM_SIZE }}
+        heap-size: ${{ env.EMULATOR_HEAP_SIZE }}
+        disk-size: ${{ env.EMULATOR_DISK_SIZE }}
+        cores: ${{ env.EMULATOR_CORES }}
         force-avd-creation: true
-        emulator-options: -no-snapshot-load -noaudio -no-boot-anim -camera-back none
+        emulator-options: ${{ env.COMMON_EMULATOR_OPTIONS }} -no-snapshot-load
+        emulator-boot-timeout: ${{ env.EMULATOR_BOOT_TIMEOUT }}
         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
+      uses: actions/cache/save@v4
       with:
         path: |
           ~/.android/avd/*
           ~/.android/avd/*/snapshots/*
           ~/.android/adb*
           ~/__rustc_hash__
-        key: avd-${{ matrix.api-level }}-${{ matrix.arch }}+termux-${{ env.TERMUX }}+nextest+rustc-hash
+        key: avd-${{ env.AVD_CACHE_KEY }}
     - uses: juliangruber/read-file-action@v1
       id: read_rustc_hash
       with:
         # ~ expansion didn't work
-        path: /Users/runner/__rustc_hash__
+        path: ${{ runner.os == 'Linux' && '/home/runner/__rustc_hash__' || '/Users/runner/__rustc_hash__' }}
         trim: true
     - name: Restore rust cache
       id: rust-cache
-      uses: actions/cache/restore@v3
+      uses: actions/cache/restore@v4
       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: Collect information about runner resources
+      if: always()
+      continue-on-error: true
+      run: |
+        free -mh
+        df -Th
     - name: Build and Test
-      uses: reactivecircus/android-emulator-runner@v2
+      uses: reactivecircus/android-emulator-runner@v2.34.0
       with:
         api-level: ${{ matrix.api-level }}
         target: ${{ matrix.target }}
         arch: ${{ matrix.arch }}
-        ram-size: 2048M
-        disk-size: 7GB
+        ram-size: ${{ env.EMULATOR_RAM_SIZE }}
+        heap-size: ${{ env.EMULATOR_HEAP_SIZE }}
+        disk-size: ${{ env.EMULATOR_DISK_SIZE }}
+        cores: ${{ env.EMULATOR_CORES }}
         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 }}
+        emulator-options: ${{ env.COMMON_EMULATOR_OPTIONS }} -no-snapshot-save -snapshot ${{ env.AVD_CACHE_KEY }}
+        emulator-boot-timeout: ${{ env.EMULATOR_BOOT_TIMEOUT }}
         # 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.
@@ -91,10 +180,28 @@ jobs:
           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
+          if [ "${{ steps.rust-cache.outputs.cache-hit }}" != 'true' ]; then util/android-commands.sh sync_image; fi; exit 0
+    - name: Collect information about runner resources
+      if: always()
+      continue-on-error: true
+      run: |
+        free -mh
+        df -Th
     - name: Save rust cache
       if: steps.rust-cache.outputs.cache-hit != 'true'
-      uses: actions/cache/save@v3
+      uses: actions/cache/save@v4
       with:
         path: ~/__rust_cache__
         key: ${{ matrix.arch }}_${{ matrix.target}}_${{ steps.read_rustc_hash.outputs.content }}_${{ hashFiles('**/Cargo.toml', '**/Cargo.lock') }}_v3
+    - name: archive any output (error screenshots)
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test_output_${{ env.AVD_CACHE_KEY }}
+        path: output
+    - name: Collect information about runner resources
+      if: always()
+      continue-on-error: true
+      run: |
+        free -mh
+        df -Th
diff --git a/.github/workflows/code-quality.yml b/.github/workflows/code-quality.yml
new file mode 100644
index 00000000000..a5bbf42af4d
--- /dev/null
+++ b/.github/workflows/code-quality.yml
@@ -0,0 +1,218 @@
+name: Code Quality
+
+# spell-checker:ignore (people) reactivecircus Swatinem dtolnay juliangruber pell taplo
+# spell-checker:ignore (misc) TERMUX noaudio pkill swiftshader esac sccache pcoreutils shopt subshell dequote
+
+on:
+  pull_request:
+  push:
+    branches:
+      - '*'
+
+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
+
+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_format:
+    name: Style/format
+    runs-on: ${{ matrix.job.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: ubuntu-latest , features: feat_os_unix }
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: stable
+        components: rustfmt
+    - uses: Swatinem/rust-cache@v2
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case "$STYLE_FAIL_ON_FAULT" in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
+    - name: "`cargo fmt` testing"
+      shell: bash
+      run: |
+        ## `cargo fmt` testing
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        # * 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 ; }
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+    - name: "cargo fmt on fuzz dir"
+      shell: bash
+      run: |
+        cd fuzz
+        cargo fmt --check
+
+  style_lint:
+    name: Style/lint
+    runs-on: ${{ matrix.job.os }}
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
+    strategy:
+      fail-fast: false
+      matrix:
+        job:
+          - { os: ubuntu-latest  , features: all             , workspace: true }
+          - { os: macos-latest   , features: feat_os_macos }
+          - { os: windows-latest , features: feat_os_windows }
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - 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.9
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case "$STYLE_FAIL_ON_FAULT" in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        ## Install/setup prerequisites
+        case '${{ matrix.job.os }}' in
+          ubuntu-*)
+            # selinux headers needed to enable all features
+            sudo apt-get -y install libselinux1-dev
+          ;;
+        esac
+    - name: "`cargo clippy` lint testing"
+      uses: nick-fields/retry@v3
+      with:
+        max_attempts: 3
+        retry_on: error
+        timeout_minutes: 90
+        shell: bash
+        command: |
+          ## `cargo clippy` lint testing
+          unset fault
+          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>
+          if [[ "${{ matrix.job.features }}" == "all" ]]; then
+            extra="--all-features"
+          else
+            extra="--features ${{ matrix.job.features }}"
+          fi
+          case '${{ matrix.job.workspace-tests }}' in
+          1|t|true|y|yes)
+            extra="${extra} --workspace"
+            ;;
+          esac
+          S=$(cargo clippy --all-targets $extra --tests -pcoreutils -- -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 }}
+    strategy:
+      matrix:
+        job:
+          - { os: ubuntu-latest , features: feat_os_unix }
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        ## VARs setup
+        outputs() { step_id="${{ github.action }}"; for var in "$@" ; do echo steps.${step_id}.outputs.${var}="${!var}"; echo "${var}=${!var}" >> $GITHUB_OUTPUT; done; }
+        # failure mode
+        unset FAIL_ON_FAULT ; case "$STYLE_FAIL_ON_FAULT" in
+          ''|0|f|false|n|no|off) FAULT_TYPE=warning ;;
+          *) FAIL_ON_FAULT=true ; FAULT_TYPE=error ;;
+        esac;
+        outputs FAIL_ON_FAULT FAULT_TYPE
+    - name: Install/setup prerequisites
+      shell: bash
+      run: |
+        sudo apt-get -y update ; sudo apt-get -y install npm ; sudo npm install cspell -g ;
+    - name: Run `cspell`
+      shell: bash
+      run: |
+        ## Run `cspell`
+        unset fault
+        fault_type="${{ steps.vars.outputs.FAULT_TYPE }}"
+        fault_prefix=$(echo "$fault_type" | tr '[:lower:]' '[:upper:]')
+        # * find cspell configuration ; note: avoid quotes around ${cfg_file} b/c `cspell` (v4) doesn't correctly dequote the config argument (or perhaps a subshell expansion issue?)
+        cfg_files=($(shopt -s nullglob ; echo {.vscode,.}/{,.}c[sS]pell{.json,.config{.js,.cjs,.json,.yaml,.yml},.yaml,.yml} ;))
+        cfg_file=${cfg_files[0]}
+        unset CSPELL_CFG_OPTION ; if [ -n "$cfg_file" ]; then CSPELL_CFG_OPTION="--config $cfg_file" ; fi
+        S=$(cspell ${CSPELL_CFG_OPTION} --no-summary --no-progress .) && printf "%s\n" "$S" || { printf "%s\n" "$S" ; printf "%s" "$S" | sed -E -n "s/${PWD//\//\\/}\/(.*):(.*):(.*) - (.*)/::${fault_type} file=\1,line=\2,col=\3::${fault_type^^}: \4 (file:'\1', line:\2)/p" ; fault=true ; true ; }
+        if [ -n "${{ steps.vars.outputs.FAIL_ON_FAULT }}" ] && [ -n "$fault" ]; then exit 1 ; fi
+
+  toml_format:
+    name: Style/toml
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Check
+        run: npx --yes @taplo/cli fmt --check
+
+  python:
+    name: Style/Python
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ruff
+        uses: astral-sh/ruff-action@v3
+        with:
+          src: "./util"
+
+      - name: ruff - format
+        uses: astral-sh/ruff-action@v3
+        with:
+          src: "./util"
+          args: format --check
+      - name: Run Python unit tests
+        shell: bash
+        run: |
+          python3 -m unittest util/test_compare_test_results.py
diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
index 095ec323098..6ba684719ed 100644
--- a/.github/workflows/freebsd.yml
+++ b/.github/workflows/freebsd.yml
@@ -1,12 +1,16 @@
 name: FreeBSD
 
-# spell-checker:ignore sshfs usesh vmactions taiki Swatinem esac fdescfs fdesc
+# spell-checker:ignore sshfs usesh vmactions taiki Swatinem esac fdescfs fdesc sccache nextest copyback
 
 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]
+on:
+  pull_request:
+  push:
+    branches:
+      - '*'
 
 permissions:
   contents: read # to fetch code (actions/checkout)
@@ -20,26 +24,30 @@ jobs:
   style:
     name: Style and Lint
     runs-on: ${{ matrix.job.os }}
-    timeout-minutes: 90
+    timeout-minutes: 45
     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>
+          - { os: ubuntu-24.04 , features: unix }
     env:
       SCCACHE_GHA_ENABLED: "true"
       RUSTC_WRAPPER: "sccache"
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: Swatinem/rust-cache@v2
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Prepare, build and test
-      uses: vmactions/freebsd-vm@v0.3.1
+      uses: vmactions/freebsd-vm@v1.2.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
+        sync: rsync
+        copyback: false
+        # We need jq and GNU coreutils to run show-utils.sh and bash to use inline shell string replacement
+        prepare: pkg install -y curl sudo jq coreutils bash
         run: |
           ## Prepare, build, and test
           # implementation modelled after ref: <https://github.com/rust-lang/rustup/pull/2783>
@@ -48,11 +56,11 @@ jobs:
           #
           TEST_USER=tester
           REPO_NAME=${GITHUB_WORKSPACE##*/}
-          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
+          WORKSPACE_PARENT="/home/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}"/
+          chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
           whoami
           #
           # Further work needs to be done in a sudo as we are changing users
@@ -99,7 +107,7 @@ jobs:
           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 ; }
+            S=\$(cargo clippy --all-targets \${CARGO_UTILITY_LIST_OPTIONS} -- -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
@@ -109,26 +117,29 @@ jobs:
   test:
     name: Tests
     runs-on: ${{ matrix.job.os }}
-    timeout-minutes: 90
+    timeout-minutes: 45
     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>
+          - { os: ubuntu-24.04 , features: unix }
     env:
       mem: 4096
       SCCACHE_GHA_ENABLED: "true"
       RUSTC_WRAPPER: "sccache"
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
     - uses: Swatinem/rust-cache@v2
     - name: Run sccache-cache
-      uses: mozilla-actions/sccache-action@v0.0.3
+      uses: mozilla-actions/sccache-action@v0.0.9
     - name: Prepare, build and test
-      uses: vmactions/freebsd-vm@v0.3.1
+      uses: vmactions/freebsd-vm@v1.2.0
       with:
         usesh: true
-        # sync: sshfs
+        sync: rsync
+        copyback: false
         prepare: pkg install -y curl gmake sudo
         run: |
           ## Prepare, build, and test
@@ -141,12 +152,12 @@ jobs:
           #
           TEST_USER=tester
           REPO_NAME=${GITHUB_WORKSPACE##*/}
-          WORKSPACE_PARENT="/Users/runner/work/${REPO_NAME}"
+          WORKSPACE_PARENT="/home/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}"/
+          chown -R ${TEST_USER}:wheel /root/ "${WORKSPACE_PARENT}"/
           whoami
           #
           # Further work needs to be done in a sudo as we are changing users
diff --git a/.github/workflows/fuzzing.yml b/.github/workflows/fuzzing.yml
new file mode 100644
index 00000000000..e7da4b5926d
--- /dev/null
+++ b/.github/workflows/fuzzing.yml
@@ -0,0 +1,281 @@
+name: Fuzzing
+
+# spell-checker:ignore fuzzer dtolnay Swatinem
+
+on:
+  pull_request:
+  push:
+    branches:
+      - '*'
+
+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:
+  fuzz-build:
+    name: Build the fuzzers
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@nightly
+    - name: Install `cargo-fuzz`
+      run: cargo install cargo-fuzz
+    - uses: Swatinem/rust-cache@v2
+      with:
+        shared-key: "cargo-fuzz-cache-key"
+        cache-directories: "fuzz/target"
+    - name: Run `cargo-fuzz build`
+      run: cargo +nightly fuzz build
+
+  fuzz-run:
+    needs: fuzz-build
+    name: Fuzz
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    env:
+      RUN_FOR: 60
+    strategy:
+      matrix:
+        test-target:
+          - { name: fuzz_test, should_pass: true }
+          # https://github.com/uutils/coreutils/issues/5311
+          - { name: fuzz_date, should_pass: false }
+          - { name: fuzz_expr, should_pass: true }
+          - { name: fuzz_printf, should_pass: true }
+          - { name: fuzz_echo, should_pass: true }
+          - { name: fuzz_seq, should_pass: false }
+          - { name: fuzz_sort, should_pass: false }
+          - { name: fuzz_wc, should_pass: false }
+          - { name: fuzz_cut, should_pass: false }
+          - { name: fuzz_split, should_pass: false }
+          - { name: fuzz_tr, should_pass: false }
+          - { name: fuzz_env, should_pass: false }
+          - { name: fuzz_cksum, should_pass: false }
+          - { name: fuzz_parse_glob, should_pass: true }
+          - { name: fuzz_parse_size, should_pass: true }
+          - { name: fuzz_parse_time, should_pass: true }
+          - { name: fuzz_seq_parse_number, should_pass: true }
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: dtolnay/rust-toolchain@nightly
+    - name: Install `cargo-fuzz`
+      run: cargo install cargo-fuzz
+    - uses: Swatinem/rust-cache@v2
+      with:
+        shared-key: "cargo-fuzz-cache-key"
+        cache-directories: "fuzz/target"
+    - name: Restore Cached Corpus
+      uses: actions/cache/restore@v4
+      with:
+        key: corpus-cache-${{ matrix.test-target.name }}
+        path: |
+          fuzz/corpus/${{ matrix.test-target.name }}
+    - name: Run ${{ matrix.test-target.name }} for XX seconds
+      id: run_fuzzer
+      shell: bash
+      continue-on-error: ${{ !matrix.test-target.name.should_pass }}
+      run: |
+        mkdir -p fuzz/stats
+        STATS_FILE="fuzz/stats/${{ matrix.test-target.name }}.txt"
+        cargo +nightly fuzz run ${{ matrix.test-target.name }} -- -max_total_time=${{ env.RUN_FOR }} -timeout=${{ env.RUN_FOR }} -detect_leaks=0 -print_final_stats=1 2>&1 | tee "$STATS_FILE"
+
+        # Extract key stats from the output
+        if grep -q "stat::number_of_executed_units" "$STATS_FILE"; then
+          RUNS=$(grep "stat::number_of_executed_units" "$STATS_FILE" | awk '{print $2}')
+          echo "runs=$RUNS" >> "$GITHUB_OUTPUT"
+        else
+          echo "runs=unknown" >> "$GITHUB_OUTPUT"
+        fi
+
+        if grep -q "stat::average_exec_per_sec" "$STATS_FILE"; then
+          EXEC_RATE=$(grep "stat::average_exec_per_sec" "$STATS_FILE" | awk '{print $2}')
+          echo "exec_rate=$EXEC_RATE" >> "$GITHUB_OUTPUT"
+        else
+          echo "exec_rate=unknown" >> "$GITHUB_OUTPUT"
+        fi
+
+        if grep -q "stat::new_units_added" "$STATS_FILE"; then
+          NEW_UNITS=$(grep "stat::new_units_added" "$STATS_FILE" | awk '{print $2}')
+          echo "new_units=$NEW_UNITS" >> "$GITHUB_OUTPUT"
+        else
+          echo "new_units=unknown" >> "$GITHUB_OUTPUT"
+        fi
+
+        # Save should_pass value to file for summary job to use
+        echo "${{ matrix.test-target.should_pass }}" > "fuzz/stats/${{ matrix.test-target.name }}.should_pass"
+
+        # Print stats to job output for immediate visibility
+        echo "----------------------------------------"
+        echo "FUZZING STATISTICS FOR ${{ matrix.test-target.name }}"
+        echo "----------------------------------------"
+        echo "Runs:           $(grep -q "stat::number_of_executed_units" "$STATS_FILE" && grep "stat::number_of_executed_units" "$STATS_FILE" | awk '{print $2}' || echo "unknown")"
+        echo "Execution Rate: $(grep -q "stat::average_exec_per_sec" "$STATS_FILE" && grep "stat::average_exec_per_sec" "$STATS_FILE" | awk '{print $2}' || echo "unknown") execs/sec"
+        echo "New Units:      $(grep -q "stat::new_units_added" "$STATS_FILE" && grep "stat::new_units_added" "$STATS_FILE" | awk '{print $2}' || echo "unknown")"
+        echo "Expected:       ${{ matrix.test-target.name.should_pass }}"
+        if grep -q "SUMMARY: " "$STATS_FILE"; then
+          echo "Status:         $(grep "SUMMARY: " "$STATS_FILE" | head -1)"
+        else
+          echo "Status:         Completed"
+        fi
+        echo "----------------------------------------"
+
+        # Add summary to GitHub step summary
+        echo "### Fuzzing Results for ${{ matrix.test-target.name }}" >> $GITHUB_STEP_SUMMARY
+        echo "" >> $GITHUB_STEP_SUMMARY
+        echo "| Metric | Value |" >> $GITHUB_STEP_SUMMARY
+        echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
+
+        if grep -q "stat::number_of_executed_units" "$STATS_FILE"; then
+          echo "| Runs | $(grep "stat::number_of_executed_units" "$STATS_FILE" | awk '{print $2}') |" >> $GITHUB_STEP_SUMMARY
+        fi
+
+        if grep -q "stat::average_exec_per_sec" "$STATS_FILE"; then
+          echo "| Execution Rate | $(grep "stat::average_exec_per_sec" "$STATS_FILE" | awk '{print $2}') execs/sec |" >> $GITHUB_STEP_SUMMARY
+        fi
+
+        if grep -q "stat::new_units_added" "$STATS_FILE"; then
+          echo "| New Units | $(grep "stat::new_units_added" "$STATS_FILE" | awk '{print $2}') |" >> $GITHUB_STEP_SUMMARY
+        fi
+
+        echo "| Should pass | ${{ matrix.test-target.should_pass }} |" >> $GITHUB_STEP_SUMMARY
+
+        if grep -q "SUMMARY: " "$STATS_FILE"; then
+          echo "| Status | $(grep "SUMMARY: " "$STATS_FILE" | head -1) |" >> $GITHUB_STEP_SUMMARY
+        else
+          echo "| Status | Completed |" >> $GITHUB_STEP_SUMMARY
+        fi
+
+        echo "" >> $GITHUB_STEP_SUMMARY
+    - name: Save Corpus Cache
+      uses: actions/cache/save@v4
+      with:
+        key: corpus-cache-${{ matrix.test-target.name }}
+        path: |
+          fuzz/corpus/${{ matrix.test-target.name }}
+    - name: Upload Stats
+      uses: actions/upload-artifact@v4
+      with:
+        name: fuzz-stats-${{ matrix.test-target.name }}
+        path: |
+          fuzz/stats/${{ matrix.test-target.name }}.txt
+          fuzz/stats/${{ matrix.test-target.name }}.should_pass
+        retention-days: 5
+  fuzz-summary:
+    needs: fuzz-run
+    name: Fuzzing Summary
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Download all stats
+        uses: actions/download-artifact@v4
+        with:
+          path: fuzz/stats-artifacts
+          pattern: fuzz-stats-*
+          merge-multiple: true
+      - name: Prepare stats directory
+        run: |
+          mkdir -p fuzz/stats
+          # Debug: List content of stats-artifacts directory
+          echo "Contents of stats-artifacts directory:"
+          find fuzz/stats-artifacts -type f | sort
+
+          # Extract files from the artifact directories - handle nested directories
+          find fuzz/stats-artifacts -type f -name "*.txt" -exec cp {} fuzz/stats/ \;
+          find fuzz/stats-artifacts -type f -name "*.should_pass" -exec cp {} fuzz/stats/ \;
+
+          # Debug information
+          echo "Contents of stats directory after extraction:"
+          ls -la fuzz/stats/
+          echo "Contents of should_pass files (if any):"
+          cat fuzz/stats/*.should_pass 2>/dev/null || echo "No should_pass files found"
+      - name: Generate Summary
+        run: |
+          echo "# Fuzzing Summary" > fuzzing_summary.md
+          echo "" >> fuzzing_summary.md
+          echo "| Target | Runs | Exec/sec | New Units | Should pass | Status |" >> fuzzing_summary.md
+          echo "|--------|------|----------|-----------|-------------|--------|" >> fuzzing_summary.md
+
+          TOTAL_RUNS=0
+          TOTAL_NEW_UNITS=0
+
+          for stat_file in fuzz/stats/*.txt; do
+            TARGET=$(basename "$stat_file" .txt)
+            SHOULD_PASS_FILE="${stat_file%.*}.should_pass"
+
+            # Get expected status
+            if [ -f "$SHOULD_PASS_FILE" ]; then
+              EXPECTED=$(cat "$SHOULD_PASS_FILE")
+            else
+              EXPECTED="unknown"
+            fi
+
+            # Extract runs
+            if grep -q "stat::number_of_executed_units" "$stat_file"; then
+              RUNS=$(grep "stat::number_of_executed_units" "$stat_file" | awk '{print $2}')
+              TOTAL_RUNS=$((TOTAL_RUNS + RUNS))
+            else
+              RUNS="unknown"
+            fi
+
+            # Extract execution rate
+            if grep -q "stat::average_exec_per_sec" "$stat_file"; then
+              EXEC_RATE=$(grep "stat::average_exec_per_sec" "$stat_file" | awk '{print $2}')
+            else
+              EXEC_RATE="unknown"
+            fi
+
+            # Extract new units added
+            if grep -q "stat::new_units_added" "$stat_file"; then
+              NEW_UNITS=$(grep "stat::new_units_added" "$stat_file" | awk '{print $2}')
+              if [[ "$NEW_UNITS" =~ ^[0-9]+$ ]]; then
+                TOTAL_NEW_UNITS=$((TOTAL_NEW_UNITS + NEW_UNITS))
+              fi
+            else
+              NEW_UNITS="unknown"
+            fi
+
+            # Extract status
+            if grep -q "SUMMARY: " "$stat_file"; then
+              STATUS=$(grep "SUMMARY: " "$stat_file" | head -1)
+            else
+              STATUS="Completed"
+            fi
+
+            echo "| $TARGET | $RUNS | $EXEC_RATE | $NEW_UNITS | $EXPECTED | $STATUS |" >> fuzzing_summary.md
+          done
+
+          echo "" >> fuzzing_summary.md
+          echo "## Overall Statistics" >> fuzzing_summary.md
+          echo "" >> fuzzing_summary.md
+          echo "- **Total runs:** $TOTAL_RUNS" >> fuzzing_summary.md
+          echo "- **Total new units discovered:** $TOTAL_NEW_UNITS" >> fuzzing_summary.md
+          echo "- **Average execution rate:** $(grep -h "stat::average_exec_per_sec" fuzz/stats/*.txt | awk '{sum += $2; count++} END {if (count > 0) print sum/count " execs/sec"; else print "unknown"}')" >> fuzzing_summary.md
+
+          # Add count by expected status
+          echo "- **Tests expected to pass:** $(find fuzz/stats -name "*.should_pass" -exec cat {} \; | grep -c "true")" >> fuzzing_summary.md
+          echo "- **Tests expected to fail:** $(find fuzz/stats -name "*.should_pass" -exec cat {} \; | grep -c "false")" >> fuzzing_summary.md
+
+          # Write to GitHub step summary
+          cat fuzzing_summary.md >> $GITHUB_STEP_SUMMARY
+      - name: Show Summary
+        run: |
+          cat fuzzing_summary.md
+      - name: Upload Summary
+        uses: actions/upload-artifact@v4
+        with:
+          name: fuzzing-summary
+          path: fuzzing_summary.md
+          retention-days: 5
diff --git a/.github/workflows/ignore-intermittent.txt b/.github/workflows/ignore-intermittent.txt
index 759bd96eb8a..9e0e2ab0df6 100644
--- a/.github/workflows/ignore-intermittent.txt
+++ b/.github/workflows/ignore-intermittent.txt
@@ -1,3 +1,6 @@
-tests/tail-2/inotify-dir-recreate
-tests/misc/timeout
+tests/tail/inotify-dir-recreate
+tests/timeout/timeout
 tests/rm/rm1
+tests/misc/stdbuf
+tests/misc/usage_vs_getopt
+tests/misc/tee
diff --git a/.gitignore b/.gitignore
index ed4e54ec5bc..7528e5f5380 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
+# spell-checker:ignore (misc) direnv
+
 target/
+coverage/
 /src/*/gen_table
 /build/
 /tmp/
@@ -10,9 +13,11 @@ target/
 .*.swp
 .*.swo
 .idea
-Cargo.lock
 lib*.a
 /docs/_build
 *.iml
 ### macOS ###
 .DS_Store
+
+### direnv ###
+/.direnv/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index f90466bed2f..534487abc8f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -4,14 +4,20 @@ repos:
     -   id: rust-linting
         name: Rust linting
         description: Run cargo fmt on files included in the commit.
-        entry: cargo +nightly fmt --
+        entry: cargo +stable fmt --
         pass_filenames: true
         types: [file, rust]
         language: system
     -   id: rust-clippy
         name: Rust clippy
         description: Run cargo clippy on files included in the commit.
-        entry: cargo +nightly clippy --workspace --all-targets --all-features --
+        entry: cargo +stable clippy --workspace --all-targets --all-features -- -D warnings
         pass_filenames: false
         types: [file, rust]
         language: system
+    -   id: cspell
+        name: Code spell checker (cspell)
+        description: Run cspell to check for spelling errors.
+        entry: cspell --no-must-find-files --
+        pass_filenames: true
+        language: system
diff --git a/.vscode/cSpell.json b/.vscode/cSpell.json
index 6ceb038c218..199830c2d1d 100644
--- a/.vscode/cSpell.json
+++ b/.vscode/cSpell.json
@@ -1,4 +1,5 @@
 // `cspell` settings
+// spell-checker:ignore oranda
 {
   // version of the setting file
   "version": "0.2",
@@ -18,15 +19,19 @@
 
   // files to ignore (globs supported)
   "ignorePaths": [
+    ".git/**",
     "Cargo.lock",
     "oranda.json",
     "target/**",
     "tests/**/fixtures/**",
     "src/uu/dd/test-resources/**",
     "vendor/**",
-    "**/*.svg"
+    "**/*.svg",
+    "src/uu/*/locales/*.ftl"
   ],
 
+  "enableGlobDot": true,
+
   // words to ignore (even if they are in the flagWords)
   "ignoreWords": [],
 
diff --git a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
index 8711913d99d..8993f5d6a31 100644
--- a/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
+++ b/.vscode/cspell.dictionaries/acronyms+names.wordlist.txt
@@ -37,6 +37,7 @@ aarch
 flac
 impls
 lzma
+loongarch
 
 # * names
 BusyBox
@@ -45,6 +46,7 @@ Codacy
 Cygwin
 Deno
 EditorConfig
+EPEL
 FreeBSD
 Gmail
 GNU
@@ -58,6 +60,7 @@ MinGW
 Minix
 NetBSD
 Novell
+Nushell
 OpenBSD
 POSIX
 PowerPC
diff --git a/.vscode/cspell.dictionaries/jargon.wordlist.txt b/.vscode/cspell.dictionaries/jargon.wordlist.txt
index dca883dc804..6358f3c7682 100644
--- a/.vscode/cspell.dictionaries/jargon.wordlist.txt
+++ b/.vscode/cspell.dictionaries/jargon.wordlist.txt
@@ -10,8 +10,10 @@ bytewise
 canonicalization
 canonicalize
 canonicalizing
+capget
 codepoint
 codepoints
+codeready
 codegen
 colorizable
 colorize
@@ -42,8 +44,11 @@ fileio
 filesystem
 filesystems
 flamegraph
+fsxattr
 fullblock
 getfacl
+getfattr
+getopt
 gibi
 gibibytes
 glob
@@ -63,6 +68,7 @@ kibi
 kibibytes
 libacl
 lcase
+llistxattr
 lossily
 lstat
 mebi
@@ -73,6 +79,7 @@ microbenchmarks
 microbenchmarking
 multibyte
 multicall
+nmerge
 noatime
 nocache
 nocreat
@@ -83,6 +90,7 @@ nolinks
 nonblock
 nonportable
 nonprinting
+nonseekable
 notrunc
 noxfer
 ofile
@@ -105,7 +113,9 @@ seedable
 semver
 semiprime
 semiprimes
+setcap
 setfacl
+setfattr
 shortcode
 shortcodes
 siginfo
@@ -133,11 +143,15 @@ urand
 whitespace
 wordlist
 wordlists
+xattrs
+xpass
 
 # * abbreviations
 consts
 deps
 dev
+fdlimit
+inacc
 maint
 proc
 procs
@@ -153,3 +167,9 @@ retval
 subdir
 val
 vals
+inval
+nofield
+
+# * clippy
+uninlined
+nonminimal
diff --git a/.vscode/cspell.dictionaries/shell.wordlist.txt b/.vscode/cspell.dictionaries/shell.wordlist.txt
index 95dea94a7cd..b1ddec7a4e0 100644
--- a/.vscode/cspell.dictionaries/shell.wordlist.txt
+++ b/.vscode/cspell.dictionaries/shell.wordlist.txt
@@ -25,6 +25,7 @@ sudoedit
 tcsh
 tzselect
 urandom
+VARNAME
 wtmp
 zsh
 
@@ -102,3 +103,4 @@ xargs
 
 # * directories
 sbin
+libexec
diff --git a/.vscode/cspell.dictionaries/workspace.wordlist.txt b/.vscode/cspell.dictionaries/workspace.wordlist.txt
index 6d6533bcf5c..bbdb825198b 100644
--- a/.vscode/cspell.dictionaries/workspace.wordlist.txt
+++ b/.vscode/cspell.dictionaries/workspace.wordlist.txt
@@ -20,12 +20,12 @@ exacl
 filetime
 formatteriteminfo
 fsext
-fundu
 getopts
 getrandom
 globset
 indicatif
 itertools
+langid
 lscolors
 mdbook
 memchr
@@ -47,6 +47,7 @@ termsize
 termwidth
 textwrap
 thiserror
+unic
 ureq
 walkdir
 winapi
@@ -59,6 +60,7 @@ clippy
 rustc
 rustfmt
 rustup
+rustdoc
 #
 bitor # BitOr trait function
 bitxor # BitXor trait function
@@ -135,6 +137,7 @@ vmsplice
 
 # * vars/libc
 COMFOLLOW
+EXDEV
 FILENO
 FTSENT
 HOSTSIZE
@@ -165,6 +168,7 @@ RTLD_NEXT
     RTLD
 SIGINT
 SIGKILL
+SIGSTOP
 SIGTERM
 SYS_fdatasync
 SYS_syncfs
@@ -322,15 +326,21 @@ libc
 libstdbuf
 musl
 tmpd
+uchild
 ucmd
 ucommand
 utmpx
 uucore
 uucore_procs
 uudoc
+uufuzz
 uumain
 uutil
+uutests
 uutils
 
 # * function names
 getcwd
+
+# * other
+algs
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
index b9c161a4c28..7ee2695db0a 100644
--- a/.vscode/extensions.json
+++ b/.vscode/extensions.json
@@ -1,4 +1,4 @@
-// spell-checker:ignore (misc) matklad
+// spell-checker:ignore (misc) matklad foxundermoon
 // see <http://go.microsoft.com/fwlink/?LinkId=827846> for the documentation about the extensions.json format
 // *
 // "foxundermoon.shell-format" ~ shell script formatting ; note: ENABLE "Use EditorConfig"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index bd87e2d05ba..8668c9a27eb 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,236 +1,273 @@
-<!-- spell-checker:ignore reimplementing toybox RUNTEST CARGOFLAGS nextest -->
+<!-- spell-checker:ignore reimplementing toybox RUNTEST CARGOFLAGS nextest embeddable Rustonomicon rustdoc's -->
 
 # Contributing to coreutils
 
-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
-
-1. Follow what GNU is doing in terms of options and behavior. It is recommended
-   to look at the GNU Coreutils manual ([on the
-   web](https://www.gnu.org/software/coreutils/manual/html_node/index.html), or
-   locally using `info <utility>`). It is more in depth than the man pages and
-   provides a good description of available features and their implementation
-   details.
-1. If possible, look at the GNU test suite execution in the CI and make the test
-   work if failing.
-1. Use clap for argument management.
-1. Make sure that the code coverage is covering all of the cases, including
-   errors.
-1. The code must be clippy-warning-free and rustfmt-compliant.
-1. Don't hesitate to move common functions into uucore if they can be reused by
-   other binaries.
-1. Unsafe code should be documented with Safety comments.
-1. uutils is original code. It cannot contain code from existing GNU or Unix-like
-   utilities, nor should it link to or reference GNU libraries.
+Hi! Welcome to uutils/coreutils!
 
-## Platforms
+Thanks for wanting to contribute to this project! This document explains
+everything you need to know to contribute. Before you start make sure to also
+check out these documents:
 
-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.
+- Our community's [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md).
+- [DEVELOPMENT.md](./DEVELOPMENT.md) for setting up your development
+  environment.
 
-**Tip:** For Windows, Microsoft provides some images (VMWare, Hyper-V,
-VirtualBox and Parallels) for development:
-<https://developer.microsoft.com/windows/downloads/virtual-machines/>
+Now follows a very important warning:
 
-## Tools
+> [!WARNING]
+> uutils is original code and cannot contain any code from GNU or
+> other implementations. This means that **we cannot accept any changes based on
+> the GNU source code**. To make sure that cannot happen, **you cannot link to
+> the GNU source code** either. It is however possible to look at other implementations
+> under a BSD or MIT license like [Apple's implementation](https://github.com/apple-oss-distributions/file_cmds/)
+> or [OpenBSD](https://github.com/openbsd/src/tree/master/bin).
 
-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.
+Finally, feel free to join our [Discord](https://discord.gg/wQVJbvJ)!
 
-### pre-commit hooks
+## Getting Oriented
 
-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.
+uutils is a big project consisting of many parts. Here are the most important
+parts for getting started:
 
-To use the provided hook:
+- [`src/uu`](https://github.com/uutils/coreutils/tree/main/src/uu/): The code for all utilities
+- [`src/uucore`](https://github.com/uutils/coreutils/tree/main/src/uucore/): Crate containing all the shared code between
+  the utilities.
+- [`tests/by-util`](https://github.com/uutils/coreutils/tree/main/tests/by-util/): The tests for all utilities.
+- [`src/bin/coreutils.rs`](https://github.com/uutils/coreutils/tree/main/src/bin/coreutils.rs): Code for the multicall
+  binary.
+- [`docs`](https://github.com/uutils/coreutils/tree/main/docs/src): the documentation for the website
+- [`tests/uutests/`](https://github.com/uutils/coreutils/tree/main/tests/uutests/):
+  Crate implementing the various functions to test uutils commands.
 
-1. [Install `pre-commit`](https://pre-commit.com/#install)
-1. Run `pre-commit install` while in the repository directory
+Each utility is defined as a separate crate. The structure of each of these
+crates is as follows:
 
-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.
+- `Cargo.toml`
+- `src/main.rs`: contains only a single macro call
+- `src/<util name>.rs`: the actual code for the utility
+- `<util name>.md`: the documentation for the utility
 
-### clippy
+We have separated repositories for crates that we maintain but also publish for
+use by others:
 
-```shell
-cargo clippy --all-targets --all-features
-```
+- [uutils-term-grid](https://github.com/uutils/uutils-term-grid)
+- [parse_datetime](https://github.com/uutils/parse_datetime)
 
-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).
+## Design Goals
 
-### rustfmt
+We have the following goals with our development:
 
-```shell
-cargo fmt --all
-```
+- **Compatible**: The utilities should be a drop-in replacement for the GNU
+  coreutils.
+- **Cross-platform**: All utilities should run on as many of the supported
+  platforms as possible.
+- **Reliable**: The utilities should never unexpectedly fail.
+- **Performant**: Our utilities should be written in fast idiomatic Rust. We aim
+  to match or exceed the performance of the GNU utilities.
+- **Well-tested**: We should have a lot of tests to be able to guarantee
+  reliability and compatibility.
 
-### cargo-deny
+## How to Help
 
-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:
+There are several ways to help and writing code is just one of them. Reporting
+issues and writing documentation are just as important as writing code.
 
-```
-cargo deny --all-features check all
-```
+### Reporting Issues
 
-### Markdown linter
+We can't fix bugs we don't know about, so good issues are super helpful! Here
+are some tips for writing good issues:
 
-We use [markdownlint](https://github.com/DavidAnson/markdownlint) to lint the
-Markdown files in the repository.
+- If you find a bug, make sure it's still a problem on the `main` branch.
+- Search through the existing issues to see whether it has already been
+  reported.
+- Make sure to include all relevant information, such as:
+  - Which version of uutils did you check?
+  - Which version of GNU coreutils are you comparing with?
+  - What platform are you on?
+- Provide a way to reliably reproduce the issue.
+- Be as specific as possible!
 
-### Spell checker
+### Writing Documentation
 
-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.
+There's never enough documentation. If you come across any documentation that
+could be improved, feel free to submit a PR for it!
 
-If you want to make the spell checker ignore a word, you can add
+### Writing Code
 
-```rust
-// spell-checker:ignore word_to_ignore
-```
+If you want to submit a PR, make sure that you've discussed the solution with
+the maintainers beforehand. We want to avoid situations where you put a lot of
+work into a fix that we can't merge! If there's no issue for what you're trying
+to fix yet, make one _before_ you start working on the PR.
 
-at the top of the file.
+Generally, we try to follow what GNU is doing in terms of options and behavior.
+It is recommended to look at the GNU coreutils manual
+([on the web](https://www.gnu.org/software/coreutils/manual/html_node/index.html),
+or locally using `info <utility>`). It is more in depth than the man pages and
+provides a good description of available features and their implementation
+details. But remember, you cannot look at the GNU source code!
 
-## Testing
+Also remember that we can only merge PRs which pass our test suite, follow
+rustfmt, and do not have any warnings from clippy. See
+[DEVELOPMENT.md](./DEVELOPMENT.md) for more information. Be sure to also read
+about our [Rust style](#our-rust-style).
 
-Testing can be done using either Cargo or `make`.
+## Our Rust Style
 
-### Testing with Cargo
+We want uutils to be written in idiomatic Rust, so here are some guidelines to
+follow. Some of these are aspirational, meaning that we don't do them correctly
+everywhere in the code. If you find violations of the advice below, feel free to
+submit a patch!
 
-Just like with building, we follow the standard procedure for testing using
-Cargo:
+### Don't `panic!`
 
-```shell
-cargo test
-```
+The coreutils should be very reliable. This means that we should never `panic!`.
+Therefore, you should avoid using `.unwrap()` and `panic!`. Sometimes the use of
+`unreachable!` can be justified with a comment explaining why that code is
+unreachable.
 
-By default, `cargo test` only runs the common programs. To run also platform
-specific tests, run:
+### Don't `exit`
 
-```shell
-cargo test --features unix
-```
+We want uutils to be embeddable in other programs. This means that no function
+in uutils should exit the program. Doing so would also lead to code with more
+confusing control flow. Avoid therefore `std::process::exit` and similar
+functions which exit the program early.
 
-If you would prefer to test a select few utilities:
+### `unsafe`
 
-```shell
-cargo test --features "chmod mv tail" --no-default-features
-```
+uutils cannot be entirely safe, because we have to call out to `libc` and do
+syscalls. However, we still want to limit our use of `unsafe`. We generally only
+accept `unsafe` for FFI, with very few exceptions. Note that performance is very
+rarely a valid argument for using `unsafe`.
 
-If you also want to test the core utilities:
+If you still need to write code with `unsafe`, make sure to read the
+[Rustonomicon](https://doc.rust-lang.org/nomicon/intro.html) and annotate the
+calls with `// SAFETY:` comments explaining why the use of `unsafe` is sound.
 
-```shell
-cargo test  -p uucore -p coreutils
-```
+### Macros
 
-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.
+Macros can be a great tool, but they are also usually hard to understand. They
+should be used sparingly. Make sure to explore simpler options before you reach
+for a solution involving macros.
 
-```shell
-cargo nextest run --features unix --no-fail-fast
-```
+### `str`, `OsStr` & `Path`
 
-To debug:
+Rust has many string-like types, and sometimes it's hard to choose the right
+one. It's tempting to use `str` (and `String`) for everything, but that is not
+always the right choice for uutils, because we need to support invalid UTF-8,
+just like the GNU coreutils. For example, paths on Linux might not be valid
+UTF-8! Whenever we are dealing with paths, we should therefore stick with
+`OsStr` and `Path`. Make sure that you only convert to `str`/`String` if you
+know that something is always valid UTF-8. If you need more operations on
+`OsStr`, you can use the [`bstr`](https://docs.rs/bstr/latest/bstr/) crate.
+
+### Doc-comments
+
+We use rustdoc for our documentation, so it's best to follow
+[rustdoc's guidelines](https://doc.rust-lang.org/rustdoc/how-to-write-documentation.html#documenting-components).
+Make sure that your documentation is not just repeating the name of the
+function, but actually giving more useful information. Rustdoc recommends the
+following structure:
 
-```shell
-gdb --args target/debug/coreutils ls
-(gdb) b ls.rs:79
-(gdb) run
 ```
+[short sentence explaining what it is]
 
-### Testing with GNU Make
+[more detailed explanation]
 
-To simply test all available utilities:
+[at least one code example that users can copy/paste to try it]
 
-```shell
-make test
+[even more advanced explanations if necessary]
 ```
 
-To test all but a few of the available utilities:
+### Other comments
 
-```shell
-make SKIP_UTILS='UTILITY_1 UTILITY_2' test
-```
+Comments should be written to _explain_ the code, not to _describe_ the code.
+Try to focus on explaining _why_ the code is the way it is. If you feel like you
+have to describe the code, that's usually a sign that you could improve the
+naming of variables and functions.
 
-To test only a few of the available utilities:
+If you edit a piece of code, make sure to update any comments that need to
+change as a result. The only thing worse than having no comments is having
+outdated comments!
 
-```shell
-make UTILS='UTILITY_1 UTILITY_2' test
-```
+## Git Etiquette
 
-To include tests for unimplemented behavior:
+To ensure easy collaboration, we have guidelines for using Git and GitHub.
 
-```shell
-make UTILS='UTILITY_1 UTILITY_2' SPEC=y test
-```
+### Commits
 
-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`:
+- Make small and atomic commits.
+- Keep a clean history of commits.
+- Write informative commit messages.
+- Annotate your commit message with the component you're editing. For example:
+  `cp: do not overwrite on with -i` or `uucore: add support for FreeBSD`.
+- Do not unnecessarily move items around in the code. This makes the changes
+  much harder to review. If you do need to move things around, do that in a
+  separate commit.
 
-```shell
-make CARGOFLAGS='--no-fail-fast' UTILS='UTILITY_1 UTILITY_2' nextest
-```
+### Commit messages
 
-### Run Busybox Tests
+You can read [this section in the Git book](https://git-scm.com/book/ms/v2/Distributed-Git-Contributing-to-a-Project) to learn how to write good commit
+messages.
 
-This testing functionality is only available on *nix operating systems and
-requires `make`.
+In addition, here are a few examples for a summary line when committing to
+uutils:
 
-To run busybox tests for all utilities for which busybox has tests
+- commit for a single utility
 
-```shell
-make busytest
+```
+nohup: cleanup and refactor
 ```
 
-To run busybox tests for a few of the available utilities
+- commit for a utility's tests
 
-```shell
-make UTILS='UTILITY_1 UTILITY_2' busytest
+```
+tests/rm: test new feature
 ```
 
-To pass an argument like "-v" to the busybox test runtime
+Beyond changes to an individual utility or its tests, other summary lines for
+non-utility modules include:
 
-```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
+README: add help
+uucore: add new modules
+uutils: add new utility
+gitignore: add temporary files
 ```
 
-Note that it relies on individual utilities (not the multicall binary).
+### PRs
+
+- Make the titles of PRs descriptive.
+  - This means describing the problem you solve. For example, do not write
+    `Fix #1234`, but `ls: fix version sort order`.
+  - You can prefix the title with the utility the PR concerns.
+- Keep PRs small and self-contained. A set of small PRs is much more likely to
+  get merged quickly than one large PR.
+- Make sure the CI passes (up to intermittently failing tests).
+- You know your code best, that's why it's best if you can solve merge conflicts
+  on your branch yourself.
+  - It's up to you whether you want to use `git merge main` or
+    `git rebase main`.
+  - Feel free to ask for help with merge conflicts.
+- You do not need to ping maintainers to request a review, but it's fine to do
+  so if you don't get a response within a few days.
 
-### Improving the GNU compatibility
+## Platforms
+
+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 [on their official download page](https://developer.microsoft.com/windows/downloads/virtual-machines/).
+
+## Improving the GNU compatibility
+
+Please make sure you have installed
+[GNU utils and prerequisites](DEVELOPMENT.md#gnu-utils-and-prerequisites) and
+can execute commands described in
+[Comparing with GNU](DEVELOPMENT.md#comparing-with-gnu) section of
+[DEVELOPMENT.md](DEVELOPMENT.md)
 
 The Python script `./util/remaining-gnu-error.py` shows the list of failing
 tests in the CI.
@@ -254,112 +291,29 @@ To improve the GNU compatibility, the following process is recommended:
 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 <https://git-scm.com/book/ch5-2.html>:
-
-```
-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 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, 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:
-
-* commit for a single utility
-
-```
-nohup: cleanup and refactor
-```
-
-* commit for a utility's tests
-
-```
-tests/rm: test new feature
-```
-
-Beyond changes to an individual utility or its tests, other summary
-lines for non-utility modules include:
-
-```
-README: add help
-```
-
-```
-uucore: add new modules
-```
-
-```
-uutils: add new utility
-```
-
-```
-gitignore: add temporary files
-```
-
 ## Code coverage
 
-<!-- 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
-```
-
-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.
+To generate code coverage report locally please follow
+[Code coverage report](DEVELOPMENT.md#code-coverage-report) section of
+[DEVELOPMENT.md](DEVELOPMENT.md)
 
 ## Other implementations
 
-The Coreutils have different implementations, with different levels of completions:
+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)
-* [Perl Power Tools](https://metacpan.org/pod/PerlPowerTools)
+- [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)
+- [Mac OS](https://github.com/apple-oss-distributions/file_cmds/)
+- [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)
+- [Perl Power Tools](https://metacpan.org/pod/PerlPowerTools)
 
-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).
+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
 
@@ -374,17 +328,17 @@ If you wish to add or change dependencies as part of a contribution to the
 project, a tool like `cargo-license` can be used to show their license details.
 The following types of license are acceptable:
 
-* MIT License
-* Dual- or tri-license with an MIT License option ("Apache-2.0 or MIT" is a
+- MIT License
+- Dual- or tri-license with an MIT License option ("Apache-2.0 or MIT" is a
   popular combination)
-* "MIT equivalent" license (2-clause BSD, 3-clause BSD, ISC)
-* License less restrictive than the MIT License (CC0 1.0 Universal)
-* Apache License version 2.0
+- "MIT equivalent" license (2-clause BSD, 3-clause BSD, ISC)
+- License less restrictive than the MIT License (CC0 1.0 Universal)
+- Apache License version 2.0
 
 Licenses we will not use:
 
-* An ambiguous license, or no license
-* Strongly reciprocal licenses (GNU GPL, GNU LGPL)
+- An ambiguous license, or no license
+- Strongly reciprocal licenses (GNU GPL, GNU LGPL)
 
 If you wish to add a reference but it doesn't meet these requirements, please
 raise an issue to describe the dependency.
diff --git a/Cargo.lock b/Cargo.lock
index f4885faa05c..d447ee4e408 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,22 +1,28 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
 [[package]]
 name = "aho-corasick"
-version = "1.0.4"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -32,79 +38,99 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "ansi-width"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219e3ce6f2611d83b51ec2098a12702112c29e57203a6b0a0929b2cddb486608"
+dependencies = [
+ "unicode-width 0.1.14",
+]
+
 [[package]]
 name = "anstream"
-version = "0.3.2"
+version = "0.6.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ca84f3628370c59db74ee214b3263d58f9aadd9b4fe7e711fd87dc452b7f163"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
 dependencies = [
  "anstyle",
  "anstyle-parse",
  "anstyle-query",
  "anstyle-wincon",
  "colorchoice",
- "is-terminal",
+ "is_terminal_polyfill",
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle"
-version = "1.0.0"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41ed9a86bf92ae6580e0a31281f65a1b1d867c0cc68d5346e2ae128dddfa6a7d"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.0"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e765fd216e48e067936442276d1d57399e37bce53c264d6fefbe298080cb57ee"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "1.0.1"
+version = "3.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180abfa45703aebe0093f79badacc01b8fd4ea2e35118747e5811127f926e188"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
 dependencies = [
  "anstyle",
- "windows-sys 0.48.0",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+dependencies = [
+ "derive_arbitrary",
 ]
 
 [[package]]
 name = "arrayref"
-version = "0.3.6"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
 
 [[package]]
 name = "arrayvec"
-version = "0.7.2"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "bigdecimal"
-version = "0.4.0"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5274a6b6e0ee020148397245b973e30163b7bffbc6d473613f850cb99888581e"
+checksum = "1a22f228ab7a1b23027ccc6c350b72868017af7ea8356fbdf19f8d991c690013"
 dependencies = [
+ "autocfg",
  "libm",
  "num-bigint",
  "num-integer",
@@ -120,26 +146,44 @@ dependencies = [
  "compare",
 ]
 
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
+
 [[package]]
 name = "bindgen"
-version = "0.63.0"
+version = "0.71.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36d860121800b2a9a94f9b5604b332d5cffb234ce17609ea479d723dbc9d3885"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "cexpr",
  "clang-sys",
- "lazy_static",
- "lazycell",
+ "itertools 0.13.0",
  "log",
- "peeking_take_while",
+ "prettyplease",
  "proc-macro2",
  "quote",
  "regex",
  "rustc-hash",
  "shlex",
- "syn 1.0.109",
- "which",
+ "syn",
 ]
 
 [[package]]
@@ -150,15 +194,27 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.3.3"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630be753d4e58660abd17930c71b647fe46c27ea6b63cc59e1e3851406972e42"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
 
 [[package]]
-name = "blake2b_simd"
+name = "bitvec"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c2f0dc9a68c6317d884f97cc36cf5a3d20ba14ce404227df55e1af708ab04bc"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2b_simd"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06e903a20b159e944f91ec8499fe1e55651480c541ea0a584f5d967c49ad9d99"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -167,32 +223,31 @@ dependencies = [
 
 [[package]]
 name = "blake3"
-version = "1.4.0"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "729b71f35bd3fa1a4c86b85d32c8b9069ea7fe14f7a53cfabb65f62d4265b888"
+checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
 dependencies = [
  "arrayref",
  "arrayvec",
  "cc",
  "cfg-if",
  "constant_time_eq",
- "digest",
 ]
 
 [[package]]
 name = "block-buffer"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "bstr"
-version = "1.6.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
  "regex-automata",
@@ -201,27 +256,30 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.11.1"
+version = "3.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
+checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
 
 [[package]]
 name = "bytecount"
-version = "0.6.3"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c676a478f63e9fa2dd5368a42f28bba0d6c560b775f38583c8bbaa7fcd67c9c"
+checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+dependencies = [
+ "shlex",
+]
 
 [[package]]
 name = "cexpr"
@@ -229,7 +287,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
 dependencies = [
- "nom",
+ "nom 7.1.3",
 ]
 
 [[package]]
@@ -238,23 +296,50 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chrono"
-version = "0.4.28"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ed24df0632f708f5f6d8082675bef2596f7084dee3dd55f632290bf35bfe0f"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "num-traits",
- "windows-targets 0.48.0",
+ "windows-link",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efdce149c370f133a071ca8ef6ea340b7b88748ab0810097a9e2976eaa34b4f3"
+dependencies = [
+ "chrono",
+ "chrono-tz-build",
+ "phf",
+]
+
+[[package]]
+name = "chrono-tz-build"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e94fea34d77a245229e7746bd2beb786cd2a896f306ff491fb8cecb3074b10a7"
+dependencies = [
+ "parse-zoneinfo",
+ "phf_codegen",
 ]
 
 [[package]]
 name = "clang-sys"
-version = "1.4.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa2e27ae6ab525c3d369ded447057bca5438d86dc3a68f6faafb8269ba82ebf3"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
  "glob",
  "libc",
@@ -263,47 +348,46 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.3.21"
+version = "4.5.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c27cdf28c0f604ba3f512b0c9a409f8de8513e4816705deb0498b627e7c3a3fd"
+checksum = "fd60e63e9be68e5fb56422e397cf9baddded06dae1d2e523401542383bc72a9f"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.3.21"
+version = "4.5.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a9f1ab5e9f01a9b81f202e8562eb9a10de70abf9eaeac1be465c28b75aa4aa"
+checksum = "89cc6392a1f72bbeb820d71f32108f61fdaf18bc526e1d23954168a67759ef51"
 dependencies = [
  "anstream",
  "anstyle",
  "clap_lex",
- "once_cell",
  "strsim",
  "terminal_size",
 ]
 
 [[package]]
 name = "clap_complete"
-version = "4.3.0"
+version = "4.5.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a04ddfaacc3bc9e6ea67d024575fafc2a813027cf374b8f24f7bc233c6b6be12"
+checksum = "8d2267df7f3c8e74e38268887ea5235d4dfadd39bfff2d56ab82d61776be355e"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.5.0"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
 
 [[package]]
 name = "clap_mangen"
-version = "0.2.9"
+version = "0.2.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb0f09a0ca8f0dd8ac92c546b426f466ef19828185c6d504c80c48c9c2768ed9"
+checksum = "724842fa9b144f9b89b3f3d371a89f3455eea660361d13a554f68f8ae5d6c13a"
 dependencies = [
  "clap",
  "roff",
@@ -311,9 +395,9 @@ dependencies = [
 
 [[package]]
 name = "colorchoice"
-version = "1.0.0"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 
 [[package]]
 name = "compare"
@@ -323,86 +407,85 @@ checksum = "120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3"
 
 [[package]]
 name = "console"
-version = "0.15.7"
+version = "0.15.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
 dependencies = [
  "encode_unicode",
- "lazy_static",
  "libc",
- "unicode-width",
- "windows-sys 0.45.0",
+ "once_cell",
+ "unicode-width 0.2.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "const-random"
-version = "0.1.15"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368a7a772ead6ce7e1de82bfb04c485f3db8ec744f72925af5735e29a22cc18e"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
 dependencies = [
  "const-random-macro",
- "proc-macro-hack",
 ]
 
 [[package]]
 name = "const-random-macro"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d7d6ab3c3a2282db210df5f02c4dab6e0a7057af0fb7ebd4070f30fe05c0ddb"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "once_cell",
- "proc-macro-hack",
  "tiny-keccak",
 ]
 
 [[package]]
 name = "constant_time_eq"
-version = "0.2.4"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3ad85c1f65dc7b37604eb0e89748faf0b9653065f2a8ef69f96a687ec1e9279"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
 
 [[package]]
-name = "conv"
-version = "0.3.3"
+name = "convert_case"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ff10625fd0ac447827aa30ea8b861fead473bb60aeb73af6c1c58caf0d1299"
+checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
 dependencies = [
- "custom_derive",
+ "unicode-segmentation",
 ]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.3"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "coreutils"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
+ "bincode",
  "chrono",
  "clap",
  "clap_complete",
  "clap_mangen",
- "conv",
+ "ctor",
  "filetime",
  "glob",
  "hex-literal",
- "is-terminal",
  "libc",
  "nix",
- "once_cell",
+ "num-prime",
  "phf",
  "phf_codegen",
  "pretty_assertions",
  "procfs",
- "rand",
- "rand_pcg",
+ "rand 0.9.1",
  "regex",
  "rlimit",
  "rstest",
  "selinux",
+ "serde",
+ "serde-big-array",
  "sha1",
  "tempfile",
  "textwrap",
@@ -474,7 +557,6 @@ dependencies = [
  "uu_pwd",
  "uu_readlink",
  "uu_realpath",
- "uu_relpath",
  "uu_rm",
  "uu_rmdir",
  "uu_runcon",
@@ -513,60 +595,52 @@ dependencies = [
  "uu_yes",
  "uucore",
  "uuhelp_parser",
+ "uutests",
  "walkdir",
+ "xattr",
  "zip",
 ]
 
-[[package]]
-name = "coz"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cef55b3fe2f5477d59e12bc792e8b3c95a25bd099eadcfae006ecea136de76e2"
-dependencies = [
- "libc",
- "once_cell",
-]
-
 [[package]]
 name = "cpp"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa65869ef853e45c60e9828aa08cdd1398cb6e13f3911d9cb2a079b144fcd64"
+checksum = "f36bcac3d8234c1fb813358e83d1bb6b0290a3d2b3b5efc6b88bfeaf9d8eec17"
 dependencies = [
  "cpp_macros",
 ]
 
 [[package]]
 name = "cpp_build"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e361fae2caf9758164b24da3eedd7f7d7451be30d90d8e7b5d2be29a2f0cf5b"
+checksum = "27f8638c97fbd79cc6fc80b616e0e74b49bac21014faed590bbc89b7e2676c90"
 dependencies = [
  "cc",
  "cpp_common",
  "lazy_static",
  "proc-macro2",
  "regex",
- "syn 2.0.23",
+ "syn",
  "unicode-xid",
 ]
 
 [[package]]
 name = "cpp_common"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e1a2532e4ed4ea13031c13bc7bc0dbca4aae32df48e9d77f0d1e743179f2ea1"
+checksum = "25fcfea2ee05889597d35e986c2ad0169694320ae5cc8f6d2640a4bb8a884560"
 dependencies = [
  "lazy_static",
  "proc-macro2",
- "syn 2.0.23",
+ "syn",
 ]
 
 [[package]]
 name = "cpp_macros"
-version = "0.5.9"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47ec9cc90633446f779ef481a9ce5a0077107dd5b87016440448d908625a83fd"
+checksum = "d156158fe86e274820f5a53bc9edb0885a6e7113909497aa8d883b69dd171871"
 dependencies = [
  "aho-corasick",
  "byteorder",
@@ -574,81 +648,66 @@ dependencies = [
  "lazy_static",
  "proc-macro2",
  "quote",
- "syn 2.0.23",
+ "syn",
 ]
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.5"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "crc32fast"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.8"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
 dependencies = [
  "cfg-if",
- "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.2"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
- "cfg-if",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.14"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "autocfg",
- "cfg-if",
  "crossbeam-utils",
- "memoffset",
- "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.15"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
-dependencies = [
- "cfg-if",
-]
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crossterm"
-version = "0.27.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
- "bitflags 2.3.3",
+ "bitflags 2.9.0",
  "crossterm_winapi",
- "libc",
+ "derive_more",
+ "document-features",
+ "filedescriptor",
  "mio",
  "parking_lot",
+ "rustix 1.0.1",
  "signal-hook",
  "signal-hook-mio",
  "winapi",
@@ -665,9 +724,9 @@ dependencies = [
 
 [[package]]
 name = "crunchy"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
 
 [[package]]
 name = "crypto-common"
@@ -680,32 +739,42 @@ dependencies = [
 ]
 
 [[package]]
-name = "ctrlc"
-version = "3.4.0"
+name = "ctor"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a011bbe2c35ce9c1f143b7af6f94f29a167beb4cd1d29e6740ce836f723120e"
+checksum = "a4735f265ba6a1188052ca32d461028a7d1125868be18e287e756019da7607b5"
 dependencies = [
- "nix",
- "windows-sys 0.48.0",
+ "ctor-proc-macro",
+ "dtor",
 ]
 
 [[package]]
-name = "custom_derive"
-version = "0.1.7"
+name = "ctor-proc-macro"
+version = "0.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef8ae57c4978a2acd8b869ce6b9ca1dfe817bff704c220209fdef2c0b75a01b9"
+checksum = "4f211af61d8efdd104f96e57adf5e426ba1bc3ed7a4ead616e15e5881fd79c4d"
+
+[[package]]
+name = "ctrlc"
+version = "3.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46f93780a459b7d656ef7f071fe699c4d3d2cb201c4b24d085b6ddc505276e73"
+dependencies = [
+ "nix",
+ "windows-sys 0.59.0",
+]
 
 [[package]]
 name = "data-encoding"
-version = "2.4.0"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
 
 [[package]]
 name = "data-encoding-macro"
-version = "0.1.13"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c904b33cc60130e1aeea4956ab803d08a3f4a0ca82d64ed757afac3891f2bb99"
+checksum = "47ce6c96ea0102f01122a185683611bd5ac8d99e62bc59dd12e6bda344ee673d"
 dependencies = [
  "data-encoding",
  "data-encoding-macro-internal",
@@ -713,12 +782,53 @@ dependencies = [
 
 [[package]]
 name = "data-encoding-macro-internal"
-version = "0.1.11"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fdf3fce3ce863539ec1d7fd1b6dcc3c645663376b43ed376bbf887733e4f772"
+checksum = "8d162beedaa69905488a8da94f5ac3edb4dd4788b732fadb7bd120b2625c1976"
 dependencies = [
  "data-encoding",
- "syn 1.0.109",
+ "syn",
+]
+
+[[package]]
+name = "deranged"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30542c1ad912e0e3d22a1935c290e12e8a29d704a420177a31faad4a601a0800"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
@@ -735,23 +845,33 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
- "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
 name = "dlv-list"
-version = "0.5.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d529fd73d344663edfd598ccb3f344e46034db51ebd103518eae34338248ad73"
+checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
 dependencies = [
  "const-random",
 ]
 
 [[package]]
 name = "dns-lookup"
-version = "2.0.2"
+version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f332aa79f9e9de741ac013237294ef42ce2e9c6394dc7d766725812f1238812"
+checksum = "e5766087c2235fec47fafa4cfecc81e494ee679d0fd4a59887ea0919bfb0e4fc"
 dependencies = [
  "cfg-if",
  "libc",
@@ -759,62 +879,71 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "document-features"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
+dependencies = [
+ "litrs",
+]
+
+[[package]]
+name = "dtor"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97cbdf2ad6846025e8e25df05171abfb30e3ababa12ee0a0e44b9bbe570633a8"
+dependencies = [
+ "dtor-proc-macro",
+]
+
+[[package]]
+name = "dtor-proc-macro"
+version = "0.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7454e41ff9012c00d53cf7f475c5e3afa3b91b7c90568495495e8d9bf47a1055"
+
 [[package]]
 name = "dunce"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
 
 [[package]]
 name = "either"
-version = "1.8.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
 name = "encode_unicode"
-version = "0.3.6"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
 [[package]]
-name = "env_logger"
-version = "0.8.4"
+name = "equivalent"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a19187fea3ac7e84da7dacf48de0c45d63c6a76f9490dae389aead16c243fce3"
-dependencies = [
- "log",
- "regex",
-]
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "errno"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
+version = "0.3.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d"
 dependencies = [
- "cc",
  "libc",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "exacl"
-version = "0.10.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfeb22a59deb24c3262c43ffcafd1eb807180f371f9fcc99098d181b5d639be"
+checksum = "22be12de19decddab85d09f251ec8363f060ccb22ec9c81bc157c0c8433946d8"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "log",
  "scopeguard",
  "uuid",
@@ -822,9 +951,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.0.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
 name = "file_diff"
@@ -832,164 +961,166 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "31a7a908b8f32538a2143e59a6e4e2508988832d5d4d6f7c156b3cbc762643a5"
 
+[[package]]
+name = "filedescriptor"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d"
+dependencies = [
+ "libc",
+ "thiserror 1.0.69",
+ "winapi",
+]
+
 [[package]]
 name = "filetime"
-version = "0.2.22"
+version = "0.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4029edd3e734da6fe05b6cd7bd2960760a616bd2ddd0d59a0124746d6272af0"
+checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
- "windows-sys 0.48.0",
+ "libredox",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "flate2"
-version = "1.0.24"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
+checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece"
 dependencies = [
  "crc32fast",
+ "libz-rs-sys",
  "miniz_oxide",
 ]
 
 [[package]]
-name = "fnv"
-version = "1.0.7"
+name = "fluent"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+checksum = "8137a6d5a2c50d6b0ebfcb9aaa91a28154e0a70605f112d30cb0cd4a78670477"
+dependencies = [
+ "fluent-bundle",
+ "unic-langid",
+]
 
 [[package]]
-name = "fs_extra"
-version = "1.3.0"
+name = "fluent-bundle"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+checksum = "01203cb8918f5711e73891b347816d932046f95f54207710bda99beaeb423bf4"
+dependencies = [
+ "fluent-langneg",
+ "fluent-syntax",
+ "intl-memoizer",
+ "intl_pluralrules",
+ "rustc-hash",
+ "self_cell",
+ "smallvec",
+ "unic-langid",
+]
 
 [[package]]
-name = "fsevent-sys"
-version = "4.1.0"
+name = "fluent-langneg"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+checksum = "2c4ad0989667548f06ccd0e306ed56b61bd4d35458d54df5ec7587c0e8ed5e94"
 dependencies = [
- "libc",
+ "unic-langid",
 ]
 
 [[package]]
-name = "fts-sys"
-version = "0.2.4"
+name = "fluent-syntax"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a66c0a21e344f20c87b4ca12643cf4f40a7018f132c98d344e989b959f49dd1"
+checksum = "54f0d287c53ffd184d04d8677f590f4ac5379785529e5e08b1c8083acdd5c198"
 dependencies = [
- "bindgen",
- "libc",
+ "memchr",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
-name = "fundu"
-version = "2.0.0"
+name = "fnv"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c04cb831a8dccadfe3774b07cba4574a1ec24974d761510e65d8a543c2d7cb4"
-dependencies = [
- "fundu-core",
-]
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
-name = "fundu-core"
-version = "0.3.0"
+name = "foldhash"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76a889e633afd839fb5b04fe53adfd588cefe518e71ec8d3c929698c6daf2acd"
+checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
 
 [[package]]
-name = "futures"
-version = "0.3.28"
+name = "fs_extra"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
 [[package]]
-name = "futures-channel"
-version = "0.3.28"
+name = "fsevent-sys"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
 dependencies = [
- "futures-core",
- "futures-sink",
+ "libc",
 ]
 
 [[package]]
-name = "futures-core"
-version = "0.3.28"
+name = "fts-sys"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "43119ec0f2227f8505c8bb6c60606b5eefc328607bfe1a421e561c4decfa02ab"
+dependencies = [
+ "bindgen",
+ "libc",
+]
 
 [[package]]
-name = "futures-executor"
-version = "0.3.28"
+name = "funty"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
-name = "futures-io"
-version = "0.3.28"
+name = "futures-core"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.23",
+ "syn",
 ]
 
-[[package]]
-name = "futures-sink"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
-
 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
 [[package]]
 name = "futures-timer"
-version = "3.0.2"
+version = "3.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
 
 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
- "futures-channel",
  "futures-core",
- "futures-io",
  "futures-macro",
- "futures-sink",
  "futures-task",
- "memchr",
  "pin-project-lite",
  "pin-utils",
  "slab",
@@ -1003,9 +1134,9 @@ checksum = "1d758ba1b47b00caf47f24925c0074ecb20d6dfcffe7f6d53395c0465674841a"
 
 [[package]]
 name = "generic-array"
-version = "0.14.6"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -1013,41 +1144,59 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.9"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi",
+ "wasi 0.11.0+wasi-snapshot-preview1",
 ]
 
 [[package]]
-name = "glob"
+name = "getrandom"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.13.3+wasi-0.2.2",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
 [[package]]
 name = "half"
-version = "2.2.1"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b4af3693f1b705df946e9fe5631932443781d0aabb423b62fcd4d73f6d2fd0"
+checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
 dependencies = [
+ "cfg-if",
  "crunchy",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.13.2"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
-name = "hermit-abi"
-version = "0.3.2"
+name = "hashbrown"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
 
 [[package]]
 name = "hex"
@@ -1057,33 +1206,34 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hex-literal"
-version = "0.4.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
+checksum = "bcaaec4551594c969335c98c903c1397853d4198408ea609190f420500f6be71"
 
 [[package]]
 name = "hostname"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
+checksum = "a56f203cd1c76362b69e3863fd987520ac36cf70a8c92627449b2f64a8cf7d65"
 dependencies = [
+ "cfg-if",
  "libc",
- "match_cfg",
- "winapi",
+ "windows-link",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.53"
+version = "0.1.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
+ "log",
  "wasm-bindgen",
- "winapi",
+ "windows-core",
 ]
 
 [[package]]
@@ -1095,25 +1245,36 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "indexmap"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.15.2",
+]
+
 [[package]]
 name = "indicatif"
-version = "0.17.3"
+version = "0.17.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cef509aa9bc73864d6756f0d34d35504af3cf0844373afe9b8669a5b8005a729"
+checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
 dependencies = [
  "console",
  "number_prefix",
  "portable-atomic",
- "unicode-width",
+ "unicode-width 0.2.0",
+ "web-time",
 ]
 
 [[package]]
 name = "inotify"
-version = "0.9.6"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
+checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "inotify-sys",
  "libc",
 ]
@@ -1128,65 +1289,78 @@ dependencies = [
 ]
 
 [[package]]
-name = "io-lifetimes"
-version = "1.0.11"
+name = "intl-memoizer"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
+checksum = "310da2e345f5eb861e7a07ee182262e94975051db9e4223e909ba90f392f163f"
 dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys 0.48.0",
+ "type-map",
+ "unic-langid",
 ]
 
 [[package]]
-name = "is-terminal"
-version = "0.4.9"
+name = "intl_pluralrules"
+version = "7.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
+checksum = "078ea7b7c29a2b4df841a7f6ac8775ff6074020c6776d48491ce2268e068f972"
 dependencies = [
- "hermit-abi",
- "rustix 0.38.8",
- "windows-sys 0.48.0",
+ "unic-langid",
 ]
 
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
 [[package]]
 name = "itertools"
-version = "0.11.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "itoa"
-version = "1.0.4"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4217ad341ebadf8d8e724e264f13e593e0648f5b3e94b3896a5df283be015ecc"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "js-sys"
-version = "0.3.64"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
 dependencies = [
+ "once_cell",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "keccak"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
 dependencies = [
  "cpufeatures",
 ]
 
 [[package]]
 name = "kqueue"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c8fc60ba15bf51257aa9807a48a61013db043fcf3a78cb0d916e8e396dcad98"
+checksum = "7447f1ca1b7b563588a205fe93dea8df60fd981423a768bc1c0ded35ed147d0c"
 dependencies = [
  "kqueue-sys",
  "libc",
@@ -1194,9 +1368,9 @@ dependencies = [
 
 [[package]]
 name = "kqueue-sys"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8367585489f01bc55dd27404dcf56b95e6da061a256a666ab23be9ba96a2e587"
+checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
 dependencies = [
  "bitflags 1.3.2",
  "libc",
@@ -1204,123 +1378,136 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "lazycell"
-version = "1.3.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.147"
+version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
 [[package]]
 name = "libloading"
-version = "0.7.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "winapi",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
 name = "libm"
-version = "0.2.7"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+checksum = "8355be11b20d696c8f18f6cc018c4e372165b1fa8126cef092399c9951984ffa"
 
 [[package]]
-name = "linux-raw-sys"
-version = "0.1.4"
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.9.0",
+ "libc",
+ "redox_syscall",
+]
+
+[[package]]
+name = "libz-rs-sys"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
+checksum = "6489ca9bd760fe9642d7644e827b0c9add07df89857b0416ee15c1cc1a3b8c5a"
+dependencies = [
+ "zlib-rs",
+]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.3.8"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.5"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+
+[[package]]
+name = "litrs"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
 
 [[package]]
 name = "lock_api"
-version = "0.4.9"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
 dependencies = [
  "autocfg",
  "scopeguard",
 ]
 
+[[package]]
+name = "lockfree-object-pool"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9374ef4228402d4b7e403e5838cb880d9ee663314b0a900d5a6aabf0c213552e"
+
 [[package]]
 name = "log"
-version = "0.4.17"
+version = "0.4.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+checksum = "30bde2b3dc3671ae49d8e2e9f044c7c005836e7a023ee57cffa25ab82764bb9e"
+
+[[package]]
+name = "lru"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38"
 dependencies = [
- "cfg-if",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
 name = "lscolors"
-version = "0.15.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf7015a04103ad78abb77e4b79ed151e767922d1cfde5f62640471c629a2320d"
+checksum = "61183da5de8ba09a58e330d55e5ea796539d8443bd00fdeb863eac39724aa4ab"
 dependencies = [
+ "aho-corasick",
  "nu-ansi-term",
 ]
 
-[[package]]
-name = "match_cfg"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
-
 [[package]]
 name = "md-5"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6365506850d44bff6e2fbcb5176cf63650e48bd45ef2fe2665ae1570e0f4b9ca"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
 dependencies = [
+ "cfg-if",
  "digest",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.6.2"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5486aed0026218e61b8a01d5fbd5a0a134649abb71a0e53b7bc088529dced86e"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memmap2"
-version = "0.7.0"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "180d4b35be83d33392d1d1bfbd2ae1eca7ff5de1a94d3fc87faaa99a069e7cbd"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
 dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -1329,35 +1516,35 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.5.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
+checksum = "8e3e04debbb59698c15bacbb6d93584a8c0ca9cc3213cb423d31f760d8843ce5"
 dependencies = [
- "adler",
+ "adler2",
 ]
 
 [[package]]
 name = "mio"
-version = "0.8.6"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
 dependencies = [
  "libc",
  "log",
- "wasi",
- "windows-sys 0.45.0",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "nix"
-version = "0.26.2"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfdda3d196821d6af13126e40375cdf7da646a96114af134d5f417a9a1dc8e1a"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "cfg-if",
+ "cfg_aliases",
  "libc",
- "static_assertions",
 ]
 
 [[package]]
@@ -1370,78 +1557,116 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "notify"
-version = "6.0.1"
+version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5738a2795d57ea20abec2d6d76c6081186709c0024187cd5977265eda6598b51"
+checksum = "2fee8403b3d66ac7b26aee6e40a897d85dc5ce26f44da36b8b73e987cc52e943"
 dependencies = [
- "bitflags 1.3.2",
- "crossbeam-channel",
+ "bitflags 2.9.0",
  "filetime",
  "fsevent-sys",
  "inotify",
  "kqueue",
  "libc",
+ "log",
  "mio",
+ "notify-types",
  "walkdir",
- "windows-sys 0.45.0",
+ "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "notify-types"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e0826a989adedc2a244799e823aece04662b66609d96af8dff7ac6df9a8925d"
+
 [[package]]
 name = "nu-ansi-term"
-version = "0.49.0"
+version = "0.50.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c073d3c1930d0751774acf49e66653acecb416c3a54c6ec095a9b11caddb5a68"
+checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "num-bigint"
-version = "0.4.4"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
- "autocfg",
  "num-integer",
  "num-traits",
+ "rand 0.8.5",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
  "num-traits",
 ]
 
 [[package]]
-name = "num-traits"
-version = "0.2.16"
+name = "num-modular"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
+checksum = "64a5fe11d4135c3bcdf3a95b18b194afa9608a5f6ff034f5d857bc9a27fb0119"
 dependencies = [
- "autocfg",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
-name = "num_cpus"
-version = "1.16.0"
+name = "num-prime"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+checksum = "e238432a7881ec7164503ccc516c014bf009be7984cde1ba56837862543bdec3"
 dependencies = [
- "hermit-abi",
- "libc",
+ "bitvec",
+ "either",
+ "lru",
+ "num-bigint",
+ "num-integer",
+ "num-modular",
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
 ]
 
 [[package]]
 name = "num_threads"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
 dependencies = [
  "libc",
 ]
@@ -1454,17 +1679,17 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
 
 [[package]]
 name = "onig"
-version = "6.4.0"
+version = "6.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c4b31c8722ad9171c6d77d3557db078cab2bd50afcc9d09c8b315c59df8ca4f"
+checksum = "336b9c63443aceef14bea841b899035ae3abe89b7c486aaf4c5bd8aafedac3f0"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "libc",
  "once_cell",
  "onig_sys",
@@ -1472,9 +1697,9 @@ dependencies = [
 
 [[package]]
 name = "onig_sys"
-version = "69.8.1"
+version = "69.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b829e3d7e9cc74c7e315ee8edb185bf4190da5acde74afd7fc59c35b1f086e7"
+checksum = "c7f86c6eef3d6df15f23bcfb6af487cbd2fed4e5581d58d5bf1f5f8b7f6727dc"
 dependencies = [
  "cc",
  "pkg-config",
@@ -1482,28 +1707,28 @@ dependencies = [
 
 [[package]]
 name = "ordered-multimap"
-version = "0.6.0"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ed8acf08e98e744e5384c8bc63ceb0364e68a6854187221c18df61c4797690e"
+checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
 dependencies = [
  "dlv-list",
- "hashbrown",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
 name = "os_display"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a6229bad892b46b0dcfaaeb18ad0d2e56400f5aaea05b768bde96e73676cf75"
+checksum = "ad5fd71b79026fb918650dde6d125000a233764f1c2f1659a1c71118e33ea08f"
 dependencies = [
- "unicode-width",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]
 name = "parking_lot"
-version = "0.12.1"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -1511,47 +1736,51 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.8"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets 0.48.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "parse_datetime"
-version = "0.4.0"
+name = "parse-zoneinfo"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fecceaede7767a9a98058687a321bc91742eff7670167a34104afb30fc8757df"
+checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
 dependencies = [
- "chrono",
  "regex",
 ]
 
 [[package]]
-name = "peeking_take_while"
-version = "0.1.2"
+name = "parse_datetime"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+checksum = "2fd3830b49ee3a0dcc8fdfadc68c6354c97d00101ac1cac5b2eee25d35c42066"
+dependencies = [
+ "chrono",
+ "nom 8.0.0",
+ "regex",
+]
 
 [[package]]
 name = "phf"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
  "phf_shared",
 ]
 
 [[package]]
 name = "phf_codegen"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
 dependencies = [
  "phf_generator",
  "phf_shared",
@@ -1559,28 +1788,28 @@ dependencies = [
 
 [[package]]
 name = "phf_generator"
-version = "0.11.1"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1181c94580fa345f50f19d738aaa39c0ed30a600d95cb2d3e23f94266f14fbf"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
  "phf_shared",
- "rand",
+ "rand 0.8.5",
 ]
 
 [[package]]
 name = "phf_shared"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
 dependencies = [
  "siphasher",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "pin-utils"
@@ -1590,15 +1819,15 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.26"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
 [[package]]
 name = "platform-info"
-version = "2.0.2"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6259c4860e53bf665016f1b2f46a8859cadfa717581dc9d597ae4069de6300f"
+checksum = "7539aeb3fdd8cb4f6a331307cf71a1039cee75e94e8a71725b9484f4a0d9451a"
 dependencies = [
  "libc",
  "winapi",
@@ -1606,80 +1835,106 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "0.3.15"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15eb2c6e362923af47e13c23ca5afb859e83d54452c55b0b9ac763b8f7c1ac16"
+checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
 
 [[package]]
 name = "pretty_assertions"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
 dependencies = [
  "diff",
  "yansi",
 ]
 
 [[package]]
-name = "proc-macro-hack"
-version = "0.5.20+deprecated"
+name = "prettyplease"
+version = "0.2.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
+checksum = "f1ccf34da56fc294e7d4ccf69a85992b7dfb826b7cf57bac6a70bba3494cc08a"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
+dependencies = [
+ "toml_edit",
+]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.63"
+version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "procfs"
-version = "0.15.1"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "943ca7f9f29bab5844ecd8fdb3992c5969b6622bb9609b9502fef9b4310e3f1f"
+checksum = "cc5b72d8145275d844d4b5f6d4e1eef00c8cd889edb6035c21675d1bb1f45c9f"
 dependencies = [
- "bitflags 1.3.2",
- "byteorder",
+ "bitflags 2.9.0",
  "hex",
- "lazy_static",
- "rustix 0.36.15",
+ "procfs-core",
+ "rustix 0.38.44",
 ]
 
 [[package]]
-name = "quick-error"
-version = "2.0.1"
+name = "procfs-core"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
-[[package]]
-name = "quickcheck"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+checksum = "239df02d8349b06fc07398a3a1697b06418223b1c7725085e801e7c0fc6a12ec"
 dependencies = [
- "env_logger",
- "log",
- "rand",
+ "bitflags 2.9.0",
+ "hex",
 ]
 
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
 [[package]]
 name = "quote"
-version = "1.0.29"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "573015e8ab27661678357f27dc26460738fd2b6c86e46f386fde94cb5d913105"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -1687,8 +1942,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -1698,7 +1963,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
@@ -1707,23 +1982,23 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
 ]
 
 [[package]]
-name = "rand_pcg"
-version = "0.3.1"
+name = "rand_core"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "rand_core",
+ "getrandom 0.3.1",
 ]
 
 [[package]]
 name = "rayon"
-version = "1.7.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
  "either",
  "rayon-core",
@@ -1731,36 +2006,28 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
- "num_cpus",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.3.5"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
 ]
 
-[[package]]
-name = "reference-counted-singleton"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bfbf25d7eb88ddcbb1ec3d755d0634da8f7657b2cb8b74089121409ab8228f"
-
 [[package]]
 name = "regex"
-version = "1.9.5"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1770,9 +2037,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1781,125 +2048,118 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.5"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "relative-path"
-version = "1.8.0"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bf2521270932c3c7bed1a59151222bd7643c79310f2916f01925e1e16255698"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 
 [[package]]
 name = "rlimit"
-version = "0.10.1"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3560f70f30a0f16d11d01ed078a07740fe6b489667abc7c7b029155d9f21c3d8"
+checksum = "7043b63bd0cd1aaa628e476b80e6d4023a3b50eb32789f2728908107bd0c793a"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "roff"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b833d8d034ea094b1ea68aa6d5c740e0d04bad9d16568d08ba6f76823a114316"
+checksum = "88f8660c1ff60292143c98d08fc6e2f654d722db50410e3f3797d40baaf9d8f3"
 
 [[package]]
 name = "rstest"
-version = "0.18.2"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97eeab2f3c0a199bc4be135c36c924b6590b88c377d416494288c14f2db30199"
+checksum = "6fc39292f8613e913f7df8fa892b8944ceb47c247b78e1b1ae2f09e019be789d"
 dependencies = [
- "futures",
  "futures-timer",
+ "futures-util",
  "rstest_macros",
  "rustc_version",
 ]
 
 [[package]]
 name = "rstest_macros"
-version = "0.18.2"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d428f8247852f894ee1be110b375111b586d4fa431f6c46e64ba5a0dcccbe605"
+checksum = "1f168d99749d307be9de54d23fd226628d99768225ef08f6ffb52e0182a27746"
 dependencies = [
  "cfg-if",
  "glob",
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
  "regex",
  "relative-path",
  "rustc_version",
- "syn 2.0.23",
+ "syn",
  "unicode-ident",
 ]
 
 [[package]]
 name = "rust-ini"
-version = "0.19.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e2a3bcec1f113553ef1c88aae6c020a369d03d55b58de9869a0908930385091"
+checksum = "4e310ef0e1b6eeb79169a1171daf9abcb87a2e17c03bee2c4bb100b55c75409f"
 dependencies = [
  "cfg-if",
  "ordered-multimap",
+ "trim-in-place",
 ]
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
 name = "rustc_version"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
 dependencies = [
  "semver",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.36.15"
+version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c37f1bd5ef1b5422177b7646cba67430579cfe2ace80f284fee876bca52ad941"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "errno",
- "io-lifetimes",
  "libc",
- "linux-raw-sys 0.1.4",
- "windows-sys 0.45.0",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.37.23"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
+checksum = "dade4812df5c384711475be5fcd8c162555352945401aed22a35bffeab61f657"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "errno",
- "io-lifetimes",
  "libc",
- "linux-raw-sys 0.3.8",
- "windows-sys 0.48.0",
+ "linux-raw-sys 0.9.4",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "rustix"
-version = "0.38.8"
+name = "rustversion"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19ed4fa021d81c8392ce04db050a3da9a60299050b7ae1cf482d862b54a7218f"
-dependencies = [
- "bitflags 2.3.3",
- "errno",
- "libc",
- "linux-raw-sys 0.4.5",
- "windows-sys 0.48.0",
-]
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
 
 [[package]]
 name = "same-file"
@@ -1912,35 +2172,35 @@ dependencies = [
 
 [[package]]
 name = "scopeguard"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "self_cell"
-version = "1.0.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c309e515543e67811222dbc9e3dd7e1056279b782e1dacffe4242b718734fb6"
+checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
 
 [[package]]
 name = "selinux"
-version = "0.4.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a00576725d21b588213fbd4af84cd7e4cc4304e8e9bd6c0f5a1498a3e2ca6a51"
+checksum = "e37f432dfe840521abd9a72fefdf88ed7ad0f43bbea7d9d1d3d80383e9f4ad13"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.0",
  "libc",
  "once_cell",
- "reference-counted-singleton",
+ "parking_lot",
  "selinux-sys",
- "thiserror",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
 name = "selinux-sys"
-version = "0.6.2"
+version = "0.6.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "806d381649bb85347189d2350728817418138d11d738e2482cb644ec7f3c755d"
+checksum = "280da3df1236da180be5ac50a893b26a1d3c49e3a44acb2d10d1f082523ff916"
 dependencies = [
  "bindgen",
  "cc",
@@ -1950,21 +2210,44 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.14"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
+checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0"
 
 [[package]]
 name = "serde"
-version = "1.0.147"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-big-array"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11fc7cc2c76d73e0f27ee52abbd64eec84d46f370c88371120433196934e4b7f"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d193d69bae983fc11a79df82342761dfbf28a99fc8d203dca4c3c1b590948965"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "sha1"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -1973,9 +2256,9 @@ dependencies = [
 
 [[package]]
 name = "sha2"
-version = "0.10.7"
+version = "0.10.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
  "cpufeatures",
@@ -1994,15 +2277,15 @@ dependencies = [
 
 [[package]]
 name = "shlex"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "signal-hook"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
 dependencies = [
  "libc",
  "signal-hook-registry",
@@ -2010,9 +2293,9 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-mio"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af"
+checksum = "34db1a06d485c9142248b7a054f034b349b212551f3dfd19c94d45a754a217cd"
 dependencies = [
  "libc",
  "mio",
@@ -2021,24 +2304,30 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
 dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
 [[package]]
 name = "siphasher"
-version = "0.3.10"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "slab"
-version = "0.4.7"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
  "autocfg",
 ]
@@ -2054,49 +2343,37 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
 
 [[package]]
 name = "smawk"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"
+checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
 
 [[package]]
 name = "socket2"
-version = "0.5.3"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2538b18701741680e0322a2302176d3253a35388e2e62f172f64f4f16605f877"
+checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8"
 dependencies = [
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
 [[package]]
 name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "subtle"
-version = "2.4.1"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+checksum = "e02e925281e18ffd9d640e234264753c43edc62d64b2d4cf898f1bc5e75f3fc2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2104,89 +2381,98 @@ dependencies = [
 ]
 
 [[package]]
-name = "syn"
-version = "2.0.23"
+name = "tap"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59fb7d6d8281a51045d62b8eb3a7d1ce347b76f312af50cd3dc0af39c87c1737"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
-version = "3.8.0"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
- "cfg-if",
  "fastrand",
- "redox_syscall",
- "rustix 0.38.8",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "term_grid"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "230d3e804faaed5a39b08319efb797783df2fd9671b39b7596490cb486d702cf"
-dependencies = [
- "unicode-width",
+ "getrandom 0.3.1",
+ "once_cell",
+ "rustix 1.0.1",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "terminal_size"
-version = "0.2.6"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e6bf6f19e9f8ed8d4048dc22981458ebcf406d67e94cd422e5ecd73d63b3237"
+checksum = "45c6481c4829e4cc63825e62c49186a34538b7b2750b73b266581ffb612fb5ed"
 dependencies = [
- "rustix 0.37.23",
- "windows-sys 0.48.0",
+ "rustix 1.0.1",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "textwrap"
-version = "0.16.0"
+version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
 dependencies = [
  "smawk",
  "terminal_size",
  "unicode-linebreak",
- "unicode-width",
+ "unicode-width 0.2.0",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
 ]
 
 [[package]]
 name = "thiserror"
-version = "1.0.37"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+dependencies = [
+ "thiserror-impl 2.0.12",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
- "thiserror-impl",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.37"
+version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn",
 ]
 
 [[package]]
 name = "time"
-version = "0.3.20"
+version = "0.3.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
+checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
 dependencies = [
+ "deranged",
  "itoa",
  "libc",
+ "num-conv",
  "num_threads",
+ "powerfmt",
  "serde",
  "time-core",
  "time-macros",
@@ -2194,16 +2480,17 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.0"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
 
 [[package]]
 name = "time-macros"
-version = "0.2.8"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
+checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49"
 dependencies = [
+ "num-conv",
  "time-core",
 ]
 
@@ -2216,17 +2503,77 @@ dependencies = [
  "crunchy",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
+
+[[package]]
+name = "toml_edit"
+version = "0.22.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "trim-in-place"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "343e926fc669bc8cde4fa3129ab681c63671bae288b1f1081ceee6d9d37904fc"
+
+[[package]]
+name = "type-map"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90"
+dependencies = [
+ "rustc-hash",
+]
+
 [[package]]
 name = "typenum"
-version = "1.15.0"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
+[[package]]
+name = "unic-langid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ba52c9b05311f4f6e62d5d9d46f094bd6e84cb8df7b3ef952748d752a7d05"
+dependencies = [
+ "unic-langid-impl",
+]
+
+[[package]]
+name = "unic-langid-impl"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+checksum = "dce1bf08044d4b7a94028c93786f8566047edc11110595914de93362559bc658"
+dependencies = [
+ "tinystr",
+]
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.5"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unicode-linebreak"
@@ -2236,37 +2583,73 @@ checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.1"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.10"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "unindent"
-version = "0.2.1"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
+
+[[package]]
+name = "unty"
+version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aa30f5ea51ff7edfc797c6d3f9ec8cbd8cfedef5371766b7181d33977f4814f"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
 
 [[package]]
 name = "utf8parse"
-version = "0.2.1"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "utmp-classic"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e24c654e19afaa6b8f3877ece5d3bed849c2719c56f6752b18ca7da4fcc6e85a"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "thiserror 1.0.69",
+ "time",
+ "utmp-classic-raw",
+ "zerocopy",
+]
+
+[[package]]
+name = "utmp-classic-raw"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+checksum = "22c226537a3d6e01c440c1926ca0256dbee2d19b2229ede6fc4863a6493dd831"
+dependencies = [
+ "cfg-if",
+ "zerocopy",
+]
 
 [[package]]
 name = "uu_arch"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "platform-info",
@@ -2275,7 +2658,7 @@ dependencies = [
 
 [[package]]
 name = "uu_base32"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2283,15 +2666,16 @@ dependencies = [
 
 [[package]]
 name = "uu_base64"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
+ "clap",
  "uu_base32",
  "uucore",
 ]
 
 [[package]]
 name = "uu_basename"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2299,7 +2683,7 @@ dependencies = [
 
 [[package]]
 name = "uu_basenc"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uu_base32",
@@ -2308,30 +2692,30 @@ dependencies = [
 
 [[package]]
 name = "uu_cat"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "is-terminal",
+ "memchr",
  "nix",
- "thiserror",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_chcon"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "fts-sys",
  "libc",
  "selinux",
- "thiserror",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_chgrp"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2339,7 +2723,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chmod"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2348,7 +2732,7 @@ dependencies = [
 
 [[package]]
 name = "uu_chown"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2356,24 +2740,26 @@ dependencies = [
 
 [[package]]
 name = "uu_chroot"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_cksum"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "hex",
+ "regex",
  "uucore",
 ]
 
 [[package]]
 name = "uu_comm"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2381,13 +2767,14 @@ dependencies = [
 
 [[package]]
 name = "uu_cp"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "exacl",
  "filetime",
  "indicatif",
  "libc",
+ "linux-raw-sys 0.9.4",
  "quick-error",
  "selinux",
  "uucore",
@@ -2397,62 +2784,63 @@ dependencies = [
 
 [[package]]
 name = "uu_csplit"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "regex",
- "thiserror",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_cut"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "bstr",
  "clap",
- "is-terminal",
  "memchr",
  "uucore",
 ]
 
 [[package]]
 name = "uu_date"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "chrono",
  "clap",
  "libc",
  "parse_datetime",
  "uucore",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_dd"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "gcd",
  "libc",
  "nix",
  "signal-hook",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_df"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "tempfile",
- "unicode-width",
+ "thiserror 2.0.12",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_dir"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uu_ls",
@@ -2461,7 +2849,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dircolors"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2469,7 +2857,7 @@ dependencies = [
 
 [[package]]
 name = "uu_dirname"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2477,18 +2865,19 @@ dependencies = [
 
 [[package]]
 name = "uu_du"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "chrono",
  "clap",
  "glob",
+ "thiserror 2.0.12",
  "uucore",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_echo"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2496,50 +2885,53 @@ dependencies = [
 
 [[package]]
 name = "uu_env"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "nix",
  "rust-ini",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_expand"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "unicode-width",
+ "thiserror 2.0.12",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_expr"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "num-bigint",
  "num-traits",
  "onig",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_factor"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "coz",
+ "num-bigint",
+ "num-prime",
  "num-traits",
- "quickcheck",
- "rand",
+ "rand 0.9.1",
  "smallvec",
  "uucore",
 ]
 
 [[package]]
 name = "uu_false"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2547,16 +2939,16 @@ dependencies = [
 
 [[package]]
 name = "uu_fmt"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "unicode-width",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_fold"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2564,15 +2956,16 @@ dependencies = [
 
 [[package]]
 name = "uu_groups"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_hashsum"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "hex",
@@ -2583,16 +2976,17 @@ dependencies = [
 
 [[package]]
 name = "uu_head"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "memchr",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_hostid"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2601,17 +2995,18 @@ dependencies = [
 
 [[package]]
 name = "uu_hostname"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "dns-lookup",
  "hostname",
  "uucore",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_id"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "selinux",
@@ -2620,27 +3015,29 @@ dependencies = [
 
 [[package]]
 name = "uu_install"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "file_diff",
  "filetime",
  "libc",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_join"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "memchr",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_kill"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "nix",
@@ -2649,7 +3046,7 @@ dependencies = [
 
 [[package]]
 name = "uu_link"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2657,15 +3054,16 @@ dependencies = [
 
 [[package]]
 name = "uu_ln"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_logname"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2674,25 +3072,25 @@ dependencies = [
 
 [[package]]
 name = "uu_ls"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
+ "ansi-width",
  "chrono",
  "clap",
  "glob",
- "is-terminal",
+ "hostname",
  "lscolors",
  "number_prefix",
- "once_cell",
  "selinux",
- "term_grid",
  "terminal_size",
- "unicode-width",
+ "thiserror 2.0.12",
  "uucore",
+ "uutils_term_grid",
 ]
 
 [[package]]
 name = "uu_mkdir"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2700,7 +3098,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mkfifo"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2709,7 +3107,7 @@ dependencies = [
 
 [[package]]
 name = "uu_mknod"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2718,40 +3116,44 @@ dependencies = [
 
 [[package]]
 name = "uu_mktemp"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "rand",
+ "rand 0.9.1",
  "tempfile",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_more"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "crossterm",
- "is-terminal",
  "nix",
+ "tempfile",
  "unicode-segmentation",
- "unicode-width",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_mv"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "fs_extra",
  "indicatif",
+ "libc",
+ "thiserror 2.0.12",
  "uucore",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_nice"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2761,7 +3163,7 @@ dependencies = [
 
 [[package]]
 name = "uu_nl"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "regex",
@@ -2770,17 +3172,17 @@ dependencies = [
 
 [[package]]
 name = "uu_nohup"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "is-terminal",
  "libc",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_nproc"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2789,15 +3191,16 @@ dependencies = [
 
 [[package]]
 name = "uu_numfmt"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_od"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "byteorder",
  "clap",
@@ -2807,7 +3210,7 @@ dependencies = [
 
 [[package]]
 name = "uu_paste"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2815,7 +3218,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pathchk"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2824,7 +3227,7 @@ dependencies = [
 
 [[package]]
 name = "uu_pinky"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2832,19 +3235,19 @@ dependencies = [
 
 [[package]]
 name = "uu_pr"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "chrono",
  "clap",
- "itertools",
- "quick-error",
+ "itertools 0.14.0",
  "regex",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_printenv"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2852,7 +3255,7 @@ dependencies = [
 
 [[package]]
 name = "uu_printf"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2860,16 +3263,17 @@ dependencies = [
 
 [[package]]
 name = "uu_ptx"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "regex",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_pwd"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2877,7 +3281,7 @@ dependencies = [
 
 [[package]]
 name = "uu_readlink"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2885,15 +3289,7 @@ dependencies = [
 
 [[package]]
 name = "uu_realpath"
-version = "0.0.21"
-dependencies = [
- "clap",
- "uucore",
-]
-
-[[package]]
-name = "uu_relpath"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -2901,18 +3297,17 @@ dependencies = [
 
 [[package]]
 name = "uu_rm"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
  "uucore",
- "walkdir",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_rmdir"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -2921,95 +3316,98 @@ dependencies = [
 
 [[package]]
 name = "uu_runcon"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
  "selinux",
- "thiserror",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_seq"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "bigdecimal",
  "clap",
  "num-bigint",
  "num-traits",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_shred"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
- "rand",
+ "rand 0.9.1",
  "uucore",
 ]
 
 [[package]]
 name = "uu_shuf"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "memchr",
- "rand",
- "rand_core",
+ "rand 0.9.1",
+ "rand_core 0.9.3",
  "uucore",
 ]
 
 [[package]]
 name = "uu_sleep"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "fundu",
  "uucore",
 ]
 
 [[package]]
 name = "uu_sort"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "binary-heap-plus",
  "clap",
  "compare",
  "ctrlc",
  "fnv",
- "itertools",
+ "itertools 0.14.0",
  "memchr",
- "rand",
+ "nix",
+ "rand 0.9.1",
  "rayon",
  "self_cell",
  "tempfile",
- "unicode-width",
+ "thiserror 2.0.12",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_split"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "memchr",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_stat"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
+ "chrono",
  "clap",
  "uucore",
 ]
 
 [[package]]
 name = "uu_stdbuf"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "tempfile",
@@ -3019,17 +3417,16 @@ dependencies = [
 
 [[package]]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "cpp",
  "cpp_build",
  "libc",
- "uucore",
 ]
 
 [[package]]
 name = "uu_stty"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "nix",
@@ -3038,7 +3435,7 @@ dependencies = [
 
 [[package]]
 name = "uu_sum"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -3046,33 +3443,32 @@ dependencies = [
 
 [[package]]
 name = "uu_sync"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
  "nix",
  "uucore",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_tac"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "memchr",
  "memmap2",
  "regex",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_tail"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "fundu",
- "is-terminal",
  "libc",
  "memchr",
  "notify",
@@ -3080,31 +3476,30 @@ dependencies = [
  "same-file",
  "uucore",
  "winapi-util",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_tee"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "libc",
+ "nix",
  "uucore",
 ]
 
 [[package]]
 name = "uu_test"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
- "redox_syscall",
  "uucore",
 ]
 
 [[package]]
 name = "uu_timeout"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "libc",
@@ -3114,28 +3509,29 @@ dependencies = [
 
 [[package]]
 name = "uu_touch"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "chrono",
  "clap",
  "filetime",
  "parse_datetime",
+ "thiserror 2.0.12",
  "uucore",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_tr"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "nom",
+ "nom 8.0.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_true"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -3143,7 +3539,7 @@ dependencies = [
 
 [[package]]
 name = "uu_truncate"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -3151,25 +3547,25 @@ dependencies = [
 
 [[package]]
 name = "uu_tsort"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "thiserror 2.0.12",
  "uucore",
 ]
 
 [[package]]
 name = "uu_tty"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "is-terminal",
  "nix",
  "uucore",
 ]
 
 [[package]]
 name = "uu_uname"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "platform-info",
@@ -3178,16 +3574,17 @@ dependencies = [
 
 [[package]]
 name = "uu_unexpand"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "unicode-width",
+ "thiserror 2.0.12",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_uniq"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -3195,7 +3592,7 @@ dependencies = [
 
 [[package]]
 name = "uu_unlink"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -3203,24 +3600,27 @@ dependencies = [
 
 [[package]]
 name = "uu_uptime"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "chrono",
  "clap",
+ "thiserror 2.0.12",
+ "utmp-classic",
  "uucore",
 ]
 
 [[package]]
 name = "uu_users"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
+ "utmp-classic",
  "uucore",
 ]
 
 [[package]]
 name = "uu_vdir"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uu_ls",
@@ -3229,20 +3629,20 @@ dependencies = [
 
 [[package]]
 name = "uu_wc"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "bytecount",
  "clap",
  "libc",
  "nix",
- "thiserror",
- "unicode-width",
+ "thiserror 2.0.12",
+ "unicode-width 0.2.0",
  "uucore",
 ]
 
 [[package]]
 name = "uu_who"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
  "uucore",
@@ -3250,63 +3650,75 @@ dependencies = [
 
 [[package]]
 name = "uu_whoami"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "libc",
  "uucore",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "uu_yes"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "clap",
- "itertools",
+ "itertools 0.14.0",
  "nix",
  "uucore",
 ]
 
 [[package]]
 name = "uucore"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
+ "bigdecimal",
  "blake2b_simd",
  "blake3",
+ "chrono",
+ "chrono-tz",
  "clap",
+ "crc32fast",
  "data-encoding",
  "data-encoding-macro",
  "digest",
  "dns-lookup",
  "dunce",
+ "fluent",
+ "fluent-bundle",
  "glob",
  "hex",
- "itertools",
+ "iana-time-zone",
+ "itertools 0.14.0",
  "libc",
  "md-5",
  "memchr",
  "nix",
- "once_cell",
+ "num-traits",
+ "number_prefix",
  "os_display",
+ "regex",
+ "selinux",
  "sha1",
  "sha2",
  "sha3",
  "sm3",
  "tempfile",
- "thiserror",
+ "thiserror 2.0.12",
  "time",
+ "unic-langid",
+ "utmp-classic",
  "uucore_procs",
  "walkdir",
  "wild",
  "winapi-util",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
+ "xattr",
  "z85",
 ]
 
 [[package]]
 name = "uucore_procs"
-version = "0.0.21"
+version = "0.1.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3315,28 +3727,60 @@ dependencies = [
 
 [[package]]
 name = "uuhelp_parser"
-version = "0.0.21"
+version = "0.1.0"
 
 [[package]]
 name = "uuid"
-version = "1.2.2"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "422ee0de9031b5b948b97a8fc04e3aa35230001a722ddd27943e0be31564ce4c"
+checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587"
+
+[[package]]
+name = "uutests"
+version = "0.1.0"
+dependencies = [
+ "ctor",
+ "glob",
+ "libc",
+ "nix",
+ "pretty_assertions",
+ "rand 0.9.1",
+ "regex",
+ "rlimit",
+ "tempfile",
+ "time",
+ "uucore",
+ "xattr",
+]
+
+[[package]]
+name = "uutils_term_grid"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcba141ce511bad08e80b43f02976571072e1ff4286f7d628943efbd277c6361"
+dependencies = [
+ "ansi-width",
+]
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
 
 [[package]]
 name = "walkdir"
-version = "2.3.2"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
  "same-file",
- "winapi",
  "winapi-util",
 ]
 
@@ -3346,36 +3790,46 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.87"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
+ "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.87"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.23",
+ "syn",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.87"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3383,39 +3837,41 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.87"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.23",
+ "syn",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.87"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
-name = "which"
-version = "4.3.0"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
- "either",
- "libc",
- "once_cell",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
 name = "wild"
-version = "2.1.0"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b116685a6be0c52f5a103334cbff26db643826c7b3735fc0a3ba9871310a74"
+checksum = "a3131afc8c575281e1e80f36ed6a092aa502c08b18ed7524e86fbbb12bb410e1"
 dependencies = [
  "glob",
 ]
@@ -3438,11 +3894,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -3452,12 +3908,62 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "windows-sys"
-version = "0.45.0"
+name = "windows-core"
+version = "0.60.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca21a92a9cae9bf4ccae5cf8368dce0837100ddf6e6d57936749e85f152f6247"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83577b051e2f49a058c308f17f273b570a6a758386fc291b5f6a934dd84e48c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+
+[[package]]
+name = "windows-result"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "06374efe858fab7e4f881500e6e86ec8bc28f9462c47e5a9941a0142ad86b189"
 dependencies = [
- "windows-targets 0.42.2",
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87fa48cc5d406560701792be122a10132491cff9d0aeb23583cc2dcafc847319"
+dependencies = [
+ "windows-link",
 ]
 
 [[package]]
@@ -3466,152 +3972,263 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "windows-targets 0.48.0",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
 dependencies = [
- "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",
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.48.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 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",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.48.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.0"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.42.2"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.0"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winnow"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+dependencies = [
+ "bitflags 2.9.0",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
 
 [[package]]
 name = "xattr"
-version = "1.0.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4686009f71ff3e5c4dbcf1a282d0a44db3f021ba69350cd42086b3e5f1c6985"
+checksum = "0d65cbf2f12c15564212d48f4e3dfb87923d25d611f2aed18f4cb23f0413d89e"
 dependencies = [
  "libc",
+ "rustix 1.0.1",
 ]
 
 [[package]]
 name = "yansi"
-version = "0.5.1"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
 name = "z85"
-version = "3.0.5"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a599daf1b507819c1121f0bf87fa37eb19daac6aff3aefefd4e6e2e0f2020fc"
+checksum = "9b3a41ce106832b4da1c065baa4c31cf640cf965fa1483816402b7f6b96f0a64"
 
 [[package]]
-name = "zip"
-version = "0.6.6"
+name = "zerocopy"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
  "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+
+[[package]]
+name = "zerovec"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
+dependencies = [
+ "zerofrom",
+]
+
+[[package]]
+name = "zip"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "153a6fff49d264c4babdcfa6b4d534747f520e56e8f0f384f3b808c4b64cc1fd"
+dependencies = [
+ "arbitrary",
  "crc32fast",
- "crossbeam-utils",
  "flate2",
+ "indexmap",
+ "memchr",
+ "zopfli",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "868b928d7949e09af2f6086dfc1e01936064cc7a819253bce650d4e2a2d63ba8"
+
+[[package]]
+name = "zopfli"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5019f391bac5cf252e93bbcc53d039ffd62c7bfb7c150414d61369afe57e946"
+dependencies = [
+ "bumpalo",
+ "crc32fast",
+ "lockfree-object-pool",
+ "log",
+ "once_cell",
+ "simd-adler32",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 320aa0f4307..4a61b5f0321 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,25 +1,26 @@
 # coreutils (uutils)
 # * see the repository LICENSE, README, and CONTRIBUTING files for more information
 
-# spell-checker:ignore (libs) bigdecimal datetime fundu gethostid kqueue libselinux mangen memmap procfs uuhelp
+# spell-checker:ignore (libs) bigdecimal datetime serde bincode gethostid kqueue libselinux mangen memmap procfs uuhelp startswith constness expl
 
 [package]
 name = "coreutils"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
 default-run = "coreutils"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils"
 readme = "README.md"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-rust-version = "1.64.0"
-edition = "2021"
-
+rust-version = "1.85.0"
 build = "build.rs"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
 
 [features]
 default = ["feat_common_core"]
@@ -30,6 +31,9 @@ windows = ["feat_os_windows"]
 ## project-specific feature shortcodes
 nightly = []
 test_unimplemented = []
+expensive_tests = []
+# "test_risky_names" == enable tests that create problematic file names (would make a network share inaccessible to Windows, breaks SVN on Mac OS, etc.)
+test_risky_names = []
 # * only build `uudoc` when `--feature uudoc` is activated
 uudoc = ["zip", "dep:uuhelp_parser"]
 ## features
@@ -45,7 +49,12 @@ feat_acl = ["cp/feat_acl"]
 feat_selinux = [
   "cp/selinux",
   "id/selinux",
+  "install/selinux",
   "ls/selinux",
+  "mkdir/selinux",
+  "mkfifo/selinux",
+  "mknod/selinux",
+  "stat/selinux",
   "selinux",
   "feat_require_selinux",
 ]
@@ -100,7 +109,6 @@ feat_common_core = [
   "pwd",
   "readlink",
   "realpath",
-  "relpath",
   "rm",
   "rmdir",
   "seq",
@@ -145,7 +153,8 @@ feat_os_macos = [
   #
   "feat_require_unix_hostid",
 ]
-# "feat_os_unix" == set of utilities which can be built/run on modern/usual *nix platforms
+# "feat_os_unix" == set of utilities which can be built/run on modern/usual *nix platforms.
+# Also used for targets binding to the "musl" library (ref: <https://musl.libc.org/about.html>)
 feat_os_unix = [
   "feat_Tier1",
   #
@@ -167,13 +176,6 @@ feat_os_unix_gnueabihf = [
   "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_os_unix_android = [
   "feat_Tier1",
   #
@@ -241,6 +243,7 @@ feat_os_unix_redox = [
   "feat_common_core",
   #
   "chmod",
+  "stat",
   "uname",
 ]
 # "feat_os_windows_legacy" == slightly restricted set of utilities which can be built/run on early windows platforms (eg, "WinXP")
@@ -257,101 +260,120 @@ feat_os_windows_legacy = [
 # * 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"]
 
+[workspace.package]
+authors = ["uutils developers"]
+categories = ["command-line-utilities"]
+edition = "2024"
+homepage = "https://github.com/uutils/coreutils"
+keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
+license = "MIT"
+readme = "README.package.md"
+version = "0.1.0"
+
 [workspace.dependencies]
+ansi-width = "0.1.0"
 bigdecimal = "0.4"
 binary-heap-plus = "0.5.0"
-bstr = "1.6"
-bytecount = "0.6.3"
-byteorder = "1.4.3"
-chrono = { version = "^0.4.28", default-features = false, features = [
+bstr = "1.9.1"
+bytecount = "0.6.8"
+byteorder = "1.5.0"
+chrono = { version = "0.4.41", default-features = false, features = [
   "std",
   "alloc",
   "clock",
 ] }
-clap = { version = "4.3", features = ["wrap_help", "cargo"] }
-clap_complete = "4.3"
+chrono-tz = "0.10.0"
+clap = { version = "4.5", features = ["wrap_help", "cargo"] }
+clap_complete = "4.4"
 clap_mangen = "0.2"
 compare = "0.1.0"
-coz = { version = "0.1.3" }
-crossterm = ">=0.27.0"
-ctrlc = { version = "3.4", features = ["termination"] }
-exacl = "0.10.0"
+crossterm = "0.29.0"
+ctrlc = { version = "3.4.7", features = ["termination"] }
+dns-lookup = { version = "2.0.4" }
+exacl = "0.12.0"
 file_diff = "1.0.0"
-filetime = "0.2"
+filetime = "0.2.23"
 fnv = "1.0.7"
 fs_extra = "1.3.0"
-fts-sys = "0.2"
-fundu = "2.0.0"
+fts-sys = "0.2.16"
 gcd = "2.3"
 glob = "0.3.1"
-half = "2.2"
-indicatif = "0.17"
-is-terminal = "0.4.9"
-itertools = "0.11.0"
-libc = "0.2.147"
-lscolors = { version = "0.15.0", default-features = false, features = [
-  "nu-ansi-term",
+half = "2.4.1"
+hostname = "0.4"
+iana-time-zone = "0.1.57"
+indicatif = "0.17.8"
+itertools = "0.14.0"
+libc = "0.2.172"
+linux-raw-sys = "0.9"
+lscolors = { version = "0.20.0", default-features = false, features = [
+  "gnu_legacy",
 ] }
-memchr = "2"
-memmap2 = "0.7"
-nix = { version = "0.26", default-features = false }
-nom = "7.1.3"
-notify = { version = "=6.0.1", features = ["macos_kqueue"] }
+memchr = "2.7.2"
+memmap2 = "0.9.4"
+nix = { version = "0.30", default-features = false }
+nom = "8.0.0"
+notify = { version = "=8.0.0", features = ["macos_kqueue"] }
 num-bigint = "0.4.4"
-num-traits = "0.2.16"
+num-prime = "0.4.4"
+num-traits = "0.2.19"
 number_prefix = "0.4"
-once_cell = "1.18.0"
-onig = { version = "~6.4", default-features = false }
-parse_datetime = "0.4.0"
+onig = { version = "~6.5.1", default-features = false }
+parse_datetime = "0.9.0"
 phf = "0.11.2"
 phf_codegen = "0.11.2"
-platform-info = "2.0.2"
+platform-info = "2.0.3"
 quick-error = "2.0.1"
-rand = { version = "0.8", features = ["small_rng"] }
-rand_core = "0.6"
-rayon = "1.7"
-redox_syscall = "0.3"
-regex = "1.9.5"
-rstest = "0.18.2"
-rust-ini = "0.19.0"
+rand = { version = "0.9.0", features = ["small_rng"] }
+rand_core = "0.9.0"
+rayon = "1.10"
+regex = "1.10.4"
+rstest = "0.25.0"
+rust-ini = "0.21.0"
 same-file = "1.0.6"
-self_cell = "1.0.1"
-selinux = "0.4"
+self_cell = "1.0.4"
+selinux = "0.5.1"
+selinux-sys = "0.6.14"
 signal-hook = "0.3.17"
-smallvec = { version = "1.11", features = ["union"] }
-tempfile = "3.8.0"
-term_grid = "0.1.5"
-terminal_size = "0.2.6"
-textwrap = { version = "0.16.0", features = ["terminal_size"] }
-thiserror = "1.0"
-time = { version = "0.3" }
-unicode-segmentation = "1.10.1"
-unicode-width = "0.1.10"
-utf-8 = "0.7.6"
-walkdir = "2.3"
-winapi-util = "0.1.5"
-windows-sys = { version = "0.48.0", default-features = false }
-xattr = "1.0.1"
-zip = { version = "0.6.6", default_features = false, features = ["deflate"] }
+smallvec = { version = "1.13.2", features = ["union"] }
+tempfile = "3.15.0"
+terminal_size = "0.4.0"
+textwrap = { version = "0.16.1", features = ["terminal_size"] }
+thiserror = "2.0.3"
+time = { version = "0.3.36" }
+unicode-segmentation = "1.11.0"
+unicode-width = "0.2.0"
+utmp-classic = "0.1.6"
+uutils_term_grid = "0.7"
+walkdir = "2.5"
+winapi-util = "0.1.8"
+windows-sys = { version = "0.59.0", default-features = false }
+xattr = "1.3.1"
+zip = { version = "4.0.0", default-features = false, features = ["deflate"] }
 
 hex = "0.4.3"
-md-5 = "0.10.5"
-sha1 = "0.10.5"
-sha2 = "0.10.7"
+md-5 = "0.10.6"
+sha1 = "0.10.6"
+sha2 = "0.10.8"
 sha3 = "0.10.8"
-blake2b_simd = "1.0.1"
-blake3 = "1.4.0"
+blake2b_simd = "1.0.2"
+blake3 = "1.5.1"
 sm3 = "0.4.2"
+crc32fast = "1.4.2"
 digest = "0.10.7"
 
-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" }
+# Fluent dependencies
+fluent-bundle = "0.16.0"
+fluent = "0.17.0"
+unic-langid = "0.9.6"
+
+uucore = { version = "0.1.0", package = "uucore", path = "src/uucore" }
+uucore_procs = { version = "0.1.0", package = "uucore_procs", path = "src/uucore_procs" }
+uu_ls = { version = "0.1.0", path = "src/uu/ls" }
+uu_base32 = { version = "0.1.0", path = "src/uu/base32" }
+uutests = { version = "0.1.0", package = "uutests", path = "tests/uutests/" }
 
 [dependencies]
 clap = { workspace = true }
-once_cell = { workspace = true }
 uucore = { workspace = true }
 clap_complete = { workspace = true }
 clap_mangen = { workspace = true }
@@ -363,110 +385,109 @@ 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.21", package = "uu_test", path = "src/uu/test" }
+uu_test = { optional = true, version = "0.1.0", package = "uu_test", path = "src/uu/test" }
 #
-arch = { optional = true, version = "0.0.21", package = "uu_arch", path = "src/uu/arch" }
-base32 = { optional = true, version = "0.0.21", package = "uu_base32", path = "src/uu/base32" }
-base64 = { optional = true, version = "0.0.21", package = "uu_base64", path = "src/uu/base64" }
-basename = { optional = true, version = "0.0.21", package = "uu_basename", path = "src/uu/basename" }
-basenc = { optional = true, version = "0.0.21", package = "uu_basenc", path = "src/uu/basenc" }
-cat = { optional = true, version = "0.0.21", package = "uu_cat", path = "src/uu/cat" }
-chcon = { optional = true, version = "0.0.21", package = "uu_chcon", path = "src/uu/chcon" }
-chgrp = { optional = true, version = "0.0.21", package = "uu_chgrp", path = "src/uu/chgrp" }
-chmod = { optional = true, version = "0.0.21", package = "uu_chmod", path = "src/uu/chmod" }
-chown = { optional = true, version = "0.0.21", package = "uu_chown", path = "src/uu/chown" }
-chroot = { optional = true, version = "0.0.21", package = "uu_chroot", path = "src/uu/chroot" }
-cksum = { optional = true, version = "0.0.21", package = "uu_cksum", path = "src/uu/cksum" }
-comm = { optional = true, version = "0.0.21", package = "uu_comm", path = "src/uu/comm" }
-cp = { optional = true, version = "0.0.21", package = "uu_cp", path = "src/uu/cp" }
-csplit = { optional = true, version = "0.0.21", package = "uu_csplit", path = "src/uu/csplit" }
-cut = { optional = true, version = "0.0.21", package = "uu_cut", path = "src/uu/cut" }
-date = { optional = true, version = "0.0.21", package = "uu_date", path = "src/uu/date" }
-dd = { optional = true, version = "0.0.21", package = "uu_dd", path = "src/uu/dd" }
-df = { optional = true, version = "0.0.21", package = "uu_df", path = "src/uu/df" }
-dir = { optional = true, version = "0.0.21", package = "uu_dir", path = "src/uu/dir" }
-dircolors = { optional = true, version = "0.0.21", package = "uu_dircolors", path = "src/uu/dircolors" }
-dirname = { optional = true, version = "0.0.21", package = "uu_dirname", path = "src/uu/dirname" }
-du = { optional = true, version = "0.0.21", package = "uu_du", path = "src/uu/du" }
-echo = { optional = true, version = "0.0.21", package = "uu_echo", path = "src/uu/echo" }
-env = { optional = true, version = "0.0.21", package = "uu_env", path = "src/uu/env" }
-expand = { optional = true, version = "0.0.21", package = "uu_expand", path = "src/uu/expand" }
-expr = { optional = true, version = "0.0.21", package = "uu_expr", path = "src/uu/expr" }
-factor = { optional = true, version = "0.0.21", package = "uu_factor", path = "src/uu/factor" }
-false = { optional = true, version = "0.0.21", package = "uu_false", path = "src/uu/false" }
-fmt = { optional = true, version = "0.0.21", package = "uu_fmt", path = "src/uu/fmt" }
-fold = { optional = true, version = "0.0.21", package = "uu_fold", path = "src/uu/fold" }
-groups = { optional = true, version = "0.0.21", package = "uu_groups", path = "src/uu/groups" }
-hashsum = { optional = true, version = "0.0.21", package = "uu_hashsum", path = "src/uu/hashsum" }
-head = { optional = true, version = "0.0.21", package = "uu_head", path = "src/uu/head" }
-hostid = { optional = true, version = "0.0.21", package = "uu_hostid", path = "src/uu/hostid" }
-hostname = { optional = true, version = "0.0.21", package = "uu_hostname", path = "src/uu/hostname" }
-id = { optional = true, version = "0.0.21", package = "uu_id", path = "src/uu/id" }
-install = { optional = true, version = "0.0.21", package = "uu_install", path = "src/uu/install" }
-join = { optional = true, version = "0.0.21", package = "uu_join", path = "src/uu/join" }
-kill = { optional = true, version = "0.0.21", package = "uu_kill", path = "src/uu/kill" }
-link = { optional = true, version = "0.0.21", package = "uu_link", path = "src/uu/link" }
-ln = { optional = true, version = "0.0.21", package = "uu_ln", path = "src/uu/ln" }
-ls = { optional = true, version = "0.0.21", package = "uu_ls", path = "src/uu/ls" }
-logname = { optional = true, version = "0.0.21", package = "uu_logname", path = "src/uu/logname" }
-mkdir = { optional = true, version = "0.0.21", package = "uu_mkdir", path = "src/uu/mkdir" }
-mkfifo = { optional = true, version = "0.0.21", package = "uu_mkfifo", path = "src/uu/mkfifo" }
-mknod = { optional = true, version = "0.0.21", package = "uu_mknod", path = "src/uu/mknod" }
-mktemp = { optional = true, version = "0.0.21", package = "uu_mktemp", path = "src/uu/mktemp" }
-more = { optional = true, version = "0.0.21", package = "uu_more", path = "src/uu/more" }
-mv = { optional = true, version = "0.0.21", package = "uu_mv", path = "src/uu/mv" }
-nice = { optional = true, version = "0.0.21", package = "uu_nice", path = "src/uu/nice" }
-nl = { optional = true, version = "0.0.21", package = "uu_nl", path = "src/uu/nl" }
-nohup = { optional = true, version = "0.0.21", package = "uu_nohup", path = "src/uu/nohup" }
-nproc = { optional = true, version = "0.0.21", package = "uu_nproc", path = "src/uu/nproc" }
-numfmt = { optional = true, version = "0.0.21", package = "uu_numfmt", path = "src/uu/numfmt" }
-od = { optional = true, version = "0.0.21", package = "uu_od", path = "src/uu/od" }
-paste = { optional = true, version = "0.0.21", package = "uu_paste", path = "src/uu/paste" }
-pathchk = { optional = true, version = "0.0.21", package = "uu_pathchk", path = "src/uu/pathchk" }
-pinky = { optional = true, version = "0.0.21", package = "uu_pinky", path = "src/uu/pinky" }
-pr = { optional = true, version = "0.0.21", package = "uu_pr", path = "src/uu/pr" }
-printenv = { optional = true, version = "0.0.21", package = "uu_printenv", path = "src/uu/printenv" }
-printf = { optional = true, version = "0.0.21", package = "uu_printf", path = "src/uu/printf" }
-ptx = { optional = true, version = "0.0.21", package = "uu_ptx", path = "src/uu/ptx" }
-pwd = { optional = true, version = "0.0.21", package = "uu_pwd", path = "src/uu/pwd" }
-readlink = { optional = true, version = "0.0.21", package = "uu_readlink", path = "src/uu/readlink" }
-realpath = { optional = true, version = "0.0.21", package = "uu_realpath", path = "src/uu/realpath" }
-relpath = { optional = true, version = "0.0.21", package = "uu_relpath", path = "src/uu/relpath" }
-rm = { optional = true, version = "0.0.21", package = "uu_rm", path = "src/uu/rm" }
-rmdir = { optional = true, version = "0.0.21", package = "uu_rmdir", path = "src/uu/rmdir" }
-runcon = { optional = true, version = "0.0.21", package = "uu_runcon", path = "src/uu/runcon" }
-seq = { optional = true, version = "0.0.21", package = "uu_seq", path = "src/uu/seq" }
-shred = { optional = true, version = "0.0.21", package = "uu_shred", path = "src/uu/shred" }
-shuf = { optional = true, version = "0.0.21", package = "uu_shuf", path = "src/uu/shuf" }
-sleep = { optional = true, version = "0.0.21", package = "uu_sleep", path = "src/uu/sleep" }
-sort = { optional = true, version = "0.0.21", package = "uu_sort", path = "src/uu/sort" }
-split = { optional = true, version = "0.0.21", package = "uu_split", path = "src/uu/split" }
-stat = { optional = true, version = "0.0.21", package = "uu_stat", path = "src/uu/stat" }
-stdbuf = { optional = true, version = "0.0.21", package = "uu_stdbuf", path = "src/uu/stdbuf" }
-stty = { optional = true, version = "0.0.21", package = "uu_stty", path = "src/uu/stty" }
-sum = { optional = true, version = "0.0.21", package = "uu_sum", path = "src/uu/sum" }
-sync = { optional = true, version = "0.0.21", package = "uu_sync", path = "src/uu/sync" }
-tac = { optional = true, version = "0.0.21", package = "uu_tac", path = "src/uu/tac" }
-tail = { optional = true, version = "0.0.21", package = "uu_tail", path = "src/uu/tail" }
-tee = { optional = true, version = "0.0.21", package = "uu_tee", path = "src/uu/tee" }
-timeout = { optional = true, version = "0.0.21", package = "uu_timeout", path = "src/uu/timeout" }
-touch = { optional = true, version = "0.0.21", package = "uu_touch", path = "src/uu/touch" }
-tr = { optional = true, version = "0.0.21", package = "uu_tr", path = "src/uu/tr" }
-true = { optional = true, version = "0.0.21", package = "uu_true", path = "src/uu/true" }
-truncate = { optional = true, version = "0.0.21", package = "uu_truncate", path = "src/uu/truncate" }
-tsort = { optional = true, version = "0.0.21", package = "uu_tsort", path = "src/uu/tsort" }
-tty = { optional = true, version = "0.0.21", package = "uu_tty", path = "src/uu/tty" }
-uname = { optional = true, version = "0.0.21", package = "uu_uname", path = "src/uu/uname" }
-unexpand = { optional = true, version = "0.0.21", package = "uu_unexpand", path = "src/uu/unexpand" }
-uniq = { optional = true, version = "0.0.21", package = "uu_uniq", path = "src/uu/uniq" }
-unlink = { optional = true, version = "0.0.21", package = "uu_unlink", path = "src/uu/unlink" }
-uptime = { optional = true, version = "0.0.21", package = "uu_uptime", path = "src/uu/uptime" }
-users = { optional = true, version = "0.0.21", package = "uu_users", path = "src/uu/users" }
-vdir = { optional = true, version = "0.0.21", package = "uu_vdir", path = "src/uu/vdir" }
-wc = { optional = true, version = "0.0.21", package = "uu_wc", path = "src/uu/wc" }
-who = { optional = true, version = "0.0.21", package = "uu_who", path = "src/uu/who" }
-whoami = { optional = true, version = "0.0.21", package = "uu_whoami", path = "src/uu/whoami" }
-yes = { optional = true, version = "0.0.21", package = "uu_yes", path = "src/uu/yes" }
+arch = { optional = true, version = "0.1.0", package = "uu_arch", path = "src/uu/arch" }
+base32 = { optional = true, version = "0.1.0", package = "uu_base32", path = "src/uu/base32" }
+base64 = { optional = true, version = "0.1.0", package = "uu_base64", path = "src/uu/base64" }
+basename = { optional = true, version = "0.1.0", package = "uu_basename", path = "src/uu/basename" }
+basenc = { optional = true, version = "0.1.0", package = "uu_basenc", path = "src/uu/basenc" }
+cat = { optional = true, version = "0.1.0", package = "uu_cat", path = "src/uu/cat" }
+chcon = { optional = true, version = "0.1.0", package = "uu_chcon", path = "src/uu/chcon" }
+chgrp = { optional = true, version = "0.1.0", package = "uu_chgrp", path = "src/uu/chgrp" }
+chmod = { optional = true, version = "0.1.0", package = "uu_chmod", path = "src/uu/chmod" }
+chown = { optional = true, version = "0.1.0", package = "uu_chown", path = "src/uu/chown" }
+chroot = { optional = true, version = "0.1.0", package = "uu_chroot", path = "src/uu/chroot" }
+cksum = { optional = true, version = "0.1.0", package = "uu_cksum", path = "src/uu/cksum" }
+comm = { optional = true, version = "0.1.0", package = "uu_comm", path = "src/uu/comm" }
+cp = { optional = true, version = "0.1.0", package = "uu_cp", path = "src/uu/cp" }
+csplit = { optional = true, version = "0.1.0", package = "uu_csplit", path = "src/uu/csplit" }
+cut = { optional = true, version = "0.1.0", package = "uu_cut", path = "src/uu/cut" }
+date = { optional = true, version = "0.1.0", package = "uu_date", path = "src/uu/date" }
+dd = { optional = true, version = "0.1.0", package = "uu_dd", path = "src/uu/dd" }
+df = { optional = true, version = "0.1.0", package = "uu_df", path = "src/uu/df" }
+dir = { optional = true, version = "0.1.0", package = "uu_dir", path = "src/uu/dir" }
+dircolors = { optional = true, version = "0.1.0", package = "uu_dircolors", path = "src/uu/dircolors" }
+dirname = { optional = true, version = "0.1.0", package = "uu_dirname", path = "src/uu/dirname" }
+du = { optional = true, version = "0.1.0", package = "uu_du", path = "src/uu/du" }
+echo = { optional = true, version = "0.1.0", package = "uu_echo", path = "src/uu/echo" }
+env = { optional = true, version = "0.1.0", package = "uu_env", path = "src/uu/env" }
+expand = { optional = true, version = "0.1.0", package = "uu_expand", path = "src/uu/expand" }
+expr = { optional = true, version = "0.1.0", package = "uu_expr", path = "src/uu/expr" }
+factor = { optional = true, version = "0.1.0", package = "uu_factor", path = "src/uu/factor" }
+false = { optional = true, version = "0.1.0", package = "uu_false", path = "src/uu/false" }
+fmt = { optional = true, version = "0.1.0", package = "uu_fmt", path = "src/uu/fmt" }
+fold = { optional = true, version = "0.1.0", package = "uu_fold", path = "src/uu/fold" }
+groups = { optional = true, version = "0.1.0", package = "uu_groups", path = "src/uu/groups" }
+hashsum = { optional = true, version = "0.1.0", package = "uu_hashsum", path = "src/uu/hashsum" }
+head = { optional = true, version = "0.1.0", package = "uu_head", path = "src/uu/head" }
+hostid = { optional = true, version = "0.1.0", package = "uu_hostid", path = "src/uu/hostid" }
+hostname = { optional = true, version = "0.1.0", package = "uu_hostname", path = "src/uu/hostname" }
+id = { optional = true, version = "0.1.0", package = "uu_id", path = "src/uu/id" }
+install = { optional = true, version = "0.1.0", package = "uu_install", path = "src/uu/install" }
+join = { optional = true, version = "0.1.0", package = "uu_join", path = "src/uu/join" }
+kill = { optional = true, version = "0.1.0", package = "uu_kill", path = "src/uu/kill" }
+link = { optional = true, version = "0.1.0", package = "uu_link", path = "src/uu/link" }
+ln = { optional = true, version = "0.1.0", package = "uu_ln", path = "src/uu/ln" }
+ls = { optional = true, version = "0.1.0", package = "uu_ls", path = "src/uu/ls" }
+logname = { optional = true, version = "0.1.0", package = "uu_logname", path = "src/uu/logname" }
+mkdir = { optional = true, version = "0.1.0", package = "uu_mkdir", path = "src/uu/mkdir" }
+mkfifo = { optional = true, version = "0.1.0", package = "uu_mkfifo", path = "src/uu/mkfifo" }
+mknod = { optional = true, version = "0.1.0", package = "uu_mknod", path = "src/uu/mknod" }
+mktemp = { optional = true, version = "0.1.0", package = "uu_mktemp", path = "src/uu/mktemp" }
+more = { optional = true, version = "0.1.0", package = "uu_more", path = "src/uu/more" }
+mv = { optional = true, version = "0.1.0", package = "uu_mv", path = "src/uu/mv" }
+nice = { optional = true, version = "0.1.0", package = "uu_nice", path = "src/uu/nice" }
+nl = { optional = true, version = "0.1.0", package = "uu_nl", path = "src/uu/nl" }
+nohup = { optional = true, version = "0.1.0", package = "uu_nohup", path = "src/uu/nohup" }
+nproc = { optional = true, version = "0.1.0", package = "uu_nproc", path = "src/uu/nproc" }
+numfmt = { optional = true, version = "0.1.0", package = "uu_numfmt", path = "src/uu/numfmt" }
+od = { optional = true, version = "0.1.0", package = "uu_od", path = "src/uu/od" }
+paste = { optional = true, version = "0.1.0", package = "uu_paste", path = "src/uu/paste" }
+pathchk = { optional = true, version = "0.1.0", package = "uu_pathchk", path = "src/uu/pathchk" }
+pinky = { optional = true, version = "0.1.0", package = "uu_pinky", path = "src/uu/pinky" }
+pr = { optional = true, version = "0.1.0", package = "uu_pr", path = "src/uu/pr" }
+printenv = { optional = true, version = "0.1.0", package = "uu_printenv", path = "src/uu/printenv" }
+printf = { optional = true, version = "0.1.0", package = "uu_printf", path = "src/uu/printf" }
+ptx = { optional = true, version = "0.1.0", package = "uu_ptx", path = "src/uu/ptx" }
+pwd = { optional = true, version = "0.1.0", package = "uu_pwd", path = "src/uu/pwd" }
+readlink = { optional = true, version = "0.1.0", package = "uu_readlink", path = "src/uu/readlink" }
+realpath = { optional = true, version = "0.1.0", package = "uu_realpath", path = "src/uu/realpath" }
+rm = { optional = true, version = "0.1.0", package = "uu_rm", path = "src/uu/rm" }
+rmdir = { optional = true, version = "0.1.0", package = "uu_rmdir", path = "src/uu/rmdir" }
+runcon = { optional = true, version = "0.1.0", package = "uu_runcon", path = "src/uu/runcon" }
+seq = { optional = true, version = "0.1.0", package = "uu_seq", path = "src/uu/seq" }
+shred = { optional = true, version = "0.1.0", package = "uu_shred", path = "src/uu/shred" }
+shuf = { optional = true, version = "0.1.0", package = "uu_shuf", path = "src/uu/shuf" }
+sleep = { optional = true, version = "0.1.0", package = "uu_sleep", path = "src/uu/sleep" }
+sort = { optional = true, version = "0.1.0", package = "uu_sort", path = "src/uu/sort" }
+split = { optional = true, version = "0.1.0", package = "uu_split", path = "src/uu/split" }
+stat = { optional = true, version = "0.1.0", package = "uu_stat", path = "src/uu/stat" }
+stdbuf = { optional = true, version = "0.1.0", package = "uu_stdbuf", path = "src/uu/stdbuf" }
+stty = { optional = true, version = "0.1.0", package = "uu_stty", path = "src/uu/stty" }
+sum = { optional = true, version = "0.1.0", package = "uu_sum", path = "src/uu/sum" }
+sync = { optional = true, version = "0.1.0", package = "uu_sync", path = "src/uu/sync" }
+tac = { optional = true, version = "0.1.0", package = "uu_tac", path = "src/uu/tac" }
+tail = { optional = true, version = "0.1.0", package = "uu_tail", path = "src/uu/tail" }
+tee = { optional = true, version = "0.1.0", package = "uu_tee", path = "src/uu/tee" }
+timeout = { optional = true, version = "0.1.0", package = "uu_timeout", path = "src/uu/timeout" }
+touch = { optional = true, version = "0.1.0", package = "uu_touch", path = "src/uu/touch" }
+tr = { optional = true, version = "0.1.0", package = "uu_tr", path = "src/uu/tr" }
+true = { optional = true, version = "0.1.0", package = "uu_true", path = "src/uu/true" }
+truncate = { optional = true, version = "0.1.0", package = "uu_truncate", path = "src/uu/truncate" }
+tsort = { optional = true, version = "0.1.0", package = "uu_tsort", path = "src/uu/tsort" }
+tty = { optional = true, version = "0.1.0", package = "uu_tty", path = "src/uu/tty" }
+uname = { optional = true, version = "0.1.0", package = "uu_uname", path = "src/uu/uname" }
+unexpand = { optional = true, version = "0.1.0", package = "uu_unexpand", path = "src/uu/unexpand" }
+uniq = { optional = true, version = "0.1.0", package = "uu_uniq", path = "src/uu/uniq" }
+unlink = { optional = true, version = "0.1.0", package = "uu_unlink", path = "src/uu/unlink" }
+uptime = { optional = true, version = "0.1.0", package = "uu_uptime", path = "src/uu/uptime" }
+users = { optional = true, version = "0.1.0", package = "uu_users", path = "src/uu/users" }
+vdir = { optional = true, version = "0.1.0", package = "uu_vdir", path = "src/uu/vdir" }
+wc = { optional = true, version = "0.1.0", package = "uu_wc", path = "src/uu/wc" }
+who = { optional = true, version = "0.1.0", package = "uu_who", path = "src/uu/who" }
+whoami = { optional = true, version = "0.1.0", package = "uu_whoami", path = "src/uu/whoami" }
+yes = { optional = true, version = "0.1.0", 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" }
@@ -478,30 +499,45 @@ yes = { optional = true, version = "0.0.21", package = "uu_yes", path = "src/uu/
 
 [dev-dependencies]
 chrono = { workspace = true }
-conv = "0.3"
 filetime = { workspace = true }
 glob = { workspace = true }
 libc = { workspace = true }
-pretty_assertions = "1"
+num-prime = { workspace = true }
+pretty_assertions = "1.4.0"
 rand = { workspace = true }
 regex = { workspace = true }
-sha1 = { version = "0.10", features = ["std"] }
+sha1 = { workspace = true, features = ["std"] }
 tempfile = { workspace = true }
 time = { workspace = true, features = ["local-offset"] }
-unindent = "0.2"
-uucore = { workspace = true, features = ["entries", "process", "signals"] }
+unindent = "0.2.3"
+uutests = { workspace = true }
+uucore = { workspace = true, features = [
+  "mode",
+  "entries",
+  "process",
+  "signals",
+  "utmpx",
+] }
 walkdir = { workspace = true }
-is-terminal = { workspace = true }
-hex-literal = "0.4.1"
+hex-literal = "1.0.0"
 rstest = { workspace = true }
+ctor = "0.4.1"
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dev-dependencies]
-procfs = { version = "0.15", default-features = false }
-rlimit = "0.10.1"
+procfs = { version = "0.17", default-features = false }
 
 [target.'cfg(unix)'.dev-dependencies]
-nix = { workspace = true, features = ["process", "signal", "user"] }
-rand_pcg = "0.3"
+nix = { workspace = true, features = ["process", "signal", "user", "term"] }
+rlimit = "0.10.1"
+xattr = { workspace = true }
+
+# Specifically used in test_uptime::test_uptime_with_file_containing_valid_boot_time_utmpx_record
+# to deserialize a utmpx struct into a binary file
+[target.'cfg(all(target_family= "unix",not(target_os = "macos")))'.dev-dependencies]
+serde = { version = "1.0.202", features = ["derive"] }
+bincode = { version = "2.0.1", features = ["serde"] }
+serde-big-array = "0.5.1"
+
 
 [build-dependencies]
 phf_codegen = { workspace = true }
@@ -515,9 +551,9 @@ 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.
+# The default release profile. It contains all optimizations.
+# With this profile (like in the standard release profile),
+# the stack traces will still be available.
 [profile.release]
 lto = true
 
@@ -533,3 +569,108 @@ inherits = "release"
 opt-level = "z"
 panic = "abort"
 strip = true
+
+# A release-like profile with debug info, useful for profiling.
+# See https://github.com/mstange/samply .
+[profile.profiling]
+inherits = "release"
+debug = true
+
+[lints.clippy]
+multiple_crate_versions = "allow"
+cargo_common_metadata = "allow"
+uninlined_format_args = "allow"
+missing_panics_doc = "allow"
+# TODO remove when https://github.com/rust-lang/rust-clippy/issues/13774 is fixed
+large_stack_arrays = "allow"
+
+use_self = "warn"
+needless_pass_by_value = "warn"
+semicolon_if_nothing_returned = "warn"
+single_char_pattern = "warn"
+explicit_iter_loop = "warn"
+if_not_else = "warn"
+manual_let_else = "warn"
+
+all = { level = "deny", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+pedantic = { level = "deny", priority = -1 }
+
+# This is the linting configuration for all crates.
+# Eventually the clippy settings from the `[lints]` section should be moved here.
+# In order to use these, all crates have `[lints] workspace = true` section.
+[workspace.lints.rust]
+unused_qualifications = "warn"
+
+[workspace.lints.clippy]
+# The counts were generated with this command:
+#   cargo clippy --all-targets --workspace --message-format=json --quiet \
+#     | jq -r '.message.code.code | select(. != null and startswith("clippy::"))' \
+#     | sort | uniq -c | sort -h -r
+#
+# TODO:
+#  remove large_stack_arrays when https://github.com/rust-lang/rust-clippy/issues/13774 is fixed
+#
+all = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+cargo_common_metadata = "allow"              # 3240
+multiple_crate_versions = "allow"            # 2314
+missing_errors_doc = "allow"                 # 1504
+missing_panics_doc = "allow"                 # 946
+must_use_candidate = "allow"                 # 322
+doc_markdown = "allow"                       # 267
+match_same_arms = "allow"                    # 212
+unnecessary_semicolon = "allow"              # 156
+redundant_closure_for_method_calls = "allow" # 133
+cast_possible_truncation = "allow"           # 118
+too_many_lines = "allow"                     # 81
+cast_possible_wrap = "allow"                 # 76
+trivially_copy_pass_by_ref = "allow"         # 74
+cast_sign_loss = "allow"                     # 70
+struct_excessive_bools = "allow"             # 68
+single_match_else = "allow"                  # 66
+redundant_else = "allow"                     # 58
+map_unwrap_or = "allow"                      # 54
+cast_precision_loss = "allow"                # 52
+unnested_or_patterns = "allow"               # 40
+inefficient_to_string = "allow"              # 38
+unnecessary_wraps = "allow"                  # 37
+cast_lossless = "allow"                      # 33
+ignored_unit_patterns = "allow"              # 29
+needless_continue = "allow"                  # 28
+items_after_statements = "allow"             # 22
+similar_names = "allow"                      # 20
+wildcard_imports = "allow"                   # 18
+used_underscore_binding = "allow"            # 16
+large_stack_arrays = "allow"                 # 14
+float_cmp = "allow"                          # 12
+# semicolon_if_nothing_returned = "allow"  # 9
+used_underscore_items = "allow"    # 8
+return_self_not_must_use = "allow" # 8
+needless_pass_by_value = "allow"   # 8
+# manual_let_else = "allow"  # 8
+# needless_raw_string_hashes = "allow"  # 7
+match_on_vec_items = "allow" # 6
+inline_always = "allow"      # 6
+# format_push_string = "allow"  # 6
+fn_params_excessive_bools = "allow" # 6
+# single_char_pattern = "allow"  # 4
+# ptr_cast_constness = "allow"  # 4
+# match_wildcard_for_single_variants = "allow"  # 4
+# manual_is_variant_and = "allow"  # 4
+# explicit_deref_methods = "allow"  # 4
+# enum_glob_use = "allow"  # 3
+# unnecessary_literal_bound = "allow"  # 2
+# stable_sort_primitive = "allow"  # 2
+should_panic_without_expect = "allow" # 2
+# ptr_as_ptr = "allow"  # 2
+# needless_for_each = "allow"  # 2
+if_not_else = "allow"             # 2
+expl_impl_clone_on_copy = "allow" # 2
+# cloned_instead_of_copied = "allow"  # 2
+# borrow_as_ptr = "allow"  # 2
+bool_to_int_with_if = "allow" # 2
+# ref_as_ptr = "allow"  # 2
+# unreadable_literal = "allow"  # 1
+uninlined_format_args = "allow" # ?
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
new file mode 100644
index 00000000000..6091c394fc4
--- /dev/null
+++ b/DEVELOPMENT.md
@@ -0,0 +1,342 @@
+<!-- spell-checker:ignore (flags) Ccodegen Coverflow Cpanic Cinstrument Zpanic reimplementing toybox RUNTEST CARGOFLAGS nextest prereq autopoint gettext texinfo automake findutils shellenv libexec gnubin toolchains gsed -->
+
+# Setting up your local development environment
+
+For contributing rules and best practices please refer to [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## Before you start
+
+For this guide we assume that you already have a GitHub account and have `git` and your favorite code editor or IDE installed and configured.
+Before you start working on coreutils, please follow these steps:
+
+1. Fork the [coreutils repository](https://github.com/uutils/coreutils) to your GitHub account.
+***Tip:*** See [this GitHub guide](https://docs.github.com/en/get-started/quickstart/fork-a-repo) for more information on this step.
+2. Clone that fork to your local development environment:
+
+```shell
+git clone https://github.com/YOUR-GITHUB-ACCOUNT/coreutils
+cd coreutils
+```
+
+## Tools
+
+You will need the tools mentioned in this section to build and test your code changes locally.
+This section will explain how to install and configure these tools.
+We also have an extensive CI that uses these tools and will check your code before it can be merged.
+The next section [Testing](#testing) will explain how to run those checks locally to avoid waiting for the CI.
+
+### Rust toolchain
+
+[Install Rust](https://www.rust-lang.org/tools/install)
+
+If you're using rustup to install and manage your Rust toolchains, `clippy` and `rustfmt` are usually already installed. If you are using one of the alternative methods, please make sure to install them manually. See following sub-sections for their usage: [clippy](#clippy) [rustfmt](#rustfmt).
+
+***Tip*** You might also need to add 'llvm-tools' component if you are going to [generate code coverage reports locally](#code-coverage-report):
+
+```shell
+rustup component add llvm-tools-preview
+```
+
+### GNU utils and prerequisites
+
+If you are developing on Linux, most likely you already have all/most GNU utilities and prerequisites installed.
+
+To make sure, please check GNU coreutils [README-prereq](https://github.com/coreutils/coreutils/blob/master/README-prereq).
+
+You will need these to [run uutils against the GNU test suite locally](#comparing-with-gnu).
+
+For MacOS and Windows platform specific setup please check [MacOS GNU utils](#macos-gnu-utils) and [Windows GNU utils](#windows-gnu-utils) sections respectfully.
+
+### 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.
+
+**NOTE: On MacOS** the pre-commit hooks are currently broken. There are workarounds involving switching to unstable nightly Rust and components.
+
+### 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:
+
+```shell
+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
+
+This section explains how to run our CI checks locally.
+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
+# or
+cargo test --all-features -p uucore
+```
+
+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
+rust-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 with release optimizations
+bash util/build-gnu.sh --release-build
+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
+```
+
+***Tip:*** First time you run `bash util/build-gnu.sh` command, it will provide instructions on how to checkout GNU coreutils repository at the correct release tag. Please follow those instructions and when done, run `bash util/build-gnu.sh` command again.
+
+Note that GNU test suite relies on individual utilities (not the multicall binary).
+
+You also need to install [quilt](https://savannah.nongnu.org/projects/quilt), a tool used to manage a stack of patches for modifying GNU tests.
+
+On FreeBSD, you need to install packages for GNU coreutils and sed (used in shell scripts instead of system commands):
+
+```shell
+pkg install coreutils gsed
+```
+
+## Code coverage report
+
+Code coverage report can be generated using [grcov](https://github.com/mozilla/grcov).
+
+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="-Cinstrument-coverage -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.
+
+## Tips for setting up on Mac
+
+### C Compiler and linker
+
+On MacOS you'll need to install C compiler & linker:
+
+```shell
+xcode-select --install
+```
+
+### MacOS GNU utils
+
+On MacOS you will need to install [Homebrew](https://docs.brew.sh/Installation) and use it to install the following Homebrew formulas:
+
+```shell
+brew install \
+  coreutils \
+  autoconf \
+  gettext \
+  wget \
+  texinfo \
+  xz \
+  automake \
+  gnu-sed \
+  m4 \
+  bison \
+  pre-commit \
+  findutils
+```
+
+After installing these Homebrew formulas, please make sure to add the following lines to your `zsh` or `bash` rc file, i.e. `~/.profile` or `~/.zshrc` or `~/.bashrc` ...
+(assuming Homebrew is installed at default location `/opt/homebrew`):
+
+```shell
+eval "$(/opt/homebrew/bin/brew shellenv)"
+export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH"
+export PATH="/opt/homebrew/opt/bison/bin:$PATH"
+export PATH="/opt/homebrew/opt/findutils/libexec/gnubin:$PATH"
+```
+
+Last step is to link Homebrew coreutils version of `timeout` to `/usr/local/bin` (as admin user):
+
+```shell
+sudo ln -s /opt/homebrew/bin/timeout /usr/local/bin/timeout
+```
+
+Do not forget to either source updated rc file or restart you terminal session to update environment variables.
+
+## Tips for setting up on Windows
+
+### MSVC build tools
+
+On Windows you'll need the MSVC build tools for Visual Studio 2013 or later.
+
+If you are using `rustup-init.exe` to install Rust toolchain, it will guide you through the process of downloading and installing these prerequisites.
+
+Otherwise please follow [this guide](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup).
+
+### Windows GNU utils
+
+If you have used [Git for Windows](https://gitforwindows.org) to install `git` on you Windows system you might already have some GNU core utilities installed as part of "GNU Bash" included in Git for Windows package, but it is not a complete package. [This article](https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058) provides instruction on how to add more to it.
+
+Alternatively you can install [Cygwin](https://www.cygwin.com) and/or use [WSL2](https://learn.microsoft.com/en-us/windows/wsl/compare-versions#whats-new-in-wsl-2) to get access to all GNU core utilities on Windows.
+
+## Preparing a new release
+
+1. Modify `util/update-version.sh` (FROM & TO) and run it
+1. Submit a new PR with these changes and wait for it to be merged
+1. Tag the new release `git tag -a X.Y.Z` and `git push --tags`
+1. Once the CI is green, a new release will be automatically created in draft mode.
+   Reuse this release and make sure that assets have been added.
+1. Write the release notes (it takes time) following previous examples
+1. Run `util/publish.sh --do-it` to publish the new release to crates.io
diff --git a/GNUmakefile b/GNUmakefile
index c672458a1cd..dbcdcd0ce08 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -3,11 +3,20 @@
 # Config options
 PROFILE         ?= debug
 MULTICALL       ?= n
+COMPLETIONS     ?= y
+MANPAGES        ?= y
+LOCALES         ?= y
 INSTALL         ?= install
 ifneq (,$(filter install, $(MAKECMDGOALS)))
 override PROFILE:=release
 endif
 
+# Needed for the foreach loops to split each loop into a separate command
+define newline
+
+
+endef
+
 PROFILE_CMD :=
 ifeq ($(PROFILE),release)
 	PROFILE_CMD = --release
@@ -33,23 +42,32 @@ PROG_PREFIX ?=
 # This won't support any directory with spaces in its name, but you can just
 # make a symlink without spaces that points to the directory.
 BASEDIR       ?= $(shell pwd)
+ifdef CARGO_TARGET_DIR
+BUILDDIR 	  := $(CARGO_TARGET_DIR)/${PROFILE}
+else
 BUILDDIR      := $(BASEDIR)/target/${PROFILE}
+endif
 PKG_BUILDDIR  := $(BUILDDIR)/deps
 DOCSDIR       := $(BASEDIR)/docs
 
 BUSYBOX_ROOT := $(BASEDIR)/tmp
-BUSYBOX_VER  := 1.35.0
+BUSYBOX_VER  := 1.36.1
 BUSYBOX_SRC  := $(BUSYBOX_ROOT)/busybox-$(BUSYBOX_VER)
 
 TOYBOX_ROOT := $(BASEDIR)/tmp
-TOYBOX_VER  := 0.8.8
+TOYBOX_VER  := 0.8.12
 TOYBOX_SRC  := $(TOYBOX_ROOT)/toybox-$(TOYBOX_VER)
 
-ifeq ($(SELINUX_ENABLED),)
-	SELINUX_ENABLED := 0
+
+ifdef SELINUX_ENABLED
+	override SELINUX_ENABLED := 0
+# Now check if we should enable it (only on non-Windows)
 	ifneq ($(OS),Windows_NT)
-		ifeq ($(shell /sbin/selinuxenabled 2>/dev/null ; echo $$?),0)
-			SELINUX_ENABLED := 1
+		ifeq ($(shell if [ -x /sbin/selinuxenabled ] && /sbin/selinuxenabled 2>/dev/null; then echo 0; else echo 1; fi),0)
+			override SELINUX_ENABLED := 1
+$(info /sbin/selinuxenabled successful)
+	    else
+$(info SELINUX_ENABLED=1 but /sbin/selinuxenabled failed)
 		endif
 	endif
 endif
@@ -102,7 +120,6 @@ PROGS       := \
 	pwd \
 	readlink \
 	realpath \
-	relpath \
 	rm \
 	rmdir \
 	seq \
@@ -111,6 +128,7 @@ PROGS       := \
 	sleep \
 	sort \
 	split \
+	stty \
 	sum \
 	sync \
 	tac \
@@ -165,9 +183,7 @@ SELINUX_PROGS := \
 
 ifneq ($(OS),Windows_NT)
 	PROGS := $(PROGS) $(UNIX_PROGS)
-endif
-
-ifeq ($(SELINUX_ENABLED),1)
+# Build the selinux command even if not on the system
 	PROGS := $(PROGS) $(SELINUX_PROGS)
 endif
 
@@ -222,6 +238,7 @@ TEST_PROGS  := \
 	rmdir \
 	runcon \
 	seq \
+	sleep \
 	sort \
 	split \
 	stat \
@@ -252,7 +269,8 @@ TEST_NO_FAIL_FAST :=--no-fail-fast
 TEST_SPEC_FEATURE := test_unimplemented
 else ifeq ($(SELINUX_ENABLED),1)
 TEST_NO_FAIL_FAST :=
-TEST_SPEC_FEATURE := feat_selinux
+TEST_SPEC_FEATURE := selinux
+BUILD_SPEC_FEATURE := selinux
 endif
 
 define TEST_BUSYBOX
@@ -276,11 +294,15 @@ use_default := 1
 
 build-pkgs:
 ifneq (${MULTICALL}, y)
+ifdef BUILD_SPEC_FEATURE
+	${CARGO} build ${CARGOFLAGS} --features "$(BUILD_SPEC_FEATURE)" ${PROFILE_CMD} $(foreach pkg,$(EXES),-p uu_$(pkg))
+else
 	${CARGO} build ${CARGOFLAGS} ${PROFILE_CMD} $(foreach pkg,$(EXES),-p uu_$(pkg))
 endif
+endif
 
-build-coreutils:
-	${CARGO} build ${CARGOFLAGS} --features "${EXES}" ${PROFILE_CMD} --no-default-features
+build-coreutils: locales
+	${CARGO} build ${CARGOFLAGS} --features "${EXES} $(BUILD_SPEC_FEATURE)" ${PROFILE_CMD} --no-default-features
 
 build: build-coreutils build-pkgs
 
@@ -337,45 +359,83 @@ clean:
 distclean: clean
 	$(CARGO) clean $(CARGOFLAGS) && $(CARGO) update $(CARGOFLAGS)
 
+ifeq ($(MANPAGES),y)
 manpages: build-coreutils
 	mkdir -p $(BUILDDIR)/man/
 	$(foreach prog, $(INSTALLEES), \
-		$(BUILDDIR)/coreutils manpage $(prog) > $(BUILDDIR)/man/$(PROG_PREFIX)$(prog).1; \
+		$(BUILDDIR)/coreutils manpage $(prog) > $(BUILDDIR)/man/$(PROG_PREFIX)$(prog).1 $(newline) \
 	)
 
+install-manpages: manpages
+	mkdir -p $(DESTDIR)$(DATAROOTDIR)/man/man1
+	$(foreach prog, $(INSTALLEES), \
+		$(INSTALL) $(BUILDDIR)/man/$(PROG_PREFIX)$(prog).1 $(DESTDIR)$(DATAROOTDIR)/man/man1/ $(newline) \
+	)
+else
+install-manpages:
+endif
+
+ifeq ($(COMPLETIONS),y)
 completions: build-coreutils
 	mkdir -p $(BUILDDIR)/completions/zsh $(BUILDDIR)/completions/bash $(BUILDDIR)/completions/fish
 	$(foreach prog, $(INSTALLEES), \
-		$(BUILDDIR)/coreutils completion $(prog) zsh > $(BUILDDIR)/completions/zsh/_$(PROG_PREFIX)$(prog); \
-		$(BUILDDIR)/coreutils completion $(prog) bash > $(BUILDDIR)/completions/bash/$(PROG_PREFIX)$(prog); \
-		$(BUILDDIR)/coreutils completion $(prog) fish > $(BUILDDIR)/completions/fish/$(PROG_PREFIX)$(prog).fish; \
+		$(BUILDDIR)/coreutils completion $(prog) zsh > $(BUILDDIR)/completions/zsh/_$(PROG_PREFIX)$(prog) $(newline) \
+		$(BUILDDIR)/coreutils completion $(prog) bash > $(BUILDDIR)/completions/bash/$(PROG_PREFIX)$(prog) $(newline) \
+		$(BUILDDIR)/coreutils completion $(prog) fish > $(BUILDDIR)/completions/fish/$(PROG_PREFIX)$(prog).fish $(newline) \
+	)
+
+install-completions: completions
+	mkdir -p $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions
+	mkdir -p $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions
+	mkdir -p $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d
+	$(foreach prog, $(INSTALLEES), \
+		$(INSTALL) $(BUILDDIR)/completions/zsh/_$(PROG_PREFIX)$(prog) $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/ $(newline) \
+		$(INSTALL) $(BUILDDIR)/completions/bash/$(PROG_PREFIX)$(prog) $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/ $(newline) \
+		$(INSTALL) $(BUILDDIR)/completions/fish/$(PROG_PREFIX)$(prog).fish $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/ $(newline) \
+	)
+else
+install-completions:
+endif
+
+ifeq ($(LOCALES),y)
+locales:
+	$(foreach prog, $(INSTALLEES), \
+		if [ -d "$(BASEDIR)/src/uu/$(prog)/locales" ]; then \
+			mkdir -p "$(BUILDDIR)/locales/$(prog)"; \
+			for locale_file in "$(BASEDIR)"/src/uu/$(prog)/locales/*.ftl; do \
+				$(INSTALL) -v "$$locale_file" "$(BUILDDIR)/locales/$(prog)/"; \
+			done; \
+		fi $(newline) \
 	)
 
-install: build manpages completions
+
+install-locales:
+	$(foreach prog, $(INSTALLEES), \
+		if [ -d "$(BASEDIR)/src/uu/$(prog)/locales" ]; then \
+			mkdir -p "$(DESTDIR)$(DATAROOTDIR)/locales/$(prog)"; \
+			for locale_file in "$(BASEDIR)"/src/uu/$(prog)/locales/*.ftl; do \
+				$(INSTALL) -v "$$locale_file" "$(DESTDIR)$(DATAROOTDIR)/locales/$(prog)/"; \
+			done; \
+		fi $(newline) \
+	)
+else
+install-locales:
+endif
+
+install: build install-manpages install-completions install-locales
 	mkdir -p $(INSTALLDIR_BIN)
 ifeq (${MULTICALL}, y)
 	$(INSTALL) $(BUILDDIR)/coreutils $(INSTALLDIR_BIN)/$(PROG_PREFIX)coreutils
-	cd $(INSTALLDIR_BIN) && $(foreach prog, $(filter-out coreutils, $(INSTALLEES)), \
-		ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)$(prog) &&) :
+	$(foreach prog, $(filter-out coreutils, $(INSTALLEES)), \
+		cd $(INSTALLDIR_BIN) && ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)$(prog) $(newline) \
+	)
 	$(if $(findstring test,$(INSTALLEES)), cd $(INSTALLDIR_BIN) && ln -fs $(PROG_PREFIX)coreutils $(PROG_PREFIX)[)
 else
 	$(foreach prog, $(INSTALLEES), \
-		$(INSTALL) $(BUILDDIR)/$(prog) $(INSTALLDIR_BIN)/$(PROG_PREFIX)$(prog);)
+		$(INSTALL) $(BUILDDIR)/$(prog) $(INSTALLDIR_BIN)/$(PROG_PREFIX)$(prog) $(newline) \
+	)
 	$(if $(findstring test,$(INSTALLEES)), $(INSTALL) $(BUILDDIR)/test $(INSTALLDIR_BIN)/$(PROG_PREFIX)[)
 endif
-	mkdir -p $(DESTDIR)$(DATAROOTDIR)/man/man1
-	$(foreach prog, $(INSTALLEES), \
-		$(INSTALL) $(BUILDDIR)/man/$(PROG_PREFIX)$(prog).1 $(DESTDIR)$(DATAROOTDIR)/man/man1/; \
-	)
-
-	mkdir -p $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions
-	mkdir -p $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions
-	mkdir -p $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d
-	$(foreach prog, $(INSTALLEES), \
-		$(INSTALL) $(BUILDDIR)/completions/zsh/_$(PROG_PREFIX)$(prog) $(DESTDIR)$(DATAROOTDIR)/zsh/site-functions/; \
-		$(INSTALL) $(BUILDDIR)/completions/bash/$(PROG_PREFIX)$(prog) $(DESTDIR)$(DATAROOTDIR)/bash-completion/completions/; \
-		$(INSTALL) $(BUILDDIR)/completions/fish/$(PROG_PREFIX)$(prog).fish $(DESTDIR)$(DATAROOTDIR)/fish/vendor_completions.d/; \
-	)
 
 uninstall:
 ifeq (${MULTICALL}, y)
diff --git a/LICENSE b/LICENSE
index 49fdbd4cf5f..21bd44404e3 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) Jordi Boggiano and many others
+Copyright (c) uutils developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/README.md b/README.md
index c5b4609c924..1d9a7ddd190 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
 [![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)
+![MSRV](https://img.shields.io/badge/MSRV-1.85.0-brightgreen)
 
 </div>
 
@@ -45,17 +45,16 @@ 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,
+utils on Linux, macOS, Windows and other platforms. This ensures, for example,
 that scripts can be easily transferred between platforms.
 
 <div class="oranda-hide">
 
 ## Documentation
-
 uutils has both user and developer documentation available:
 
-- [User Manual](https://uutils.github.io/coreutils/book/)
-- [Developer Documentation](https://uutils.github.io/dev/coreutils/) (currently offline, you can use docs.rs in the meantime)
+- [User Manual](https://uutils.github.io/coreutils/docs/)
+- [Developer Documentation](https://docs.rs/crate/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.
@@ -71,7 +70,7 @@ the [coreutils docs](https://github.com/uutils/uutils.github.io) repository.
 ### 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`.
+nightly. The current Minimum Supported Rust Version (MSRV) is `1.85.0`.
 
 ## Building
 
@@ -79,7 +78,7 @@ 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.
+> and GNU Make on a Unix platform.
 
 For either method, we first need to fetch the repository:
 
@@ -224,6 +223,12 @@ Installing with `make` installs shell completions for all installed utilities
 for `bash`, `fish` and `zsh`. Completions for `elvish` and `powershell` can also
 be generated; See `Manually install shell completions`.
 
+To skip installation of completions and manpages:
+
+```shell
+make COMPLETIONS=n MANPAGES=n install
+```
+
 ### Manually install shell completions
 
 The `coreutils` binary can generate completions for the `bash`, `elvish`,
@@ -267,7 +272,7 @@ Make to uninstall.
 To uninstall uutils:
 
 ```shell
-cargo uninstall uutils
+cargo uninstall coreutils
 ```
 
 ### Uninstall with GNU Make
@@ -303,12 +308,12 @@ make PREFIX=/my/path uninstall
 
 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/coreutils/book/test_coverage.html).
+[in the user manual](https://uutils.github.io/coreutils/docs/test_coverage.html).
 
-See <https://github.com/uutils/coreutils/issues/3336> for the main meta bugs
+See <https://github.com/orgs/uutils/projects/1> for the main meta bugs
 (many are missing).
 
-![Evolution over time](https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.png?raw=true)
+![Evolution over time](https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.svg?raw=true)
 
 </div> <!-- close oranda-hide div -->
 
diff --git a/README.package.md b/README.package.md
new file mode 100644
index 00000000000..355b153db28
--- /dev/null
+++ b/README.package.md
@@ -0,0 +1,31 @@
+<!-- markdownlint-disable MD033 MD041 MD002 -->
+<!-- markdownlint-disable commands-show-output no-duplicate-heading -->
+<!-- spell-checker:ignore markdownlint ; (options) DESTDIR UTILNAME manpages reimplementation oranda -->
+<div class="oranda-hide">
+<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)
+[![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.70.0-brightgreen)
+
+</div>
+
+---
+
+</div>
+
+This package is part of uutils coreutils.
+
+uutils coreutils is a cross-platform reimplementation of the GNU coreutils in
+[Rust](http://www.rust-lang.org).
+
+This package does not have its specific `README.md`.
+
diff --git a/build.rs b/build.rs
index bb4e2b53609..3b6aa3878d1 100644
--- a/build.rs
+++ b/build.rs
@@ -11,14 +11,18 @@ use std::io::Write;
 use std::path::Path;
 
 pub fn main() {
-    if let Ok(profile) = env::var("PROFILE") {
-        println!("cargo:rustc-cfg=build={profile:?}");
-    }
-
     const ENV_FEATURE_PREFIX: &str = "CARGO_FEATURE_";
     const FEATURE_PREFIX: &str = "feat_";
     const OVERRIDE_PREFIX: &str = "uu_";
 
+    // Do not rebuild build script unless the script itself or the enabled features are modified
+    // See <https://doc.rust-lang.org/cargo/reference/build-scripts.html#change-detection>
+    println!("cargo:rerun-if-changed=build.rs");
+
+    if let Ok(profile) = env::var("PROFILE") {
+        println!("cargo:rustc-cfg=build={profile:?}");
+    }
+
     let out_dir = env::var("OUT_DIR").unwrap();
 
     let mut crates = Vec::new();
@@ -29,8 +33,10 @@ pub fn main() {
             #[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
-                "uudoc" => continue,                          // is not a utility
+                "nightly" | "test_unimplemented" | "expensive_tests" | "test_risky_names" => {
+                    continue;
+                } // crate-local custom features
+                "uudoc" => continue, // is not a utility
                 "test" => continue, // over-ridden with 'uu_test' to avoid collision with rust core crate 'test'
                 s if s.starts_with(FEATURE_PREFIX) => continue, // crate feature sets
                 _ => {}             // util feature name
@@ -46,6 +52,7 @@ pub fn main() {
         "type UtilityMap<T> = phf::OrderedMap<&'static str, (fn(T) -> i32, fn() -> Command)>;\n\
          \n\
          #[allow(clippy::too_many_lines)]
+         #[allow(clippy::unreadable_literal)]
          fn util_map<T: uucore::Args>() -> UtilityMap<T> {\n"
             .as_bytes(),
     )
diff --git a/deny.toml b/deny.toml
index c2e580a4de0..1b1700dcdf4 100644
--- a/deny.toml
+++ b/deny.toml
@@ -6,10 +6,8 @@
 [advisories]
 db-path = "~/.cargo/advisory-db"
 db-urls = ["https://github.com/rustsec/advisory-db"]
-vulnerability = "warn"
-unmaintained = "warn"
+version = 2
 yanked = "warn"
-notice = "warn"
 ignore = [
   #"RUSTSEC-0000-0000",
 ]
@@ -18,20 +16,18 @@ ignore = [
 # More documentation for the licenses section can be found here:
 # https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
 [licenses]
-unlicensed = "deny"
+version = 2
 allow = [
   "MIT",
   "Apache-2.0",
   "ISC",
   "BSD-2-Clause",
-  "BSD-2-Clause-FreeBSD",
   "BSD-3-Clause",
+  "BSL-1.0",
   "CC0-1.0",
-  "Unicode-DFS-2016",
+  "Unicode-3.0",
+  "Zlib",
 ]
-copyleft = "deny"
-allow-osi-fsf-free = "neither"
-default = "deny"
 confidence-threshold = 0.8
 
 [[licenses.clarify]]
@@ -58,35 +54,50 @@ highlight = "all"
 # introduces it.
 # spell-checker: disable
 skip = [
-  # procfs
-  { name = "rustix", version = "0.36.15" },
-  # rustix
-  { name = "linux-raw-sys", version = "0.1.4" },
-  { name = "linux-raw-sys", version = "0.3.8" },
-  # terminal_size
-  { name = "rustix", version = "0.37.23" },
-  # various crates
-  { name = "windows-sys", version = "0.45.0" },
+  # dns-lookup
+  { name = "windows-sys", version = "0.48.0" },
+  # mio, nu-ansi-term, socket2
+  { name = "windows-sys", version = "0.52.0" },
   # windows-sys
-  { name = "windows-targets", version = "0.42.2" },
+  { name = "windows-targets", version = "0.48.0" },
   # windows-targets
-  { name = "windows_aarch64_gnullvm", version = "0.42.2" },
+  { name = "windows_aarch64_gnullvm", version = "0.48.0" },
   # windows-targets
-  { name = "windows_aarch64_msvc", version = "0.42.2" },
+  { name = "windows_aarch64_msvc", version = "0.48.0" },
   # windows-targets
-  { name = "windows_i686_gnu", version = "0.42.2" },
+  { name = "windows_i686_gnu", version = "0.48.0" },
   # windows-targets
-  { name = "windows_i686_msvc", version = "0.42.2" },
+  { name = "windows_i686_msvc", version = "0.48.0" },
   # windows-targets
-  { name = "windows_x86_64_gnu", version = "0.42.2" },
+  { name = "windows_x86_64_gnu", version = "0.48.0" },
   # windows-targets
-  { name = "windows_x86_64_gnullvm", version = "0.42.2" },
+  { name = "windows_x86_64_gnullvm", version = "0.48.0" },
   # windows-targets
-  { name = "windows_x86_64_msvc", version = "0.42.2" },
-  # various crates
-  { name = "syn", version = "1.0.109" },
-  # various crates
+  { name = "windows_x86_64_msvc", version = "0.48.0" },
+  # kqueue-sys, onig
   { name = "bitflags", version = "1.3.2" },
+  # ansi-width
+  { name = "unicode-width", version = "0.1.13" },
+  # filedescriptor, utmp-classic
+  { name = "thiserror", version = "1.0.69" },
+  # thiserror
+  { name = "thiserror-impl", version = "1.0.69" },
+  # bindgen
+  { name = "itertools", version = "0.13.0" },
+  # ordered-multimap
+  { name = "hashbrown", version = "0.14.5" },
+  # cexpr (via bindgen)
+  { name = "nom", version = "7.1.3" },
+  # const-random-macro, rand_core
+  { name = "getrandom", version = "0.2.15" },
+  # getrandom, mio
+  { name = "wasi", version = "0.11.0+wasi-snapshot-preview1" },
+  # num-bigint, num-prime, phf_generator
+  { name = "rand", version = "0.8.5" },
+  # rand
+  { name = "rand_chacha", version = "0.3.1" },
+  # rand
+  { name = "rand_core", version = "0.6.4" },
 ]
 # spell-checker: enable
 
diff --git a/docs/compiles_table.csv b/docs/compiles_table.csv
index d18854e0e91..e263067b78d 100644
--- a/docs/compiles_table.csv
+++ b/docs/compiles_table.csv
@@ -1,21 +1,21 @@
-target,arch,base32,base64,basename,cat,chgrp,chmod,chown,chroot,cksum,comm,cp,csplit,cut,date,df,dircolors,dirname,du,echo,env,expand,expr,factor,false,fmt,fold,groups,hashsum,head,hostid,hostname,id,install,join,kill,link,ln,logname,ls,mkdir,mkfifo,mknod,mktemp,more,mv,nice,nl,nohup,nproc,numfmt,od,paste,pathchk,pinky,printenv,printf,ptx,pwd,readlink,realpath,relpath,rm,rmdir,seq,shred,shuf,sleep,sort,split,stat,stdbuf,sum,sync,tac,tail,tee,test,timeout,touch,tr,true,truncate,tsort,tty,uname,unexpand,uniq,unlink,uptime,users,wc,who,whoami,yes,chcon,pr,dir,vdir,dd,basenc,runcon
-aarch64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-i686-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-powerpc64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-riscv64gc-unknown-linux-gnu,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-x86_64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-aarch64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,101,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,101,0,0,0,0,0,0,0,0
-i686-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-i686-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-apple-darwin,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-x86_64-unknown-freebsd,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-x86_64-unknown-netbsd,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
-aarch64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
-x86_64-sun-solaris,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-wasm32-wasi,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-x86_64-unknown-redox,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-aarch64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
-x86_64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+target,arch,base32,base64,basename,cat,chgrp,chmod,chown,chroot,cksum,comm,cp,csplit,cut,date,df,dircolors,dirname,du,echo,env,expand,expr,factor,false,fmt,fold,groups,hashsum,head,hostid,hostname,id,install,join,kill,link,ln,logname,ls,mkdir,mkfifo,mknod,mktemp,more,mv,nice,nl,nohup,nproc,numfmt,od,paste,pathchk,pinky,printenv,printf,ptx,pwd,readlink,realpath,rm,rmdir,seq,shred,shuf,sleep,sort,split,stat,stdbuf,sum,sync,tac,tail,tee,test,timeout,touch,tr,true,truncate,tsort,tty,uname,unexpand,uniq,unlink,uptime,users,wc,who,whoami,yes,chcon,pr,dir,vdir,dd,basenc,runcon
+aarch64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+i686-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+powerpc64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+riscv64gc-unknown-linux-gnu,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+x86_64-unknown-linux-gnu,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+aarch64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,101,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,101,0,0,0,0,0,0,0,0
+i686-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+i686-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-pc-windows-gnu,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-pc-windows-msvc,0,0,0,0,0,101,101,101,101,0,0,0,0,0,0,0,0,0,101,0,0,0,101,0,0,0,0,101,0,0,0,0,101,101,0,101,0,0,0,0,0,101,101,0,0,0,101,0,101,0,0,0,0,101,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,101,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,101,0,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-apple-darwin,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+x86_64-unknown-freebsd,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+x86_64-unknown-netbsd,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
+aarch64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-linux-android,0,0,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,0,0,0,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,101,0,0,101,0,0,0,0,101,0,0,0,0,0,0,101,0,0,0,101,101,0,101,0,0,0,0,0,0,0,0,0
+x86_64-sun-solaris,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+wasm32-wasi,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+x86_64-unknown-redox,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+aarch64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
+x86_64-fuchsia,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101
diff --git a/docs/compiles_table.py b/docs/compiles_table.py
index 83c98bed1de..884b0bc39e1 100644
--- a/docs/compiles_table.py
+++ b/docs/compiles_table.py
@@ -10,7 +10,7 @@
 # third party dependencies
 from tqdm import tqdm
 
-# spell-checker:ignore (libs) tqdm imap ; (shell/mac) xcrun ; (vars) nargs
+# spell-checker:ignore (libs) tqdm imap ; (shell/mac) xcrun ; (vars) nargs retcode csvfile
 
 BINS_PATH = Path("../src/uu")
 CACHE_PATH = Path("compiles_table.csv")
diff --git a/docs/src/CODE_OF_CONDUCT.md b/docs/src/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000000..ce326a1ee03
--- /dev/null
+++ b/docs/src/CODE_OF_CONDUCT.md
@@ -0,0 +1,3 @@
+<!-- markdownlint-disable MD041 -->
+
+{{ #include ../../CODE_OF_CONDUCT.md }}
diff --git a/docs/src/contributing.md b/docs/src/CONTRIBUTING.md
similarity index 100%
rename from docs/src/contributing.md
rename to docs/src/CONTRIBUTING.md
diff --git a/docs/src/DEVELOPMENT.md b/docs/src/DEVELOPMENT.md
new file mode 100644
index 00000000000..580cecf0855
--- /dev/null
+++ b/docs/src/DEVELOPMENT.md
@@ -0,0 +1,3 @@
+<!-- markdownlint-disable MD041 -->
+
+{{ #include ../../DEVELOPMENT.md }}
diff --git a/docs/src/extensions.md b/docs/src/extensions.md
index eeb00ff350e..af6119da51a 100644
--- a/docs/src/extensions.md
+++ b/docs/src/extensions.md
@@ -1,3 +1,5 @@
+<!-- spell-checker:ignore hhhhp armv7 cccccccccccccccccccccccccccccccdp ccccccccccccccd ccccccccccccccdp fffffffp -->
+
 # Extensions over GNU
 
 Though the main goal of the project is compatibility, uutils supports a few
@@ -22,8 +24,13 @@ $ ls -w=80
 
 ## `env`
 
-`env` has an additional `-f`/`--file` flag that can parse `.env` files and set
-variables accordingly. This feature is adopted from `dotenv` style packages.
+GNU `env` allows the empty string to be used as an environment variable name.
+This is unsupported by uutils, and it will show a warning on any such
+assignment.
+
+ `env` has an additional `-f`/`--file` flag that can
+parse `.env` files and set variables accordingly. This feature is adopted from `dotenv` style
+packages.
 
 ## `cp`
 
@@ -66,8 +73,84 @@ feature is adopted from [FreeBSD](https://www.freebsd.org/cgi/man.cgi?cut).
 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.
 
+## `printf`
+
+`printf` uses arbitrary precision decimal numbers to parse and format floating point
+numbers. GNU coreutils uses `long double`, whose actual size may be [double precision
+64-bit float](https://en.wikipedia.org/wiki/Double-precision_floating-point_format)
+(e.g 32-bit arm), [extended precision 80-bit float](https://en.wikipedia.org/wiki/Extended_precision)
+(x86(-64)), or
+[quadruple precision 128-bit float](https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format) (e.g. arm64).
+
+Practically, this means that printing a number with a large precision will stay exact:
+```
+printf "%.48f\n" 0.1
+0.100000000000000000000000000000000000000000000000 << uutils on all platforms
+0.100000000000000000001355252715606880542509316001 << GNU coreutils on x86(-64)
+0.100000000000000000000000000000000004814824860968 << GNU coreutils on arm64
+0.100000000000000005551115123125782702118158340454 << GNU coreutils on armv7 (32-bit)
+```
+
+### Hexadecimal floats
+
+For hexadecimal float format (`%a`), POSIX only states that one hexadecimal number
+should be present left of the decimal point (`0xh.hhhhp±d` [1]), but does not say how
+many _bits_ should be included (between 1 and 4). On x86(-64), the first digit always
+includes 4 bits, so its value is always between `0x8` and `0xf`, while on other
+architectures, only 1 bit is included, so the value is always `0x1`.
+
+However, the first digit will of course be `0x0` if the number is zero. Also,
+rounding numbers may cause the first digit to be `0x1` on x86(-64) (e.g.
+`0xf.fffffffp-5` rounds to `0x1.00p-1`), or `0x2` on other architectures.
+
+We chose to replicate x86-64 behavior on all platforms.
+
+Additionally, the default precision of the hexadecimal float format (`%a` without
+any specifier) is expected to be "sufficient for exact representation of the value" [1].
+This is not possible in uutils as we store arbitrary precision numbers that may be
+periodic in hexadecimal form (`0.1 = 0xc.ccc...p-7`), so we revert
+to the number of digits that would be required to exactly print an
+[extended precision 80-bit float](https://en.wikipedia.org/wiki/Extended_precision),
+emulating GNU coreutils behavior on x86(-64). An 80-bit float has 64 bits in its
+integer and fractional part, so 16 hexadecimal digits are printed in total (1 digit
+before the decimal point, 15 after).
+
+Practically, this means that the default hexadecimal floating point output is
+identical to x86(-64) GNU coreutils:
+```
+printf "%a\n" 0.1
+0xc.ccccccccccccccdp-7 << uutils on all platforms
+0xc.ccccccccccccccdp-7 << GNU coreutils on x86-64
+0x1.999999999999999999999999999ap-4 << GNU coreutils on arm64
+0x1.999999999999ap-4   << GNU coreutils on armv7 (32-bit)
+```
+
+We _can_ print an arbitrary number of digits if a larger precision is requested,
+and the leading digit will still be in the `0x8`-`0xf` range:
+```
+printf "%.32a\n" 0.1
+0xc.cccccccccccccccccccccccccccccccdp-7 << uutils on all platforms
+0xc.ccccccccccccccd00000000000000000p-7 << GNU coreutils on x86-64
+0x1.999999999999999999999999999a0000p-4 << GNU coreutils on arm64
+0x1.999999999999a0000000000000000000p-4 << GNU coreutils on armv7 (32-bit)
+```
+
+***Note: The architecture-specific behavior on non-x86(-64) platforms may change in
+the future.***
+
 ## `seq`
 
+Unlike GNU coreutils, `seq` always uses arbitrary precision decimal numbers, no
+matter the parameters (integers, decimal numbers, positive or negative increments,
+format specified, etc.), so its output will be more correct than GNU coreutils for
+some inputs (e.g. small fractional increments where GNU coreutils uses `long double`).
+
+The only limitation is that the position of the decimal point is stored in a `i64`,
+so values smaller than 10**(-2**63) will underflow to 0, and some values larger
+than 10**(2**63) may overflow to infinity.
+
+See also comments under `printf` for formatting precision and differences.
+
 `seq` provides `-t`/`--terminator` to set the terminator character.
 
 ## `ls`
@@ -75,6 +158,29 @@ number of spaces representing a tab when determining the line length.
 GNU `ls` provides two ways to use a long listing format: `-l` and `--format=long`. We support a
 third way: `--long`.
 
+GNU `ls --sort=VALUE` only supports special non-default sort orders.
+We support `--sort=name`, which makes it possible to override an earlier value.
+
 ## `du`
 
-`du` allows `birth` and `creation` as values for the `--time` argument to show the creation time.
+`du` allows `birth` and `creation` as values for the `--time` argument to show the creation time. It
+also provides a `-v`/`--verbose` flag.
+
+## `id`
+
+`id` has three additional flags:
+* `-P` displays the id as a password file entry
+* `-p` makes the output human-readable
+* `-A` displays the process audit user ID
+
+## `uptime`
+
+Similar to the proc-ps implementation and unlike GNU/Coreutils, `uptime` provides `-s`/`--since` to show since when the system is up.
+
+## `base32/base64/basenc`
+
+Just like on macOS, `base32/base64/basenc` provides `-D` to decode data.
+
+## `shred`
+
+The number of random passes is deterministic in both GNU and uutils. However, uutils `shred` computes the number of random passes in a simplified way, specifically `max(3, x / 10)`, which is very close but not identical to the number of random passes that GNU would do. This also satisfies an expectation that reasonable users might have, namely that the number of random passes increases monotonically with the number of passes overall; GNU `shred` violates this assumption.
diff --git a/docs/src/installation.md b/docs/src/installation.md
index da124ead977..856ca9d22f5 100644
--- a/docs/src/installation.md
+++ b/docs/src/installation.md
@@ -1,4 +1,4 @@
-<!-- spell-checker:ignore pacman pamac nixpkgs openmandriva conda -->
+<!-- spell-checker:ignore pacman pamac nixpkgs openmandriva conda winget openembedded yocto bblayers bitbake -->
 
 # Installation
 
@@ -6,21 +6,21 @@ This is a list of uutils packages in various distributions and package managers.
 Note that these are packaged by third-parties and the packages might contain
 patches.
 
-You can also [build uutils from source](/build.md).
+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)
+[![crates.io package](https://repology.org/badge/version-for-repo/crates_io/uutils-coreutils.svg)](https://crates.io/crates/coreutils)
 
 ```shell
 # Linux
-cargo install coreutils --features unix
+cargo install coreutils --features unix --locked
 # MacOs
-cargo install coreutils --features macos
+cargo install coreutils --features macos --locked
 # Windows
-cargo install coreutils --features windows
+cargo install coreutils --features windows --locked
 ```
 
 ## Linux
@@ -53,7 +53,15 @@ apt install rust-coreutils
 export PATH=/usr/lib/cargo/bin/coreutils:$PATH
 ```
 
-> **Note**: Only available from Bookworm (Debian 12)
+### Fedora
+
+[![Fedora package](https://repology.org/badge/version-for-repo/fedora_rawhide/uutils-coreutils.svg)](https://packages.fedoraproject.org/pkgs/rust-coreutils/uutils-coreutils)
+
+```shell
+dnf install uutils-coreutils
+# To use it:
+export PATH=/usr/libexec/uutils-coreutils:$PATH
+```
 
 ### Gentoo
 
@@ -65,9 +73,9 @@ 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)
+[![Manjaro Stable package](https://repology.org/badge/version-for-repo/manjaro_stable/uutils-coreutils.svg)](https://packages.manjaro.org/?query=uutils-coreutils)
+[![Manjaro Testing package](https://repology.org/badge/version-for-repo/manjaro_testing/uutils-coreutils.svg)](https://packages.manjaro.org/?query=uutils-coreutils)
+[![Manjaro Unstable package](https://repology.org/badge/version-for-repo/manjaro_unstable/uutils-coreutils.svg)](https://packages.manjaro.org/?query=uutils-coreutils)
 
 ```shell
 pacman -S uutils-coreutils
@@ -77,7 +85,7 @@ 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)
+[![nixpkgs unstable package](https://repology.org/badge/version-for-repo/nix_unstable/uutils-coreutils.svg)](https://search.nixos.org/packages?query=uutils-coreutils)
 
 ```shell
 nix-env -iA nixos.uutils-coreutils
@@ -91,9 +99,22 @@ nix-env -iA nixos.uutils-coreutils
 dnf install uutils-coreutils
 ```
 
+### RHEL/AlmaLinux/CENTOS Stream/Rocky Linux/EPEL 9
+
+[![epel 9 package](https://repology.org/badge/version-for-repo/epel_9/uutils-coreutils.svg)](https://packages.fedoraproject.org/pkgs/rust-coreutils/uutils-coreutils/epel-9.html)
+
+```shell
+# Install EPEL 9 - Specific For RHEL please check codeready-builder-for-rhel-9 First then install epel
+dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm -y
+# Install Core Utils
+dnf install uutils-coreutils
+# To use it:
+export PATH=/usr/libexec/uutils-coreutils:$PATH
+```
+
 ### Ubuntu
 
-[![Ubuntu package](https://repology.org/badge/version-for-repo/ubuntu_23_04/uutils-coreutils.svg)](https://packages.ubuntu.com/source/lunar/rust-coreutils)
+[![Ubuntu package](https://repology.org/badge/version-for-repo/ubuntu_25_04/uutils-coreutils.svg)](https://packages.ubuntu.com/source/plucky/rust-coreutils)
 
 ```shell
 apt install rust-coreutils
@@ -101,8 +122,6 @@ apt install rust-coreutils
 export PATH=/usr/lib/cargo/bin/coreutils:$PATH
 ```
 
-> **Note**: Only available from Kinetic (Ubuntu 22.10)
-
 ## MacOS
 
 ### Homebrew
@@ -123,7 +142,7 @@ 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)
+[![FreeBSD port](https://repology.org/badge/version-for-repo/freebsd/rust-coreutils.svg)](https://repology.org/project/rust-coreutils/versions)
 
 ```sh
 pkg install rust-coreutils
@@ -131,9 +150,15 @@ pkg install rust-coreutils
 
 ## Windows
 
+### Winget
+
+```shell
+winget install uutils.coreutils
+```
+
 ### 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)
+[Scoop package](https://scoop.sh/#/apps?q=uutils-coreutils&s=0&d=1&o=true)
 
 ```shell
 scoop install uutils-coreutils
@@ -146,15 +171,24 @@ scoop install uutils-coreutils
 [Conda package](https://anaconda.org/conda-forge/uutils-coreutils)
 
 ```
-conda install -c conda-forge uutils-coreutils 
+conda install -c conda-forge uutils-coreutils
 ```
 
+### Yocto
+
+[Yocto recipe](https://github.com/openembedded/meta-openembedded/tree/master/meta-oe/recipes-core/uutils-coreutils)
+
+The uutils-coreutils recipe is provided as part of the meta-openembedded yocto layer.
+Clone [poky](https://github.com/yoctoproject/poky) and [meta-openembedded](https://github.com/openembedded/meta-openembedded/tree/master), add
+`meta-openembedded/meta-oe` as layer in your `build/conf/bblayers.conf` file,
+and then either call `bitbake uutils-coreutils`, or use
+`PREFERRED_PROVIDER_coreutils = "uutils-coreutils"` in your `build/conf/local.conf` file and
+then build your usual yocto image.
+
 ## Non-standard packages
 
-### `coreutils-hybrid` (AUR)
+### `coreutils-uutils` (AUR)
 
-[![AUR package](https://repology.org/badge/version-for-repo/aur/coreutils-hybrid.svg)](https://aur.archlinux.org/packages/coreutils-hybrid)
+[AUR package](https://aur.archlinux.org/packages/coreutils-uutils)
 
-A GNU coreutils / uutils coreutils hybrid package. Uses stable uutils
-programs mixed with GNU counterparts if uutils counterpart is
-unfinished or buggy.
+Cross-platform Rust rewrite of the GNU coreutils being used as actual system coreutils.
diff --git a/docs/src/performance.md b/docs/src/performance.md
new file mode 100644
index 00000000000..10c7b383447
--- /dev/null
+++ b/docs/src/performance.md
@@ -0,0 +1,108 @@
+<!-- spell-checker:ignore taskset -->
+
+# Performance Profiling Tutorial
+
+## Effective Benchmarking with Hyperfine
+
+[Hyperfine](https://github.com/sharkdp/hyperfine) is a powerful command-line benchmarking tool that allows you to measure and compare execution times of commands with statistical rigor.
+
+### Benchmarking Best Practices
+
+When evaluating performance improvements, always set up your benchmarks to compare:
+
+1. The GNU implementation as reference
+2. The implementation without the change
+3. The implementation with your change
+
+This three-way comparison provides clear insights into:
+- How your implementation compares to the standard (GNU)
+- The actual performance impact of your specific change
+
+### Example Benchmark
+
+First, you will need to build the binary in release mode. Debug builds are significantly slower:
+
+```bash
+cargo build --features unix --profile profiling
+```
+
+```bash
+# Three-way comparison benchmark
+hyperfine \
+  --warmup 3 \
+  "/usr/bin/ls -R ." \
+  "./target/profiling/coreutils.prev ls -R ." \
+  "./target/profiling/coreutils ls -R ."
+
+# can be simplified with:
+hyperfine \
+  --warmup 3 \
+  -L ls /usr/bin/ls,"./target/profiling/coreutils.prev ls","./target/profiling/coreutils ls" \
+  "{ls} -R ."
+```
+
+```
+# to improve the reproducibility of the results:
+taskset -c 0
+```
+
+### Interpreting Results
+
+Hyperfine provides summary statistics including:
+- Mean execution time
+- Standard deviation
+- Min/max times
+- Relative performance comparison
+
+Look for consistent patterns rather than focusing on individual runs, and be aware of system noise that might affect results.
+
+## Using Samply for Profiling
+
+[Samply](https://github.com/mstange/samply) is a sampling profiler that helps you identify performance bottlenecks in your code.
+
+### Basic Profiling
+
+```bash
+# Generate a flame graph for your application
+samply record ./target/debug/coreutils ls -R
+
+# Profile with higher sampling frequency
+samply record --rate 1000 ./target/debug/coreutils seq 1 1000
+```
+
+The output using the `debug` profile might be easier to understand, but the performance characteristics may be somewhat different from `release` profile that we _actually_ care about.
+
+Consider using the `profiling` profile, that compiles in `release` mode but with debug symbols. For example:
+```bash
+cargo build --profile profiling -p uu_ls
+samply record -r 10000 target/profiling/ls -lR /var .git .git .git > /dev/null
+```
+
+## Workflow: Measuring Performance Improvements
+
+1. **Establish baselines**:
+   ```bash
+   hyperfine --warmup 3 \
+     "/usr/bin/sort large_file.txt" \
+     "our-sort-v1 large_file.txt"
+   ```
+
+2. **Identify bottlenecks**:
+   ```bash
+   samply record ./our-sort-v1 large_file.txt
+   ```
+
+3. **Make targeted improvements** based on profiling data
+
+4. **Verify improvements**:
+   ```bash
+   hyperfine --warmup 3 \
+     "/usr/bin/sort large_file.txt" \
+     "our-sort-v1 large_file.txt" \
+     "our-sort-v2 large_file.txt"
+   ```
+
+5. **Document performance changes** with concrete numbers
+   ```bash
+   hyperfine --export-markdown file.md [...]
+   ```
diff --git a/docs/src/test_coverage.js b/docs/src/test_coverage.js
index e601229affc..318c9934d53 100644
--- a/docs/src/test_coverage.js
+++ b/docs/src/test_coverage.js
@@ -19,7 +19,7 @@ function progressBar(totals) {
         var(--SKIP) ${skipPercentage}%`
 		)
         + (skipPercentage === 100 ? ")" : ", var(--FAIL) 0)");
-	
+
 	const progress = document.createElement("div");
 	progress.className = "progress"
 	progress.innerHTML = `
@@ -74,7 +74,7 @@ function parse_result(parent, obj) {
 	return totals;
 }
 
-fetch("https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json")
+fetch("https://raw.githubusercontent.com/uutils/coreutils-tracking/main/aggregated-result.json")
 	.then((r) => r.json())
 	.then((obj) => {
 		let parent = document.getElementById("test-cov");
diff --git a/docs/src/test_coverage.md b/docs/src/test_coverage.md
index b8376058873..2bfad68bcac 100644
--- a/docs/src/test_coverage.md
+++ b/docs/src/test_coverage.md
@@ -18,4 +18,4 @@ or resulted in an error.
 
 ## Progress over time
 
-<image src="https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.png?raw=true">
+<image src="https://github.com/uutils/coreutils-tracking/blob/main/gnu-results.svg?raw=true">
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 00000000000..fbf85d3df31
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,42 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1720633750,
+        "narHash": "sha256-N8apMO2pP/upWeH+JY5eM8VDp2qBAAzE+OY5LRW6qpw=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "54bc082f5a7219d122e74fe52c021cf59fed9d6f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "systems": "systems"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 00000000000..9c99b7b72e1
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,75 @@
+# spell-checker:ignore bintools gnum gperf ldflags libclang nixpkgs numtide pkgs texinfo gettext
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs";
+
+    # <https://github.com/nix-systems/nix-systems>
+    systems.url = "github:nix-systems/default";
+  };
+
+  outputs = inputs: let
+    inherit (inputs.nixpkgs) lib legacyPackages;
+    eachSystem = lib.genAttrs (import inputs.systems);
+    pkgsFor = legacyPackages;
+  in {
+    devShells = eachSystem (
+      system: let
+        libselinuxPath = with pkgsFor.${system};
+          lib.makeLibraryPath [
+            libselinux
+          ];
+
+        libaclPath = with pkgsFor.${system};
+          lib.makeLibraryPath [
+            acl
+          ];
+
+        build_deps = with pkgsFor.${system}; [
+          clang
+          llvmPackages.bintools
+          rustup
+
+          pre-commit
+          nodePackages.cspell
+
+          # debugging
+          gdb
+        ];
+
+        gnu_testing_deps = with pkgsFor.${system}; [
+          autoconf
+          automake
+          bison
+          gnum4
+          gperf
+          gettext
+          texinfo
+        ];
+      in {
+        default = pkgsFor.${system}.pkgs.mkShell {
+          packages = build_deps ++ gnu_testing_deps;
+
+          RUSTC_VERSION = "1.85";
+          LIBCLANG_PATH = pkgsFor.${system}.lib.makeLibraryPath [pkgsFor.${system}.llvmPackages_latest.libclang.lib];
+          shellHook = ''
+            export PATH=$PATH:''${CARGO_HOME:-~/.cargo}/bin
+            export PATH=$PATH:''${RUSTUP_HOME:-~/.rustup}/toolchains/$RUSTC_VERSION-x86_64-unknown-linux-gnu/bin/
+          '';
+
+          SELINUX_INCLUDE_DIR = ''${pkgsFor.${system}.libselinux.dev}/include'';
+          SELINUX_LIB_DIR = libselinuxPath;
+          SELINUX_STATIC = "0";
+
+          # Necessary to build GNU.
+          LDFLAGS = ''-L ${libselinuxPath} -L ${libaclPath}'';
+
+          # Add precompiled library to rustc search path
+          RUSTFLAGS = [
+            ''-L ${libselinuxPath}''
+            ''-L ${libaclPath}''
+          ];
+        };
+      }
+    );
+  };
+}
diff --git a/fuzz/Cargo.lock b/fuzz/Cargo.lock
new file mode 100644
index 00000000000..4495a0a5a60
--- /dev/null
+++ b/fuzz/Cargo.lock
@@ -0,0 +1,1804 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6680de5231bd6ee4c6191b8a1325daa282b415391ec9d3a37bd34f2060dc73fa"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "bigdecimal"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a22f228ab7a1b23027ccc6c350b72868017af7ea8356fbdf19f8d991c690013"
+dependencies = [
+ "autocfg",
+ "libm",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "binary-heap-plus"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4551d8382e911ecc0d0f0ffb602777988669be09447d536ff4388d1def11296"
+dependencies = [
+ "compare",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+
+[[package]]
+name = "blake2b_simd"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06e903a20b159e944f91ec8499fe1e55651480c541ea0a584f5d967c49ad9d99"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "blake3"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bstr"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
+
+[[package]]
+name = "bytecount"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
+
+[[package]]
+name = "cc"
+version = "1.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f4ac86a9e5bc1e2b3449ab9d7d3a6a405e3d1bb28d7b9be8614f55846ae3766"
+dependencies = [
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chrono"
+version = "0.4.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "num-traits",
+ "windows-link",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efdce149c370f133a071ca8ef6ea340b7b88748ab0810097a9e2976eaa34b4f3"
+dependencies = [
+ "chrono",
+ "chrono-tz-build",
+ "phf",
+]
+
+[[package]]
+name = "chrono-tz-build"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f10f8c9340e31fc120ff885fcdb54a0b48e474bbd77cab557f0c30a3e569402"
+dependencies = [
+ "parse-zoneinfo",
+ "phf_codegen",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+ "terminal_size",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+
+[[package]]
+name = "compare"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3"
+
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "unicode-width",
+ "windows-sys",
+]
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.16",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctrlc"
+version = "3.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46f93780a459b7d656ef7f071fe699c4d3d2cb201c4b24d085b6ddc505276e73"
+dependencies = [
+ "nix",
+ "windows-sys",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+
+[[package]]
+name = "data-encoding-macro"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47ce6c96ea0102f01122a185683611bd5ac8d99e62bc59dd12e6bda344ee673d"
+dependencies = [
+ "data-encoding",
+ "data-encoding-macro-internal",
+]
+
+[[package]]
+name = "data-encoding-macro-internal"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d162beedaa69905488a8da94f5ac3edb4dd4788b732fadb7bd120b2625c1976"
+dependencies = [
+ "data-encoding",
+ "syn",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dlv-list"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
+dependencies = [
+ "const-random",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "errno"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fluent"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8137a6d5a2c50d6b0ebfcb9aaa91a28154e0a70605f112d30cb0cd4a78670477"
+dependencies = [
+ "fluent-bundle",
+ "unic-langid",
+]
+
+[[package]]
+name = "fluent-bundle"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01203cb8918f5711e73891b347816d932046f95f54207710bda99beaeb423bf4"
+dependencies = [
+ "fluent-langneg",
+ "fluent-syntax",
+ "intl-memoizer",
+ "intl_pluralrules",
+ "rustc-hash 2.1.1",
+ "self_cell",
+ "smallvec",
+ "unic-langid",
+]
+
+[[package]]
+name = "fluent-langneg"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c4ad0989667548f06ccd0e306ed56b61bd4d35458d54df5ec7587c0e8ed5e94"
+dependencies = [
+ "unic-langid",
+]
+
+[[package]]
+name = "fluent-syntax"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54f0d287c53ffd184d04d8677f590f4ac5379785529e5e08b1c8083acdd5c198"
+dependencies = [
+ "memchr",
+ "thiserror",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "intl-memoizer"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "310da2e345f5eb861e7a07ee182262e94975051db9e4223e909ba90f392f163f"
+dependencies = [
+ "type-map",
+ "unic-langid",
+]
+
+[[package]]
+name = "intl_pluralrules"
+version = "7.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078ea7b7c29a2b4df841a7f6ac8775ff6074020c6776d48491ce2268e068f972"
+dependencies = [
+ "unic-langid",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+dependencies = [
+ "getrandom 0.3.3",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.172"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf78f52d400cf2d84a3a973a78a592b4adc535739e0a5597a0da6f0c357adc75"
+dependencies = [
+ "arbitrary",
+ "cc",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+
+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "number_prefix"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+
+[[package]]
+name = "onig"
+version = "6.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "336b9c63443aceef14bea841b899035ae3abe89b7c486aaf4c5bd8aafedac3f0"
+dependencies = [
+ "bitflags",
+ "libc",
+ "once_cell",
+ "onig_sys",
+]
+
+[[package]]
+name = "onig_sys"
+version = "69.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7f86c6eef3d6df15f23bcfb6af487cbd2fed4e5581d58d5bf1f5f8b7f6727dc"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
+[[package]]
+name = "ordered-multimap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
+dependencies = [
+ "dlv-list",
+ "hashbrown",
+]
+
+[[package]]
+name = "os_display"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad5fd71b79026fb918650dde6d125000a233764f1c2f1659a1c71118e33ea08f"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "parse-zoneinfo"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "parse_datetime"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fd3830b49ee3a0dcc8fdfadc68c6354c97d00101ac1cac5b2eee25d35c42066"
+dependencies = [
+ "chrono",
+ "nom",
+ "regex",
+]
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+dependencies = [
+ "rand_chacha",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.3",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
+[[package]]
+name = "rust-ini"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e310ef0e1b6eeb79169a1171daf9abcb87a2e17c03bee2c4bb100b55c75409f"
+dependencies = [
+ "cfg-if",
+ "ordered-multimap",
+ "trim-in-place",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "rustix"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+
+[[package]]
+name = "self_cell"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
+
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest",
+ "keccak",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
+[[package]]
+name = "sm3"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebb9a3b702d0a7e33bc4d85a14456633d2b165c2ad839c5fd9a8417c1ab15860"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.101"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.3",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45c6481c4829e4cc63825e62c49186a34538b7b2750b73b266581ffb612fb5ed"
+dependencies = [
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "trim-in-place"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "343e926fc669bc8cde4fa3129ab681c63671bae288b1f1081ceee6d9d37904fc"
+
+[[package]]
+name = "type-map"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f"
+dependencies = [
+ "rustc-hash 1.1.0",
+]
+
+[[package]]
+name = "typenum"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
+[[package]]
+name = "unic-langid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ba52c9b05311f4f6e62d5d9d46f094bd6e84cb8df7b3ef952748d752a7d05"
+dependencies = [
+ "unic-langid-impl",
+]
+
+[[package]]
+name = "unic-langid-impl"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce1bf08044d4b7a94028c93786f8566047edc11110595914de93362559bc658"
+dependencies = [
+ "tinystr",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uu_cksum"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "hex",
+ "regex",
+ "uucore",
+]
+
+[[package]]
+name = "uu_cut"
+version = "0.1.0"
+dependencies = [
+ "bstr",
+ "clap",
+ "memchr",
+ "uucore",
+]
+
+[[package]]
+name = "uu_date"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "clap",
+ "libc",
+ "parse_datetime",
+ "uucore",
+ "windows-sys",
+]
+
+[[package]]
+name = "uu_echo"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "uucore",
+]
+
+[[package]]
+name = "uu_env"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "nix",
+ "rust-ini",
+ "thiserror",
+ "uucore",
+]
+
+[[package]]
+name = "uu_expr"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "num-bigint",
+ "num-traits",
+ "onig",
+ "thiserror",
+ "uucore",
+]
+
+[[package]]
+name = "uu_printf"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "uucore",
+]
+
+[[package]]
+name = "uu_seq"
+version = "0.1.0"
+dependencies = [
+ "bigdecimal",
+ "clap",
+ "num-bigint",
+ "num-traits",
+ "thiserror",
+ "uucore",
+]
+
+[[package]]
+name = "uu_sort"
+version = "0.1.0"
+dependencies = [
+ "binary-heap-plus",
+ "clap",
+ "compare",
+ "ctrlc",
+ "fnv",
+ "itertools",
+ "memchr",
+ "nix",
+ "rand 0.9.1",
+ "rayon",
+ "self_cell",
+ "tempfile",
+ "thiserror",
+ "unicode-width",
+ "uucore",
+]
+
+[[package]]
+name = "uu_split"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "memchr",
+ "thiserror",
+ "uucore",
+]
+
+[[package]]
+name = "uu_test"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "libc",
+ "uucore",
+]
+
+[[package]]
+name = "uu_tr"
+version = "0.1.0"
+dependencies = [
+ "clap",
+ "nom",
+ "uucore",
+]
+
+[[package]]
+name = "uu_wc"
+version = "0.1.0"
+dependencies = [
+ "bytecount",
+ "clap",
+ "libc",
+ "nix",
+ "thiserror",
+ "unicode-width",
+ "uucore",
+]
+
+[[package]]
+name = "uucore"
+version = "0.1.0"
+dependencies = [
+ "bigdecimal",
+ "blake2b_simd",
+ "blake3",
+ "chrono",
+ "chrono-tz",
+ "clap",
+ "crc32fast",
+ "data-encoding",
+ "data-encoding-macro",
+ "digest",
+ "dunce",
+ "fluent",
+ "fluent-bundle",
+ "glob",
+ "hex",
+ "iana-time-zone",
+ "itertools",
+ "libc",
+ "md-5",
+ "memchr",
+ "nix",
+ "num-traits",
+ "number_prefix",
+ "os_display",
+ "sha1",
+ "sha2",
+ "sha3",
+ "sm3",
+ "thiserror",
+ "unic-langid",
+ "uucore_procs",
+ "wild",
+ "winapi-util",
+ "windows-sys",
+ "z85",
+]
+
+[[package]]
+name = "uucore-fuzz"
+version = "0.0.0"
+dependencies = [
+ "libfuzzer-sys",
+ "rand 0.9.1",
+ "uu_cksum",
+ "uu_cut",
+ "uu_date",
+ "uu_echo",
+ "uu_env",
+ "uu_expr",
+ "uu_printf",
+ "uu_seq",
+ "uu_sort",
+ "uu_split",
+ "uu_test",
+ "uu_tr",
+ "uu_wc",
+ "uucore",
+ "uufuzz",
+]
+
+[[package]]
+name = "uucore_procs"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "uuhelp_parser",
+]
+
+[[package]]
+name = "uufuzz"
+version = "0.1.0"
+dependencies = [
+ "console",
+ "libc",
+ "rand 0.9.1",
+ "similar",
+ "tempfile",
+ "uucore",
+]
+
+[[package]]
+name = "uuhelp_parser"
+version = "0.1.0"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wild"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3131afc8c575281e1e80f36ed6a092aa502c08b18ed7524e86fbbb12bb410e1"
+dependencies = [
+ "glob",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "z85"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b3a41ce106832b4da1c065baa4c31cf640cf965fa1483816402b7f6b96f0a64"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+
+[[package]]
+name = "zerovec"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
+dependencies = [
+ "zerofrom",
+]
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 91a85b45a0f..48da8e846b4 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,21 +1,36 @@
 [package]
 name = "uucore-fuzz"
 version = "0.0.0"
+description = "uutils ~ 'core' uutils fuzzers"
+repository = "https://github.com/uutils/coreutils/tree/main/fuzz/"
+edition.workspace = true
 publish = false
-edition = "2021"
+
+[workspace.package]
+edition = "2024"
+license = "MIT"
 
 [package.metadata]
 cargo-fuzz = true
 
 [dependencies]
-libfuzzer-sys = "0.4"
-libc = "0.2"
-rand = { version = "0.8", features = ["small_rng"] }
-
-uucore = { path = "../src/uucore/" }
+libfuzzer-sys = "0.4.7"
+rand = { version = "0.9.0", features = ["small_rng"] }
+uufuzz = { path = "uufuzz/" }
+uucore = { path = "../src/uucore/", features = ["parser"] }
 uu_date = { path = "../src/uu/date/" }
 uu_test = { path = "../src/uu/test/" }
-
+uu_expr = { path = "../src/uu/expr/" }
+uu_printf = { path = "../src/uu/printf/" }
+uu_echo = { path = "../src/uu/echo/" }
+uu_seq = { path = "../src/uu/seq/" }
+uu_sort = { path = "../src/uu/sort/" }
+uu_wc = { path = "../src/uu/wc/" }
+uu_cut = { path = "../src/uu/cut/" }
+uu_split = { path = "../src/uu/split/" }
+uu_tr = { path = "../src/uu/tr/" }
+uu_env = { path = "../src/uu/env/" }
+uu_cksum = { path = "../src/uu/cksum/" }
 
 # Prevent this from interfering with workspaces
 [workspace]
@@ -27,12 +42,66 @@ path = "fuzz_targets/fuzz_date.rs"
 test = false
 doc = false
 
+[[bin]]
+name = "fuzz_printf"
+path = "fuzz_targets/fuzz_printf.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_echo"
+path = "fuzz_targets/fuzz_echo.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_seq"
+path = "fuzz_targets/fuzz_seq.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_sort"
+path = "fuzz_targets/fuzz_sort.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_split"
+path = "fuzz_targets/fuzz_split.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_cut"
+path = "fuzz_targets/fuzz_cut.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_wc"
+path = "fuzz_targets/fuzz_wc.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_expr"
+path = "fuzz_targets/fuzz_expr.rs"
+test = false
+doc = false
+
 [[bin]]
 name = "fuzz_test"
 path = "fuzz_targets/fuzz_test.rs"
 test = false
 doc = false
 
+[[bin]]
+name = "fuzz_seq_parse_number"
+path = "fuzz_targets/fuzz_seq_parse_number.rs"
+test = false
+doc = false
+
 [[bin]]
 name = "fuzz_parse_glob"
 path = "fuzz_targets/fuzz_parse_glob.rs"
@@ -50,3 +119,21 @@ name = "fuzz_parse_time"
 path = "fuzz_targets/fuzz_parse_time.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "fuzz_tr"
+path = "fuzz_targets/fuzz_tr.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_env"
+path = "fuzz_targets/fuzz_env.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_cksum"
+path = "fuzz_targets/fuzz_cksum.rs"
+test = false
+doc = false
diff --git a/fuzz/fuzz_targets/fuzz_cksum.rs b/fuzz/fuzz_targets/fuzz_cksum.rs
new file mode 100644
index 00000000000..be93a96050e
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_cksum.rs
@@ -0,0 +1,170 @@
+// 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.
+// spell-checker:ignore chdir
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use rand::Rng;
+use std::env::temp_dir;
+use std::ffi::OsString;
+use std::fs::{self, File};
+use std::io::Write;
+use std::process::Command;
+use uu_cksum::uumain;
+use uufuzz::{
+    CommandResult, compare_result, generate_and_run_uumain, generate_random_file,
+    generate_random_string,
+    pretty_print::{print_or_empty, print_test_begin},
+    replace_fuzz_binary_name, run_gnu_cmd,
+};
+
+static CMD_PATH: &str = "cksum";
+
+fn generate_cksum_args() -> Vec<String> {
+    let mut rng = rand::rng();
+    let mut args = Vec::new();
+
+    let digests = [
+        "sysv", "bsd", "crc", "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "blake2b",
+        "sm3",
+    ];
+    let digest_opts = [
+        "--base64",
+        "--raw",
+        "--tag",
+        "--untagged",
+        "--text",
+        "--binary",
+    ];
+
+    if rng.random_bool(0.3) {
+        args.push("-a".to_string());
+        args.push(digests[rng.random_range(0..digests.len())].to_string());
+    }
+
+    if rng.random_bool(0.2) {
+        args.push(digest_opts[rng.random_range(0..digest_opts.len())].to_string());
+    }
+
+    if rng.random_bool(0.15) {
+        args.push("-l".to_string());
+        args.push(rng.random_range(8..513).to_string());
+    }
+
+    if rng.random_bool(0.05) {
+        for _ in 0..rng.random_range(0..3) {
+            args.push(format!("file_{}", generate_random_string(5)));
+        }
+    } else {
+        args.push("-c".to_string());
+    }
+
+    if rng.random_bool(0.25) {
+        if let Ok(file_path) = generate_random_file() {
+            args.push(file_path);
+        }
+    }
+
+    if args.is_empty() || !args.iter().any(|arg| arg.starts_with("file_")) {
+        args.push("-a".to_string());
+        args.push(digests[rng.random_range(0..digests.len())].to_string());
+
+        if let Ok(file_path) = generate_random_file() {
+            args.push(file_path);
+        }
+    }
+
+    args
+}
+
+fn generate_checksum_file(
+    algo: &str,
+    file_path: &str,
+    digest_opts: &[&str],
+) -> Result<String, std::io::Error> {
+    let checksum_file_path = temp_dir().join("checksum_file");
+    let mut cmd = Command::new(CMD_PATH);
+    cmd.arg("-a").arg(algo);
+
+    for opt in digest_opts {
+        cmd.arg(opt);
+    }
+
+    cmd.arg(file_path);
+    let output = cmd.output()?;
+
+    let mut checksum_file = File::create(&checksum_file_path)?;
+    checksum_file.write_all(&output.stdout)?;
+
+    Ok(checksum_file_path.to_str().unwrap().to_string())
+}
+
+fn select_random_digest_opts<'a>(
+    rng: &mut rand::rngs::ThreadRng,
+    digest_opts: &'a [&'a str],
+) -> Vec<&'a str> {
+    digest_opts
+        .iter()
+        .filter(|_| rng.random_bool(0.5))
+        .copied()
+        .collect()
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let cksum_args = generate_cksum_args();
+    let mut args = vec![OsString::from("cksum")];
+    args.extend(cksum_args.iter().map(OsString::from));
+
+    if let Ok(file_path) = generate_random_file() {
+        let algo = cksum_args
+            .iter()
+            .position(|arg| arg == "-a")
+            .map_or("md5", |index| &cksum_args[index + 1]);
+
+        let all_digest_opts = ["--base64", "--raw", "--tag", "--untagged"];
+        let mut rng = rand::rng();
+        let selected_digest_opts = select_random_digest_opts(&mut rng, &all_digest_opts);
+
+        if let Ok(checksum_file_path) =
+            generate_checksum_file(algo, &file_path, &selected_digest_opts)
+        {
+            print_test_begin(format!("cksum {args:?}"));
+
+            if let Ok(content) = fs::read_to_string(&checksum_file_path) {
+                println!("File content ({checksum_file_path})");
+                print_or_empty(&content);
+            } else {
+                eprintln!("Error reading the checksum file.");
+            }
+            let mut rust_result = generate_and_run_uumain(&args, uumain, None);
+
+            let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+                Ok(result) => result,
+                Err(error_result) => {
+                    eprintln!("Failed to run GNU command:");
+                    eprintln!("Stderr: {}", error_result.stderr);
+                    eprintln!("Exit Code: {}", error_result.exit_code);
+                    CommandResult {
+                        stdout: String::new(),
+                        stderr: error_result.stderr,
+                        exit_code: error_result.exit_code,
+                    }
+                }
+            };
+
+            // Lower the number of false positives caused by binary names
+            replace_fuzz_binary_name("cksum", &mut rust_result);
+
+            compare_result(
+                "cksum",
+                &format!("{:?}", &args[1..]),
+                None,
+                &rust_result,
+                &gnu_result,
+                false,
+            );
+        }
+    }
+});
diff --git a/fuzz/fuzz_targets/fuzz_cut.rs b/fuzz/fuzz_targets/fuzz_cut.rs
new file mode 100644
index 00000000000..4a5215f8aec
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_cut.rs
@@ -0,0 +1,86 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_cut::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+use uufuzz::{
+    CommandResult, compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+static CMD_PATH: &str = "cut";
+
+fn generate_cut_args() -> String {
+    let mut rng = rand::rng();
+    let arg_count = rng.random_range(1..=6);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        if rng.random_bool(0.1) {
+            args.push(generate_random_string(rng.random_range(1..=20)));
+        } else {
+            match rng.random_range(0..=4) {
+                0 => args.push(String::from("-b") + &rng.random_range(1..=10).to_string()),
+                1 => args.push(String::from("-c") + &rng.random_range(1..=10).to_string()),
+                2 => args.push(String::from("-d,") + &generate_random_string(1)), // Using a comma as a default delimiter
+                3 => args.push(String::from("-f") + &rng.random_range(1..=5).to_string()),
+                _ => (),
+            }
+        }
+    }
+
+    args.join(" ")
+}
+
+fn generate_delimited_data(count: usize) -> String {
+    let mut rng = rand::rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        let fields = (0..rng.random_range(1..=5))
+            .map(|_| generate_random_string(rng.random_range(1..=10)))
+            .collect::<Vec<_>>()
+            .join(",");
+        lines.push(fields);
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let cut_args = generate_cut_args();
+    let mut args = vec![OsString::from("cut")];
+    args.extend(cut_args.split_whitespace().map(OsString::from));
+
+    let input_lines = generate_delimited_data(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "cut",
+        &format!("{:?}", &args[1..]),
+        Some(&input_lines),
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_date.rs b/fuzz/fuzz_targets/fuzz_date.rs
index 96c56cc6bf2..0f9cb262c06 100644
--- a/fuzz/fuzz_targets/fuzz_date.rs
+++ b/fuzz/fuzz_targets/fuzz_date.rs
@@ -9,6 +9,6 @@ fuzz_target!(|data: &[u8]| {
     let args = data
         .split(|b| *b == delim)
         .filter_map(|e| std::str::from_utf8(e).ok())
-        .map(|e| OsString::from(e));
+        .map(OsString::from);
     uumain(args);
 });
diff --git a/fuzz/fuzz_targets/fuzz_echo.rs b/fuzz/fuzz_targets/fuzz_echo.rs
new file mode 100644
index 00000000000..e6b0ba9a6aa
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_echo.rs
@@ -0,0 +1,84 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_echo::uumain;
+
+use rand::Rng;
+use rand::prelude::IndexedRandom;
+use std::ffi::OsString;
+
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd};
+
+static CMD_PATH: &str = "echo";
+
+fn generate_echo() -> String {
+    let mut rng = rand::rng();
+    let mut echo_str = String::new();
+
+    // Randomly decide whether to include options
+    let include_n = rng.random_bool(0.1); // 10% chance
+    let include_e = rng.random_bool(0.1); // 10% chance
+    #[allow(non_snake_case)]
+    let include_E = rng.random_bool(0.1); // 10% chance
+
+    if include_n {
+        echo_str.push_str("-n ");
+    }
+    if include_e {
+        echo_str.push_str("-e ");
+    }
+    if include_E {
+        echo_str.push_str("-E ");
+    }
+
+    // Add a random string
+    echo_str.push_str(&generate_random_string(rng.random_range(1..=10)));
+
+    // Include escape sequences if -e is enabled
+    if include_e {
+        // Add a 10% chance of including an escape sequence
+        if rng.random_bool(0.1) {
+            echo_str.push_str(&generate_escape_sequence(&mut rng));
+        }
+    }
+
+    echo_str
+}
+
+fn generate_escape_sequence(rng: &mut impl Rng) -> String {
+    let escape_sequences = [
+        "\\\\", "\\a", "\\b", "\\c", "\\e", "\\f", "\\n", "\\r", "\\t", "\\v", "\\0NNN", "\\xHH",
+    ];
+    // \0NNN and \xHH need more work
+    escape_sequences.choose(rng).unwrap().to_string()
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let echo_input = generate_echo();
+    let mut args = vec![OsString::from("echo")];
+    args.extend(echo_input.split_whitespace().map(OsString::from));
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "echo",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        true,
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_env.rs b/fuzz/fuzz_targets/fuzz_env.rs
new file mode 100644
index 00000000000..284089f8378
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_env.rs
@@ -0,0 +1,96 @@
+// 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.
+// spell-checker:ignore chdir
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_env::uumain;
+
+use std::ffi::OsString;
+
+use rand::Rng;
+use uufuzz::{
+    CommandResult, compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+
+static CMD_PATH: &str = "env";
+
+fn generate_env_args() -> Vec<String> {
+    let mut rng = rand::rng();
+    let mut args = Vec::new();
+
+    let opts = ["-i", "-0", "-v", "-vv"];
+    for opt in &opts {
+        if rng.random_bool(0.2) {
+            args.push(opt.to_string());
+        }
+    }
+
+    if rng.random_bool(0.3) {
+        args.push(format!(
+            "-u={}",
+            generate_random_string(rng.random_range(3..10))
+        ));
+    }
+
+    if rng.random_bool(0.2) {
+        args.push(format!("--chdir={}", "/tmp")); // Simplified example
+    }
+
+    /*
+        Options not implemented for now
+    if rng.random_bool(0.15) {
+        let sig_opts = ["--block-signal"];//, /*"--default-signal",*/ "--ignore-signal"];
+        let chosen_sig_opt = sig_opts[rng.random_range(0..sig_opts.len())];
+        args.push(chosen_sig_opt.to_string());
+        // Simplify by assuming SIGPIPE for demonstration
+        if !chosen_sig_opt.ends_with("list-signal-handling") {
+            args.push(String::from("SIGPIPE"));
+        }
+    }*/
+
+    // Adding a few random NAME=VALUE pairs
+    for _ in 0..rng.random_range(0..3) {
+        args.push(format!(
+            "{}={}",
+            generate_random_string(5),
+            generate_random_string(5)
+        ));
+    }
+
+    args
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let env_args = generate_env_args();
+    let mut args = vec![OsString::from("env")];
+    args.extend(env_args.iter().map(OsString::from));
+    let input_lines = generate_random_string(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "env",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false,
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_expr.rs b/fuzz/fuzz_targets/fuzz_expr.rs
new file mode 100644
index 00000000000..77ecffabc1b
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_expr.rs
@@ -0,0 +1,96 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_expr::uumain;
+
+use rand::Rng;
+use rand::prelude::IndexedRandom;
+use std::{env, ffi::OsString};
+
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd};
+static CMD_PATH: &str = "expr";
+
+fn generate_expr(max_depth: u32) -> String {
+    let mut rng = rand::rng();
+    let ops = [
+        "+", "-", "*", "/", "%", "<", ">", "=", "&", "|", "!=", "<=", ">=", ":", "index", "length",
+        "substr",
+    ];
+
+    let mut expr = String::new();
+    let mut depth = 0;
+    let mut last_was_operator = false;
+
+    while depth <= max_depth {
+        if last_was_operator || depth == 0 {
+            // Add a number
+            expr.push_str(&rng.random_range(1..=100).to_string());
+            last_was_operator = false;
+        } else {
+            // 90% chance to add an operator followed by a number
+            if rng.random_bool(0.9) {
+                let op = *ops.choose(&mut rng).unwrap();
+                expr.push_str(&format!(" {op} "));
+                last_was_operator = true;
+            }
+            // 10% chance to add a random string (potentially invalid syntax)
+            else {
+                let random_str = generate_random_string(rng.random_range(1..=10));
+                expr.push_str(&random_str);
+                last_was_operator = false;
+            }
+        }
+        depth += 1;
+    }
+
+    // Ensure the expression ends with a number if it ended with an operator
+    if last_was_operator {
+        expr.push_str(&rng.random_range(1..=100).to_string());
+    }
+
+    expr
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let mut rng = rand::rng();
+    let expr = generate_expr(rng.random_range(0..=20));
+    let mut args = vec![OsString::from("expr")];
+    args.extend(expr.split_whitespace().map(OsString::from));
+
+    // Use C locale to avoid false positives, like in https://github.com/uutils/coreutils/issues/5378,
+    // because uutils expr doesn't support localization yet
+    // TODO remove once uutils expr supports localization
+    unsafe {
+        env::set_var("LC_COLLATE", "C");
+    }
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "expr",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_parse_glob.rs b/fuzz/fuzz_targets/fuzz_parse_glob.rs
index 061569bc418..66e772959e7 100644
--- a/fuzz/fuzz_targets/fuzz_parse_glob.rs
+++ b/fuzz/fuzz_targets/fuzz_parse_glob.rs
@@ -1,10 +1,10 @@
 #![no_main]
 
 use libfuzzer_sys::fuzz_target;
-use uucore::parse_glob;
+use uucore::parser::parse_glob;
 
 fuzz_target!(|data: &[u8]| {
     if let Ok(s) = std::str::from_utf8(data) {
-        _ = parse_glob::from_str(s)
+        _ = parse_glob::from_str(s);
     }
 });
diff --git a/fuzz/fuzz_targets/fuzz_parse_size.rs b/fuzz/fuzz_targets/fuzz_parse_size.rs
index 23b3b5ea426..4e8d7e2216b 100644
--- a/fuzz/fuzz_targets/fuzz_parse_size.rs
+++ b/fuzz/fuzz_targets/fuzz_parse_size.rs
@@ -1,10 +1,10 @@
 #![no_main]
 
 use libfuzzer_sys::fuzz_target;
-use uucore::parse_size::parse_size;
+use uucore::parser::parse_size::parse_size_u64;
 
 fuzz_target!(|data: &[u8]| {
     if let Ok(s) = std::str::from_utf8(data) {
-        _ = parse_size(s);
+        _ = parse_size_u64(s);
     }
 });
diff --git a/fuzz/fuzz_targets/fuzz_parse_time.rs b/fuzz/fuzz_targets/fuzz_parse_time.rs
index a643c6d805c..5745e5c8709 100644
--- a/fuzz/fuzz_targets/fuzz_parse_time.rs
+++ b/fuzz/fuzz_targets/fuzz_parse_time.rs
@@ -1,10 +1,11 @@
 #![no_main]
 
 use libfuzzer_sys::fuzz_target;
-use uucore::parse_time;
+use uucore::parser::parse_time;
 
 fuzz_target!(|data: &[u8]| {
     if let Ok(s) = std::str::from_utf8(data) {
-        _ = parse_time::from_str(s);
+        _ = parse_time::from_str(s, true);
+        _ = parse_time::from_str(s, false);
     }
 });
diff --git a/fuzz/fuzz_targets/fuzz_printf.rs b/fuzz/fuzz_targets/fuzz_printf.rs
new file mode 100644
index 00000000000..885ebb815bf
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_printf.rs
@@ -0,0 +1,109 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_printf::uumain;
+
+use rand::Rng;
+use rand::seq::IndexedRandom;
+use std::env;
+use std::ffi::OsString;
+
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd};
+
+static CMD_PATH: &str = "printf";
+
+fn generate_escape_sequence(rng: &mut impl Rng) -> String {
+    let escape_sequences = [
+        "\\\"",
+        "\\\\",
+        "\\a",
+        "\\b",
+        "\\c",
+        "\\e",
+        "\\f",
+        "\\n",
+        "\\r",
+        "\\t",
+        "\\v",
+        "\\000",
+        "\\x00",
+        "\\u0000",
+        "\\U00000000",
+        "%%",
+    ];
+    escape_sequences.choose(rng).unwrap().to_string()
+}
+
+fn generate_printf() -> String {
+    let mut rng = rand::rng();
+    let format_specifiers = ["%s", "%d", "%f", "%x", "%o", "%c", "%b", "%q"];
+    let mut printf_str = String::new();
+    // Add a 20% chance of generating an invalid format specifier
+    if rng.random_bool(0.2) {
+        printf_str.push_str("%z"); // Invalid format specifier
+    } else {
+        let specifier = *format_specifiers.choose(&mut rng).unwrap();
+        printf_str.push_str(specifier);
+
+        // Add a 20% chance of introducing complex format strings
+        if rng.random_bool(0.2) {
+            printf_str.push_str(&format!(" %{}", rng.random_range(1..=1000)));
+        } else {
+            // Add a random string or number after the specifier
+            if specifier == "%s" {
+                printf_str.push_str(&format!(
+                    " {}",
+                    generate_random_string(rng.random_range(1..=10))
+                ));
+            } else {
+                printf_str.push_str(&format!(" {}", rng.random_range(1..=1000)));
+            }
+        }
+    }
+
+    // Add a 10% chance of including an escape sequence
+    if rng.random_bool(0.1) {
+        printf_str.push_str(&generate_escape_sequence(&mut rng));
+    }
+    printf_str
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let printf_input = generate_printf();
+    let mut args = vec![OsString::from("printf")];
+    args.extend(printf_input.split_whitespace().map(OsString::from));
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    // TODO remove once uutils printf supports localization
+    unsafe {
+        env::set_var("LC_ALL", "C");
+    }
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "printf",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_seq.rs b/fuzz/fuzz_targets/fuzz_seq.rs
new file mode 100644
index 00000000000..35721865e8c
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_seq.rs
@@ -0,0 +1,72 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_seq::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd};
+static CMD_PATH: &str = "seq";
+
+fn generate_seq() -> String {
+    let mut rng = rand::rng();
+
+    // Generate 1 to 3 numbers for seq arguments
+    let arg_count = rng.random_range(1..=3);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        if rng.random_ratio(1, 100) {
+            // 1% chance to add a random string
+            args.push(generate_random_string(rng.random_range(1..=10)));
+        } else {
+            // 99% chance to add a numeric value
+            match rng.random_range(0..=3) {
+                0 => args.push(rng.random_range(-10000..=10000).to_string()), // Large or small integers
+                1 => args.push(rng.random_range(-100.0..100.0).to_string()), // Floating-point numbers
+                2 => args.push(rng.random_range(-100..0).to_string()),       // Negative integers
+                _ => args.push(rng.random_range(1..=100).to_string()),       // Regular integers
+            }
+        }
+    }
+
+    args.join(" ")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let seq = generate_seq();
+    let mut args = vec![OsString::from("seq")];
+    args.extend(seq.split_whitespace().map(OsString::from));
+
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "seq",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_seq_parse_number.rs b/fuzz/fuzz_targets/fuzz_seq_parse_number.rs
new file mode 100644
index 00000000000..04da6d47f99
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_seq_parse_number.rs
@@ -0,0 +1,15 @@
+// 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.
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use std::str::FromStr;
+use uu_seq::number::PreciseNumber;
+
+fuzz_target!(|data: &[u8]| {
+    if let Ok(s) = std::str::from_utf8(data) {
+        let _ = PreciseNumber::from_str(s);
+    }
+});
diff --git a/fuzz/fuzz_targets/fuzz_sort.rs b/fuzz/fuzz_targets/fuzz_sort.rs
new file mode 100644
index 00000000000..8b38f39ec1b
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_sort.rs
@@ -0,0 +1,85 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_sort::uumain;
+
+use rand::Rng;
+use std::env;
+use std::ffi::OsString;
+
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd};
+static CMD_PATH: &str = "sort";
+
+fn generate_sort_args() -> String {
+    let mut rng = rand::rng();
+
+    let arg_count = rng.random_range(1..=5);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        match rng.random_range(0..=4) {
+            0 => args.push(String::from("-r")), // Reverse the result of comparisons
+            1 => args.push(String::from("-n")), // Compare according to string numerical value
+            2 => args.push(String::from("-f")), // Fold lower case to upper case characters
+            3 => args.push(generate_random_string(rng.random_range(1..=10))), // Random string (to simulate file names)
+            _ => args.push(String::from("-k") + &rng.random_range(1..=5).to_string()), // Sort via a specified field
+        }
+    }
+
+    args.join(" ")
+}
+
+fn generate_random_lines(count: usize) -> String {
+    let mut rng = rand::rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        lines.push(generate_random_string(rng.random_range(1..=20)));
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let sort_args = generate_sort_args();
+    let mut args = vec![OsString::from("sort")];
+    args.extend(sort_args.split_whitespace().map(OsString::from));
+
+    // Generate random lines to sort
+    let input_lines = generate_random_lines(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+
+    // TODO remove once uutils sort supports localization
+    unsafe {
+        env::set_var("LC_ALL", "C");
+    }
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "sort",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_split.rs b/fuzz/fuzz_targets/fuzz_split.rs
new file mode 100644
index 00000000000..70860ece731
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_split.rs
@@ -0,0 +1,104 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_split::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+use uufuzz::{
+    CommandResult, compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+static CMD_PATH: &str = "split";
+
+fn generate_split_args() -> String {
+    let mut rng = rand::rng();
+    let mut args = Vec::new();
+
+    match rng.random_range(0..=9) {
+        0 => {
+            args.push(String::from("-a")); // Suffix length
+            args.push(rng.random_range(1..=8).to_string());
+        }
+        1 => {
+            args.push(String::from("--additional-suffix"));
+            args.push(generate_random_string(5)); // Random suffix
+        }
+        2 => {
+            args.push(String::from("-b")); // Bytes per output file
+            args.push(rng.random_range(1..=1024).to_string() + "K");
+        }
+        3 => {
+            args.push(String::from("-C")); // Line bytes
+            args.push(rng.random_range(1..=1024).to_string());
+        }
+        4 => args.push(String::from("-d")), // Use numeric suffixes
+        5 => args.push(String::from("-x")), // Use hex suffixes
+        6 => {
+            args.push(String::from("-l")); // Number of lines per output file
+            args.push(rng.random_range(1..=1000).to_string());
+        }
+        7 => {
+            args.push(String::from("--filter"));
+            args.push(String::from("cat > /dev/null")); // Example filter command
+        }
+        8 => {
+            args.push(String::from("-t")); // Separator
+            args.push(String::from("\n")); // Newline as separator
+        }
+        9 => args.push(String::from("--verbose")), // Verbose
+        _ => (),
+    }
+
+    args.join(" ")
+}
+
+// Function to generate a random string of lines
+fn generate_random_lines(count: usize) -> String {
+    let mut rng = rand::rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        lines.push(generate_random_string(rng.random_range(1..=20)));
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let split_args = generate_split_args();
+    let mut args = vec![OsString::from("split")];
+    args.extend(split_args.split_whitespace().map(OsString::from));
+
+    let input_lines = generate_random_lines(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "split",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_test.rs b/fuzz/fuzz_targets/fuzz_test.rs
index 537e21abda5..894a1dcd56b 100644
--- a/fuzz/fuzz_targets/fuzz_test.rs
+++ b/fuzz/fuzz_targets/fuzz_test.rs
@@ -8,13 +8,14 @@
 use libfuzzer_sys::fuzz_target;
 use uu_test::uumain;
 
-use rand::seq::SliceRandom;
 use rand::Rng;
+use rand::prelude::IndexedRandom;
 use std::ffi::OsString;
 
-use libc::{dup, dup2, STDOUT_FILENO};
-use std::process::Command;
+use uufuzz::CommandResult;
+use uufuzz::{compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd};
 
+#[allow(clippy::upper_case_acronyms)]
 #[derive(PartialEq, Debug, Clone)]
 enum ArgType {
     STRING,
@@ -26,41 +27,7 @@ enum ArgType {
     // Add any other types as needed
 }
 
-fn run_gnu_test(args: &[OsString]) -> Result<(String, i32), std::io::Error> {
-    let mut command = Command::new("test");
-    for arg in args {
-        command.arg(arg);
-    }
-    let output = command.output()?;
-    let exit_status = output.status.code().unwrap_or(-1); // Capture the exit status code
-    Ok((
-        String::from_utf8_lossy(&output.stdout).to_string(),
-        exit_status,
-    ))
-}
-
-fn generate_random_string(max_length: usize) -> String {
-    let mut rng = rand::thread_rng();
-    let valid_utf8: Vec<char> = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-        .chars()
-        .collect();
-    let invalid_utf8 = [0xC3, 0x28]; // Invalid UTF-8 sequence
-    let mut result = String::new();
-
-    for _ in 0..rng.gen_range(1..=max_length) {
-        if rng.gen_bool(0.9) {
-            let ch = valid_utf8.choose(&mut rng).unwrap();
-            result.push(*ch);
-        } else {
-            let ch = invalid_utf8.choose(&mut rng).unwrap();
-            if let Some(c) = char::from_u32(*ch as u32) {
-                result.push(c);
-            }
-        }
-    }
-
-    result
-}
+static CMD_PATH: &str = "test";
 
 #[derive(Debug, Clone)]
 struct TestArg {
@@ -69,7 +36,7 @@ struct TestArg {
 }
 
 fn generate_random_path(rng: &mut dyn rand::RngCore) -> &'static str {
-    match rng.gen_range(0..=3) {
+    match rng.random_range(0..=3) {
         0 => "/dev/null",
         1 => "/dev/random",
         2 => "/tmp",
@@ -95,6 +62,14 @@ fn generate_test_args() -> Vec<TestArg> {
             arg: "!=".to_string(),
             arg_type: ArgType::STRINGSTRING,
         },
+        TestArg {
+            arg: ">".to_string(),
+            arg_type: ArgType::STRINGSTRING,
+        },
+        TestArg {
+            arg: "<".to_string(),
+            arg_type: ArgType::STRINGSTRING,
+        },
         TestArg {
             arg: "-eq".to_string(),
             arg_type: ArgType::INTEGERINTEGER,
@@ -143,49 +118,46 @@ fn generate_test_args() -> Vec<TestArg> {
 }
 
 fn generate_test_arg() -> String {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     let test_args = generate_test_args();
     let mut arg = String::new();
 
-    let choice = rng.gen_range(0..=5);
+    let choice = rng.random_range(0..=5);
 
     match choice {
         0 => {
-            arg.push_str(&rng.gen_range(-100..=100).to_string());
+            arg.push_str(&rng.random_range(-100..=100).to_string());
         }
-        1 | 2 | 3 => {
+        1..=3 => {
             let test_arg = test_args
                 .choose(&mut rng)
                 .expect("Failed to choose a random test argument");
             if test_arg.arg_type == ArgType::INTEGER {
                 arg.push_str(&format!(
                     "{} {} {}",
-                    &rng.gen_range(-100..=100).to_string(),
+                    rng.random_range(-100..=100).to_string(),
                     test_arg.arg,
-                    &rng.gen_range(-100..=100).to_string()
+                    rng.random_range(-100..=100).to_string()
                 ));
             } else if test_arg.arg_type == ArgType::STRINGSTRING {
-                let random_str = generate_random_string(rng.gen_range(1..=10));
-                let random_str2 = generate_random_string(rng.gen_range(1..=10));
+                let random_str = generate_random_string(rng.random_range(1..=10));
+                let random_str2 = generate_random_string(rng.random_range(1..=10));
 
-                arg.push_str(&format!(
-                    "{} {} {}",
-                    &random_str, test_arg.arg, &random_str2
-                ));
+                arg.push_str(&format!("{random_str} {} {random_str2}", test_arg.arg,));
             } else if test_arg.arg_type == ArgType::STRING {
-                let random_str = generate_random_string(rng.gen_range(1..=10));
-                arg.push_str(&format!("{} {}", test_arg.arg, &random_str));
+                let random_str = generate_random_string(rng.random_range(1..=10));
+                arg.push_str(&format!("{} {random_str}", test_arg.arg));
             } else if test_arg.arg_type == ArgType::FILEFILE {
                 let path = generate_random_path(&mut rng);
                 let path2 = generate_random_path(&mut rng);
-                arg.push_str(&format!("{} {} {}", path, test_arg.arg, path2));
+                arg.push_str(&format!("{path} {} {path2}", test_arg.arg));
             } else if test_arg.arg_type == ArgType::FILE {
                 let path = generate_random_path(&mut rng);
-                arg.push_str(&format!("{} {}", test_arg.arg, path));
+                arg.push_str(&format!("{} {path}", test_arg.arg));
             }
         }
         4 => {
-            let random_str = generate_random_string(rng.gen_range(1..=10));
+            let random_str = generate_random_string(rng.random_range(1..=10));
             arg.push_str(&random_str);
         }
         _ => {
@@ -198,7 +170,7 @@ fn generate_test_arg() -> String {
                 .collect();
 
             if let Some(test_arg) = file_test_args.choose(&mut rng) {
-                arg.push_str(&format!("{}{}", test_arg.arg, path));
+                arg.push_str(&format!("{}{path}", test_arg.arg));
             }
         }
     }
@@ -207,85 +179,36 @@ fn generate_test_arg() -> String {
 }
 
 fuzz_target!(|_data: &[u8]| {
-    let mut rng = rand::thread_rng();
-    let max_args = rng.gen_range(1..=6);
+    let mut rng = rand::rng();
+    let max_args = rng.random_range(1..=6);
     let mut args = vec![OsString::from("test")];
-    let uumain_exit_status;
 
     for _ in 0..max_args {
         args.push(OsString::from(generate_test_arg()));
     }
 
-    // Save the original stdout file descriptor
-    let original_stdout_fd = unsafe { dup(STDOUT_FILENO) };
-    println!("Running test {:?}", &args[1..]);
-    // Create a pipe to capture stdout
-    let mut pipe_fds = [-1; 2];
-    unsafe { libc::pipe(pipe_fds.as_mut_ptr()) };
-
-    {
-        // Redirect stdout to the write end of the pipe
-        unsafe { dup2(pipe_fds[1], STDOUT_FILENO) };
-
-        // Run uumain with the provided arguments
-        uumain_exit_status = uumain(args.clone().into_iter());
-
-        // Restore original stdout
-        unsafe { dup2(original_stdout_fd, STDOUT_FILENO) };
-        unsafe { libc::close(original_stdout_fd) };
-    }
-    // Close the write end of the pipe
-    unsafe { libc::close(pipe_fds[1]) };
-
-    // Read captured output from the read end of the pipe
-    let mut captured_output = Vec::new();
-    let mut read_buffer = [0; 1024];
-    loop {
-        let bytes_read = unsafe {
-            libc::read(
-                pipe_fds[0],
-                read_buffer.as_mut_ptr() as *mut libc::c_void,
-                read_buffer.len(),
-            )
-        };
-        if bytes_read <= 0 {
-            break;
-        }
-        captured_output.extend_from_slice(&read_buffer[..bytes_read as usize]);
-    }
-
-    // Close the read end of the pipe
-    unsafe { libc::close(pipe_fds[0]) };
-
-    // Convert captured output to a string
-    let my_output = String::from_utf8_lossy(&captured_output)
-        .to_string()
-        .trim()
-        .to_owned();
-
-    // Run GNU test with the provided arguments and compare the output
-    match run_gnu_test(&args[1..]) {
-        Ok((gnu_output, gnu_exit_status)) => {
-            let gnu_output = gnu_output.trim().to_owned();
-            println!("gnu_exit_status {}", gnu_exit_status);
-            println!("uumain_exit_status {}", uumain_exit_status);
-            if my_output != gnu_output || uumain_exit_status != gnu_exit_status {
-                println!("Discrepancy detected!");
-                println!("Test: {:?}", &args[1..]);
-                println!("My output: {}", my_output);
-                println!("GNU output: {}", gnu_output);
-                println!("My exit status: {}", uumain_exit_status);
-                println!("GNU exit status: {}", gnu_exit_status);
-                panic!();
-            } else {
-                println!(
-                    "Outputs and exit statuses matched for expression {:?}",
-                    &args[1..]
-                );
+    let rust_result = generate_and_run_uumain(&args, uumain, None);
+
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, None) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
             }
         }
-        Err(_) => {
-            println!("GNU test execution failed for expression {:?}", &args[1..]);
-        }
-    }
+    };
+
+    compare_result(
+        "test",
+        &format!("{:?}", &args[1..]),
+        None,
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
 });
diff --git a/fuzz/fuzz_targets/fuzz_tr.rs b/fuzz/fuzz_targets/fuzz_tr.rs
new file mode 100644
index 00000000000..5055ec0d748
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_tr.rs
@@ -0,0 +1,72 @@
+// 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.
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use std::ffi::OsString;
+use uu_tr::uumain;
+
+use rand::Rng;
+
+use uufuzz::{
+    CommandResult, compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+static CMD_PATH: &str = "tr";
+
+fn generate_tr_args() -> Vec<String> {
+    let mut rng = rand::rng();
+    let mut args = Vec::new();
+
+    // Translate, squeeze, and/or delete characters
+    let opts = ["-c", "-d", "-s", "-t"];
+    for opt in &opts {
+        if rng.random_bool(0.25) {
+            args.push(opt.to_string());
+        }
+    }
+
+    // Generating STRING1 and optionally STRING2
+    let string1 = generate_random_string(rng.random_range(1..=20));
+    args.push(string1);
+    if rng.random_bool(0.7) {
+        // Higher chance to add STRING2 for translation
+        let string2 = generate_random_string(rng.random_range(1..=20));
+        args.push(string2);
+    }
+
+    args
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let tr_args = generate_tr_args();
+    let mut args = vec![OsString::from("tr")];
+    args.extend(tr_args.iter().map(OsString::from));
+
+    let input_chars = generate_random_string(100);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_chars));
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_chars)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "tr",
+        &format!("{:?}", &args[1..]),
+        Some(&input_chars),
+        &rust_result,
+        &gnu_result,
+        false,
+    );
+});
diff --git a/fuzz/fuzz_targets/fuzz_wc.rs b/fuzz/fuzz_targets/fuzz_wc.rs
new file mode 100644
index 00000000000..dbc046522bb
--- /dev/null
+++ b/fuzz/fuzz_targets/fuzz_wc.rs
@@ -0,0 +1,98 @@
+// 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.
+// spell-checker:ignore parens
+
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+use uu_wc::uumain;
+
+use rand::Rng;
+use std::ffi::OsString;
+
+use uufuzz::{
+    CommandResult, compare_result, generate_and_run_uumain, generate_random_string, run_gnu_cmd,
+};
+static CMD_PATH: &str = "wc";
+
+fn generate_wc_args() -> String {
+    let mut rng = rand::rng();
+    let arg_count = rng.random_range(1..=6);
+    let mut args = Vec::new();
+
+    for _ in 0..arg_count {
+        // Introduce a chance to add invalid arguments
+        if rng.random_bool(0.1) {
+            args.push(generate_random_string(rng.random_range(1..=20)));
+        } else {
+            match rng.random_range(0..=5) {
+                0 => args.push(String::from("-c")),
+                1 => args.push(String::from("-m")),
+                2 => args.push(String::from("-l")),
+                3 => args.push(String::from("-L")),
+                4 => args.push(String::from("-w")),
+                // TODO
+                5 => {
+                    args.push(String::from("--files0-from"));
+                    if rng.random_bool(0.5) {
+                        args.push(generate_random_string(50)); // Longer invalid file name
+                    } else {
+                        args.push(generate_random_string(5));
+                    }
+                }
+                _ => (),
+            }
+        }
+    }
+
+    args.join(" ")
+}
+
+// Function to generate a random string of lines, including invalid ones
+fn generate_random_lines(count: usize) -> String {
+    let mut rng = rand::rng();
+    let mut lines = Vec::new();
+
+    for _ in 0..count {
+        if rng.random_bool(0.1) {
+            lines.push(generate_random_string(rng.random_range(1000..=5000))); // Very long invalid line
+        } else {
+            lines.push(generate_random_string(rng.random_range(1..=20)));
+        }
+    }
+
+    lines.join("\n")
+}
+
+fuzz_target!(|_data: &[u8]| {
+    let wc_args = generate_wc_args();
+    let mut args = vec![OsString::from("wc")];
+    args.extend(wc_args.split_whitespace().map(OsString::from));
+
+    let input_lines = generate_random_lines(10);
+
+    let rust_result = generate_and_run_uumain(&args, uumain, Some(&input_lines));
+    let gnu_result = match run_gnu_cmd(CMD_PATH, &args[1..], false, Some(&input_lines)) {
+        Ok(result) => result,
+        Err(error_result) => {
+            eprintln!("Failed to run GNU command:");
+            eprintln!("Stderr: {}", error_result.stderr);
+            eprintln!("Exit Code: {}", error_result.exit_code);
+            CommandResult {
+                stdout: String::new(),
+                stderr: error_result.stderr,
+                exit_code: error_result.exit_code,
+            }
+        }
+    };
+
+    compare_result(
+        "wc",
+        &format!("{:?}", &args[1..]),
+        Some(&input_lines),
+        &rust_result,
+        &gnu_result,
+        false, // Set to true if you want to fail on stderr diff
+    );
+});
diff --git a/fuzz/uufuzz/Cargo.toml b/fuzz/uufuzz/Cargo.toml
new file mode 100644
index 00000000000..d206d86319a
--- /dev/null
+++ b/fuzz/uufuzz/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "uufuzz"
+authors = ["uutils developers"]
+description = "uutils ~ 'core' uutils fuzzing library"
+repository = "https://github.com/uutils/coreutils/tree/main/fuzz/uufuzz"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+
+[dependencies]
+console = "0.15.0"
+libc = "0.2.153"
+rand = { version = "0.9.0", features = ["small_rng"] }
+similar = "2.5.0"
+uucore = { path = "../../src/uucore/", features = ["parser"] }
+tempfile = "3.15.0"
diff --git a/fuzz/uufuzz/src/lib.rs b/fuzz/uufuzz/src/lib.rs
new file mode 100644
index 00000000000..e887bfc6755
--- /dev/null
+++ b/fuzz/uufuzz/src/lib.rs
@@ -0,0 +1,438 @@
+// 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.
+
+use console::Style;
+use libc::STDIN_FILENO;
+use libc::{STDERR_FILENO, STDOUT_FILENO, close, dup, dup2, pipe};
+use pretty_print::{
+    print_diff, print_end_with_status, print_or_empty, print_section, print_with_style,
+};
+use rand::Rng;
+use rand::prelude::IndexedRandom;
+use std::env::temp_dir;
+use std::ffi::OsString;
+use std::fs::File;
+use std::io::{Seek, SeekFrom, Write};
+use std::os::fd::{AsRawFd, RawFd};
+use std::process::{Command, Stdio};
+use std::sync::atomic::Ordering;
+use std::sync::{Once, atomic::AtomicBool};
+use std::{io, thread};
+
+pub mod pretty_print;
+
+/// Represents the result of running a command, including its standard output,
+/// standard error, and exit code.
+pub struct CommandResult {
+    /// The standard output (stdout) of the command as a string.
+    pub stdout: String,
+
+    /// The standard error (stderr) of the command as a string.
+    pub stderr: String,
+
+    /// The exit code of the command.
+    pub exit_code: i32,
+}
+
+static CHECK_GNU: Once = Once::new();
+static IS_GNU: AtomicBool = AtomicBool::new(false);
+
+pub fn is_gnu_cmd(cmd_path: &str) -> Result<(), std::io::Error> {
+    CHECK_GNU.call_once(|| {
+        let version_output = Command::new(cmd_path).arg("--version").output().unwrap();
+
+        println!("version_output {version_output:#?}");
+
+        let version_str = String::from_utf8_lossy(&version_output.stdout).to_string();
+        if version_str.contains("GNU coreutils") {
+            IS_GNU.store(true, Ordering::Relaxed);
+        }
+    });
+
+    if IS_GNU.load(Ordering::Relaxed) {
+        Ok(())
+    } else {
+        panic!("Not the GNU implementation");
+    }
+}
+
+pub fn generate_and_run_uumain<F>(
+    args: &[OsString],
+    uumain_function: F,
+    pipe_input: Option<&str>,
+) -> CommandResult
+where
+    F: FnOnce(std::vec::IntoIter<OsString>) -> i32 + Send + 'static,
+{
+    // Duplicate the stdout and stderr file descriptors
+    let original_stdout_fd = unsafe { dup(STDOUT_FILENO) };
+    let original_stderr_fd = unsafe { dup(STDERR_FILENO) };
+    if original_stdout_fd == -1 || original_stderr_fd == -1 {
+        return CommandResult {
+            stdout: "".to_string(),
+            stderr: "Failed to duplicate STDOUT_FILENO or STDERR_FILENO".to_string(),
+            exit_code: -1,
+        };
+    }
+
+    println!("Running test {:?}", &args[0..]);
+    let mut pipe_stdout_fds = [-1; 2];
+    let mut pipe_stderr_fds = [-1; 2];
+
+    // Create pipes for stdout and stderr
+    if unsafe { pipe(pipe_stdout_fds.as_mut_ptr()) } == -1
+        || unsafe { pipe(pipe_stderr_fds.as_mut_ptr()) } == -1
+    {
+        return CommandResult {
+            stdout: "".to_string(),
+            stderr: "Failed to create pipes".to_string(),
+            exit_code: -1,
+        };
+    }
+
+    // Redirect stdout and stderr to their respective pipes
+    if unsafe { dup2(pipe_stdout_fds[1], STDOUT_FILENO) } == -1
+        || unsafe { dup2(pipe_stderr_fds[1], STDERR_FILENO) } == -1
+    {
+        unsafe {
+            close(pipe_stdout_fds[0]);
+            close(pipe_stdout_fds[1]);
+            close(pipe_stderr_fds[0]);
+            close(pipe_stderr_fds[1]);
+        }
+        return CommandResult {
+            stdout: "".to_string(),
+            stderr: "Failed to redirect STDOUT_FILENO or STDERR_FILENO".to_string(),
+            exit_code: -1,
+        };
+    }
+
+    let original_stdin_fd = if let Some(input_str) = pipe_input {
+        // we have pipe input
+        let mut input_file = tempfile::tempfile().unwrap();
+        write!(input_file, "{input_str}").unwrap();
+        input_file.seek(SeekFrom::Start(0)).unwrap();
+
+        // Redirect stdin to read from the in-memory file
+        let original_stdin_fd = unsafe { dup(STDIN_FILENO) };
+        if original_stdin_fd == -1 || unsafe { dup2(input_file.as_raw_fd(), STDIN_FILENO) } == -1 {
+            return CommandResult {
+                stdout: "".to_string(),
+                stderr: "Failed to set up stdin redirection".to_string(),
+                exit_code: -1,
+            };
+        }
+        Some(original_stdin_fd)
+    } else {
+        None
+    };
+
+    let (uumain_exit_status, captured_stdout, captured_stderr) = thread::scope(|s| {
+        let out = s.spawn(|| read_from_fd(pipe_stdout_fds[0]));
+        let err = s.spawn(|| read_from_fd(pipe_stderr_fds[0]));
+        #[allow(clippy::unnecessary_to_owned)]
+        // TODO: clippy wants us to use args.iter().cloned() ?
+        let status = uumain_function(args.to_owned().into_iter());
+        // Reset the exit code global variable in case we run another test after this one
+        // See https://github.com/uutils/coreutils/issues/5777
+        uucore::error::set_exit_code(0);
+        io::stdout().flush().unwrap();
+        io::stderr().flush().unwrap();
+        unsafe {
+            close(pipe_stdout_fds[1]);
+            close(pipe_stderr_fds[1]);
+            close(STDOUT_FILENO);
+            close(STDERR_FILENO);
+        }
+        (status, out.join().unwrap(), err.join().unwrap())
+    });
+
+    // Restore the original stdout and stderr
+    if unsafe { dup2(original_stdout_fd, STDOUT_FILENO) } == -1
+        || unsafe { dup2(original_stderr_fd, STDERR_FILENO) } == -1
+    {
+        return CommandResult {
+            stdout: "".to_string(),
+            stderr: "Failed to restore the original STDOUT_FILENO or STDERR_FILENO".to_string(),
+            exit_code: -1,
+        };
+    }
+    unsafe {
+        close(original_stdout_fd);
+        close(original_stderr_fd);
+    }
+
+    // Restore the original stdin if it was modified
+    if let Some(fd) = original_stdin_fd {
+        if unsafe { dup2(fd, STDIN_FILENO) } == -1 {
+            return CommandResult {
+                stdout: "".to_string(),
+                stderr: "Failed to restore the original STDIN".to_string(),
+                exit_code: -1,
+            };
+        }
+        unsafe { close(fd) };
+    }
+
+    CommandResult {
+        stdout: captured_stdout,
+        stderr: captured_stderr
+            .split_once(':')
+            .map(|x| x.1)
+            .unwrap_or("")
+            .trim()
+            .to_string(),
+        exit_code: uumain_exit_status,
+    }
+}
+
+fn read_from_fd(fd: RawFd) -> String {
+    let mut captured_output = Vec::new();
+    let mut read_buffer = [0; 1024];
+    loop {
+        let bytes_read = unsafe {
+            libc::read(
+                fd,
+                read_buffer.as_mut_ptr() as *mut libc::c_void,
+                read_buffer.len(),
+            )
+        };
+
+        if bytes_read == -1 {
+            eprintln!("Failed to read from the pipe");
+            break;
+        }
+        if bytes_read == 0 {
+            break;
+        }
+        captured_output.extend_from_slice(&read_buffer[..bytes_read as usize]);
+    }
+
+    unsafe { libc::close(fd) };
+
+    String::from_utf8_lossy(&captured_output).into_owned()
+}
+
+pub fn run_gnu_cmd(
+    cmd_path: &str,
+    args: &[OsString],
+    check_gnu: bool,
+    pipe_input: Option<&str>,
+) -> Result<CommandResult, CommandResult> {
+    if check_gnu {
+        match is_gnu_cmd(cmd_path) {
+            Ok(_) => {} // if the check passes, do nothing
+            Err(e) => {
+                // Convert the io::Error into the function's error type
+                return Err(CommandResult {
+                    stdout: String::new(),
+                    stderr: e.to_string(),
+                    exit_code: -1,
+                });
+            }
+        }
+    }
+
+    let mut command = Command::new(cmd_path);
+    for arg in args {
+        command.arg(arg);
+    }
+
+    // See https://github.com/uutils/coreutils/issues/6794
+    // uutils' coreutils is not locale-aware, and aims to mirror/be compatible with GNU Core Utilities's LC_ALL=C behavior
+    command.env("LC_ALL", "C");
+
+    let output = if let Some(input_str) = pipe_input {
+        // We have an pipe input
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        let mut child = command.spawn().expect("Failed to execute command");
+        let child_stdin = child.stdin.as_mut().unwrap();
+        child_stdin
+            .write_all(input_str.as_bytes())
+            .expect("Failed to write to stdin");
+
+        match child.wait_with_output() {
+            Ok(output) => output,
+            Err(e) => {
+                return Err(CommandResult {
+                    stdout: String::new(),
+                    stderr: e.to_string(),
+                    exit_code: -1,
+                });
+            }
+        }
+    } else {
+        // Just run with args
+        match command.output() {
+            Ok(output) => output,
+            Err(e) => {
+                return Err(CommandResult {
+                    stdout: String::new(),
+                    stderr: e.to_string(),
+                    exit_code: -1,
+                });
+            }
+        }
+    };
+    let exit_code = output.status.code().unwrap_or(-1);
+    // Here we get stdout and stderr as Strings
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+    let stderr = stderr
+        .split_once(':')
+        .map(|x| x.1)
+        .unwrap_or("")
+        .trim()
+        .to_string();
+
+    if output.status.success() || !check_gnu {
+        Ok(CommandResult {
+            stdout,
+            stderr,
+            exit_code,
+        })
+    } else {
+        Err(CommandResult {
+            stdout,
+            stderr,
+            exit_code,
+        })
+    }
+}
+
+/// Compare results from two different implementations of a command.
+///
+/// # Arguments
+/// * `test_type` - The command.
+/// * `input` - The input provided to the command.
+/// * `rust_result` - The result of running the command with the Rust implementation.
+/// * `gnu_result` - The result of running the command with the GNU implementation.
+/// * `fail_on_stderr_diff` - Whether to fail the test if there is a difference in stderr output.
+pub fn compare_result(
+    test_type: &str,
+    input: &str,
+    pipe_input: Option<&str>,
+    rust_result: &CommandResult,
+    gnu_result: &CommandResult,
+    fail_on_stderr_diff: bool,
+) {
+    print_section(format!("Compare result for: {test_type} {input}"));
+
+    if let Some(pipe) = pipe_input {
+        println!("Pipe: {pipe}");
+    }
+
+    let mut discrepancies = Vec::new();
+    let mut should_panic = false;
+
+    if rust_result.stdout.trim() != gnu_result.stdout.trim() {
+        discrepancies.push("stdout differs");
+        println!("Rust stdout:");
+        print_or_empty(rust_result.stdout.as_str());
+        println!("GNU stdout:");
+        print_or_empty(gnu_result.stdout.as_ref());
+        print_diff(&rust_result.stdout, &gnu_result.stdout);
+        should_panic = true;
+    }
+
+    if rust_result.stderr.trim() != gnu_result.stderr.trim() {
+        discrepancies.push("stderr differs");
+        println!("Rust stderr:");
+        print_or_empty(rust_result.stderr.as_str());
+        println!("GNU stderr:");
+        print_or_empty(gnu_result.stderr.as_str());
+        print_diff(&rust_result.stderr, &gnu_result.stderr);
+        if fail_on_stderr_diff {
+            should_panic = true;
+        }
+    }
+
+    if rust_result.exit_code != gnu_result.exit_code {
+        discrepancies.push("exit code differs");
+        println!(
+            "Different exit code: (Rust: {}, GNU: {})",
+            rust_result.exit_code, gnu_result.exit_code
+        );
+        should_panic = true;
+    }
+
+    if discrepancies.is_empty() {
+        print_end_with_status("Same behavior", true);
+    } else {
+        print_with_style(
+            format!("Discrepancies detected: {}", discrepancies.join(", ")),
+            Style::new().red(),
+        );
+        if should_panic {
+            print_end_with_status(
+                format!("Test failed and will panic for: {test_type} {input}"),
+                false,
+            );
+            panic!("Test failed for: {test_type} {input}");
+        } else {
+            print_end_with_status(
+                format!("Test completed with discrepancies for: {test_type} {input}"),
+                false,
+            );
+        }
+    }
+    println!();
+}
+
+pub fn generate_random_string(max_length: usize) -> String {
+    let mut rng = rand::rng();
+    let valid_utf8: Vec<char> = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+        .chars()
+        .collect();
+    let invalid_utf8 = [0xC3, 0x28]; // Invalid UTF-8 sequence
+    let mut result = String::new();
+
+    for _ in 0..rng.random_range(0..=max_length) {
+        if rng.random_bool(0.9) {
+            let ch = valid_utf8.choose(&mut rng).unwrap();
+            result.push(*ch);
+        } else {
+            let ch = invalid_utf8.choose(&mut rng).unwrap();
+            if let Some(c) = char::from_u32(*ch as u32) {
+                result.push(c);
+            }
+        }
+    }
+
+    result
+}
+
+#[allow(dead_code)]
+pub fn generate_random_file() -> Result<String, std::io::Error> {
+    let mut rng = rand::rng();
+    let file_name: String = (0..10)
+        .map(|_| rng.random_range(b'a'..=b'z') as char)
+        .collect();
+    let mut file_path = temp_dir();
+    file_path.push(file_name);
+
+    let mut file = File::create(&file_path)?;
+
+    let content_length = rng.random_range(10..1000);
+    let content: String = (0..content_length)
+        .map(|_| (rng.random_range(b' '..=b'~') as char))
+        .collect();
+
+    file.write_all(content.as_bytes())?;
+
+    Ok(file_path.to_str().unwrap().to_string())
+}
+
+#[allow(dead_code)]
+pub fn replace_fuzz_binary_name(cmd: &str, result: &mut CommandResult) {
+    let fuzz_bin_name = format!("fuzz/target/x86_64-unknown-linux-gnu/release/fuzz_{cmd}");
+
+    result.stdout = result.stdout.replace(&fuzz_bin_name, cmd);
+    result.stderr = result.stderr.replace(&fuzz_bin_name, cmd);
+}
diff --git a/fuzz/uufuzz/src/pretty_print.rs b/fuzz/uufuzz/src/pretty_print.rs
new file mode 100644
index 00000000000..ecdfccfd035
--- /dev/null
+++ b/fuzz/uufuzz/src/pretty_print.rs
@@ -0,0 +1,69 @@
+// 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.
+
+use std::fmt;
+
+use console::{Style, style};
+use similar::TextDiff;
+
+pub fn print_section<S: fmt::Display>(s: S) {
+    println!("{}", style(format!("=== {s}")).bold());
+}
+
+pub fn print_subsection<S: fmt::Display>(s: S) {
+    println!("{}", style(format!("--- {s}")).bright());
+}
+
+#[allow(dead_code)]
+pub fn print_test_begin<S: fmt::Display>(msg: S) {
+    println!(
+        "{} {} {}",
+        style("===").bold(), // Kind of gray
+        style("TEST").black().on_yellow().bold(),
+        style(msg).bold()
+    );
+}
+
+pub fn print_end_with_status<S: fmt::Display>(msg: S, ok: bool) {
+    let ok = if ok {
+        style(" OK ").black().on_green().bold()
+    } else {
+        style(" KO ").black().on_red().bold()
+    };
+
+    println!(
+        "{} {ok} {}",
+        style("===").bold(), // Kind of gray
+        style(msg).bold()
+    );
+}
+
+pub fn print_or_empty(s: &str) {
+    let to_print = if s.is_empty() { "(empty)" } else { s };
+
+    println!("{}", style(to_print).dim());
+}
+
+pub fn print_with_style<S: fmt::Display>(msg: S, style: Style) {
+    println!("{}", style.apply_to(msg));
+}
+
+pub fn print_diff(got: &str, expected: &str) {
+    let diff = TextDiff::from_lines(got, expected);
+
+    print_subsection("START diff");
+
+    for change in diff.iter_all_changes() {
+        let (sign, style) = match change.tag() {
+            similar::ChangeTag::Equal => (" ", Style::new().dim()),
+            similar::ChangeTag::Delete => ("-", Style::new().red()),
+            similar::ChangeTag::Insert => ("+", Style::new().green()),
+        };
+        print!("{}{}", style.apply_to(sign).bold(), style.apply_to(change));
+    }
+
+    print_subsection("END diff");
+    println!();
+}
diff --git a/renovate.json b/renovate.json
index 9dc8c691977..8f60343a8ef 100644
--- a/renovate.json
+++ b/renovate.json
@@ -1,5 +1,5 @@
 {
 	"extends": [
-		"config:base"
+		"config:recommended"
 	]
 }
diff --git a/src/bin/coreutils.rs b/src/bin/coreutils.rs
index fc2cd16add2..b29e7ea2337 100644
--- a/src/bin/coreutils.rs
+++ b/src/bin/coreutils.rs
@@ -21,7 +21,10 @@ include!(concat!(env!("OUT_DIR"), "/uutils_map.rs"));
 
 fn usage<T>(utils: &UtilityMap<T>, name: &str) {
     println!("{name} {VERSION} (multi-call binary)\n");
-    println!("Usage: {name} [function [arguments...]]\n");
+    println!("Usage: {name} [function [arguments...]]");
+    println!("       {name} --list\n");
+    println!("Options:");
+    println!("      --list    lists all defined functions, one per row\n");
     println!("Currently defined functions:\n");
     #[allow(clippy::map_clone)]
     let mut utils: Vec<&str> = utils.keys().map(|&s| s).collect();
@@ -34,6 +37,8 @@ fn usage<T>(utils: &UtilityMap<T>, name: &str) {
     );
 }
 
+/// # Panics
+/// Panics if the binary path cannot be determined
 fn binary_path(args: &mut impl Iterator<Item = OsString>) -> PathBuf {
     match args.next() {
         Some(ref s) if !s.is_empty() => PathBuf::from(s),
@@ -60,7 +65,7 @@ fn main() {
 
     // binary name equals util name?
     if let Some(&(uumain, _)) = utils.get(binary_as_util) {
-        process::exit(uumain((vec![binary.into()].into_iter()).chain(args)));
+        process::exit(uumain(vec![binary.into()].into_iter().chain(args)));
     }
 
     // binary name equals prefixed util name?
@@ -85,36 +90,42 @@ fn main() {
             process::exit(1);
         }
 
-        let util = match util_os.to_str() {
-            Some(util) => util,
-            None => not_found(&util_os),
+        let Some(util) = util_os.to_str() else {
+            not_found(&util_os)
         };
 
-        if util == "completion" {
-            gen_completions(args, &utils);
-        }
-
-        if util == "manpage" {
-            gen_manpage(args, &utils);
+        match util {
+            "completion" => gen_completions(args, &utils),
+            "manpage" => gen_manpage(args, &utils),
+            "--list" => {
+                let mut utils: Vec<_> = utils.keys().collect();
+                utils.sort();
+                for util in utils {
+                    println!("{util}");
+                }
+                process::exit(0);
+            }
+            // Not a special command: fallthrough to calling a util
+            _ => {}
         }
 
         match utils.get(util) {
             Some(&(uumain, _)) => {
-                process::exit(uumain((vec![util_os].into_iter()).chain(args)));
+                process::exit(uumain(vec![util_os].into_iter().chain(args)));
             }
             None => {
                 if util == "--help" || util == "-h" {
                     // see if they want help on a specific util
                     if let Some(util_os) = args.next() {
-                        let util = match util_os.to_str() {
-                            Some(util) => util,
-                            None => not_found(&util_os),
+                        let Some(util) = util_os.to_str() else {
+                            not_found(&util_os)
                         };
 
                         match utils.get(util) {
                             Some(&(uumain, _)) => {
                                 let code = uumain(
-                                    (vec![util_os, OsString::from("--help")].into_iter())
+                                    vec![util_os, OsString::from("--help")]
+                                        .into_iter()
                                         .chain(args),
                                 );
                                 io::stdout().flush().expect("could not flush stdout");
@@ -138,6 +149,8 @@ fn main() {
 }
 
 /// Prints completions for the utility in the first parameter for the shell in the second parameter to stdout
+/// # Panics
+/// Panics if the utility map is empty
 fn gen_completions<T: uucore::Args>(
     args: impl Iterator<Item = OsString>,
     util_map: &UtilityMap<T>,
@@ -176,6 +189,8 @@ fn gen_completions<T: uucore::Args>(
 }
 
 /// Generate the manpage for the utility in the first parameter
+/// # Panics
+/// Panics if the utility map is empty
 fn gen_manpage<T: uucore::Args>(
     args: impl Iterator<Item = OsString>,
     util_map: &UtilityMap<T>,
@@ -208,6 +223,8 @@ fn gen_manpage<T: uucore::Args>(
     process::exit(0);
 }
 
+/// # Panics
+/// Panics if the utility map is empty
 fn gen_coreutils_app<T: uucore::Args>(util_map: &UtilityMap<T>) -> Command {
     let mut command = Command::new("coreutils");
     for (name, (_, sub_app)) in util_map {
diff --git a/src/bin/uudoc.rs b/src/bin/uudoc.rs
index 77c7a2fcfdd..6a215a4ada4 100644
--- a/src/bin/uudoc.rs
+++ b/src/bin/uudoc.rs
@@ -13,6 +13,9 @@ use zip::ZipArchive;
 
 include!(concat!(env!("OUT_DIR"), "/uutils_map.rs"));
 
+/// # Errors
+/// Returns an error if the writer fails.
+#[allow(clippy::too_many_lines)]
 fn main() -> io::Result<()> {
     let mut tldr_zip = File::open("docs/tldr.zip")
         .ok()
@@ -20,7 +23,9 @@ fn main() -> io::Result<()> {
 
     if tldr_zip.is_none() {
         println!("Warning: No tldr archive found, so the documentation will not include examples.");
-        println!("To include examples in the documentation, download the tldr archive and put it in the docs/ folder.");
+        println!(
+            "To include examples in the documentation, download the tldr archive and put it in the docs/ folder."
+        );
         println!();
         println!("  curl https://tldr.sh/assets/tldr.zip -o docs/tldr.zip");
         println!();
@@ -43,7 +48,9 @@ fn main() -> io::Result<()> {
         * [Installation](installation.md)\n\
         * [Build from source](build.md)\n\
         * [Platform support](platforms.md)\n\
-        * [Contributing](contributing.md)\n\
+        * [Contributing](CONTRIBUTING.md)\n\
+        \t* [Development](DEVELOPMENT.md)\n\
+        \t* [Code of Conduct](CODE_OF_CONDUCT.md)\n\
         * [GNU test coverage](test_coverage.md)\n\
         * [Extensions](extensions.md)\n\
         \n\
@@ -57,7 +64,7 @@ fn main() -> io::Result<()> {
         for platform in ["unix", "macos", "windows", "unix_android"] {
             let platform_utils: Vec<String> = String::from_utf8(
                 std::process::Command::new("./util/show-utils.sh")
-                    .arg(format!("--features=feat_os_{}", platform))
+                    .arg(format!("--features=feat_os_{platform}"))
                     .output()?
                     .stdout,
             )
@@ -107,7 +114,7 @@ fn main() -> io::Result<()> {
             "| util             | Linux | macOS | Windows | FreeBSD | Android |\n\
              | ---------------- | ----- | ----- | ------- | ------- | ------- |"
         )?;
-        for (&name, _) in &utils {
+        for &(&name, _) in &utils {
             if name == "[" {
                 continue;
             }
@@ -131,7 +138,7 @@ fn main() -> io::Result<()> {
         if name == "[" {
             continue;
         }
-        let p = format!("docs/src/utils/{}.md", name);
+        let p = format!("docs/src/utils/{name}.md");
 
         let markdown = File::open(format!("src/uu/{name}/{name}.md"))
             .and_then(|mut f: File| {
@@ -151,11 +158,11 @@ fn main() -> io::Result<()> {
                 markdown,
             }
             .markdown()?;
-            println!("Wrote to '{}'", p);
+            println!("Wrote to '{p}'");
         } else {
-            println!("Error writing to {}", p);
+            println!("Error writing to {p}");
         }
-        writeln!(summary, "* [{0}](utils/{0}.md)", name)?;
+        writeln!(summary, "* [{name}](utils/{name}.md)")?;
     }
     Ok(())
 }
@@ -169,7 +176,9 @@ struct MDWriter<'a, 'b> {
     markdown: Option<String>,
 }
 
-impl<'a, 'b> MDWriter<'a, 'b> {
+impl MDWriter<'_, '_> {
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn markdown(&mut self) -> io::Result<()> {
         write!(self.w, "# {}\n\n", self.name)?;
         self.additional()?;
@@ -180,6 +189,8 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         self.examples()
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn additional(&mut self) -> io::Result<()> {
         writeln!(self.w, "<div class=\"additional\">")?;
         self.platforms()?;
@@ -187,6 +198,8 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         writeln!(self.w, "</div>")
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn platforms(&mut self) -> io::Result<()> {
         writeln!(self.w, "<div class=\"platforms\">")?;
         for (feature, icon) in [
@@ -201,7 +214,7 @@ impl<'a, 'b> MDWriter<'a, 'b> {
                     .iter()
                     .any(|u| u == self.name)
             {
-                writeln!(self.w, "<i class=\"fa fa-brands fa-{}\"></i>", icon)?;
+                writeln!(self.w, "<i class=\"fa fa-brands fa-{icon}\"></i>")?;
             }
         }
         writeln!(self.w, "</div>")?;
@@ -209,6 +222,10 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         Ok(())
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
+    /// # Panics
+    /// Panics if the version is not found.
     fn version(&mut self) -> io::Result<()> {
         writeln!(
             self.w,
@@ -217,19 +234,23 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         )
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn usage(&mut self) -> io::Result<()> {
         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, "{usage}")?;
             writeln!(self.w, "```")
         } else {
             Ok(())
         }
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn about(&mut self) -> io::Result<()> {
         if let Some(markdown) = &self.markdown {
             writeln!(self.w, "{}", uuhelp_parser::parse_about(markdown))
@@ -238,6 +259,8 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         }
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn after_help(&mut self) -> io::Result<()> {
         if let Some(markdown) = &self.markdown {
             if let Some(after_help) = uuhelp_parser::parse_section("after help", markdown) {
@@ -248,6 +271,8 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         Ok(())
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn examples(&mut self) -> io::Result<()> {
         if let Some(zip) = self.tldr_zip {
             let content = if let Some(f) =
@@ -268,14 +293,14 @@ impl<'a, 'b> MDWriter<'a, 'b> {
             writeln!(self.w)?;
             for line in content.lines().skip_while(|l| !l.starts_with('-')) {
                 if let Some(l) = line.strip_prefix("- ") {
-                    writeln!(self.w, "{}", l)?;
+                    writeln!(self.w, "{l}")?;
                 } else if line.starts_with('`') {
                     writeln!(self.w, "```shell\n{}\n```", line.trim_matches('`'))?;
                 } else if line.is_empty() {
                     writeln!(self.w)?;
                 } else {
                     println!("Not sure what to do with this line:");
-                    println!("{}", line);
+                    println!("{line}");
                 }
             }
             writeln!(self.w)?;
@@ -292,6 +317,8 @@ impl<'a, 'b> MDWriter<'a, 'b> {
         Ok(())
     }
 
+    /// # Errors
+    /// Returns an error if the writer fails.
     fn options(&mut self) -> io::Result<()> {
         writeln!(self.w, "<h2>Options</h2>")?;
         write!(self.w, "<dl>")?;
@@ -305,14 +332,14 @@ impl<'a, 'b> MDWriter<'a, 'b> {
                     write!(self.w, ", ")?;
                 }
                 write!(self.w, "<code>")?;
-                write!(self.w, "--{}", l)?;
+                write!(self.w, "--{l}")?;
                 if let Some(names) = arg.get_value_names() {
                     write!(
                         self.w,
                         "={}",
                         names
                             .iter()
-                            .map(|x| format!("&lt;{}&gt;", x))
+                            .map(|x| format!("&lt;{x}&gt;"))
                             .collect::<Vec<_>>()
                             .join(" ")
                     )?;
@@ -326,14 +353,14 @@ impl<'a, 'b> MDWriter<'a, 'b> {
                     write!(self.w, ", ")?;
                 }
                 write!(self.w, "<code>")?;
-                write!(self.w, "-{}", s)?;
+                write!(self.w, "-{s}")?;
                 if let Some(names) = arg.get_value_names() {
                     write!(
                         self.w,
                         " {}",
                         names
                             .iter()
-                            .map(|x| format!("&lt;{}&gt;", x))
+                            .map(|x| format!("&lt;{x}&gt;"))
                             .collect::<Vec<_>>()
                             .join(" ")
                     )?;
@@ -354,6 +381,8 @@ impl<'a, 'b> MDWriter<'a, 'b> {
     }
 }
 
+/// # Panics
+/// Panics if the archive is not ok
 fn get_zip_content(archive: &mut ZipArchive<impl Read + Seek>, name: &str) -> Option<String> {
     let mut s = String::new();
     archive.by_name(name).ok()?.read_to_string(&mut s).unwrap();
diff --git a/src/uu/arch/Cargo.toml b/src/uu/arch/Cargo.toml
index cd12cb4d483..611aa6845cf 100644
--- a/src/uu/arch/Cargo.toml
+++ b/src/uu/arch/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_arch"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "arch ~ (uutils) display machine architecture"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/arch"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/arch.rs"
diff --git a/src/uu/arch/arch.md b/src/uu/arch/arch.md
deleted file mode 100644
index a4ba2e75fce..00000000000
--- a/src/uu/arch/arch.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# arch
-
-```
-arch
-```
-
-Display machine architecture
-
-## After Help
-
-Determine architecture name for current machine.
diff --git a/src/uu/arch/locales/en-US.ftl b/src/uu/arch/locales/en-US.ftl
new file mode 100644
index 00000000000..1646e50030d
--- /dev/null
+++ b/src/uu/arch/locales/en-US.ftl
@@ -0,0 +1,5 @@
+# Error message when system architecture information cannot be retrieved
+cannot-get-system = cannot get system name
+
+arch-about = Display machine architecture
+arch-after-help = Determine architecture name for current machine.
diff --git a/src/uu/arch/locales/fr-FR.ftl b/src/uu/arch/locales/fr-FR.ftl
new file mode 100644
index 00000000000..f08462a87b4
--- /dev/null
+++ b/src/uu/arch/locales/fr-FR.ftl
@@ -0,0 +1,5 @@
+# Error message when system architecture information cannot be retrieved
+cannot-get-system = impossible d'obtenir le nom du système
+
+arch-about = Afficher l'architecture de la machine
+arch-after-help = Déterminer le nom de l'architecture pour la machine actuelle.
diff --git a/src/uu/arch/src/arch.rs b/src/uu/arch/src/arch.rs
index 0d71a818379..82e9bb79e5c 100644
--- a/src/uu/arch/src/arch.rs
+++ b/src/uu/arch/src/arch.rs
@@ -5,18 +5,17 @@
 
 use platform_info::*;
 
-use clap::{crate_version, Command};
+use clap::Command;
 use uucore::error::{UResult, USimpleError};
-use uucore::{help_about, help_section};
-
-static ABOUT: &str = help_about!("arch.md");
-static SUMMARY: &str = help_section!("after help", "arch.md");
+use uucore::locale::{self, get_message};
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    locale::setup_localization(uucore::util_name())?;
     uu_app().try_get_matches_from(args)?;
 
-    let uts = PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+    let uts =
+        PlatformInfo::new().map_err(|_e| USimpleError::new(1, get_message("cannot-get-system")))?;
 
     println!("{}", uts.machine().to_string_lossy().trim());
     Ok(())
@@ -24,8 +23,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
-        .about(ABOUT)
-        .after_help(SUMMARY)
+        .version(uucore::crate_version!())
+        .about(get_message("arch-about"))
+        .after_help(get_message("arch-after-help"))
         .infer_long_args(true)
 }
diff --git a/src/uu/base32/Cargo.toml b/src/uu/base32/Cargo.toml
index 044b92d23fc..42421311c0e 100644
--- a/src/uu/base32/Cargo.toml
+++ b/src/uu/base32/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_base32"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "base32 ~ (uutils) decode/encode input (base32-encoding)"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/base32"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/base32.rs"
diff --git a/src/uu/base32/src/base32.rs b/src/uu/base32/src/base32.rs
index 09250421c25..e14e83921e2 100644
--- a/src/uu/base32/src/base32.rs
+++ b/src/uu/base32/src/base32.rs
@@ -3,13 +3,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use std::io::{stdin, Read};
+pub mod base_common;
 
+use base_common::ReadSeek;
 use clap::Command;
 use uucore::{encoding::Format, error::UResult, help_about, help_usage};
 
-pub mod base_common;
-
 const ABOUT: &str = help_about!("base32.md");
 const USAGE: &str = help_usage!("base32.md");
 
@@ -17,20 +16,11 @@ const USAGE: &str = help_usage!("base32.md");
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let format = Format::Base32;
 
-    let config: base_common::Config = base_common::parse_base_cmd_args(args, ABOUT, USAGE)?;
+    let config = base_common::parse_base_cmd_args(args, ABOUT, USAGE)?;
 
-    // Create a reference to stdin so we can return a locked stdin from
-    // parse_base_cmd_args
-    let stdin_raw = stdin();
-    let mut input: Box<dyn Read> = base_common::get_input(&config, &stdin_raw)?;
+    let mut input: Box<dyn ReadSeek> = base_common::get_input(&config)?;
 
-    base_common::handle_input(
-        &mut input,
-        format,
-        config.wrap_cols,
-        config.ignore_garbage,
-        config.decode,
-    )
+    base_common::handle_input(&mut input, format, config)
 }
 
 pub fn uu_app() -> Command {
diff --git a/src/uu/base32/src/base_common.rs b/src/uu/base32/src/base_common.rs
index 4a30705afcd..05bfc89b28f 100644
--- a/src/uu/base32/src/base_common.rs
+++ b/src/uu/base32/src/base_common.rs
@@ -3,27 +3,35 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use std::io::{stdout, Read, Write};
+// spell-checker:ignore hexupper lsbf msbf unpadded nopad aGVsbG8sIHdvcmxkIQ
 
+use clap::{Arg, ArgAction, Command};
+use std::fs::File;
+use std::io::{self, ErrorKind, Read, Seek, SeekFrom};
+use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::encoding::{wrap_print, Data, Format};
+use uucore::encoding::{
+    BASE2LSBF, BASE2MSBF, Format, Z85Wrapper,
+    for_base_common::{BASE32, BASE32HEX, BASE64, BASE64_NOPAD, BASE64URL, HEXUPPER_PERMISSIVE},
+};
+use uucore::encoding::{EncodingWrapper, SupportsFastDecodeAndEncode};
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::format_usage;
 
-use std::fs::File;
-use std::io::{BufReader, Stdin};
-use std::path::Path;
-
-use clap::{crate_version, Arg, ArgAction, Command};
+pub const BASE_CMD_PARSE_ERROR: i32 = 1;
 
-pub static BASE_CMD_PARSE_ERROR: i32 = 1;
+/// Encoded output will be formatted in lines of this length (the last line can be shorter)
+///
+/// Other implementations default to 76
+///
+/// This default is only used if no "-w"/"--wrap" argument is passed
+pub const WRAP_DEFAULT: usize = 76;
 
-// Config.
 pub struct Config {
     pub decode: bool,
     pub ignore_garbage: bool,
     pub wrap_cols: Option<usize>,
-    pub to_read: Option<String>,
+    pub to_read: Option<PathBuf>,
 }
 
 pub mod options {
@@ -35,32 +43,36 @@ pub mod options {
 
 impl Config {
     pub fn from(options: &clap::ArgMatches) -> UResult<Self> {
-        let file: Option<String> = match options.get_many::<String>(options::FILE) {
+        let to_read = match options.get_many::<String>(options::FILE) {
             Some(mut values) => {
                 let name = values.next().unwrap();
+
                 if let Some(extra_op) = values.next() {
                     return Err(UUsageError::new(
                         BASE_CMD_PARSE_ERROR,
-                        format!("extra operand {}", extra_op.quote(),),
+                        format!("extra operand {}", extra_op.quote()),
                     ));
                 }
 
                 if name == "-" {
                     None
                 } else {
-                    if !Path::exists(Path::new(name)) {
+                    let path = Path::new(name);
+
+                    if !path.exists() {
                         return Err(USimpleError::new(
                             BASE_CMD_PARSE_ERROR,
-                            format!("{}: No such file or directory", name.maybe_quote()),
+                            format!("{}: No such file or directory", path.maybe_quote()),
                         ));
                     }
-                    Some(name.to_owned())
+
+                    Some(path.to_owned())
                 }
             }
             None => None,
         };
 
-        let cols = options
+        let wrap_cols = options
             .get_one::<String>(options::WRAP)
             .map(|num| {
                 num.parse::<usize>().map_err(|_| {
@@ -75,8 +87,8 @@ impl Config {
         Ok(Self {
             decode: options.get_flag(options::DECODE),
             ignore_garbage: options.get_flag(options::IGNORE_GARBAGE),
-            wrap_cols: cols,
-            to_read: file,
+            wrap_cols,
+            to_read,
         })
     }
 }
@@ -87,13 +99,12 @@ pub fn parse_base_cmd_args(
     usage: &str,
 ) -> UResult<Config> {
     let command = base_app(about, usage);
-    let arg_list = args.collect_lossy();
-    Config::from(&command.try_get_matches_from(arg_list)?)
+    Config::from(&command.try_get_matches_from(args)?)
 }
 
 pub fn base_app(about: &'static str, usage: &str) -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(about)
         .override_usage(format_usage(usage))
         .infer_long_args(true)
@@ -101,84 +112,735 @@ pub fn base_app(about: &'static str, usage: &str) -> Command {
         .arg(
             Arg::new(options::DECODE)
                 .short('d')
+                .visible_short_alias('D')
                 .long(options::DECODE)
                 .help("decode data")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::DECODE),
         )
         .arg(
             Arg::new(options::IGNORE_GARBAGE)
                 .short('i')
                 .long(options::IGNORE_GARBAGE)
                 .help("when decoding, ignore non-alphabetic characters")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::IGNORE_GARBAGE),
         )
         .arg(
             Arg::new(options::WRAP)
                 .short('w')
                 .long(options::WRAP)
                 .value_name("COLS")
-                .help(
-                    "wrap encoded lines after COLS character (default 76, 0 to disable wrapping)",
-                ),
+                .help(format!("wrap encoded lines after COLS character (default {WRAP_DEFAULT}, 0 to disable wrapping)"))
+                .overrides_with(options::WRAP),
         )
         // "multiple" arguments are used to check whether there is more than one
         // file passed in.
         .arg(
             Arg::new(options::FILE)
                 .index(1)
-                .action(clap::ArgAction::Append)
+                .action(ArgAction::Append)
                 .value_hint(clap::ValueHint::FilePath),
         )
 }
 
-pub fn get_input<'a>(config: &Config, stdin_ref: &'a Stdin) -> UResult<Box<dyn Read + 'a>> {
+/// A trait alias for types that implement both `Read` and `Seek`.
+pub trait ReadSeek: Read + Seek {}
+
+/// Automatically implement the `ReadSeek` trait for any type that implements both `Read` and `Seek`.
+impl<T: Read + Seek> ReadSeek for T {}
+
+pub fn get_input(config: &Config) -> UResult<Box<dyn ReadSeek>> {
     match &config.to_read {
-        Some(name) => {
-            let file_buf =
-                File::open(Path::new(name)).map_err_context(|| name.maybe_quote().to_string())?;
-            Ok(Box::new(BufReader::new(file_buf))) // as Box<dyn Read>
+        Some(path_buf) => {
+            // Do not buffer input, because buffering is handled by `fast_decode` and `fast_encode`
+            let file =
+                File::open(path_buf).map_err_context(|| path_buf.maybe_quote().to_string())?;
+            Ok(Box::new(file))
         }
         None => {
-            Ok(Box::new(stdin_ref.lock())) // as Box<dyn Read>
+            let mut buffer = Vec::new();
+            io::stdin().read_to_end(&mut buffer)?;
+            Ok(Box::new(io::Cursor::new(buffer)))
         }
     }
 }
 
-pub fn handle_input<R: Read>(
-    input: &mut R,
+/// Determines if the input buffer ends with padding ('=') after trimming trailing whitespace.
+fn has_padding<R: Read + Seek>(input: &mut R) -> UResult<bool> {
+    let mut buf = Vec::new();
+    input
+        .read_to_end(&mut buf)
+        .map_err(|err| USimpleError::new(1, format_read_error(err.kind())))?;
+
+    // Reverse iterator and skip trailing whitespace without extra collections
+    let has_padding = buf
+        .iter()
+        .rfind(|&&byte| !byte.is_ascii_whitespace())
+        .is_some_and(|&byte| byte == b'=');
+
+    input.seek(SeekFrom::Start(0))?;
+    Ok(has_padding)
+}
+
+pub fn handle_input<R: Read + Seek>(input: &mut R, format: Format, config: Config) -> UResult<()> {
+    let has_padding = has_padding(input)?;
+
+    let supports_fast_decode_and_encode =
+        get_supports_fast_decode_and_encode(format, config.decode, has_padding);
+
+    let supports_fast_decode_and_encode_ref = supports_fast_decode_and_encode.as_ref();
+
+    let mut stdout_lock = io::stdout().lock();
+
+    if config.decode {
+        fast_decode::fast_decode(
+            input,
+            &mut stdout_lock,
+            supports_fast_decode_and_encode_ref,
+            config.ignore_garbage,
+        )
+    } else {
+        fast_encode::fast_encode(
+            input,
+            &mut stdout_lock,
+            supports_fast_decode_and_encode_ref,
+            config.wrap_cols,
+        )
+    }
+}
+
+pub fn get_supports_fast_decode_and_encode(
     format: Format,
-    line_wrap: Option<usize>,
-    ignore_garbage: bool,
     decode: bool,
-) -> UResult<()> {
-    let mut data = Data::new(input, format).ignore_garbage(ignore_garbage);
-    if let Some(wrap) = line_wrap {
-        data = data.line_wrap(wrap);
-    }
-
-    if decode {
-        match data.decode() {
-            Ok(s) => {
-                // Silent the warning as we want to the error message
-                #[allow(clippy::question_mark)]
-                if stdout().write_all(&s).is_err() {
-                    // on windows console, writing invalid utf8 returns an error
-                    return Err(USimpleError::new(1, "error: cannot write non-utf8 data"));
+    has_padding: bool,
+) -> Box<dyn SupportsFastDecodeAndEncode> {
+    const BASE16_VALID_DECODING_MULTIPLE: usize = 2;
+    const BASE2_VALID_DECODING_MULTIPLE: usize = 8;
+    const BASE32_VALID_DECODING_MULTIPLE: usize = 8;
+    const BASE64_VALID_DECODING_MULTIPLE: usize = 4;
+
+    const BASE16_UNPADDED_MULTIPLE: usize = 1;
+    const BASE2_UNPADDED_MULTIPLE: usize = 1;
+    const BASE32_UNPADDED_MULTIPLE: usize = 5;
+    const BASE64_UNPADDED_MULTIPLE: usize = 3;
+
+    match format {
+        Format::Base16 => Box::from(EncodingWrapper::new(
+            HEXUPPER_PERMISSIVE,
+            BASE16_VALID_DECODING_MULTIPLE,
+            BASE16_UNPADDED_MULTIPLE,
+            // spell-checker:disable-next-line
+            b"0123456789ABCDEFabcdef",
+        )),
+        Format::Base2Lsbf => Box::from(EncodingWrapper::new(
+            BASE2LSBF,
+            BASE2_VALID_DECODING_MULTIPLE,
+            BASE2_UNPADDED_MULTIPLE,
+            // spell-checker:disable-next-line
+            b"01",
+        )),
+        Format::Base2Msbf => Box::from(EncodingWrapper::new(
+            BASE2MSBF,
+            BASE2_VALID_DECODING_MULTIPLE,
+            BASE2_UNPADDED_MULTIPLE,
+            // spell-checker:disable-next-line
+            b"01",
+        )),
+        Format::Base32 => Box::from(EncodingWrapper::new(
+            BASE32,
+            BASE32_VALID_DECODING_MULTIPLE,
+            BASE32_UNPADDED_MULTIPLE,
+            // spell-checker:disable-next-line
+            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+        )),
+        Format::Base32Hex => Box::from(EncodingWrapper::new(
+            BASE32HEX,
+            BASE32_VALID_DECODING_MULTIPLE,
+            BASE32_UNPADDED_MULTIPLE,
+            // spell-checker:disable-next-line
+            b"0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+        )),
+        Format::Base64 => {
+            let alphabet: &[u8] = if has_padding {
+                &b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/="[..]
+            } else {
+                &b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"[..]
+            };
+            let wrapper = if decode && !has_padding {
+                BASE64_NOPAD
+            } else {
+                BASE64
+            };
+            Box::from(EncodingWrapper::new(
+                wrapper,
+                BASE64_VALID_DECODING_MULTIPLE,
+                BASE64_UNPADDED_MULTIPLE,
+                alphabet,
+            ))
+        }
+        Format::Base64Url => Box::from(EncodingWrapper::new(
+            BASE64URL,
+            BASE64_VALID_DECODING_MULTIPLE,
+            BASE64_UNPADDED_MULTIPLE,
+            // spell-checker:disable-next-line
+            b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=_-",
+        )),
+        Format::Z85 => Box::from(Z85Wrapper {}),
+    }
+}
+
+pub mod fast_encode {
+    use crate::base_common::{WRAP_DEFAULT, format_read_error};
+    use std::{
+        collections::VecDeque,
+        io::{self, ErrorKind, Read, Write},
+        num::NonZeroUsize,
+    };
+    use uucore::{
+        encoding::SupportsFastDecodeAndEncode,
+        error::{UResult, USimpleError},
+    };
+
+    struct LineWrapping {
+        line_length: NonZeroUsize,
+        print_buffer: Vec<u8>,
+    }
+
+    // Start of helper functions
+    fn encode_in_chunks_to_buffer(
+        supports_fast_decode_and_encode: &dyn SupportsFastDecodeAndEncode,
+        encode_in_chunks_of_size: usize,
+        bytes_to_steal: usize,
+        read_buffer: &[u8],
+        encoded_buffer: &mut VecDeque<u8>,
+        leftover_buffer: &mut VecDeque<u8>,
+    ) -> UResult<()> {
+        let bytes_to_chunk = if bytes_to_steal > 0 {
+            let (stolen_bytes, rest_of_read_buffer) = read_buffer.split_at(bytes_to_steal);
+
+            leftover_buffer.extend(stolen_bytes);
+
+            // After appending the stolen bytes to `leftover_buffer`, it should be the right size
+            assert_eq!(leftover_buffer.len(), encode_in_chunks_of_size);
+
+            // Encode the old unencoded data and the stolen bytes, and add the result to
+            // `encoded_buffer`
+            supports_fast_decode_and_encode
+                .encode_to_vec_deque(leftover_buffer.make_contiguous(), encoded_buffer)?;
+
+            // Reset `leftover_buffer`
+            leftover_buffer.clear();
+
+            rest_of_read_buffer
+        } else {
+            // Do not need to steal bytes from `read_buffer`
+            read_buffer
+        };
+
+        let chunks_exact = bytes_to_chunk.chunks_exact(encode_in_chunks_of_size);
+
+        let remainder = chunks_exact.remainder();
+
+        for sl in chunks_exact {
+            assert_eq!(sl.len(), encode_in_chunks_of_size);
+
+            supports_fast_decode_and_encode.encode_to_vec_deque(sl, encoded_buffer)?;
+        }
+
+        leftover_buffer.extend(remainder);
+
+        Ok(())
+    }
+
+    fn write_without_line_breaks(
+        encoded_buffer: &mut VecDeque<u8>,
+        output: &mut dyn Write,
+        is_cleanup: bool,
+        empty_wrap: bool,
+    ) -> io::Result<()> {
+        // TODO
+        // `encoded_buffer` only has to be a VecDeque if line wrapping is enabled
+        // (`make_contiguous` should be a no-op here)
+        // Refactoring could avoid this call
+        output.write_all(encoded_buffer.make_contiguous())?;
+
+        if is_cleanup {
+            if !empty_wrap {
+                output.write_all(b"\n")?;
+            }
+        } else {
+            encoded_buffer.clear();
+        }
+
+        Ok(())
+    }
+
+    fn write_with_line_breaks(
+        &mut LineWrapping {
+            ref line_length,
+            ref mut print_buffer,
+        }: &mut LineWrapping,
+        encoded_buffer: &mut VecDeque<u8>,
+        output: &mut dyn Write,
+        is_cleanup: bool,
+    ) -> io::Result<()> {
+        let line_length = line_length.get();
+
+        let make_contiguous_result = encoded_buffer.make_contiguous();
+
+        let chunks_exact = make_contiguous_result.chunks_exact(line_length);
+
+        let mut bytes_added_to_print_buffer = 0;
+
+        for sl in chunks_exact {
+            bytes_added_to_print_buffer += sl.len();
+
+            print_buffer.extend_from_slice(sl);
+            print_buffer.push(b'\n');
+        }
+
+        output.write_all(print_buffer)?;
+
+        // Remove the bytes that were just printed from `encoded_buffer`
+        drop(encoded_buffer.drain(..bytes_added_to_print_buffer));
+
+        if is_cleanup {
+            if encoded_buffer.is_empty() {
+                // Do not write a newline in this case, because two trailing newlines should never be printed
+            } else {
+                // Print the partial line, since this is cleanup and no more data is coming
+                output.write_all(encoded_buffer.make_contiguous())?;
+                output.write_all(b"\n")?;
+            }
+        } else {
+            print_buffer.clear();
+        }
+
+        Ok(())
+    }
+
+    fn write_to_output(
+        line_wrapping: &mut Option<LineWrapping>,
+        encoded_buffer: &mut VecDeque<u8>,
+        output: &mut dyn Write,
+        is_cleanup: bool,
+        empty_wrap: bool,
+    ) -> io::Result<()> {
+        // Write all data in `encoded_buffer` to `output`
+        if let &mut Some(ref mut li) = line_wrapping {
+            write_with_line_breaks(li, encoded_buffer, output, is_cleanup)?;
+        } else {
+            write_without_line_breaks(encoded_buffer, output, is_cleanup, empty_wrap)?;
+        }
+
+        Ok(())
+    }
+    // End of helper functions
+
+    pub fn fast_encode(
+        input: &mut dyn Read,
+        output: &mut dyn Write,
+        supports_fast_decode_and_encode: &dyn SupportsFastDecodeAndEncode,
+        wrap: Option<usize>,
+    ) -> UResult<()> {
+        // Based on performance testing
+        const INPUT_BUFFER_SIZE: usize = 32 * 1_024;
+
+        const ENCODE_IN_CHUNKS_OF_SIZE_MULTIPLE: usize = 1_024;
+
+        let encode_in_chunks_of_size =
+            supports_fast_decode_and_encode.unpadded_multiple() * ENCODE_IN_CHUNKS_OF_SIZE_MULTIPLE;
+
+        assert!(encode_in_chunks_of_size > 0);
+
+        // The "data-encoding" crate supports line wrapping, but not arbitrary line wrapping, only certain widths, so
+        // line wrapping must be handled here.
+        // https://github.com/ia0/data-encoding/blob/4f42ad7ef242f6d243e4de90cd1b46a57690d00e/lib/src/lib.rs#L1710
+        let mut line_wrapping = match wrap {
+            // Line wrapping is disabled because "-w"/"--wrap" was passed with "0"
+            Some(0) => None,
+            // A custom line wrapping value was passed
+            Some(an) => Some(LineWrapping {
+                line_length: NonZeroUsize::new(an).unwrap(),
+                print_buffer: Vec::<u8>::new(),
+            }),
+            // Line wrapping was not set, so the default is used
+            None => Some(LineWrapping {
+                line_length: NonZeroUsize::new(WRAP_DEFAULT).unwrap(),
+                print_buffer: Vec::<u8>::new(),
+            }),
+        };
+
+        // Start of buffers
+        // Data that was read from `input`
+        let mut input_buffer = vec![0; INPUT_BUFFER_SIZE];
+
+        assert!(!input_buffer.is_empty());
+
+        // Data that was read from `input` but has not been encoded yet
+        let mut leftover_buffer = VecDeque::<u8>::new();
+
+        // Encoded data that needs to be written to `output`
+        let mut encoded_buffer = VecDeque::<u8>::new();
+        // End of buffers
+
+        loop {
+            match input.read(&mut input_buffer) {
+                Ok(bytes_read_from_input) => {
+                    if bytes_read_from_input == 0 {
+                        break;
+                    }
+
+                    // The part of `input_buffer` that was actually filled by the call to `read`
+                    let read_buffer = &input_buffer[..bytes_read_from_input];
+
+                    // How many bytes to steal from `read_buffer` to get `leftover_buffer` to the right size
+                    let bytes_to_steal = encode_in_chunks_of_size - leftover_buffer.len();
+
+                    if bytes_to_steal > bytes_read_from_input {
+                        // Do not have enough data to encode a chunk, so copy data to `leftover_buffer` and read more
+                        leftover_buffer.extend(read_buffer);
+
+                        assert!(leftover_buffer.len() < encode_in_chunks_of_size);
+
+                        continue;
+                    }
+
+                    // Encode data in chunks, then place it in `encoded_buffer`
+                    encode_in_chunks_to_buffer(
+                        supports_fast_decode_and_encode,
+                        encode_in_chunks_of_size,
+                        bytes_to_steal,
+                        read_buffer,
+                        &mut encoded_buffer,
+                        &mut leftover_buffer,
+                    )?;
+
+                    assert!(leftover_buffer.len() < encode_in_chunks_of_size);
+                    // Write all data in `encoded_buffer` to `output`
+                    write_to_output(
+                        &mut line_wrapping,
+                        &mut encoded_buffer,
+                        output,
+                        false,
+                        wrap == Some(0),
+                    )?;
+                }
+                Err(er) => {
+                    let kind = er.kind();
+
+                    if kind == ErrorKind::Interrupted {
+                        // Retry reading
+                        continue;
+                    }
+
+                    return Err(USimpleError::new(1, format_read_error(kind)));
                 }
-                Ok(())
             }
-            Err(_) => Err(USimpleError::new(1, "error: invalid input")),
         }
-    } else {
-        match data.encode() {
-            Ok(s) => {
-                wrap_print(&data, &s);
-                Ok(())
+
+        // Cleanup
+        // `input` has finished producing data, so the data remaining in the buffers needs to be encoded and printed
+        {
+            // Encode all remaining unencoded bytes, placing them in `encoded_buffer`
+            supports_fast_decode_and_encode
+                .encode_to_vec_deque(leftover_buffer.make_contiguous(), &mut encoded_buffer)?;
+
+            // Write all data in `encoded_buffer` to output
+            // `is_cleanup` triggers special cleanup-only logic
+            write_to_output(
+                &mut line_wrapping,
+                &mut encoded_buffer,
+                output,
+                true,
+                wrap == Some(0),
+            )?;
+        }
+
+        Ok(())
+    }
+}
+
+pub mod fast_decode {
+    use crate::base_common::format_read_error;
+    use std::io::{self, ErrorKind, Read, Write};
+    use uucore::{
+        encoding::SupportsFastDecodeAndEncode,
+        error::{UResult, USimpleError},
+    };
+
+    // Start of helper functions
+    fn alphabet_to_table(alphabet: &[u8], ignore_garbage: bool) -> [bool; 256] {
+        // If `ignore_garbage` is enabled, all characters outside the alphabet are ignored
+        // If it is not enabled, only '\n' and '\r' are ignored
+        if ignore_garbage {
+            // Note: "false" here
+            let mut table = [false; 256];
+
+            // Pass through no characters except those in the alphabet
+            for ue in alphabet {
+                let us = usize::from(*ue);
+
+                // Should not have been set yet
+                assert!(!table[us]);
+
+                table[us] = true;
+            }
+
+            table
+        } else {
+            // Note: "true" here
+            let mut table = [true; 256];
+
+            // Pass through all characters except '\n' and '\r'
+            for ue in [b'\n', b'\r'] {
+                let us = usize::from(ue);
+
+                // Should not have been set yet
+                assert!(table[us]);
+
+                table[us] = false;
+            }
+
+            table
+        }
+    }
+
+    fn decode_in_chunks_to_buffer(
+        supports_fast_decode_and_encode: &dyn SupportsFastDecodeAndEncode,
+        decode_in_chunks_of_size: usize,
+        bytes_to_steal: usize,
+        read_buffer_filtered: &[u8],
+        decoded_buffer: &mut Vec<u8>,
+        leftover_buffer: &mut Vec<u8>,
+    ) -> UResult<()> {
+        let bytes_to_chunk = if bytes_to_steal > 0 {
+            let (stolen_bytes, rest_of_read_buffer_filtered) =
+                read_buffer_filtered.split_at(bytes_to_steal);
+
+            leftover_buffer.extend(stolen_bytes);
+
+            // After appending the stolen bytes to `leftover_buffer`, it should be the right size
+            assert_eq!(leftover_buffer.len(), decode_in_chunks_of_size);
+
+            // Decode the old un-decoded data and the stolen bytes, and add the result to
+            // `decoded_buffer`
+            supports_fast_decode_and_encode.decode_into_vec(leftover_buffer, decoded_buffer)?;
+
+            // Reset `leftover_buffer`
+            leftover_buffer.clear();
+
+            rest_of_read_buffer_filtered
+        } else {
+            // Do not need to steal bytes from `read_buffer`
+            read_buffer_filtered
+        };
+
+        let chunks_exact = bytes_to_chunk.chunks_exact(decode_in_chunks_of_size);
+
+        let remainder = chunks_exact.remainder();
+
+        for sl in chunks_exact {
+            assert_eq!(sl.len(), decode_in_chunks_of_size);
+
+            supports_fast_decode_and_encode.decode_into_vec(sl, decoded_buffer)?;
+        }
+
+        leftover_buffer.extend(remainder);
+
+        Ok(())
+    }
+
+    fn write_to_output(decoded_buffer: &mut Vec<u8>, output: &mut dyn Write) -> io::Result<()> {
+        // Write all data in `decoded_buffer` to `output`
+        output.write_all(decoded_buffer.as_slice())?;
+
+        decoded_buffer.clear();
+
+        Ok(())
+    }
+    // End of helper functions
+
+    pub fn fast_decode(
+        input: &mut dyn Read,
+        output: &mut dyn Write,
+        supports_fast_decode_and_encode: &dyn SupportsFastDecodeAndEncode,
+        ignore_garbage: bool,
+    ) -> UResult<()> {
+        // Based on performance testing
+        const INPUT_BUFFER_SIZE: usize = 32 * 1_024;
+
+        const DECODE_IN_CHUNKS_OF_SIZE_MULTIPLE: usize = 1_024;
+
+        let alphabet = supports_fast_decode_and_encode.alphabet();
+        let decode_in_chunks_of_size = supports_fast_decode_and_encode.valid_decoding_multiple()
+            * DECODE_IN_CHUNKS_OF_SIZE_MULTIPLE;
+
+        assert!(decode_in_chunks_of_size > 0);
+
+        // Note that it's not worth using "data-encoding"'s ignore functionality if `ignore_garbage` is true, because
+        // "data-encoding"'s ignore functionality cannot discard non-ASCII bytes. The data has to be filtered before
+        // passing it to "data-encoding", so there is no point in doing any filtering in "data-encoding". This also
+        // allows execution to stay on the happy path in "data-encoding":
+        // https://github.com/ia0/data-encoding/blob/4f42ad7ef242f6d243e4de90cd1b46a57690d00e/lib/src/lib.rs#L754-L756
+        // It is also not worth using "data-encoding"'s ignore functionality when `ignore_garbage` is
+        // false.
+        // Note that the alphabet constants above already include the padding characters
+        // TODO
+        // Precompute this
+        let table = alphabet_to_table(alphabet, ignore_garbage);
+
+        // Start of buffers
+        // Data that was read from `input`
+        let mut input_buffer = vec![0; INPUT_BUFFER_SIZE];
+
+        assert!(!input_buffer.is_empty());
+
+        // Data that was read from `input` but has not been decoded yet
+        let mut leftover_buffer = Vec::<u8>::new();
+
+        // Decoded data that needs to be written to `output`
+        let mut decoded_buffer = Vec::<u8>::new();
+
+        // Buffer that will be used when `ignore_garbage` is true, and the chunk read from `input` contains garbage
+        // data
+        let mut non_garbage_buffer = Vec::<u8>::new();
+        // End of buffers
+
+        loop {
+            match input.read(&mut input_buffer) {
+                Ok(bytes_read_from_input) => {
+                    if bytes_read_from_input == 0 {
+                        break;
+                    }
+
+                    let read_buffer_filtered = {
+                        // The part of `input_buffer` that was actually filled by the call to `read`
+                        let read_buffer = &input_buffer[..bytes_read_from_input];
+
+                        // First just scan the data for the happy path
+                        // Yields significant speedup when the input does not contain line endings
+                        let found_garbage = read_buffer.iter().any(|ue| {
+                            // Garbage, since it was not found in the table
+                            !table[usize::from(*ue)]
+                        });
+
+                        if found_garbage {
+                            non_garbage_buffer.clear();
+
+                            for ue in read_buffer {
+                                if table[usize::from(*ue)] {
+                                    // Not garbage, since it was found in the table
+                                    non_garbage_buffer.push(*ue);
+                                }
+                            }
+
+                            non_garbage_buffer.as_slice()
+                        } else {
+                            read_buffer
+                        }
+                    };
+
+                    // How many bytes to steal from `read_buffer` to get `leftover_buffer` to the right size
+                    let bytes_to_steal = decode_in_chunks_of_size - leftover_buffer.len();
+
+                    if bytes_to_steal > read_buffer_filtered.len() {
+                        // Do not have enough data to decode a chunk, so copy data to `leftover_buffer` and read more
+                        leftover_buffer.extend(read_buffer_filtered);
+
+                        assert!(leftover_buffer.len() < decode_in_chunks_of_size);
+
+                        continue;
+                    }
+
+                    // Decode data in chunks, then place it in `decoded_buffer`
+                    decode_in_chunks_to_buffer(
+                        supports_fast_decode_and_encode,
+                        decode_in_chunks_of_size,
+                        bytes_to_steal,
+                        read_buffer_filtered,
+                        &mut decoded_buffer,
+                        &mut leftover_buffer,
+                    )?;
+
+                    assert!(leftover_buffer.len() < decode_in_chunks_of_size);
+
+                    // Write all data in `decoded_buffer` to `output`
+                    write_to_output(&mut decoded_buffer, output)?;
+                }
+                Err(er) => {
+                    let kind = er.kind();
+
+                    if kind == ErrorKind::Interrupted {
+                        // Retry reading
+                        continue;
+                    }
+
+                    return Err(USimpleError::new(1, format_read_error(kind)));
+                }
+            }
+        }
+
+        // Cleanup
+        // `input` has finished producing data, so the data remaining in the buffers needs to be decoded and printed
+        {
+            // Decode all remaining encoded bytes, placing them in `decoded_buffer`
+            supports_fast_decode_and_encode
+                .decode_into_vec(&leftover_buffer, &mut decoded_buffer)?;
+
+            // Write all data in `decoded_buffer` to `output`
+            write_to_output(&mut decoded_buffer, output)?;
+        }
+
+        Ok(())
+    }
+}
+
+fn format_read_error(kind: ErrorKind) -> String {
+    let kind_string = kind.to_string();
+
+    // e.g. "is a directory" -> "Is a directory"
+    let mut kind_string_capitalized = String::with_capacity(kind_string.len());
+
+    for (index, ch) in kind_string.char_indices() {
+        if index == 0 {
+            for cha in ch.to_uppercase() {
+                kind_string_capitalized.push(cha);
             }
-            Err(_) => Err(USimpleError::new(
-                1,
-                "error: invalid input (length must be multiple of 4 characters)",
-            )),
+        } else {
+            kind_string_capitalized.push(ch);
+        }
+    }
+
+    format!("read error: {kind_string_capitalized}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_has_padding() {
+        let test_cases = vec![
+            ("aGVsbG8sIHdvcmxkIQ==", true),
+            ("aGVsbG8sIHdvcmxkIQ== ", true),
+            ("aGVsbG8sIHdvcmxkIQ==\n", true),
+            ("aGVsbG8sIHdvcmxkIQ== \n", true),
+            ("aGVsbG8sIHdvcmxkIQ=", true),
+            ("aGVsbG8sIHdvcmxkIQ= ", true),
+            ("aGVsbG8sIHdvcmxkIQ \n", false),
+            ("aGVsbG8sIHdvcmxkIQ", false),
+        ];
+
+        for (input, expected) in test_cases {
+            let mut cursor = Cursor::new(input.as_bytes());
+            assert_eq!(
+                has_padding(&mut cursor).unwrap(),
+                expected,
+                "Failed for input: '{input}'"
+            );
         }
     }
 }
diff --git a/src/uu/base64/Cargo.toml b/src/uu/base64/Cargo.toml
index 3bc04515280..aa899f1a1e6 100644
--- a/src/uu/base64/Cargo.toml
+++ b/src/uu/base64/Cargo.toml
@@ -1,20 +1,24 @@
 [package]
 name = "uu_base64"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "base64 ~ (uutils) decode/encode input (base64-encoding)"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/base64"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/base64.rs"
 
 [dependencies]
+clap = { workspace = true }
 uucore = { workspace = true, features = ["encoding"] }
 uu_base32 = { workspace = true }
 
diff --git a/src/uu/base64/src/base64.rs b/src/uu/base64/src/base64.rs
index 6544638bdae..86eb75bf119 100644
--- a/src/uu/base64/src/base64.rs
+++ b/src/uu/base64/src/base64.rs
@@ -3,13 +3,10 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use clap::Command;
 use uu_base32::base_common;
-pub use uu_base32::uu_app;
-
 use uucore::{encoding::Format, error::UResult, help_about, help_usage};
 
-use std::io::{stdin, Read};
-
 const ABOUT: &str = help_about!("base64.md");
 const USAGE: &str = help_usage!("base64.md");
 
@@ -17,18 +14,13 @@ const USAGE: &str = help_usage!("base64.md");
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let format = Format::Base64;
 
-    let config: base_common::Config = base_common::parse_base_cmd_args(args, ABOUT, USAGE)?;
+    let config = base_common::parse_base_cmd_args(args, ABOUT, USAGE)?;
 
-    // Create a reference to stdin so we can return a locked stdin from
-    // parse_base_cmd_args
-    let stdin_raw = stdin();
-    let mut input: Box<dyn Read> = base_common::get_input(&config, &stdin_raw)?;
+    let mut input = base_common::get_input(&config)?;
+
+    base_common::handle_input(&mut input, format, config)
+}
 
-    base_common::handle_input(
-        &mut input,
-        format,
-        config.wrap_cols,
-        config.ignore_garbage,
-        config.decode,
-    )
+pub fn uu_app() -> Command {
+    base_common::base_app(ABOUT, USAGE)
 }
diff --git a/src/uu/basename/Cargo.toml b/src/uu/basename/Cargo.toml
index 878a5d9e102..5123174ae2d 100644
--- a/src/uu/basename/Cargo.toml
+++ b/src/uu/basename/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_basename"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "basename ~ (uutils) display PATHNAME with leading directory components removed"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/basename"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/basename.rs"
diff --git a/src/uu/basename/basename.md b/src/uu/basename/basename.md
index b17cac74a00..ee87fa76d4e 100644
--- a/src/uu/basename/basename.md
+++ b/src/uu/basename/basename.md
@@ -1,7 +1,7 @@
 # basename
 
 ```
-basename NAME [SUFFIX]
+basename [-z] NAME [SUFFIX]
 basename OPTION... NAME...
 ```
 
diff --git a/src/uu/basename/src/basename.rs b/src/uu/basename/src/basename.rs
index 6c9baca6fce..a40fcc18534 100644
--- a/src/uu/basename/src/basename.rs
+++ b/src/uu/basename/src/basename.rs
@@ -5,8 +5,8 @@
 
 // spell-checker:ignore (ToDO) fullname
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::path::{is_separator, PathBuf};
+use clap::{Arg, ArgAction, Command};
+use std::path::{PathBuf, is_separator};
 use uucore::display::Quotable;
 use uucore::error::{UResult, UUsageError};
 use uucore::line_ending::LineEnding;
@@ -27,86 +27,48 @@ pub mod options {
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = args.collect_lossy();
 
-    // Since options have to go before names,
-    // if the first argument is not an option, then there is no option,
-    // and that implies there is exactly one name (no option => no -a option),
-    // so simple format is used
-    if args.len() > 1 && !args[1].starts_with('-') {
-        if args.len() > 3 {
-            return Err(UUsageError::new(
-                1,
-                format!("extra operand {}", args[3].to_string().quote()),
-            ));
-        }
-        let suffix = if args.len() > 2 { args[2].as_ref() } else { "" };
-        println!("{}", basename(&args[1], suffix));
-        return Ok(());
-    }
-
     //
     // Argument parsing
     //
     let matches = uu_app().try_get_matches_from(args)?;
 
-    // too few arguments
-    if !matches.contains_id(options::NAME) {
-        return Err(UUsageError::new(1, "missing operand".to_string()));
-    }
-
     let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
 
-    let opt_suffix = matches.get_one::<String>(options::SUFFIX).is_some();
-    let opt_multiple = matches.get_flag(options::MULTIPLE);
-    let multiple_paths = opt_suffix || opt_multiple;
-    let name_args_count = matches
+    let mut name_args = matches
         .get_many::<String>(options::NAME)
-        .map(|n| n.len())
-        .unwrap_or(0);
-
-    // too many arguments
-    if !multiple_paths && name_args_count > 2 {
-        return Err(UUsageError::new(
-            1,
-            format!(
-                "extra operand {}",
-                matches
-                    .get_many::<String>(options::NAME)
-                    .unwrap()
-                    .nth(2)
-                    .unwrap()
-                    .quote()
-            ),
-        ));
+        .unwrap_or_default()
+        .collect::<Vec<_>>();
+    if name_args.is_empty() {
+        return Err(UUsageError::new(1, "missing operand".to_string()));
     }
-
-    let suffix = if opt_suffix {
-        matches.get_one::<String>(options::SUFFIX).unwrap()
-    } else if !opt_multiple && name_args_count > 1 {
+    let multiple_paths =
+        matches.get_one::<String>(options::SUFFIX).is_some() || matches.get_flag(options::MULTIPLE);
+    let suffix = if multiple_paths {
         matches
-            .get_many::<String>(options::NAME)
-            .unwrap()
-            .nth(1)
-            .unwrap()
+            .get_one::<String>(options::SUFFIX)
+            .cloned()
+            .unwrap_or_default()
     } else {
-        ""
+        // "simple format"
+        match name_args.len() {
+            0 => panic!("already checked"),
+            1 => String::default(),
+            2 => name_args.pop().unwrap().clone(),
+            _ => {
+                return Err(UUsageError::new(
+                    1,
+                    format!("extra operand {}", name_args[2].quote()),
+                ));
+            }
+        }
     };
 
     //
     // Main Program Processing
     //
 
-    let paths: Vec<_> = if multiple_paths {
-        matches.get_many::<String>(options::NAME).unwrap().collect()
-    } else {
-        matches
-            .get_many::<String>(options::NAME)
-            .unwrap()
-            .take(1)
-            .collect()
-    };
-
-    for path in paths {
-        print!("{}{}", basename(path, suffix), line_ending);
+    for path in name_args {
+        print!("{}{line_ending}", basename(path, &suffix));
     }
 
     Ok(())
@@ -114,7 +76,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -123,27 +85,31 @@ pub fn uu_app() -> Command {
                 .short('a')
                 .long(options::MULTIPLE)
                 .help("support multiple arguments and treat each as a NAME")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::MULTIPLE),
         )
         .arg(
             Arg::new(options::NAME)
-                .action(clap::ArgAction::Append)
+                .action(ArgAction::Append)
                 .value_hint(clap::ValueHint::AnyPath)
-                .hide(true),
+                .hide(true)
+                .trailing_var_arg(true),
         )
         .arg(
             Arg::new(options::SUFFIX)
                 .short('s')
                 .long(options::SUFFIX)
                 .value_name("SUFFIX")
-                .help("remove a trailing SUFFIX; implies -a"),
+                .help("remove a trailing SUFFIX; implies -a")
+                .overrides_with(options::SUFFIX),
         )
         .arg(
             Arg::new(options::ZERO)
                 .short('z')
                 .long(options::ZERO)
                 .help("end each output line with NUL, not newline")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::ZERO),
         )
 }
 
@@ -159,16 +125,13 @@ fn basename(fullname: &str, suffix: &str) -> String {
 
     // Convert to path buffer and get last path component
     let pb = PathBuf::from(path);
-    match pb.components().last() {
-        Some(c) => {
-            let name = c.as_os_str().to_str().unwrap();
-            if name == suffix {
-                name.to_string()
-            } else {
-                name.strip_suffix(suffix).unwrap_or(name).to_string()
-            }
-        }
 
-        None => String::new(),
-    }
+    pb.components().next_back().map_or_else(String::new, |c| {
+        let name = c.as_os_str().to_str().unwrap();
+        if name == suffix {
+            name.to_string()
+        } else {
+            name.strip_suffix(suffix).unwrap_or(name).to_string()
+        }
+    })
 }
diff --git a/src/uu/basenc/BENCHMARKING.md b/src/uu/basenc/BENCHMARKING.md
new file mode 100644
index 00000000000..8248cbbc53b
--- /dev/null
+++ b/src/uu/basenc/BENCHMARKING.md
@@ -0,0 +1,177 @@
+<!--
+spell-checker:ignore gibibyte toybox
+-->
+
+# Benchmarking base32, base64, and basenc
+
+Note that the functionality of the `base32` and `base64` programs is identical to that of the `basenc` program, using
+the "--base32" and "--base64" options, respectively. For that reason, it is only necessary to benchmark `basenc`.
+
+To compare the runtime performance of the uutils implementation with the GNU Core Utilities implementation, you can
+use a benchmarking tool like [hyperfine][0].
+
+hyperfine currently does not measure maximum memory usage. Memory usage can be benchmarked using [poop][2], or
+[toybox][3]'s "time" subcommand (both are Linux only).
+
+Build the `basenc` binary using the release profile:
+
+```Shell
+cargo build --package uu_basenc --profile release
+```
+
+## Expected performance
+
+uutils' `basenc` performs streaming decoding and encoding, and therefore should perform all operations with a constant
+maximum memory usage, regardless of the size of the input. Release builds currently use less than 3 mebibytes of
+memory, and memory usage greater than 10 mebibytes should be considered a bug.
+
+As of September 2024, uutils' `basenc` has runtime performance equal to or superior to GNU Core Utilities' `basenc` in
+in most scenarios. uutils' `basenc` uses slightly more memory, but given how small these quantities are in absolute
+terms (see above), this is highly unlikely to be practically relevant to users.
+
+## Benchmark results (2024-09-27)
+
+### Setup
+
+```Shell
+# Use uutils' dd to create a 1 gibibyte in-memory file filled with random bytes (Linux only).
+# On other platforms, you can use /tmp instead of /dev/shm, but note that /tmp is not guaranteed to be in-memory.
+coreutils dd if=/dev/urandom of=/dev/shm/one-random-gibibyte bs=1024 count=1048576
+
+# Encode this file for use in decoding performance testing
+/usr/bin/basenc --base32hex -- /dev/shm/one-random-gibibyte 1>/dev/shm/one-random-gibibyte-base32hex-encoded
+/usr/bin/basenc --z85 -- /dev/shm/one-random-gibibyte 1>/dev/shm/one-random-gibibyte-z85-encoded
+```
+
+### Programs being tested
+
+uutils' `basenc`:
+
+```
+� git rev-list HEAD | coreutils head -n 1 -- -
+a0718ef0ffd50539a2e2bc0095c9fadcd70ab857
+```
+
+GNU Core Utilities' `basenc`:
+
+```
+� /usr/bin/basenc --version | coreutils head -n 1 -- -
+basenc (GNU coreutils) 9.4
+```
+
+### Encoding performance
+
+#### "--base64", default line wrapping (76 characters)
+
+âž• Faster than GNU Core Utilities
+
+```
+� hyperfine \
+    --sort \
+    command \
+    -- \
+    '/usr/bin/basenc --base64 -- /dev/shm/one-random-gibibyte 1>/dev/null' \
+    './target/release/basenc --base64 -- /dev/shm/one-random-gibibyte 1>/dev/null'
+
+Benchmark 1: /usr/bin/basenc --base64 -- /dev/shm/one-random-gibibyte 1>/dev/null
+  Time (mean ± σ):     965.1 ms ±   7.9 ms    [User: 766.2 ms, System: 193.4 ms]
+  Range (min … max):   950.2 ms … 976.9 ms    10 runs
+
+Benchmark 2: ./target/release/basenc --base64 -- /dev/shm/one-random-gibibyte 1>/dev/null
+  Time (mean ± σ):     696.6 ms ±   9.1 ms    [User: 574.9 ms, System: 117.3 ms]
+  Range (min … max):   683.1 ms … 713.5 ms    10 runs
+
+Relative speed comparison
+        1.39 ±  0.02  /usr/bin/basenc --base64 -- /dev/shm/one-random-gibibyte 1>/dev/null
+        1.00          ./target/release/basenc --base64 -- /dev/shm/one-random-gibibyte 1>/dev/null
+```
+
+#### "--base16", no line wrapping
+
+âž– Slower than GNU Core Utilities
+
+```
+� poop \
+    '/usr/bin/basenc --base16 --wrap 0 -- /dev/shm/one-random-gibibyte' \
+    './target/release/basenc --base16 --wrap 0 -- /dev/shm/one-random-gibibyte'
+
+Benchmark 1 (6 runs): /usr/bin/basenc --base16 --wrap 0 -- /dev/shm/one-random-gibibyte
+  measurement          mean ± σ            min … max           outliers         delta
+  wall_time           836ms ± 13.3ms     822ms …  855ms          0 ( 0%)        0%
+  peak_rss           2.05MB ± 73.0KB    1.94MB … 2.12MB          0 ( 0%)        0%
+  cpu_cycles         2.85G  ± 32.8M     2.82G  … 2.91G           0 ( 0%)        0%
+  instructions       14.0G  ± 58.7      14.0G  … 14.0G           0 ( 0%)        0%
+  cache_references   70.0M  ± 6.48M     63.7M  … 78.8M           0 ( 0%)        0%
+  cache_misses        582K  ±  172K      354K  …  771K           0 ( 0%)        0%
+  branch_misses       667K  ± 4.55K      662K  …  674K           0 ( 0%)        0%
+Benchmark 2 (6 runs): ./target/release/basenc --base16 --wrap 0 -- /dev/shm/one-random-gibibyte
+  measurement          mean ± σ            min … max           outliers         delta
+  wall_time           884ms ± 6.38ms     878ms …  895ms          0 ( 0%)        💩+  5.7% ±  1.6%
+  peak_rss           2.65MB ± 66.8KB    2.55MB … 2.74MB          0 ( 0%)        💩+ 29.3% ±  4.4%
+  cpu_cycles         3.15G  ± 8.61M     3.14G  … 3.16G           0 ( 0%)        💩+ 10.6% ±  1.1%
+  instructions       10.5G  ±  275      10.5G  … 10.5G           0 ( 0%)        ⚡- 24.9% ±  0.0%
+  cache_references   93.5M  ± 6.10M     87.2M  …  104M           0 ( 0%)        💩+ 33.7% ± 11.6%
+  cache_misses        415K  ± 52.3K      363K  …  474K           0 ( 0%)          - 28.8% ± 28.0%
+  branch_misses      1.43M  ± 4.82K     1.42M  … 1.43M           0 ( 0%)        💩+113.9% ±  0.9%
+```
+
+### Decoding performance
+
+#### "--base32hex"
+
+âž• Faster than GNU Core Utilities
+
+```
+� hyperfine \
+    --sort \
+    command \
+    -- \
+    '/usr/bin/basenc --base32hex --decode -- /dev/shm/one-random-gibibyte-base32hex-encoded 1>/dev/null' \
+    './target/release/basenc --base32hex --decode -- /dev/shm/one-random-gibibyte-base32hex-encoded 1>/dev/null'
+
+Benchmark 1: /usr/bin/basenc --base32hex --decode -- /dev/shm/one-random-gibibyte-base32hex-encoded 1>/dev/null
+  Time (mean ± σ):      7.154 s ±  0.082 s    [User: 6.802 s, System: 0.323 s]
+  Range (min … max):    7.051 s …  7.297 s    10 runs
+
+Benchmark 2: ./target/release/basenc --base32hex --decode -- /dev/shm/one-random-gibibyte-base32hex-encoded 1>/dev/null
+  Time (mean ± σ):      2.679 s ±  0.025 s    [User: 2.446 s, System: 0.221 s]
+  Range (min … max):    2.649 s …  2.718 s    10 runs
+
+Relative speed comparison
+        2.67 ±  0.04  /usr/bin/basenc --base32hex --decode -- /dev/shm/one-random-gibibyte-base32hex-encoded 1>/dev/null
+        1.00          ./target/release/basenc --base32hex --decode -- /dev/shm/one-random-gibibyte-base32hex-encoded 1>/dev/null
+```
+
+#### "--z85", with "--ignore-garbage"
+
+âž• Faster than GNU Core Utilities
+
+```
+� poop \
+    '/usr/bin/basenc --decode --ignore-garbage --z85 -- /dev/shm/one-random-gibibyte-z85-encoded' \
+    './target/release/basenc --decode --ignore-garbage --z85 -- /dev/shm/one-random-gibibyte-z85-encoded'
+
+Benchmark 1 (3 runs): /usr/bin/basenc --decode --ignore-garbage --z85 -- /dev/shm/one-random-gibibyte-z85-encoded
+  measurement          mean ± σ            min … max           outliers         delta
+  wall_time          14.4s  ± 68.4ms    14.3s  … 14.4s           0 ( 0%)        0%
+  peak_rss           1.98MB ± 10.8KB    1.97MB … 1.99MB          0 ( 0%)        0%
+  cpu_cycles         58.4G  ±  211M     58.3G  … 58.7G           0 ( 0%)        0%
+  instructions       74.7G  ± 64.0      74.7G  … 74.7G           0 ( 0%)        0%
+  cache_references   41.8M  ±  624K     41.2M  … 42.4M           0 ( 0%)        0%
+  cache_misses        693K  ±  118K      567K  …  802K           0 ( 0%)        0%
+  branch_misses      1.24G  ±  183K     1.24G  … 1.24G           0 ( 0%)        0%
+Benchmark 2 (3 runs): ./target/release/basenc --decode --ignore-garbage --z85 -- /dev/shm/one-random-gibibyte-z85-encoded
+  measurement          mean ± σ            min … max           outliers         delta
+  wall_time          2.80s  ± 17.9ms    2.79s  … 2.82s           0 ( 0%)        ⚡- 80.5% ±  0.8%
+  peak_rss           2.61MB ± 67.4KB    2.57MB … 2.69MB          0 ( 0%)        💩+ 31.9% ±  5.5%
+  cpu_cycles         10.8G  ± 27.9M     10.8G  … 10.9G           0 ( 0%)        ⚡- 81.5% ±  0.6%
+  instructions       39.0G  ±  353      39.0G  … 39.0G           0 ( 0%)        ⚡- 47.7% ±  0.0%
+  cache_references    114M  ± 2.43M      112M  …  116M           0 ( 0%)        💩+173.3% ±  9.6%
+  cache_misses       1.06M  ±  288K      805K  … 1.37M           0 ( 0%)          + 52.6% ± 72.0%
+  branch_misses      1.18M  ± 14.7K     1.16M  … 1.19M           0 ( 0%)        ⚡- 99.9% ±  0.0%
+```
+
+[0]: https://github.com/sharkdp/hyperfine
+[1]: https://github.com/sharkdp/hyperfine?tab=readme-ov-file#installation
+[2]: https://github.com/andrewrk/poop
+[3]: https://landley.net/toybox/
diff --git a/src/uu/basenc/Cargo.toml b/src/uu/basenc/Cargo.toml
index 92912e5dfbf..2f78a95751c 100644
--- a/src/uu/basenc/Cargo.toml
+++ b/src/uu/basenc/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_basenc"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "basenc ~ (uutils) decode/encode input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/basenc"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/basenc.rs"
diff --git a/src/uu/basenc/basenc.md b/src/uu/basenc/basenc.md
index 17916bd4ab8..001babe9e6b 100644
--- a/src/uu/basenc/basenc.md
+++ b/src/uu/basenc/basenc.md
@@ -1,7 +1,7 @@
 # basenc
 
 ```
-basenc [OPTION]... [FILE]"
+basenc [OPTION]... [FILE]
 ```
 
 Encode/decode data and print to standard output
diff --git a/src/uu/basenc/src/basenc.rs b/src/uu/basenc/src/basenc.rs
index ff512b17652..10090765232 100644
--- a/src/uu/basenc/src/basenc.rs
+++ b/src/uu/basenc/src/basenc.rs
@@ -3,19 +3,15 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-//spell-checker:ignore (args) lsbf msbf
+// spell-checker:ignore lsbf msbf
 
 use clap::{Arg, ArgAction, Command};
-use uu_base32::base_common::{self, Config, BASE_CMD_PARSE_ERROR};
-
+use uu_base32::base_common::{self, BASE_CMD_PARSE_ERROR, Config};
+use uucore::error::UClapError;
 use uucore::{
     encoding::Format,
     error::{UResult, UUsageError},
 };
-
-use std::io::{stdin, Read};
-use uucore::error::UClapError;
-
 use uucore::{help_about, help_usage};
 
 const ABOUT: &str = help_about!("basenc.md");
@@ -53,12 +49,14 @@ const ENCODINGS: &[(&str, Format, &str)] = &[
 pub fn uu_app() -> Command {
     let mut command = base_common::base_app(ABOUT, USAGE);
     for encoding in ENCODINGS {
-        command = command.arg(
-            Arg::new(encoding.0)
-                .long(encoding.0)
-                .help(encoding.2)
-                .action(ArgAction::SetTrue),
-        );
+        let raw_arg = Arg::new(encoding.0)
+            .long(encoding.0)
+            .help(encoding.2)
+            .action(ArgAction::SetTrue);
+        let overriding_arg = ENCODINGS
+            .iter()
+            .fold(raw_arg, |arg, enc| arg.overrides_with(enc.0));
+        command = command.arg(overriding_arg);
     }
     command
 }
@@ -79,16 +77,8 @@ fn parse_cmd_args(args: impl uucore::Args) -> UResult<(Config, Format)> {
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let (config, format) = parse_cmd_args(args)?;
-    // Create a reference to stdin so we can return a locked stdin from
-    // parse_base_cmd_args
-    let stdin_raw = stdin();
-    let mut input: Box<dyn Read> = base_common::get_input(&config, &stdin_raw)?;
 
-    base_common::handle_input(
-        &mut input,
-        format,
-        config.wrap_cols,
-        config.ignore_garbage,
-        config.decode,
-    )
+    let mut input = base_common::get_input(&config)?;
+
+    base_common::handle_input(&mut input, format, config)
 }
diff --git a/src/uu/cat/Cargo.toml b/src/uu/cat/Cargo.toml
index d67cd1b254d..f5ac6a64eff 100644
--- a/src/uu/cat/Cargo.toml
+++ b/src/uu/cat/Cargo.toml
@@ -1,24 +1,27 @@
 [package]
 name = "uu_cat"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "cat ~ (uutils) concatenate and display input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cat"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/cat.rs"
 
 [dependencies]
 clap = { workspace = true }
+memchr = { workspace = true }
 thiserror = { workspace = true }
-is-terminal = { workspace = true }
-uucore = { workspace = true, features = ["fs", "pipes"] }
+uucore = { workspace = true, features = ["fast-inc", "fs", "pipes"] }
 
 [target.'cfg(unix)'.dependencies]
 nix = { workspace = true }
diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs
index 8ce8052517b..45fbe6cebf3 100644
--- a/src/uu/cat/src/cat.rs
+++ b/src/uu/cat/src/cat.rs
@@ -3,37 +3,88 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) nonprint nonblank nonprinting
+// spell-checker:ignore (ToDO) nonprint nonblank nonprinting ELOOP
+use std::fs::{File, metadata};
+use std::io::{self, BufWriter, IsTerminal, Read, Write};
+/// Unix domain socket support
+#[cfg(unix)]
+use std::net::Shutdown;
+#[cfg(unix)]
+use std::os::fd::AsFd;
+#[cfg(unix)]
+use std::os::unix::fs::FileTypeExt;
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
 
-// last synced with: cat (GNU coreutils) 8.13
-use clap::{crate_version, Arg, ArgAction, Command};
-use is_terminal::IsTerminal;
-use std::fs::{metadata, File};
-use std::io::{self, Read, Write};
+use clap::{Arg, ArgAction, Command};
+use memchr::memchr2;
+#[cfg(unix)]
+use nix::fcntl::{FcntlArg, fcntl};
 use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::UResult;
 use uucore::fs::FileInformation;
-
-#[cfg(unix)]
-use std::os::unix::io::AsRawFd;
+use uucore::{fast_inc::fast_inc_one, format_usage, help_about, help_usage};
 
 /// Linux splice support
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod splice;
 
-/// Unix domain socket support
-#[cfg(unix)]
-use std::net::Shutdown;
-#[cfg(unix)]
-use std::os::unix::fs::FileTypeExt;
-#[cfg(unix)]
-use std::os::unix::net::UnixStream;
-use uucore::{format_usage, help_about, help_usage};
-
 const USAGE: &str = help_usage!("cat.md");
 const ABOUT: &str = help_about!("cat.md");
 
+// Allocate 32 digits for the line number.
+// An estimate is that we can print about 1e8 lines/seconds, so 32 digits
+// would be enough for billions of universe lifetimes.
+const LINE_NUMBER_BUF_SIZE: usize = 32;
+
+struct LineNumber {
+    buf: [u8; LINE_NUMBER_BUF_SIZE],
+    print_start: usize,
+    num_start: usize,
+    num_end: usize,
+}
+
+// Logic to store a string for the line number. Manually incrementing the value
+// represented in a buffer like this is significantly faster than storing
+// a `usize` and using the standard Rust formatting macros to format a `usize`
+// to a string each time it's needed.
+// Buffer is initialized to "     1\t" and incremented each time `increment` is
+// called, using uucore's fast_inc function that operates on strings.
+impl LineNumber {
+    fn new() -> Self {
+        let mut buf = [b'0'; LINE_NUMBER_BUF_SIZE];
+
+        let init_str = "     1\t";
+        let print_start = buf.len() - init_str.len();
+        let num_start = buf.len() - 2;
+        let num_end = buf.len() - 1;
+
+        buf[print_start..].copy_from_slice(init_str.as_bytes());
+
+        LineNumber {
+            buf,
+            print_start,
+            num_start,
+            num_end,
+        }
+    }
+
+    fn increment(&mut self) {
+        fast_inc_one(&mut self.buf, &mut self.num_start, self.num_end);
+        self.print_start = self.print_start.min(self.num_start);
+    }
+
+    #[inline]
+    fn to_str(&self) -> &[u8] {
+        &self.buf[self.print_start..]
+    }
+
+    fn write(&self, writer: &mut impl Write) -> io::Result<()> {
+        writer.write_all(self.to_str())
+    }
+}
+
 #[derive(Error, Debug)]
 enum CatError {
     /// Wrapper around `io::Error`
@@ -44,7 +95,7 @@ enum CatError {
     #[error("{0}")]
     Nix(#[from] nix::Error),
     /// Unknown file type; it's not a regular file, socket, etc.
-    #[error("unknown filetype: {}", ft_debug)]
+    #[error("unknown filetype: {ft_debug}")]
     UnknownFiletype {
         /// A debug print of the file type
         ft_debug: String,
@@ -53,6 +104,8 @@ enum CatError {
     IsDirectory,
     #[error("input file is output file")]
     OutputIsInput,
+    #[error("Too many levels of symbolic links")]
+    TooManySymlinks,
 }
 
 type CatResult<T> = Result<T, CatError>;
@@ -83,19 +136,11 @@ struct OutputOptions {
 
 impl OutputOptions {
     fn tab(&self) -> &'static str {
-        if self.show_tabs {
-            "^I"
-        } else {
-            "\t"
-        }
+        if self.show_tabs { "^I" } else { "\t" }
     }
 
     fn end_of_line(&self) -> &'static str {
-        if self.show_ends {
-            "$\n"
-        } else {
-            "\n"
-        }
+        if self.show_ends { "$\n" } else { "\n" }
     }
 
     /// We can write fast if we can simply copy the contents of the file to
@@ -113,7 +158,7 @@ impl OutputOptions {
 /// when we can't write fast.
 struct OutputState {
     /// The current line number
-    line_number: usize,
+    line_number: LineNumber,
 
     /// Whether the output cursor is at the beginning of a new line
     at_line_start: bool,
@@ -126,12 +171,12 @@ struct OutputState {
 }
 
 #[cfg(unix)]
-trait FdReadable: Read + AsRawFd {}
+trait FdReadable: Read + AsFd {}
 #[cfg(not(unix))]
 trait FdReadable: Read {}
 
 #[cfg(unix)]
-impl<T> FdReadable for T where T: Read + AsRawFd {}
+impl<T> FdReadable for T where T: Read + AsFd {}
 #[cfg(not(unix))]
 impl<T> FdReadable for T where T: Read {}
 
@@ -171,12 +216,11 @@ mod options {
     pub static SHOW_NONPRINTING_TABS: &str = "t";
     pub static SHOW_TABS: &str = "show-tabs";
     pub static SHOW_NONPRINTING: &str = "show-nonprinting";
+    pub static IGNORED_U: &str = "ignored-u";
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let number_mode = if matches.get_flag(options::NUMBER_NONBLANK) {
@@ -214,7 +258,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let squeeze_blank = matches.get_flag(options::SQUEEZE_BLANK);
     let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
-        Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+        Some(v) => v.cloned().collect(),
         None => vec!["-".to_owned()],
     };
 
@@ -230,14 +274,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::FILE)
                 .hide(true)
-                .action(clap::ArgAction::Append)
+                .action(ArgAction::Append)
                 .value_hint(clap::ValueHint::FilePath),
         )
         .arg(
@@ -252,7 +297,8 @@ pub fn uu_app() -> Command {
                 .short('b')
                 .long(options::NUMBER_NONBLANK)
                 .help("number nonempty output lines, overrides -n")
-                .overrides_with(options::NUMBER)
+                // Note: This MUST NOT .overrides_with(options::NUMBER)!
+                // In clap, overriding is symmetric, so "-b -n" counts as "-n", which is not what we want.
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -302,6 +348,12 @@ pub fn uu_app() -> Command {
                 .help("use ^ and M- notation, except for LF (\\n) and TAB (\\t)")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::IGNORED_U)
+                .short('u')
+                .help("(ignored)")
+                .action(ArgAction::SetTrue),
+        )
 }
 
 fn cat_handle<R: FdReadable>(
@@ -316,6 +368,23 @@ fn cat_handle<R: FdReadable>(
     }
 }
 
+/// Whether this process is appending to stdout.
+#[cfg(unix)]
+fn is_appending() -> bool {
+    let stdout = io::stdout();
+    let Ok(flags) = fcntl(stdout.as_fd(), FcntlArg::F_GETFL) else {
+        return false;
+    };
+    // TODO Replace `1 << 10` with `nix::fcntl::Oflag::O_APPEND`.
+    let o_append = 1 << 10;
+    (flags & o_append) > 0
+}
+
+#[cfg(not(unix))]
+fn is_appending() -> bool {
+    false
+}
+
 fn cat_path(
     path: &str,
     options: &OutputOptions,
@@ -325,10 +394,16 @@ fn cat_path(
     match get_input_type(path)? {
         InputType::StdIn => {
             let stdin = io::stdin();
+            let in_info = FileInformation::from_file(&stdin)?;
             let mut handle = InputHandle {
                 reader: stdin,
-                is_interactive: std::io::stdin().is_terminal(),
+                is_interactive: io::stdin().is_terminal(),
             };
+            if let Some(out_info) = out_info {
+                if in_info == *out_info && is_appending() {
+                    return Err(CatError::OutputIsInput);
+                }
+            }
             cat_handle(&mut handle, options, state)
         }
         InputType::Directory => Err(CatError::IsDirectory),
@@ -363,10 +438,10 @@ fn cat_path(
 }
 
 fn cat_files(files: &[String], options: &OutputOptions) -> UResult<()> {
-    let out_info = FileInformation::from_file(&std::io::stdout()).ok();
+    let out_info = FileInformation::from_file(&io::stdout()).ok();
 
     let mut state = OutputState {
-        line_number: 1,
+        line_number: LineNumber::new(),
         at_line_start: true,
         skipped_carriage_return: false,
         one_blank_kept: false,
@@ -375,7 +450,7 @@ fn cat_files(files: &[String], options: &OutputOptions) -> UResult<()> {
 
     for path in files {
         if let Err(err) = cat_path(path, options, &mut state, out_info.as_ref()) {
-            error_messages.push(format!("{}: {}", path.maybe_quote(), err));
+            error_messages.push(format!("{}: {err}", path.maybe_quote()));
         }
     }
     if state.skipped_carriage_return {
@@ -404,7 +479,23 @@ fn get_input_type(path: &str) -> CatResult<InputType> {
         return Ok(InputType::StdIn);
     }
 
-    let ft = metadata(path)?.file_type();
+    let ft = match metadata(path) {
+        Ok(md) => md.file_type(),
+        Err(e) => {
+            if let Some(raw_error) = e.raw_os_error() {
+                // On Unix-like systems, the error code for "Too many levels of symbolic links" is 40 (ELOOP).
+                // we want to provide a proper error message in this case.
+                #[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
+                let too_many_symlink_code = 40;
+                #[cfg(any(target_os = "macos", target_os = "freebsd"))]
+                let too_many_symlink_code = 62;
+                if raw_error == too_many_symlink_code {
+                    return Err(CatError::TooManySymlinks);
+                }
+            }
+            return Err(CatError::Io(e));
+        }
+    };
     match ft {
         #[cfg(unix)]
         ft if ft.is_block_device() => Ok(InputType::BlockDevice),
@@ -445,12 +536,18 @@ fn write_fast<R: FdReadable>(handle: &mut InputHandle<R>) -> CatResult<()> {
         }
         stdout_lock.write_all(&buf[..n])?;
     }
+
+    // If the splice() call failed and there has been some data written to
+    // stdout via while loop above AND there will be second splice() call
+    // that will succeed, data pushed through splice will be output before
+    // the data buffered in stdout.lock. Therefore additional explicit flush
+    // is required here.
+    stdout_lock.flush()?;
     Ok(())
 }
 
 /// 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,
@@ -458,7 +555,9 @@ fn write_lines<R: FdReadable>(
 ) -> CatResult<()> {
     let mut in_buf = [0; 1024 * 31];
     let stdout = io::stdout();
-    let mut writer = stdout.lock();
+    let stdout = stdout.lock();
+    // Add a 32K buffer for stdout - this greatly improves performance.
+    let mut writer = BufWriter::with_capacity(32 * 1024, stdout);
 
     while let Ok(n) = handle.reader.read(&mut in_buf) {
         if n == 0 {
@@ -469,22 +568,7 @@ fn write_lines<R: FdReadable>(
         while pos < n {
             // skip empty line_number enumerating them if needed
             if in_buf[pos] == b'\n' {
-                // \r followed by \n is printed as ^M when show_ends is enabled, so that \r\n prints as ^M$
-                if state.skipped_carriage_return && options.show_ends {
-                    writer.write_all(b"^M")?;
-                    state.skipped_carriage_return = false;
-                }
-                if !state.at_line_start || !options.squeeze_blank || !state.one_blank_kept {
-                    state.one_blank_kept = true;
-                    if state.at_line_start && options.number == NumberingMode::All {
-                        write!(writer, "{0:6}\t", state.line_number)?;
-                        state.line_number += 1;
-                    }
-                    writer.write_all(options.end_of_line().as_bytes())?;
-                    if handle.is_interactive {
-                        writer.flush()?;
-                    }
-                }
+                write_new_line(&mut writer, options, state, handle.is_interactive)?;
                 state.at_line_start = true;
                 pos += 1;
                 continue;
@@ -496,18 +580,13 @@ fn write_lines<R: FdReadable>(
             }
             state.one_blank_kept = false;
             if state.at_line_start && options.number != NumberingMode::None {
-                write!(writer, "{0:6}\t", state.line_number)?;
-                state.line_number += 1;
+                state.line_number.write(&mut writer)?;
+                state.line_number.increment();
             }
 
             // print to end of line or end of buffer
-            let offset = if options.show_nonprint {
-                write_nonprint_to_end(&in_buf[pos..], &mut writer, options.tab().as_bytes())
-            } else if options.show_tabs {
-                write_tab_to_end(&in_buf[pos..], &mut writer)
-            } else {
-                write_to_end(&in_buf[pos..], &mut writer)
-            };
+            let offset = write_end(&mut writer, &in_buf[pos..], options);
+
             // end of buffer?
             if offset + pos == in_buf.len() {
                 state.at_line_start = false;
@@ -518,26 +597,75 @@ fn write_lines<R: FdReadable>(
             } else {
                 assert_eq!(in_buf[pos + offset], b'\n');
                 // print suitable end of line
-                writer.write_all(options.end_of_line().as_bytes())?;
-                if handle.is_interactive {
-                    writer.flush()?;
-                }
+                write_end_of_line(
+                    &mut writer,
+                    options.end_of_line().as_bytes(),
+                    handle.is_interactive,
+                )?;
                 state.at_line_start = true;
             }
             pos += offset + 1;
         }
+        // We need to flush the buffer each time around the loop in order to pass GNU tests.
+        // When we are reading the input from a pipe, the `handle.reader.read` call at the top
+        // of this loop will block (indefinitely) whist waiting for more data. The expectation
+        // however is that anything that's ready for output should show up in the meantime,
+        // and not be buffered internally to the `cat` process.
+        // Hence it's necessary to flush our buffer before every time we could potentially block
+        // on a `std::io::Read::read` call.
+        writer.flush()?;
     }
 
     Ok(())
 }
 
+// \r followed by \n is printed as ^M when show_ends is enabled, so that \r\n prints as ^M$
+fn write_new_line<W: Write>(
+    writer: &mut W,
+    options: &OutputOptions,
+    state: &mut OutputState,
+    is_interactive: bool,
+) -> CatResult<()> {
+    if state.skipped_carriage_return {
+        if options.show_ends {
+            writer.write_all(b"^M")?;
+        } else {
+            writer.write_all(b"\r")?;
+        }
+        state.skipped_carriage_return = false;
+
+        write_end_of_line(writer, options.end_of_line().as_bytes(), is_interactive)?;
+        return Ok(());
+    }
+    if !state.at_line_start || !options.squeeze_blank || !state.one_blank_kept {
+        state.one_blank_kept = true;
+        if state.at_line_start && options.number == NumberingMode::All {
+            state.line_number.write(writer)?;
+            state.line_number.increment();
+        }
+        write_end_of_line(writer, options.end_of_line().as_bytes(), is_interactive)?;
+    }
+    Ok(())
+}
+
+fn write_end<W: Write>(writer: &mut W, in_buf: &[u8], options: &OutputOptions) -> usize {
+    if options.show_nonprint {
+        write_nonprint_to_end(in_buf, writer, options.tab().as_bytes())
+    } else if options.show_tabs {
+        write_tab_to_end(in_buf, writer)
+    } else {
+        write_to_end(in_buf, writer)
+    }
+}
+
 // write***_to_end methods
 // Write all symbols till \n or \r or end of buffer is reached
 // We need to stop at \r because it may be written as ^M depending on the byte after and settings;
 // however, write_nonprint_to_end doesn't need to stop at \r because it will always write \r as ^M.
 // Return the number of written symbols
 fn write_to_end<W: Write>(in_buf: &[u8], writer: &mut W) -> usize {
-    match in_buf.iter().position(|c| *c == b'\n' || *c == b'\r') {
+    // using memchr2 significantly improves performances
+    match memchr2(b'\n', b'\r', in_buf) {
         Some(p) => {
             writer.write_all(&in_buf[..p]).unwrap();
             p
@@ -569,7 +697,7 @@ fn write_tab_to_end<W: Write>(mut in_buf: &[u8], writer: &mut W) -> usize {
             }
             None => {
                 writer.write_all(in_buf).unwrap();
-                return in_buf.len();
+                return in_buf.len() + count;
             }
         };
     }
@@ -586,10 +714,10 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
             9 => writer.write_all(tab),
             0..=8 | 10..=31 => writer.write_all(&[b'^', byte + 64]),
             32..=126 => writer.write_all(&[byte]),
-            127 => writer.write_all(&[b'^', b'?']),
+            127 => writer.write_all(b"^?"),
             128..=159 => writer.write_all(&[b'M', b'-', b'^', byte - 64]),
             160..=254 => writer.write_all(&[b'M', b'-', byte - 128]),
-            _ => writer.write_all(&[b'M', b'-', b'^', b'?']),
+            _ => writer.write_all(b"M-^?"),
         }
         .unwrap();
         count += 1;
@@ -597,9 +725,35 @@ fn write_nonprint_to_end<W: Write>(in_buf: &[u8], writer: &mut W, tab: &[u8]) ->
     count
 }
 
+fn write_end_of_line<W: Write>(
+    writer: &mut W,
+    end_of_line: &[u8],
+    is_interactive: bool,
+) -> CatResult<()> {
+    writer.write_all(end_of_line)?;
+    if is_interactive {
+        writer.flush()?;
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
-    use std::io::{stdout, BufWriter};
+    use std::io::{BufWriter, stdout};
+
+    #[test]
+    fn test_write_tab_to_end_with_newline() {
+        let mut writer = BufWriter::with_capacity(1024 * 64, stdout());
+        let in_buf = b"a\tb\tc\n";
+        assert_eq!(super::write_tab_to_end(in_buf, &mut writer), 5);
+    }
+
+    #[test]
+    fn test_write_tab_to_end_no_newline() {
+        let mut writer = BufWriter::with_capacity(1024 * 64, stdout());
+        let in_buf = b"a\tb\tc";
+        assert_eq!(super::write_tab_to_end(in_buf, &mut writer), 5);
+    }
 
     #[test]
     fn test_write_nonprint_to_end_new_line() {
@@ -640,4 +794,25 @@ mod tests {
             assert_eq!(writer.buffer(), [b'^', byte + 64]);
         }
     }
+
+    #[test]
+    fn test_incrementing_string() {
+        let mut incrementing_string = super::LineNumber::new();
+        assert_eq!(b"     1\t", incrementing_string.to_str());
+        incrementing_string.increment();
+        assert_eq!(b"     2\t", incrementing_string.to_str());
+        // Run through to 100
+        for _ in 3..=100 {
+            incrementing_string.increment();
+        }
+        assert_eq!(b"   100\t", incrementing_string.to_str());
+        // Run through until we overflow the original size.
+        for _ in 101..=1_000_000 {
+            incrementing_string.increment();
+        }
+        // Confirm that the start position moves when we overflow the original size.
+        assert_eq!(b"1000000\t", incrementing_string.to_str());
+        incrementing_string.increment();
+        assert_eq!(b"1000001\t", incrementing_string.to_str());
+    }
 }
diff --git a/src/uu/cat/src/splice.rs b/src/uu/cat/src/splice.rs
index 5a9e8738ed2..ca5265d2bf8 100644
--- a/src/uu/cat/src/splice.rs
+++ b/src/uu/cat/src/splice.rs
@@ -5,7 +5,7 @@
 use super::{CatResult, FdReadable, InputHandle};
 
 use nix::unistd;
-use std::os::unix::io::{AsRawFd, RawFd};
+use std::os::{fd::AsFd, unix::io::AsRawFd};
 
 use uucore::pipes::{pipe, splice, splice_exact};
 
@@ -20,9 +20,9 @@ const BUF_SIZE: usize = 1024 * 16;
 /// The `bool` in the result value indicates if we need to fall back to normal
 /// copying or not. False means we don't have to.
 #[inline]
-pub(super) fn write_fast_using_splice<R: FdReadable>(
-    handle: &mut InputHandle<R>,
-    write_fd: &impl AsRawFd,
+pub(super) fn write_fast_using_splice<R: FdReadable, S: AsRawFd + AsFd>(
+    handle: &InputHandle<R>,
+    write_fd: &S,
 ) -> CatResult<bool> {
     let (pipe_rd, pipe_wr) = pipe()?;
 
@@ -38,7 +38,7 @@ pub(super) fn write_fast_using_splice<R: FdReadable>(
                     // we can recover by copying the data that we have from the
                     // intermediate pipe to stdout using normal read/write. Then
                     // we tell the caller to fall back.
-                    copy_exact(pipe_rd.as_raw_fd(), write_fd.as_raw_fd(), n)?;
+                    copy_exact(&pipe_rd, write_fd, n)?;
                     return Ok(true);
                 }
             }
@@ -52,7 +52,7 @@ pub(super) fn write_fast_using_splice<R: FdReadable>(
 /// Move exactly `num_bytes` bytes from `read_fd` to `write_fd`.
 ///
 /// Panics if not enough bytes can be read.
-fn copy_exact(read_fd: RawFd, write_fd: RawFd, num_bytes: usize) -> nix::Result<()> {
+fn copy_exact(read_fd: &impl AsFd, write_fd: &impl AsFd, num_bytes: usize) -> nix::Result<()> {
     let mut left = num_bytes;
     let mut buf = [0; BUF_SIZE];
     while left > 0 {
diff --git a/src/uu/chcon/Cargo.toml b/src/uu/chcon/Cargo.toml
index c83c8abfc14..ccf36056339 100644
--- a/src/uu/chcon/Cargo.toml
+++ b/src/uu/chcon/Cargo.toml
@@ -1,14 +1,18 @@
 [package]
 name = "uu_chcon"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "chcon ~ (uutils) change file security context"
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chcon"
 keywords = ["coreutils", "uutils", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/chcon.rs"
diff --git a/src/uu/chcon/src/chcon.rs b/src/uu/chcon/src/chcon.rs
index ec111c853fd..2b1ff2e8f97 100644
--- a/src/uu/chcon/src/chcon.rs
+++ b/src/uu/chcon/src/chcon.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 (vars) RFILE
+#![cfg(target_os = "linux")]
 #![allow(clippy::upper_case_acronyms)]
 
 use clap::builder::ValueParser;
 use uucore::error::{UResult, USimpleError, UUsageError};
 use uucore::{display::Quotable, format_usage, help_about, help_usage, show_error, show_warning};
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use selinux::{OpaqueSecurityContext, SecurityContext};
 
 use std::borrow::Cow;
@@ -149,11 +150,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .disable_help_flag(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::HELP)
                 .long(options::HELP)
@@ -163,7 +165,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::dereference::DEREFERENCE)
                 .long(options::dereference::DEREFERENCE)
-                .conflicts_with(options::dereference::NO_DEREFERENCE)
+                .overrides_with(options::dereference::NO_DEREFERENCE)
                 .help(
                     "Affect the referent of each symbolic link (this is the default), \
                      rather than the symbolic link itself.",
@@ -180,7 +182,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::preserve_root::PRESERVE_ROOT)
                 .long(options::preserve_root::PRESERVE_ROOT)
-                .conflicts_with(options::preserve_root::NO_PRESERVE_ROOT)
+                .overrides_with(options::preserve_root::NO_PRESERVE_ROOT)
                 .help("Fail to operate recursively on '/'.")
                 .action(ArgAction::SetTrue),
         )
@@ -310,7 +312,7 @@ struct Options {
     files: Vec<PathBuf>,
 }
 
-fn parse_command_line(config: clap::Command, args: impl uucore::Args) -> Result<Options> {
+fn parse_command_line(config: Command, args: impl uucore::Args) -> Result<Options> {
     let matches = config.try_get_matches_from(args)?;
 
     let verbose = matches.get_flag(options::VERBOSE);
@@ -606,7 +608,7 @@ fn process_file(
     if result.is_ok() {
         if options.verbose {
             println!(
-                "{}: Changing security context of: {}",
+                "{}: changing security context of {}",
                 uucore::util_name(),
                 file_full_name.quote()
             );
@@ -726,7 +728,7 @@ fn get_root_dev_ino() -> Result<DeviceAndINode> {
 }
 
 fn root_dev_ino_check(root_dev_ino: Option<DeviceAndINode>, dir_dev_ino: DeviceAndINode) -> bool {
-    root_dev_ino.map_or(false, |root_dev_ino| root_dev_ino == dir_dev_ino)
+    root_dev_ino == Some(dir_dev_ino)
 }
 
 fn root_dev_ino_warn(dir_name: &Path) {
@@ -776,7 +778,7 @@ enum SELinuxSecurityContext<'t> {
     String(Option<CString>),
 }
 
-impl<'t> SELinuxSecurityContext<'t> {
+impl SELinuxSecurityContext<'_> {
     fn to_c_string(&self) -> Result<Option<Cow<CStr>>> {
         match self {
             Self::File(context) => context
diff --git a/src/uu/chcon/src/errors.rs b/src/uu/chcon/src/errors.rs
index 10d5735a0c6..b8f720a3920 100644
--- a/src/uu/chcon/src/errors.rs
+++ b/src/uu/chcon/src/errors.rs
@@ -2,6 +2,8 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+#![cfg(target_os = "linux")]
+
 use std::ffi::OsString;
 use std::fmt::Write;
 use std::io;
diff --git a/src/uu/chcon/src/fts.rs b/src/uu/chcon/src/fts.rs
index a81cb39b658..c9a8599fa2a 100644
--- a/src/uu/chcon/src/fts.rs
+++ b/src/uu/chcon/src/fts.rs
@@ -2,11 +2,12 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+#![cfg(target_os = "linux")]
+
 use std::ffi::{CStr, CString, OsStr};
 use std::marker::PhantomData;
 use std::os::raw::{c_int, c_long, c_short};
 use std::path::Path;
-use std::ptr::NonNull;
 use std::{io, iter, ptr, slice};
 
 use crate::errors::{Error, Result};
@@ -69,7 +70,7 @@ impl FTS {
         // pointer assumed to be valid.
         let new_entry = unsafe { fts_sys::fts_read(self.fts.as_ptr()) };
 
-        self.entry = NonNull::new(new_entry);
+        self.entry = ptr::NonNull::new(new_entry);
         if self.entry.is_none() {
             let r = io::Error::last_os_error();
             if let Some(0) = r.raw_os_error() {
@@ -159,7 +160,7 @@ impl<'fts> EntryRef<'fts> {
             return None;
         }
 
-        NonNull::new(entry.fts_path)
+        ptr::NonNull::new(entry.fts_path)
             .map(|path_ptr| {
                 let path_size = usize::from(entry.fts_pathlen).saturating_add(1);
 
diff --git a/src/uu/chcon/src/main.rs b/src/uu/chcon/src/main.rs
index d93d7d1da2b..d1354d840af 100644
--- a/src/uu/chcon/src/main.rs
+++ b/src/uu/chcon/src/main.rs
@@ -1 +1,2 @@
+#![cfg(target_os = "linux")]
 uucore::bin!(uu_chcon);
diff --git a/src/uu/chgrp/Cargo.toml b/src/uu/chgrp/Cargo.toml
index 7f43e846625..7f23eec34d7 100644
--- a/src/uu/chgrp/Cargo.toml
+++ b/src/uu/chgrp/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_chgrp"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "chgrp ~ (uutils) change the group ownership of FILE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chgrp"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/chgrp.rs"
diff --git a/src/uu/chgrp/src/chgrp.rs b/src/uu/chgrp/src/chgrp.rs
index fba2cef1611..1763bbfeb73 100644
--- a/src/uu/chgrp/src/chgrp.rs
+++ b/src/uu/chgrp/src/chgrp.rs
@@ -8,10 +8,10 @@
 use uucore::display::Quotable;
 pub use uucore::entries;
 use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::perms::{chown_base, options, GidUidOwnerFilter, IfFrom};
+use uucore::perms::{GidUidOwnerFilter, IfFrom, chown_base, options};
 use uucore::{format_usage, help_about, help_usage};
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 
 use std::fs;
 use std::os::unix::fs::MetadataExt;
@@ -19,8 +19,26 @@ use std::os::unix::fs::MetadataExt;
 const ABOUT: &str = help_about!("chgrp.md");
 const USAGE: &str = help_usage!("chgrp.md");
 
-fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
-    let mut raw_group: String = String::new();
+fn parse_gid_from_str(group: &str) -> Result<u32, String> {
+    if let Some(gid_str) = group.strip_prefix(':') {
+        // Handle :gid format
+        gid_str
+            .parse::<u32>()
+            .map_err(|_| format!("invalid group id: '{gid_str}'"))
+    } else {
+        // Try as group name first
+        match entries::grp2gid(group) {
+            Ok(g) => Ok(g),
+            // If group name lookup fails, try parsing as raw number
+            Err(_) => group
+                .parse::<u32>()
+                .map_err(|_| format!("invalid group: '{group}'")),
+        }
+    }
+}
+
+fn get_dest_gid(matches: &ArgMatches) -> UResult<(Option<u32>, String)> {
+    let mut raw_group = String::new();
     let dest_gid = if let Some(file) = matches.get_one::<String>(options::REFERENCE) {
         fs::metadata(file)
             .map(|meta| {
@@ -38,22 +56,38 @@ fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
         if group.is_empty() {
             None
         } else {
-            match entries::grp2gid(group) {
+            match parse_gid_from_str(group) {
                 Ok(g) => Some(g),
-                _ => {
-                    return Err(USimpleError::new(
-                        1,
-                        format!("invalid group: {}", group.quote()),
-                    ))
-                }
+                Err(e) => return Err(USimpleError::new(1, e)),
             }
         }
     };
+    Ok((dest_gid, raw_group))
+}
+
+fn parse_gid_and_uid(matches: &ArgMatches) -> UResult<GidUidOwnerFilter> {
+    let (dest_gid, raw_group) = get_dest_gid(matches)?;
+
+    // Handle --from option
+    let filter = if let Some(from_group) = matches.get_one::<String>(options::FROM) {
+        match parse_gid_from_str(from_group) {
+            Ok(g) => IfFrom::Group(g),
+            Err(_) => {
+                return Err(USimpleError::new(
+                    1,
+                    format!("invalid user: '{from_group}'"),
+                ));
+            }
+        }
+    } else {
+        IfFrom::All
+    };
+
     Ok(GidUidOwnerFilter {
         dest_gid,
         dest_uid: None,
         raw_owner: raw_group,
-        filter: IfFrom::All,
+        filter,
     })
 }
 
@@ -64,7 +98,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -73,7 +107,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::HELP)
                 .long(options::HELP)
                 .help("Print help information.")
-                .action(ArgAction::Help)
+                .action(ArgAction::Help),
         )
         .arg(
             Arg::new(options::verbosity::CHANGES)
@@ -101,20 +135,6 @@ pub fn uu_app() -> Command {
                 .help("output a diagnostic for every file processed")
                 .action(ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new(options::dereference::DEREFERENCE)
-                .long(options::dereference::DEREFERENCE)
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-           Arg::new(options::dereference::NO_DEREFERENCE)
-               .short('h')
-               .long(options::dereference::NO_DEREFERENCE)
-               .help(
-                   "affect symbolic links instead of any referenced file (useful only on systems that can change the ownership of a symlink)",
-               )
-               .action(ArgAction::SetTrue),
-        )
         .arg(
             Arg::new(options::preserve_root::PRESERVE)
                 .long(options::preserve_root::PRESERVE)
@@ -134,6 +154,12 @@ pub fn uu_app() -> Command {
                 .value_hint(clap::ValueHint::FilePath)
                 .help("use RFILE's group rather than specifying GROUP values"),
         )
+        .arg(
+            Arg::new(options::FROM)
+                .long(options::FROM)
+                .value_name("GROUP")
+                .help("change the group only if its current group matches GROUP"),
+        )
         .arg(
             Arg::new(options::RECURSIVE)
                 .short('R')
@@ -141,23 +167,6 @@ pub fn uu_app() -> Command {
                 .help("operate on files and directories recursively")
                 .action(ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new(options::traverse::TRAVERSE)
-                .short(options::traverse::TRAVERSE.chars().next().unwrap())
-                .help("if a command line argument is a symbolic link to a directory, traverse it")
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new(options::traverse::NO_TRAVERSE)
-                .short(options::traverse::NO_TRAVERSE.chars().next().unwrap())
-                .help("do not traverse any symbolic links (default)")
-                .overrides_with_all([options::traverse::TRAVERSE, options::traverse::EVERY])
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new(options::traverse::EVERY)
-                .short(options::traverse::EVERY.chars().next().unwrap())
-                .help("traverse every symbolic link to a directory encountered")
-                .action(ArgAction::SetTrue),
-        )
+        // Add common arguments with chgrp, chown & chmod
+        .args(uucore::perms::common_args())
 }
diff --git a/src/uu/chmod/Cargo.toml b/src/uu/chmod/Cargo.toml
index 2a9c73d9db3..09f1c531a90 100644
--- a/src/uu/chmod/Cargo.toml
+++ b/src/uu/chmod/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_chmod"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "chmod ~ (uutils) change mode of FILE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chmod"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/chmod.rs"
@@ -17,7 +20,7 @@ path = "src/chmod.rs"
 [dependencies]
 clap = { workspace = true }
 libc = { workspace = true }
-uucore = { workspace = true, features = ["fs", "mode"] }
+uucore = { workspace = true, features = ["entries", "fs", "mode", "perms"] }
 
 [[bin]]
 name = "chmod"
diff --git a/src/uu/chmod/chmod.md b/src/uu/chmod/chmod.md
index d6c2ed2d8e3..10ddb48a2ed 100644
--- a/src/uu/chmod/chmod.md
+++ b/src/uu/chmod/chmod.md
@@ -13,4 +13,4 @@ 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]+'.
+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 b007bb1d735..dfe30485919 100644
--- a/src/uu/chmod/src/chmod.rs
+++ b/src/uu/chmod/src/chmod.rs
@@ -5,17 +5,18 @@
 
 // spell-checker:ignore (ToDO) Chmoder cmode fmode fperm fref ugoa RFILE RFILE's
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::ffi::OsString;
 use std::fs;
 use std::os::unix::fs::{MetadataExt, PermissionsExt};
 use std::path::Path;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, ExitCode, UResult, USimpleError, UUsageError};
+use uucore::error::{ExitCode, UResult, USimpleError, UUsageError, set_exit_code};
 use uucore::fs::display_permissions_unix;
 use uucore::libc::mode_t;
 #[cfg(not(windows))]
 use uucore::mode;
+use uucore::perms::{TraverseSymlinks, configure_symlink_and_recursion};
 use uucore::{format_usage, help_about, help_section, help_usage, show, show_error};
 
 const ABOUT: &str = help_about!("chmod.md");
@@ -23,6 +24,7 @@ const USAGE: &str = help_usage!("chmod.md");
 const LONG_USAGE: &str = help_section!("after help", "chmod.md");
 
 mod options {
+    pub const HELP: &str = "help";
     pub const CHANGES: &str = "changes";
     pub const QUIET: &str = "quiet"; // visible_alias("silent")
     pub const VERBOSE: &str = "verbose";
@@ -98,15 +100,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let quiet = matches.get_flag(options::QUIET);
     let verbose = matches.get_flag(options::VERBOSE);
     let preserve_root = matches.get_flag(options::PRESERVE_ROOT);
-    let recursive = matches.get_flag(options::RECURSIVE);
     let fmode = match matches.get_one::<String>(options::REFERENCE) {
         Some(fref) => match fs::metadata(fref) {
-            Ok(meta) => Some(meta.mode()),
+            Ok(meta) => Some(meta.mode() & 0o7777),
             Err(err) => {
                 return Err(USimpleError::new(
                     1,
-                    format!("cannot stat attributes of {}: {}", fref.quote(), err),
-                ))
+                    format!("cannot stat attributes of {}: {err}", fref.quote()),
+                ));
             }
         },
         None => None,
@@ -137,6 +138,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         return Err(UUsageError::new(1, "missing operand".to_string()));
     }
 
+    let (recursive, dereference, traverse_symlinks) =
+        configure_symlink_and_recursion(&matches, TraverseSymlinks::First)?;
+
     let chmoder = Chmoder {
         changes,
         quiet,
@@ -145,6 +149,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         recursive,
         fmode,
         cmode,
+        traverse_symlinks,
+        dereference,
     };
 
     chmoder.chmod(&files)
@@ -152,12 +158,19 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .args_override_self(true)
         .infer_long_args(true)
         .no_binary_name(true)
+        .disable_help_flag(true)
+        .arg(
+            Arg::new(options::HELP)
+                .long(options::HELP)
+                .help("Print help information.")
+                .action(ArgAction::Help),
+        )
         .arg(
             Arg::new(options::CHANGES)
                 .long(options::CHANGES)
@@ -206,9 +219,10 @@ pub fn uu_app() -> Command {
                 .help("use RFILE's mode instead of MODE values"),
         )
         .arg(
-            Arg::new(options::MODE).required_unless_present(options::REFERENCE), // It would be nice if clap could parse with delimiter, e.g. "g-x,u+x",
-                                                                                 // however .multiple_occurrences(true) cannot be used here because FILE already needs that.
-                                                                                 // Only one positional argument with .multiple_occurrences(true) set is allowed per command
+            Arg::new(options::MODE).required_unless_present(options::REFERENCE),
+            // It would be nice if clap could parse with delimiter, e.g. "g-x,u+x",
+            // however .multiple_occurrences(true) cannot be used here because FILE already needs that.
+            // Only one positional argument with .multiple_occurrences(true) set is allowed per command
         )
         .arg(
             Arg::new(options::FILE)
@@ -216,6 +230,8 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::Append)
                 .value_hint(clap::ValueHint::AnyPath),
         )
+        // Add common arguments with chgrp, chown & chmod
+        .args(uucore::perms::common_args())
 }
 
 struct Chmoder {
@@ -226,6 +242,8 @@ struct Chmoder {
     recursive: bool,
     fmode: Option<u32>,
     cmode: Option<String>,
+    traverse_symlinks: TraverseSymlinks,
+    dereference: bool,
 }
 
 impl Chmoder {
@@ -237,12 +255,23 @@ impl Chmoder {
             let file = Path::new(filename);
             if !file.exists() {
                 if file.is_symlink() {
+                    if !self.dereference && !self.recursive {
+                        // The file is a symlink and we should not follow it
+                        // Don't try to change the mode of the symlink itself
+                        continue;
+                    }
+                    if self.recursive && self.traverse_symlinks == TraverseSymlinks::None {
+                        continue;
+                    }
+
                     if !self.quiet {
                         show!(USimpleError::new(
                             1,
                             format!("cannot operate on dangling symlink {}", filename.quote()),
                         ));
+                        set_exit_code(1);
                     }
+
                     if self.verbose {
                         println!(
                             "failed to change mode of {} from 0000 (---------) to 1500 (r-x-----T)",
@@ -262,14 +291,19 @@ impl Chmoder {
                 // So we set the exit code, because it hasn't been set yet if `self.quiet` is true.
                 set_exit_code(1);
                 continue;
+            } else if !self.dereference && file.is_symlink() {
+                // The file is a symlink and we should not follow it
+                // chmod 755 --no-dereference a/link
+                // should not change the permissions in this case
+                continue;
             }
             if self.recursive && self.preserve_root && filename == "/" {
                 return Err(USimpleError::new(
                     1,
                     format!(
-                        "it is dangerous to operate recursively on {}\nuse --no-preserve-root to override this failsafe",
+                        "it is dangerous to operate recursively on {}\nchmod: use --no-preserve-root to override this failsafe",
                         filename.quote()
-                    )
+                    ),
                 ));
             }
             if self.recursive {
@@ -283,11 +317,23 @@ impl Chmoder {
 
     fn walk_dir(&self, file_path: &Path) -> UResult<()> {
         let mut r = self.chmod_file(file_path);
-        if !file_path.is_symlink() && file_path.is_dir() {
+        // Determine whether to traverse symlinks based on `self.traverse_symlinks`
+        let should_follow_symlink = match self.traverse_symlinks {
+            TraverseSymlinks::All => true,
+            TraverseSymlinks::First => {
+                file_path == file_path.canonicalize().unwrap_or(file_path.to_path_buf())
+            }
+            TraverseSymlinks::None => false,
+        };
+
+        // If the path is a directory (or we should follow symlinks), recurse into it
+        if (!file_path.is_symlink() || should_follow_symlink) && file_path.is_dir() {
             for dir_entry in file_path.read_dir()? {
                 let path = dir_entry?.path();
                 if !path.is_symlink() {
                     r = self.walk_dir(path.as_path());
+                } else if should_follow_symlink {
+                    r = self.chmod_file(path.as_path()).and(r);
                 }
             }
         }
@@ -303,31 +349,36 @@ impl Chmoder {
     }
     #[cfg(unix)]
     fn chmod_file(&self, file: &Path) -> UResult<()> {
-        use uucore::mode::get_umask;
+        use uucore::{mode::get_umask, perms::get_metadata};
+
+        let metadata = get_metadata(file, self.dereference);
 
-        let fperm = match fs::metadata(file) {
+        let fperm = match metadata {
             Ok(meta) => meta.mode() & 0o7777,
             Err(err) => {
-                if file.is_symlink() {
+                // Handle dangling symlinks or other errors
+                return if file.is_symlink() && !self.dereference {
                     if self.verbose {
                         println!(
                             "neither symbolic link {} nor referent has been changed",
                             file.quote()
                         );
                     }
-                    return Ok(());
+                    Ok(()) // Skip dangling symlinks
                 } else if err.kind() == std::io::ErrorKind::PermissionDenied {
                     // These two filenames would normally be conditionally
                     // quoted, but GNU's tests expect them to always be quoted
-                    return Err(USimpleError::new(
+                    Err(USimpleError::new(
                         1,
                         format!("{}: Permission denied", file.quote()),
-                    ));
+                    ))
                 } else {
-                    return Err(USimpleError::new(1, format!("{}: {}", file.quote(), err)));
-                }
+                    Err(USimpleError::new(1, format!("{}: {err}", file.quote())))
+                };
             }
         };
+
+        // Determine the new permissions to apply
         match self.fmode {
             Some(mode) => self.change_file(fperm, mode, file)?,
             None => {
@@ -335,9 +386,7 @@ impl Chmoder {
                 let mut new_mode = fperm;
                 let mut naively_expected_new_mode = new_mode;
                 for mode in cmode_unwrapped.split(',') {
-                    // cmode is guaranteed to be Some in this case
-                    let arr: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-                    let result = if mode.contains(arr) {
+                    let result = if mode.chars().any(|c| c.is_ascii_digit()) {
                         mode::parse_numeric(new_mode, mode, file.is_dir()).map(|v| (v, v))
                     } else {
                         mode::parse_symbolic(new_mode, mode, get_umask(), file.is_dir()).map(|m| {
@@ -352,20 +401,22 @@ impl Chmoder {
                             (m, naive_mode)
                         })
                     };
+
                     match result {
                         Ok((mode, naive_mode)) => {
                             new_mode = mode;
                             naively_expected_new_mode = naive_mode;
                         }
                         Err(f) => {
-                            if self.quiet {
-                                return Err(ExitCode::new(1));
+                            return if self.quiet {
+                                Err(ExitCode::new(1))
                             } else {
-                                return Err(USimpleError::new(1, f));
-                            }
+                                Err(USimpleError::new(1, f))
+                            };
                         }
                     }
                 }
+
                 self.change_file(fperm, new_mode, file)?;
                 // if a permission would have been removed if umask was 0, but it wasn't because umask was not 0, print an error and fail
                 if (new_mode & !naively_expected_new_mode) != 0 {
@@ -390,24 +441,21 @@ impl Chmoder {
         if fperm == mode {
             if self.verbose && !self.changes {
                 println!(
-                    "mode of {} retained as {:04o} ({})",
+                    "mode of {} retained as {fperm:04o} ({})",
                     file.quote(),
-                    fperm,
                     display_permissions_unix(fperm as mode_t, false),
                 );
             }
             Ok(())
         } else if let Err(err) = fs::set_permissions(file, fs::Permissions::from_mode(mode)) {
             if !self.quiet {
-                show_error!("{}", err);
+                show_error!("{err}");
             }
             if self.verbose {
                 println!(
-                    "failed to change mode of file {} from {:04o} ({}) to {:04o} ({})",
+                    "failed to change mode of file {} from {fperm:04o} ({}) to {mode:04o} ({})",
                     file.quote(),
-                    fperm,
                     display_permissions_unix(fperm as mode_t, false),
-                    mode,
                     display_permissions_unix(mode as mode_t, false)
                 );
             }
@@ -415,11 +463,9 @@ impl Chmoder {
         } else {
             if self.verbose || self.changes {
                 println!(
-                    "mode of {} changed from {:04o} ({}) to {:04o} ({})",
+                    "mode of {} changed from {fperm:04o} ({}) to {mode:04o} ({})",
                     file.quote(),
-                    fperm,
                     display_permissions_unix(fperm as mode_t, false),
-                    mode,
                     display_permissions_unix(mode as mode_t, false)
                 );
             }
diff --git a/src/uu/chown/Cargo.toml b/src/uu/chown/Cargo.toml
index 82b32875d65..dcf7c445412 100644
--- a/src/uu/chown/Cargo.toml
+++ b/src/uu/chown/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_chown"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "chown ~ (uutils) change the ownership of FILE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chown"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/chown.rs"
diff --git a/src/uu/chown/src/chown.rs b/src/uu/chown/src/chown.rs
index 8e97d565242..4389d92f663 100644
--- a/src/uu/chown/src/chown.rs
+++ b/src/uu/chown/src/chown.rs
@@ -7,12 +7,12 @@
 
 use uucore::display::Quotable;
 pub use uucore::entries::{self, Group, Locate, Passwd};
-use uucore::perms::{chown_base, options, GidUidOwnerFilter, IfFrom};
+use uucore::perms::{GidUidOwnerFilter, IfFrom, chown_base, options};
 use uucore::{format_usage, help_about, help_usage};
 
 use uucore::error::{FromIo, UResult, USimpleError};
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 
 use std::fs;
 use std::os::unix::fs::MetadataExt;
@@ -78,7 +78,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -96,25 +96,6 @@ pub fn uu_app() -> Command {
                 .help("like verbose but report only when a change is made")
                 .action(ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new(options::dereference::DEREFERENCE)
-                .long(options::dereference::DEREFERENCE)
-                .help(
-                    "affect the referent of each symbolic link (this is the default), \
-                    rather than the symbolic link itself",
-                )
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new(options::dereference::NO_DEREFERENCE)
-                .short('h')
-                .long(options::dereference::NO_DEREFERENCE)
-                .help(
-                    "affect symbolic links instead of any referenced file \
-                    (useful only on systems that can change the ownership of a symlink)",
-                )
-                .action(ArgAction::SetTrue),
-        )
         .arg(
             Arg::new(options::FROM)
                 .long(options::FROM)
@@ -165,27 +146,6 @@ pub fn uu_app() -> Command {
                 .long(options::verbosity::SILENT)
                 .action(ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new(options::traverse::TRAVERSE)
-                .short(options::traverse::TRAVERSE.chars().next().unwrap())
-                .help("if a command line argument is a symbolic link to a directory, traverse it")
-                .overrides_with_all([options::traverse::EVERY, options::traverse::NO_TRAVERSE])
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new(options::traverse::EVERY)
-                .short(options::traverse::EVERY.chars().next().unwrap())
-                .help("traverse every symbolic link to a directory encountered")
-                .overrides_with_all([options::traverse::TRAVERSE, options::traverse::NO_TRAVERSE])
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new(options::traverse::NO_TRAVERSE)
-                .short(options::traverse::NO_TRAVERSE.chars().next().unwrap())
-                .help("do not traverse any symbolic links (default)")
-                .overrides_with_all([options::traverse::TRAVERSE, options::traverse::EVERY])
-                .action(ArgAction::SetTrue),
-        )
         .arg(
             Arg::new(options::verbosity::VERBOSE)
                 .long(options::verbosity::VERBOSE)
@@ -193,6 +153,55 @@ pub fn uu_app() -> Command {
                 .help("output a diagnostic for every file processed")
                 .action(ArgAction::SetTrue),
         )
+        // Add common arguments with chgrp, chown & chmod
+        .args(uucore::perms::common_args())
+}
+
+/// Parses the user string to extract the UID.
+fn parse_uid(user: &str, spec: &str, sep: char) -> UResult<Option<u32>> {
+    if user.is_empty() {
+        return Ok(None);
+    }
+    match Passwd::locate(user) {
+        Ok(u) => Ok(Some(u.uid)), // We have been able to get the uid
+        Err(_) => {
+            // we have NOT been able to find the uid
+            // but we could be in the case where we have user.group
+            if spec.contains('.') && !spec.contains(':') && sep == ':' {
+                // but the input contains a '.' but not a ':'
+                // we might have something like username.groupname
+                // So, try to parse it this way
+                parse_spec(spec, '.').map(|(uid, _)| uid)
+            } else {
+                // It's possible that the `user` string contains a
+                // numeric user ID, in which case, we respect that.
+                match user.parse() {
+                    Ok(uid) => Ok(Some(uid)),
+                    Err(_) => Err(USimpleError::new(
+                        1,
+                        format!("invalid user: {}", spec.quote()),
+                    )),
+                }
+            }
+        }
+    }
+}
+
+/// Parses the group string to extract the GID.
+fn parse_gid(group: &str, spec: &str) -> UResult<Option<u32>> {
+    if group.is_empty() {
+        return Ok(None);
+    }
+    match Group::locate(group) {
+        Ok(g) => Ok(Some(g.gid)),
+        Err(_) => match group.parse() {
+            Ok(gid) => Ok(Some(gid)),
+            Err(_) => Err(USimpleError::new(
+                1,
+                format!("invalid group: {}", spec.quote()),
+            )),
+        },
+    }
 }
 
 /// Parse the owner/group specifier string into a user ID and a group ID.
@@ -213,52 +222,8 @@ 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() {
-        None
-    } else {
-        Some(match Passwd::locate(user) {
-            Ok(u) => u.uid, // We have been able to get the uid
-            Err(_) =>
-            // we have NOT been able to find the uid
-            // but we could be in the case where we have user.group
-            {
-                if spec.contains('.') && !spec.contains(':') && sep == ':' {
-                    // but the input contains a '.' but not a ':'
-                    // we might have something like username.groupname
-                    // So, try to parse it this way
-                    return parse_spec(spec, '.');
-                } else {
-                    // It's possible that the `user` string contains a
-                    // numeric user ID, in which case, we respect that.
-                    match user.parse() {
-                        Ok(uid) => uid,
-                        Err(_) => {
-                            return Err(USimpleError::new(
-                                1,
-                                format!("invalid user: {}", spec.quote()),
-                            ))
-                        }
-                    }
-                }
-            }
-        })
-    };
-    let gid = if group.is_empty() {
-        None
-    } else {
-        Some(match Group::locate(group) {
-            Ok(g) => g.gid,
-            Err(_) => match group.parse() {
-                Ok(gid) => gid,
-                Err(_) => {
-                    return Err(USimpleError::new(
-                        1,
-                        format!("invalid group: {}", spec.quote()),
-                    ));
-                }
-            },
-        })
-    };
+    let uid = parse_uid(user, spec, sep)?;
+    let gid = parse_gid(group, spec)?;
 
     if user.chars().next().map(char::is_numeric).unwrap_or(false)
         && group.is_empty()
diff --git a/src/uu/chroot/Cargo.toml b/src/uu/chroot/Cargo.toml
index 3c836add869..4d302d95f06 100644
--- a/src/uu/chroot/Cargo.toml
+++ b/src/uu/chroot/Cargo.toml
@@ -1,21 +1,25 @@
 [package]
 name = "uu_chroot"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "chroot ~ (uutils) run COMMAND under a new root directory"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/chroot"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/chroot.rs"
 
 [dependencies]
 clap = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true, features = ["entries", "fs"] }
 
 [[bin]]
diff --git a/src/uu/chroot/src/chroot.rs b/src/uu/chroot/src/chroot.rs
index 6366775c36d..15c7bac4d8d 100644
--- a/src/uu/chroot/src/chroot.rs
+++ b/src/uu/chroot/src/chroot.rs
@@ -7,51 +7,172 @@
 mod error;
 
 use crate::error::ChrootError;
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::ffi::CString;
 use std::io::Error;
 use std::os::unix::prelude::OsStrExt;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process;
-use uucore::error::{set_exit_code, UClapError, UResult, UUsageError};
-use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
+use uucore::entries::{Locate, Passwd, grp2gid, usr2uid};
+use uucore::error::{UClapError, UResult, UUsageError, set_exit_code};
+use uucore::fs::{MissingHandling, ResolveMode, canonicalize};
 use uucore::libc::{self, chroot, setgid, setgroups, setuid};
-use uucore::{entries, format_usage, help_about, help_usage};
+use uucore::{format_usage, help_about, help_usage, show};
 
 static ABOUT: &str = help_about!("chroot.md");
 static USAGE: &str = help_usage!("chroot.md");
 
 mod options {
     pub const NEWROOT: &str = "newroot";
-    pub const USER: &str = "user";
-    pub const GROUP: &str = "group";
     pub const GROUPS: &str = "groups";
     pub const USERSPEC: &str = "userspec";
     pub const COMMAND: &str = "command";
     pub const SKIP_CHDIR: &str = "skip-chdir";
 }
 
+/// A user and group specification, where each is optional.
+enum UserSpec {
+    NeitherGroupNorUser,
+    UserOnly(String),
+    GroupOnly(String),
+    UserAndGroup(String, String),
+}
+
+struct Options {
+    /// Path to the new root directory.
+    newroot: PathBuf,
+    /// Whether to change to the new root directory.
+    skip_chdir: bool,
+    /// List of groups under which the command will be run.
+    groups: Option<Vec<String>>,
+    /// The user and group (each optional) under which the command will be run.
+    userspec: Option<UserSpec>,
+}
+
+/// Parse a user and group from the argument to `--userspec`.
+///
+/// The `spec` must be of the form `[USER][:[GROUP]]`, otherwise an
+/// error is returned.
+fn parse_userspec(spec: &str) -> UserSpec {
+    match spec.split_once(':') {
+        // ""
+        None if spec.is_empty() => UserSpec::NeitherGroupNorUser,
+        // "usr"
+        None => UserSpec::UserOnly(spec.to_string()),
+        // ":"
+        Some(("", "")) => UserSpec::NeitherGroupNorUser,
+        // ":grp"
+        Some(("", grp)) => UserSpec::GroupOnly(grp.to_string()),
+        // "usr:"
+        Some((usr, "")) => UserSpec::UserOnly(usr.to_string()),
+        // "usr:grp"
+        Some((usr, grp)) => UserSpec::UserAndGroup(usr.to_string(), grp.to_string()),
+    }
+}
+
+// Pre-condition: `list_str` is non-empty.
+fn parse_group_list(list_str: &str) -> Result<Vec<String>, ChrootError> {
+    let split: Vec<&str> = list_str.split(',').collect();
+    if split.len() == 1 {
+        let name = split[0].trim();
+        if name.is_empty() {
+            // --groups=" "
+            // chroot: invalid group ‘ ’
+            Err(ChrootError::InvalidGroup(name.to_string()))
+        } else {
+            // --groups="blah"
+            Ok(vec![name.to_string()])
+        }
+    } else if split.iter().all(|s| s.is_empty()) {
+        // --groups=","
+        // chroot: invalid group list ‘,’
+        Err(ChrootError::InvalidGroupList(list_str.to_string()))
+    } else {
+        let mut result = vec![];
+        let mut err = false;
+        for name in split {
+            let trimmed_name = name.trim();
+            if trimmed_name.is_empty() {
+                if name.is_empty() {
+                    // --groups=","
+                    continue;
+                } else {
+                    // --groups=", "
+                    // chroot: invalid group ‘ ’
+                    show!(ChrootError::InvalidGroup(name.to_string()));
+                    err = true;
+                }
+            } else {
+                // TODO Figure out a better condition here.
+                if trimmed_name.starts_with(char::is_numeric)
+                    && trimmed_name.ends_with(|c: char| !c.is_numeric())
+                {
+                    // --groups="0trail"
+                    // chroot: invalid group ‘0trail’
+                    show!(ChrootError::InvalidGroup(name.to_string()));
+                    err = true;
+                } else {
+                    result.push(trimmed_name.to_string());
+                }
+            }
+        }
+        if err {
+            Err(ChrootError::GroupsParsingFailed)
+        } else {
+            Ok(result)
+        }
+    }
+}
+
+impl Options {
+    /// Parse parameters from the command-line arguments.
+    fn from(matches: &clap::ArgMatches) -> UResult<Self> {
+        let newroot = match matches.get_one::<String>(options::NEWROOT) {
+            Some(v) => Path::new(v).to_path_buf(),
+            None => return Err(ChrootError::MissingNewRoot.into()),
+        };
+        let groups = match matches.get_one::<String>(options::GROUPS) {
+            None => None,
+            Some(s) => {
+                if s.is_empty() {
+                    Some(vec![])
+                } else {
+                    Some(parse_group_list(s)?)
+                }
+            }
+        };
+        let skip_chdir = matches.get_flag(options::SKIP_CHDIR);
+        let userspec = matches
+            .get_one::<String>(options::USERSPEC)
+            .map(|s| parse_userspec(s));
+        Ok(Self {
+            newroot,
+            skip_chdir,
+            groups,
+            userspec,
+        })
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     let default_shell: &'static str = "/bin/sh";
     let default_option: &'static str = "-i";
     let user_shell = std::env::var("SHELL");
 
-    let newroot: &Path = match matches.get_one::<String>(options::NEWROOT) {
-        Some(v) => Path::new(v),
-        None => return Err(ChrootError::MissingNewRoot.into()),
-    };
+    let options = Options::from(&matches)?;
 
-    let skip_chdir = matches.get_flag(options::SKIP_CHDIR);
     // We are resolving the path in case it is a symlink or /. or /../
-    if skip_chdir
-        && canonicalize(newroot, MissingHandling::Normal, ResolveMode::Logical)
-            .unwrap()
-            .to_str()
+    if options.skip_chdir
+        && canonicalize(
+            &options.newroot,
+            MissingHandling::Normal,
+            ResolveMode::Logical,
+        )
+        .unwrap()
+        .to_str()
             != Some("/")
     {
         return Err(UUsageError::new(
@@ -60,8 +181,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     }
 
-    if !newroot.is_dir() {
-        return Err(ChrootError::NoSuchDirectory(format!("{}", newroot.display())).into());
+    if !options.newroot.is_dir() {
+        return Err(ChrootError::NoSuchDirectory(format!("{}", options.newroot.display())).into());
     }
 
     let commands = match matches.get_many::<String>(options::COMMAND) {
@@ -87,7 +208,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let chroot_args = &command[1..];
 
     // NOTE: Tests can only trigger code beyond this point if they're invoked with root permissions
-    set_context(newroot, &matches)?;
+    set_context(&options)?;
 
     let pstatus = match process::Command::new(chroot_command)
         .args(chroot_args)
@@ -100,7 +221,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             } else {
                 ChrootError::CommandFailed(command[0].to_string(), e)
             }
-            .into())
+            .into());
         }
     };
 
@@ -115,7 +236,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -127,35 +248,17 @@ pub fn uu_app() -> Command {
                 .required(true)
                 .index(1),
         )
-        .arg(
-            Arg::new(options::USER)
-                .short('u')
-                .long(options::USER)
-                .help("User (ID or name) to switch before running the program")
-                .value_name("USER"),
-        )
-        .arg(
-            Arg::new(options::GROUP)
-                .short('g')
-                .long(options::GROUP)
-                .help("Group (ID or name) to switch to")
-                .value_name("GROUP"),
-        )
         .arg(
             Arg::new(options::GROUPS)
-                .short('G')
                 .long(options::GROUPS)
+                .overrides_with(options::GROUPS)
                 .help("Comma-separated list of groups to switch to")
                 .value_name("GROUP1,GROUP2..."),
         )
         .arg(
             Arg::new(options::USERSPEC)
                 .long(options::USERSPEC)
-                .help(
-                    "Colon-separated user and group to switch to. \
-                     Same as -u USER -g GROUP. \
-                     Userspec has higher preference than -u and/or -g",
-                )
+                .help("Colon-separated user and group to switch to.")
                 .value_name("USER:GROUP"),
         )
         .arg(
@@ -177,119 +280,178 @@ pub fn uu_app() -> Command {
         )
 }
 
-fn set_context(root: &Path, options: &clap::ArgMatches) -> UResult<()> {
-    let userspec_str = options.get_one::<String>(options::USERSPEC);
-    let user_str = options
-        .get_one::<String>(options::USER)
-        .map(|s| s.as_str())
-        .unwrap_or_default();
-    let group_str = options
-        .get_one::<String>(options::GROUP)
-        .map(|s| s.as_str())
-        .unwrap_or_default();
-    let groups_str = options
-        .get_one::<String>(options::GROUPS)
-        .map(|s| s.as_str())
-        .unwrap_or_default();
-    let skip_chdir = options.contains_id(options::SKIP_CHDIR);
-    let userspec = match userspec_str {
-        Some(u) => {
-            let s: Vec<&str> = u.split(':').collect();
-            if s.len() != 2 || s.iter().any(|&spec| spec.is_empty()) {
-                return Err(ChrootError::InvalidUserspec(u.to_string()).into());
-            };
-            s
-        }
-        None => Vec::new(),
-    };
-
-    let (user, group) = if userspec.is_empty() {
-        (user_str, group_str)
-    } else {
-        (userspec[0], userspec[1])
-    };
+/// Get the UID for the given username, falling back to numeric parsing.
+///
+/// According to the documentation of GNU `chroot`, "POSIX requires that
+/// these commands first attempt to resolve the specified string as a
+/// name, and only once that fails, then try to interpret it as an ID."
+fn name_to_uid(name: &str) -> Result<libc::uid_t, ChrootError> {
+    match usr2uid(name) {
+        Ok(uid) => Ok(uid),
+        Err(_) => name
+            .parse::<libc::uid_t>()
+            .map_err(|_| ChrootError::NoSuchUser),
+    }
+}
 
-    enter_chroot(root, skip_chdir)?;
+/// Get the GID for the given group name, falling back to numeric parsing.
+///
+/// According to the documentation of GNU `chroot`, "POSIX requires that
+/// these commands first attempt to resolve the specified string as a
+/// name, and only once that fails, then try to interpret it as an ID."
+fn name_to_gid(name: &str) -> Result<libc::gid_t, ChrootError> {
+    match grp2gid(name) {
+        Ok(gid) => Ok(gid),
+        Err(_) => name
+            .parse::<libc::gid_t>()
+            .map_err(|_| ChrootError::NoSuchGroup),
+    }
+}
 
-    set_groups_from_str(groups_str)?;
-    set_main_group(group)?;
-    set_user(user)?;
-    Ok(())
+/// Get the list of group IDs for the given user.
+///
+/// According to the GNU documentation, "the supplementary groups are
+/// set according to the system defined list for that user". This
+/// function gets that list.
+fn supplemental_gids(uid: libc::uid_t) -> Vec<libc::gid_t> {
+    match Passwd::locate(uid) {
+        Err(_) => vec![],
+        Ok(passwd) => passwd.belongs_to(),
+    }
 }
 
-fn enter_chroot(root: &Path, skip_chdir: bool) -> UResult<()> {
-    let err = unsafe {
-        chroot(
-            CString::new(root.as_os_str().as_bytes().to_vec())
-                .unwrap()
-                .as_bytes_with_nul()
-                .as_ptr() as *const libc::c_char,
-        )
-    };
+/// Set the supplemental group IDs for this process.
+fn set_supplemental_gids(gids: &[libc::gid_t]) -> std::io::Result<()> {
+    #[cfg(any(target_vendor = "apple", target_os = "freebsd", target_os = "openbsd"))]
+    let n = gids.len() as libc::c_int;
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    let n = gids.len() as libc::size_t;
+    let err = unsafe { setgroups(n, gids.as_ptr()) };
+    if err == 0 {
+        Ok(())
+    } else {
+        Err(Error::last_os_error())
+    }
+}
 
+/// Set the group ID of this process.
+fn set_gid(gid: libc::gid_t) -> std::io::Result<()> {
+    let err = unsafe { setgid(gid) };
     if err == 0 {
-        if !skip_chdir {
-            std::env::set_current_dir(root).unwrap();
-        }
         Ok(())
     } else {
-        Err(ChrootError::CannotEnter(format!("{}", root.display()), Error::last_os_error()).into())
+        Err(Error::last_os_error())
     }
 }
 
-fn set_main_group(group: &str) -> UResult<()> {
-    if !group.is_empty() {
-        let group_id = match entries::grp2gid(group) {
-            Ok(g) => g,
-            _ => return Err(ChrootError::NoSuchGroup(group.to_string()).into()),
-        };
-        let err = unsafe { setgid(group_id) };
-        if err != 0 {
-            return Err(
-                ChrootError::SetGidFailed(group_id.to_string(), Error::last_os_error()).into(),
-            );
-        }
+/// Set the user ID of this process.
+fn set_uid(uid: libc::uid_t) -> std::io::Result<()> {
+    let err = unsafe { setuid(uid) };
+    if err == 0 {
+        Ok(())
+    } else {
+        Err(Error::last_os_error())
     }
-    Ok(())
 }
 
-#[cfg(any(target_vendor = "apple", target_os = "freebsd"))]
-fn set_groups(groups: &[libc::gid_t]) -> libc::c_int {
-    unsafe { setgroups(groups.len() as libc::c_int, groups.as_ptr()) }
+/// What to do when the `--groups` argument is missing.
+enum Strategy {
+    /// Do nothing.
+    Nothing,
+    /// Use the list of supplemental groups for the given user.
+    ///
+    /// If the `bool` parameter is `false` and the list of groups for
+    /// the given user is empty, then this will result in an error.
+    FromUID(libc::uid_t, bool),
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
-fn set_groups(groups: &[libc::gid_t]) -> libc::c_int {
-    unsafe { setgroups(groups.len() as libc::size_t, groups.as_ptr()) }
+/// Set supplemental groups when the `--groups` argument is not specified.
+fn handle_missing_groups(strategy: Strategy) -> Result<(), ChrootError> {
+    match strategy {
+        Strategy::Nothing => Ok(()),
+        Strategy::FromUID(uid, false) => {
+            let gids = supplemental_gids(uid);
+            if gids.is_empty() {
+                Err(ChrootError::NoGroupSpecified(uid))
+            } else {
+                set_supplemental_gids(&gids).map_err(ChrootError::SetGroupsFailed)
+            }
+        }
+        Strategy::FromUID(uid, true) => {
+            let gids = supplemental_gids(uid);
+            set_supplemental_gids(&gids).map_err(ChrootError::SetGroupsFailed)
+        }
+    }
 }
 
-fn set_groups_from_str(groups: &str) -> UResult<()> {
-    if !groups.is_empty() {
-        let mut groups_vec = vec![];
-        for group in groups.split(',') {
-            let gid = match entries::grp2gid(group) {
-                Ok(g) => g,
-                Err(_) => return Err(ChrootError::NoSuchGroup(group.to_string()).into()),
-            };
-            groups_vec.push(gid);
+/// Set supplemental groups for this process.
+fn set_supplemental_gids_with_strategy(
+    strategy: Strategy,
+    groups: Option<&Vec<String>>,
+) -> Result<(), ChrootError> {
+    match groups {
+        None => handle_missing_groups(strategy),
+        Some(groups) => {
+            let mut gids = vec![];
+            for group in groups {
+                gids.push(name_to_gid(group)?);
+            }
+            set_supplemental_gids(&gids).map_err(ChrootError::SetGroupsFailed)
+        }
+    }
+}
+
+/// Change the root, set the user ID, and set the group IDs for this process.
+fn set_context(options: &Options) -> UResult<()> {
+    enter_chroot(&options.newroot, options.skip_chdir)?;
+    match &options.userspec {
+        None | Some(UserSpec::NeitherGroupNorUser) => {
+            let strategy = Strategy::Nothing;
+            set_supplemental_gids_with_strategy(strategy, options.groups.as_ref())?;
         }
-        let err = set_groups(&groups_vec);
-        if err != 0 {
-            return Err(ChrootError::SetGroupsFailed(Error::last_os_error()).into());
+        Some(UserSpec::UserOnly(user)) => {
+            let uid = name_to_uid(user)?;
+            let gid = uid as libc::gid_t;
+            let strategy = Strategy::FromUID(uid, false);
+            set_supplemental_gids_with_strategy(strategy, options.groups.as_ref())?;
+            set_gid(gid).map_err(|e| ChrootError::SetGidFailed(user.to_string(), e))?;
+            set_uid(uid).map_err(|e| ChrootError::SetUserFailed(user.to_string(), e))?;
+        }
+        Some(UserSpec::GroupOnly(group)) => {
+            let gid = name_to_gid(group)?;
+            let strategy = Strategy::Nothing;
+            set_supplemental_gids_with_strategy(strategy, options.groups.as_ref())?;
+            set_gid(gid).map_err(|e| ChrootError::SetGidFailed(group.to_string(), e))?;
+        }
+        Some(UserSpec::UserAndGroup(user, group)) => {
+            let uid = name_to_uid(user)?;
+            let gid = name_to_gid(group)?;
+            let strategy = Strategy::FromUID(uid, true);
+            set_supplemental_gids_with_strategy(strategy, options.groups.as_ref())?;
+            set_gid(gid).map_err(|e| ChrootError::SetGidFailed(group.to_string(), e))?;
+            set_uid(uid).map_err(|e| ChrootError::SetUserFailed(user.to_string(), e))?;
         }
     }
     Ok(())
 }
 
-fn set_user(user: &str) -> UResult<()> {
-    if !user.is_empty() {
-        let user_id = entries::usr2uid(user).unwrap();
-        let err = unsafe { setuid(user_id as libc::uid_t) };
-        if err != 0 {
-            return Err(
-                ChrootError::SetUserFailed(user.to_string(), Error::last_os_error()).into(),
-            );
+fn enter_chroot(root: &Path, skip_chdir: bool) -> UResult<()> {
+    let err = unsafe {
+        chroot(
+            CString::new(root.as_os_str().as_bytes().to_vec())
+                .map_err(|e| ChrootError::CannotEnter("root".to_string(), e.into()))?
+                .as_bytes_with_nul()
+                .as_ptr()
+                .cast::<libc::c_char>(),
+        )
+    };
+
+    if err == 0 {
+        if !skip_chdir {
+            std::env::set_current_dir("/")?;
         }
+        Ok(())
+    } else {
+        Err(ChrootError::CannotEnter(format!("{}", root.display()), Error::last_os_error()).into())
     }
-    Ok(())
 }
diff --git a/src/uu/chroot/src/error.rs b/src/uu/chroot/src/error.rs
index 526f1a75a43..78fd7ad64e7 100644
--- a/src/uu/chroot/src/error.rs
+++ b/src/uu/chroot/src/error.rs
@@ -4,47 +4,71 @@
 // file that was distributed with this source code.
 // spell-checker:ignore NEWROOT Userspec userspec
 //! Errors returned by chroot.
-use std::fmt::Display;
 use std::io::Error;
+use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::UError;
+use uucore::libc;
 
 /// Errors that can happen while executing chroot.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum ChrootError {
     /// Failed to enter the specified directory.
-    CannotEnter(String, Error),
+    #[error("cannot chroot to {dir}: {err}", dir = .0.quote(), err = .1)]
+    CannotEnter(String, #[source] Error),
 
     /// Failed to execute the specified command.
-    CommandFailed(String, Error),
+    #[error("failed to run command {cmd}: {err}", cmd = .0.to_string().quote(), err = .1)]
+    CommandFailed(String, #[source] Error),
 
     /// Failed to find the specified command.
-    CommandNotFound(String, Error),
+    #[error("failed to run command {cmd}: {err}", cmd = .0.to_string().quote(), err = .1)]
+    CommandNotFound(String, #[source] Error),
 
-    /// The given user and group specification was invalid.
-    InvalidUserspec(String),
+    #[error("--groups parsing failed")]
+    GroupsParsingFailed,
+
+    #[error("invalid group: {group}", group = .0.quote())]
+    InvalidGroup(String),
+
+    #[error("invalid group list: {list}", list = .0.quote())]
+    InvalidGroupList(String),
 
     /// The new root directory was not given.
+    #[error(
+        "Missing operand: NEWROOT\nTry '{0} --help' for more information.",
+        uucore::execution_phrase()
+    )]
     MissingNewRoot,
 
+    #[error("no group specified for unknown uid: {0}")]
+    NoGroupSpecified(libc::uid_t),
+
+    /// Failed to find the specified user.
+    #[error("invalid user")]
+    NoSuchUser,
+
     /// Failed to find the specified group.
-    NoSuchGroup(String),
+    #[error("invalid group")]
+    NoSuchGroup,
 
     /// The given directory does not exist.
+    #[error("cannot change root directory to {dir}: no such directory", dir = .0.quote())]
     NoSuchDirectory(String),
 
     /// The call to `setgid()` failed.
-    SetGidFailed(String, Error),
+    #[error("cannot set gid to {gid}: {err}", gid = .0, err = .1)]
+    SetGidFailed(String, #[source] Error),
 
     /// The call to `setgroups()` failed.
+    #[error("cannot set groups: {0}")]
     SetGroupsFailed(Error),
 
     /// The call to `setuid()` failed.
-    SetUserFailed(String, Error),
+    #[error("cannot set user to {user}: {err}", user = .0.maybe_quote(), err = .1)]
+    SetUserFailed(String, #[source] Error),
 }
 
-impl std::error::Error for ChrootError {}
-
 impl UError for ChrootError {
     // 125 if chroot itself fails
     // 126 if command is found but cannot be invoked
@@ -57,31 +81,3 @@ impl UError for ChrootError {
         }
     }
 }
-
-impl Display for ChrootError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Self::CannotEnter(s, e) => write!(f, "cannot chroot to {}: {}", s.quote(), e,),
-            Self::CommandFailed(s, e) | Self::CommandNotFound(s, e) => {
-                write!(f, "failed to run command {}: {}", s.to_string().quote(), e,)
-            }
-            Self::InvalidUserspec(s) => write!(f, "invalid userspec: {}", s.quote(),),
-            Self::MissingNewRoot => write!(
-                f,
-                "Missing operand: NEWROOT\nTry '{} --help' for more information.",
-                uucore::execution_phrase(),
-            ),
-            Self::NoSuchGroup(s) => write!(f, "no such group: {}", s.maybe_quote(),),
-            Self::NoSuchDirectory(s) => write!(
-                f,
-                "cannot change root directory to {}: no such directory",
-                s.quote(),
-            ),
-            Self::SetGidFailed(s, e) => write!(f, "cannot set gid to {s}: {e}"),
-            Self::SetGroupsFailed(e) => write!(f, "cannot set groups: {e}"),
-            Self::SetUserFailed(s, e) => {
-                write!(f, "cannot set user to {}: {}", s.maybe_quote(), e)
-            }
-        }
-    }
-}
diff --git a/src/uu/cksum/Cargo.toml b/src/uu/cksum/Cargo.toml
index 49a881f706f..c49288aa9d4 100644
--- a/src/uu/cksum/Cargo.toml
+++ b/src/uu/cksum/Cargo.toml
@@ -1,23 +1,27 @@
 [package]
 name = "uu_cksum"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "cksum ~ (uutils) display CRC and size of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cksum"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/cksum.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["sum"] }
+uucore = { workspace = true, features = ["checksum", "encoding", "sum"] }
 hex = { workspace = true }
+regex = { workspace = true }
 
 [[bin]]
 name = "cksum"
diff --git a/src/uu/cksum/cksum.md b/src/uu/cksum/cksum.md
index 4b0d25f32c3..5ca83b40150 100644
--- a/src/uu/cksum/cksum.md
+++ b/src/uu/cksum/cksum.md
@@ -13,6 +13,7 @@ DIGEST determines the digest algorithm and default output format:
 - `sysv`:    (equivalent to sum -s)
 - `bsd`:     (equivalent to sum -r)
 - `crc`:     (equivalent to cksum)
+- `crc32b`:  (only available through cksum)
 - `md5`:     (equivalent to md5sum)
 - `sha1`:    (equivalent to sha1sum)
 - `sha224`:  (equivalent to sha224sum)
diff --git a/src/uu/cksum/src/cksum.rs b/src/uu/cksum/src/cksum.rs
index 6c9c795821b..a1a9115d9a0 100644
--- a/src/uu/cksum/src/cksum.rs
+++ b/src/uu/cksum/src/cksum.rs
@@ -4,104 +4,48 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) fname, algo
-use clap::{crate_version, Arg, ArgAction, Command};
-use hex::encode;
-use std::ffi::OsStr;
+use clap::builder::ValueParser;
+use clap::{Arg, ArgAction, Command, value_parser};
+use std::ffi::{OsStr, OsString};
 use std::fs::File;
-use std::io::{self, stdin, BufReader, Read};
+use std::io::{self, BufReader, Read, Write, stdin, stdout};
 use std::iter;
 use std::path::Path;
+use uucore::checksum::{
+    ALGORITHM_OPTIONS_BLAKE2B, ALGORITHM_OPTIONS_BSD, ALGORITHM_OPTIONS_CRC,
+    ALGORITHM_OPTIONS_CRC32B, ALGORITHM_OPTIONS_SYSV, ChecksumError, ChecksumOptions,
+    ChecksumVerbose, SUPPORTED_ALGORITHMS, calculate_blake2b_length, detect_algo, digest_reader,
+    perform_checksum_validation,
+};
 use uucore::{
-    error::{FromIo, UResult},
+    encoding,
+    error::{FromIo, UResult, USimpleError},
     format_usage, help_about, help_section, help_usage,
-    sum::{
-        div_ceil, Blake2b, Digest, DigestWriter, Md5, Sha1, Sha224, Sha256, Sha384, Sha512, Sm3,
-        BSD, CRC, SYSV,
-    },
+    line_ending::LineEnding,
+    os_str_as_bytes, show,
+    sum::Digest,
 };
 
 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";
-const ALGORITHM_OPTIONS_CRC: &str = "crc";
-const ALGORITHM_OPTIONS_MD5: &str = "md5";
-const ALGORITHM_OPTIONS_SHA1: &str = "sha1";
-const ALGORITHM_OPTIONS_SHA224: &str = "sha224";
-const ALGORITHM_OPTIONS_SHA256: &str = "sha256";
-const ALGORITHM_OPTIONS_SHA384: &str = "sha384";
-const ALGORITHM_OPTIONS_SHA512: &str = "sha512";
-const ALGORITHM_OPTIONS_BLAKE2B: &str = "blake2b";
-const ALGORITHM_OPTIONS_SM3: &str = "sm3";
-
-fn detect_algo(program: &str) -> (&'static str, Box<dyn Digest + 'static>, usize) {
-    match program {
-        ALGORITHM_OPTIONS_SYSV => (
-            ALGORITHM_OPTIONS_SYSV,
-            Box::new(SYSV::new()) as Box<dyn Digest>,
-            512,
-        ),
-        ALGORITHM_OPTIONS_BSD => (
-            ALGORITHM_OPTIONS_BSD,
-            Box::new(BSD::new()) as Box<dyn Digest>,
-            1024,
-        ),
-        ALGORITHM_OPTIONS_CRC => (
-            ALGORITHM_OPTIONS_CRC,
-            Box::new(CRC::new()) as Box<dyn Digest>,
-            256,
-        ),
-        ALGORITHM_OPTIONS_MD5 => (
-            ALGORITHM_OPTIONS_MD5,
-            Box::new(Md5::new()) as Box<dyn Digest>,
-            128,
-        ),
-        ALGORITHM_OPTIONS_SHA1 => (
-            ALGORITHM_OPTIONS_SHA1,
-            Box::new(Sha1::new()) as Box<dyn Digest>,
-            160,
-        ),
-        ALGORITHM_OPTIONS_SHA224 => (
-            ALGORITHM_OPTIONS_SHA224,
-            Box::new(Sha224::new()) as Box<dyn Digest>,
-            224,
-        ),
-        ALGORITHM_OPTIONS_SHA256 => (
-            ALGORITHM_OPTIONS_SHA256,
-            Box::new(Sha256::new()) as Box<dyn Digest>,
-            256,
-        ),
-        ALGORITHM_OPTIONS_SHA384 => (
-            ALGORITHM_OPTIONS_SHA384,
-            Box::new(Sha384::new()) as Box<dyn Digest>,
-            384,
-        ),
-        ALGORITHM_OPTIONS_SHA512 => (
-            ALGORITHM_OPTIONS_SHA512,
-            Box::new(Sha512::new()) as Box<dyn Digest>,
-            512,
-        ),
-        ALGORITHM_OPTIONS_BLAKE2B => (
-            ALGORITHM_OPTIONS_BLAKE2B,
-            Box::new(Blake2b::new()) as Box<dyn Digest>,
-            512,
-        ),
-        ALGORITHM_OPTIONS_SM3 => (
-            ALGORITHM_OPTIONS_SM3,
-            Box::new(Sm3::new()) as Box<dyn Digest>,
-            512,
-        ),
-        _ => unreachable!("unknown algorithm: clap should have prevented this case"),
-    }
+#[derive(Debug, PartialEq)]
+enum OutputFormat {
+    Hexadecimal,
+    Raw,
+    Base64,
 }
 
 struct Options {
     algo_name: &'static str,
     digest: Box<dyn Digest + 'static>,
     output_bits: usize,
-    untagged: bool,
+    tag: bool, // will cover the --untagged option
+    length: Option<usize>,
+    output_format: OutputFormat,
+    asterisk: bool, // if we display an asterisk or not (--binary/--text)
+    line_ending: LineEnding,
 }
 
 /// Calculate checksum
@@ -115,131 +59,280 @@ fn cksum<'a, I>(mut options: Options, files: I) -> UResult<()>
 where
     I: Iterator<Item = &'a OsStr>,
 {
+    let files: Vec<_> = files.collect();
+    if options.output_format == OutputFormat::Raw && files.len() > 1 {
+        return Err(Box::new(ChecksumError::RawMultipleFiles));
+    }
+
     for filename in files {
         let filename = Path::new(filename);
         let stdin_buf;
         let file_buf;
         let not_file = filename == OsStr::new("-");
+
+        // Handle the file input
         let mut file = BufReader::new(if not_file {
             stdin_buf = stdin();
             Box::new(stdin_buf) as Box<dyn Read>
         } else if filename.is_dir() {
             Box::new(BufReader::new(io::empty())) as Box<dyn Read>
         } else {
-            file_buf =
-                File::open(filename).map_err_context(|| filename.to_str().unwrap().to_string())?;
+            file_buf = match File::open(filename) {
+                Ok(file) => file,
+                Err(err) => {
+                    show!(err.map_err_context(|| filename.to_string_lossy().to_string()));
+                    continue;
+                }
+            };
             Box::new(file_buf) as Box<dyn Read>
         });
-        let (sum, sz) = digest_read(&mut options.digest, &mut file, options.output_bits)
-            .map_err_context(|| "failed to read input".to_string())?;
 
+        if filename.is_dir() {
+            show!(USimpleError::new(
+                1,
+                format!("{}: Is a directory", filename.display())
+            ));
+            continue;
+        }
+
+        let (sum_hex, sz) =
+            digest_reader(&mut options.digest, &mut file, false, options.output_bits)
+                .map_err_context(|| "failed to read input".to_string())?;
+
+        let sum = match options.output_format {
+            OutputFormat::Raw => {
+                let bytes = match options.algo_name {
+                    ALGORITHM_OPTIONS_CRC => sum_hex.parse::<u32>().unwrap().to_be_bytes().to_vec(),
+                    ALGORITHM_OPTIONS_SYSV | ALGORITHM_OPTIONS_BSD => {
+                        sum_hex.parse::<u16>().unwrap().to_be_bytes().to_vec()
+                    }
+                    _ => hex::decode(sum_hex).unwrap(),
+                };
+                // Cannot handle multiple files anyway, output immediately.
+                stdout().write_all(&bytes)?;
+                return Ok(());
+            }
+            OutputFormat::Hexadecimal => sum_hex,
+            OutputFormat::Base64 => match options.algo_name {
+                ALGORITHM_OPTIONS_CRC
+                | ALGORITHM_OPTIONS_CRC32B
+                | ALGORITHM_OPTIONS_SYSV
+                | ALGORITHM_OPTIONS_BSD => sum_hex,
+                _ => encoding::for_cksum::BASE64.encode(&hex::decode(sum_hex).unwrap()),
+            },
+        };
         // The BSD checksum output is 5 digit integer
         let bsd_width = 5;
-        match (options.algo_name, not_file) {
-            (ALGORITHM_OPTIONS_SYSV, true) => println!(
-                "{} {}",
-                sum.parse::<u16>().unwrap(),
-                div_ceil(sz, options.output_bits)
-            ),
-            (ALGORITHM_OPTIONS_SYSV, false) => println!(
-                "{} {} {}",
-                sum.parse::<u16>().unwrap(),
-                div_ceil(sz, options.output_bits),
-                filename.display()
+        let (before_filename, should_print_filename, after_filename) = match options.algo_name {
+            ALGORITHM_OPTIONS_SYSV => (
+                format!(
+                    "{} {}{}",
+                    sum.parse::<u16>().unwrap(),
+                    sz.div_ceil(options.output_bits),
+                    if not_file { "" } else { " " }
+                ),
+                !not_file,
+                String::new(),
             ),
-            (ALGORITHM_OPTIONS_BSD, true) => println!(
-                "{:0bsd_width$} {:bsd_width$}",
-                sum.parse::<u16>().unwrap(),
-                div_ceil(sz, options.output_bits)
+            ALGORITHM_OPTIONS_BSD => (
+                format!(
+                    "{:0bsd_width$} {:bsd_width$}{}",
+                    sum.parse::<u16>().unwrap(),
+                    sz.div_ceil(options.output_bits),
+                    if not_file { "" } else { " " }
+                ),
+                !not_file,
+                String::new(),
             ),
-            (ALGORITHM_OPTIONS_BSD, false) => println!(
-                "{:0bsd_width$} {:bsd_width$} {}",
-                sum.parse::<u16>().unwrap(),
-                div_ceil(sz, options.output_bits),
-                filename.display()
+            ALGORITHM_OPTIONS_CRC | ALGORITHM_OPTIONS_CRC32B => (
+                format!("{sum} {sz}{}", if not_file { "" } else { " " }),
+                !not_file,
+                String::new(),
             ),
-            (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());
+            ALGORITHM_OPTIONS_BLAKE2B if options.tag => {
+                (
+                    if let Some(length) = options.length {
+                        // Multiply by 8 here, as we want to print the length in bits.
+                        format!("BLAKE2b-{} (", length * 8)
+                    } else {
+                        "BLAKE2b (".to_owned()
+                    },
+                    true,
+                    format!(") = {sum}"),
+                )
             }
             _ => {
-                if options.untagged {
-                    println!("{sum}  {}", filename.display());
+                if options.tag {
+                    (
+                        format!("{} (", options.algo_name.to_ascii_uppercase()),
+                        true,
+                        format!(") = {sum}"),
+                    )
                 } else {
-                    println!(
-                        "{} ({}) = {sum}",
-                        options.algo_name.to_ascii_uppercase(),
-                        filename.display()
-                    );
+                    let prefix = if options.asterisk { "*" } else { " " };
+                    (format!("{sum} {prefix}"), true, String::new())
                 }
             }
+        };
+        print!("{before_filename}");
+        if should_print_filename {
+            // The filename might not be valid UTF-8, and filename.display() would mangle the names.
+            // Therefore, emit the bytes directly to stdout, without any attempt at encoding them.
+            let _dropped_result = stdout().write_all(os_str_as_bytes(filename.as_os_str())?);
         }
+        print!("{after_filename}{}", options.line_ending);
     }
 
     Ok(())
 }
 
-fn digest_read<T: Read>(
-    digest: &mut Box<dyn Digest>,
-    reader: &mut BufReader<T>,
-    output_bits: usize,
-) -> io::Result<(String, usize)> {
-    digest.reset();
-
-    // Read bytes from `reader` and write those bytes to `digest`.
-    //
-    // If `binary` is `false` and the operating system is Windows, then
-    // `DigestWriter` replaces "\r\n" with "\n" before it writes the
-    // bytes into `digest`. Otherwise, it just inserts the bytes as-is.
-    //
-    // In order to support replacing "\r\n", we must call `finalize()`
-    // in order to support the possibility that the last character read
-    // from the reader was "\r". (This character gets buffered by
-    // `DigestWriter` and only written if the following character is
-    // "\n". But when "\r" is the last character read, we need to force
-    // it to be written.)
-    let mut digest_writer = DigestWriter::new(digest, true);
-    let output_size = std::io::copy(reader, &mut digest_writer)? as usize;
-    digest_writer.finalize();
-
-    if digest.output_bits() > 0 {
-        Ok((digest.result_str(), output_size))
-    } else {
-        // Assume it's SHAKE.  result_str() doesn't work with shake (as of 8/30/2016)
-        let mut bytes = Vec::new();
-        bytes.resize((output_bits + 7) / 8, 0);
-        digest.hash_finalize(&mut bytes);
-        Ok((encode(bytes), output_size))
-    }
-}
-
 mod options {
     pub const ALGORITHM: &str = "algorithm";
     pub const FILE: &str = "file";
     pub const UNTAGGED: &str = "untagged";
+    pub const TAG: &str = "tag";
+    pub const LENGTH: &str = "length";
+    pub const RAW: &str = "raw";
+    pub const BASE64: &str = "base64";
+    pub const CHECK: &str = "check";
+    pub const STRICT: &str = "strict";
+    pub const TEXT: &str = "text";
+    pub const BINARY: &str = "binary";
+    pub const STATUS: &str = "status";
+    pub const WARN: &str = "warn";
+    pub const IGNORE_MISSING: &str = "ignore-missing";
+    pub const QUIET: &str = "quiet";
+    pub const ZERO: &str = "zero";
+}
+
+/***
+ * cksum has a bunch of legacy behavior.
+ * We handle this in this function to make sure they are self contained
+ * and "easier" to understand
+ */
+fn handle_tag_text_binary_flags<S: AsRef<OsStr>>(
+    args: impl Iterator<Item = S>,
+) -> UResult<(bool, bool)> {
+    let mut tag = true;
+    let mut binary = false;
+
+    // --binary, --tag and --untagged are tight together: none of them
+    // conflicts with each other but --tag will reset "binary" and set "tag".
+
+    for arg in args {
+        let arg = arg.as_ref();
+        if arg == "-b" || arg == "--binary" {
+            binary = true;
+        } else if arg == "--tag" {
+            tag = true;
+            binary = false;
+        } else if arg == "--untagged" {
+            tag = false;
+        }
+    }
+
+    Ok((tag, !tag && binary))
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
+    let check = matches.get_flag(options::CHECK);
+
     let algo_name: &str = match matches.get_one::<String>(options::ALGORITHM) {
         Some(v) => v,
-        None => ALGORITHM_OPTIONS_CRC,
+        None => {
+            if check {
+                // if we are doing a --check, we should not default to crc
+                ""
+            } else {
+                ALGORITHM_OPTIONS_CRC
+            }
+        }
+    };
+
+    let input_length = matches.get_one::<usize>(options::LENGTH);
+
+    let length = match input_length {
+        Some(length) => {
+            if algo_name == ALGORITHM_OPTIONS_BLAKE2B {
+                calculate_blake2b_length(*length)?
+            } else {
+                return Err(ChecksumError::LengthOnlyForBlake2b.into());
+            }
+        }
+        None => None,
+    };
+
+    if ["bsd", "crc", "sysv", "crc32b"].contains(&algo_name) && check {
+        return Err(ChecksumError::AlgorithmNotSupportedWithCheck.into());
+    }
+
+    if check {
+        let text_flag = matches.get_flag(options::TEXT);
+        let binary_flag = matches.get_flag(options::BINARY);
+        let strict = matches.get_flag(options::STRICT);
+        let status = matches.get_flag(options::STATUS);
+        let warn = matches.get_flag(options::WARN);
+        let ignore_missing = matches.get_flag(options::IGNORE_MISSING);
+        let quiet = matches.get_flag(options::QUIET);
+        let tag = matches.get_flag(options::TAG);
+
+        if tag || binary_flag || text_flag {
+            return Err(ChecksumError::BinaryTextConflict.into());
+        }
+        // Determine the appropriate algorithm option to pass
+        let algo_option = if algo_name.is_empty() {
+            None
+        } else {
+            Some(algo_name)
+        };
+
+        // Execute the checksum validation based on the presence of files or the use of stdin
+
+        let files = matches.get_many::<OsString>(options::FILE).map_or_else(
+            || iter::once(OsStr::new("-")).collect::<Vec<_>>(),
+            |files| files.map(OsStr::new).collect::<Vec<_>>(),
+        );
+
+        let verbose = ChecksumVerbose::new(status, quiet, warn);
+
+        let opts = ChecksumOptions {
+            binary: binary_flag,
+            ignore_missing,
+            strict,
+            verbose,
+        };
+
+        return perform_checksum_validation(files.iter().copied(), algo_option, length, opts);
+    }
+
+    let (tag, asterisk) = handle_tag_text_binary_flags(std::env::args_os())?;
+
+    let algo = detect_algo(algo_name, length)?;
+    let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
+
+    let output_format = if matches.get_flag(options::RAW) {
+        OutputFormat::Raw
+    } else if matches.get_flag(options::BASE64) {
+        OutputFormat::Base64
+    } else {
+        OutputFormat::Hexadecimal
     };
 
-    let (name, algo, bits) = detect_algo(algo_name);
     let opts = Options {
-        algo_name: name,
-        digest: algo,
-        output_bits: bits,
-        untagged: matches.get_flag(options::UNTAGGED),
+        algo_name: algo.name,
+        digest: (algo.create_fn)(),
+        output_bits: algo.bits,
+        length,
+        tag,
+        output_format,
+        asterisk,
+        line_ending,
     };
 
-    match matches.get_many::<String>(options::FILE) {
+    match matches.get_many::<OsString>(options::FILE) {
         Some(files) => cksum(opts, files.map(OsStr::new))?,
         None => cksum(opts, iter::once(OsStr::new("-")))?,
     };
@@ -249,14 +342,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::FILE)
                 .hide(true)
-                .action(clap::ArgAction::Append)
+                .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::FilePath),
         )
         .arg(
@@ -265,25 +360,130 @@ pub fn uu_app() -> Command {
                 .short('a')
                 .help("select the digest type to use. See DIGEST below")
                 .value_name("ALGORITHM")
-                .value_parser([
-                    ALGORITHM_OPTIONS_SYSV,
-                    ALGORITHM_OPTIONS_BSD,
-                    ALGORITHM_OPTIONS_CRC,
-                    ALGORITHM_OPTIONS_MD5,
-                    ALGORITHM_OPTIONS_SHA1,
-                    ALGORITHM_OPTIONS_SHA224,
-                    ALGORITHM_OPTIONS_SHA256,
-                    ALGORITHM_OPTIONS_SHA384,
-                    ALGORITHM_OPTIONS_SHA512,
-                    ALGORITHM_OPTIONS_BLAKE2B,
-                    ALGORITHM_OPTIONS_SM3,
-                ]),
+                .value_parser(SUPPORTED_ALGORITHMS),
         )
         .arg(
             Arg::new(options::UNTAGGED)
                 .long(options::UNTAGGED)
                 .help("create a reversed style checksum, without digest type")
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::TAG),
+        )
+        .arg(
+            Arg::new(options::TAG)
+                .long(options::TAG)
+                .help("create a BSD style checksum, undo --untagged (default)")
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::UNTAGGED),
+        )
+        .arg(
+            Arg::new(options::LENGTH)
+                .long(options::LENGTH)
+                .value_parser(value_parser!(usize))
+                .short('l')
+                .help(
+                    "digest length in bits; must not exceed the max for the blake2 algorithm \
+                    and must be a multiple of 8",
+                )
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::RAW)
+                .long(options::RAW)
+                .help("emit a raw binary digest, not hexadecimal")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::STRICT)
+                .long(options::STRICT)
+                .help("exit non-zero for improperly formatted checksum lines")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::CHECK)
+                .short('c')
+                .long(options::CHECK)
+                .help("read hashsums from the FILEs and check them")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::BASE64)
+                .long(options::BASE64)
+                .help("emit a base64 digest, not hexadecimal")
+                .action(ArgAction::SetTrue)
+                // Even though this could easily just override an earlier '--raw',
+                // GNU cksum does not permit these flags to be combined:
+                .conflicts_with(options::RAW),
+        )
+        .arg(
+            Arg::new(options::TEXT)
+                .long(options::TEXT)
+                .short('t')
+                .hide(true)
+                .overrides_with(options::BINARY)
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::BINARY)
+                .long(options::BINARY)
+                .short('b')
+                .hide(true)
+                .overrides_with(options::TEXT)
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::WARN)
+                .short('w')
+                .long("warn")
+                .help("warn about improperly formatted checksum lines")
+                .action(ArgAction::SetTrue)
+                .overrides_with_all([options::STATUS, options::QUIET]),
+        )
+        .arg(
+            Arg::new(options::STATUS)
+                .long("status")
+                .help("don't output anything, status code shows success")
+                .action(ArgAction::SetTrue)
+                .overrides_with_all([options::WARN, options::QUIET]),
+        )
+        .arg(
+            Arg::new(options::QUIET)
+                .long(options::QUIET)
+                .help("don't print OK for each successfully verified file")
+                .action(ArgAction::SetTrue)
+                .overrides_with_all([options::WARN, options::STATUS]),
+        )
+        .arg(
+            Arg::new(options::IGNORE_MISSING)
+                .long(options::IGNORE_MISSING)
+                .help("don't fail or report status for missing files")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::ZERO)
+                .long(options::ZERO)
+                .short('z')
+                .help(
+                    "end each output line with NUL, not newline,\n and disable file name escaping",
+                )
                 .action(ArgAction::SetTrue),
         )
         .after_help(AFTER_HELP)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::calculate_blake2b_length;
+
+    #[test]
+    fn test_calculate_length() {
+        assert_eq!(calculate_blake2b_length(256).unwrap(), Some(32));
+        assert_eq!(calculate_blake2b_length(512).unwrap(), None);
+        assert_eq!(calculate_blake2b_length(256).unwrap(), Some(32));
+        calculate_blake2b_length(255).unwrap_err();
+
+        calculate_blake2b_length(33).unwrap_err();
+
+        calculate_blake2b_length(513).unwrap_err();
+    }
+}
diff --git a/src/uu/comm/Cargo.toml b/src/uu/comm/Cargo.toml
index e4a1dac82fa..71617428039 100644
--- a/src/uu/comm/Cargo.toml
+++ b/src/uu/comm/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_comm"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "comm ~ (uutils) compare sorted inputs"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/comm"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/comm.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "comm"
diff --git a/src/uu/comm/src/comm.rs b/src/uu/comm/src/comm.rs
index e6977142ef5..11752c331a5 100644
--- a/src/uu/comm/src/comm.rs
+++ b/src/uu/comm/src/comm.rs
@@ -3,17 +3,17 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) delim mkdelim
+// spell-checker:ignore (ToDO) delim mkdelim pairable
 
 use std::cmp::Ordering;
-use std::fs::File;
-use std::io::{self, stdin, BufRead, BufReader, Stdin};
-use std::path::Path;
-use uucore::error::{FromIo, UResult};
+use std::fs::{File, metadata};
+use std::io::{self, BufRead, BufReader, Read, Stdin, stdin};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::fs::paths_refer_to_same_file;
 use uucore::line_ending::LineEnding;
 use uucore::{format_usage, help_about, help_usage};
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 
 const ABOUT: &str = help_about!("comm.md");
 const USAGE: &str = help_usage!("comm.md");
@@ -28,6 +28,30 @@ mod options {
     pub const FILE_2: &str = "FILE2";
     pub const TOTAL: &str = "total";
     pub const ZERO_TERMINATED: &str = "zero-terminated";
+    pub const CHECK_ORDER: &str = "check-order";
+    pub const NO_CHECK_ORDER: &str = "nocheck-order";
+}
+
+#[derive(Debug, Clone, Copy)]
+enum FileNumber {
+    One,
+    Two,
+}
+
+impl FileNumber {
+    fn as_str(&self) -> &'static str {
+        match self {
+            FileNumber::One => "1",
+            FileNumber::Two => "2",
+        }
+    }
+}
+
+struct OrderChecker {
+    last_line: Vec<u8>,
+    file_num: FileNumber,
+    check_order: bool,
+    has_error: bool,
 }
 
 enum Input {
@@ -42,7 +66,7 @@ struct LineReader {
 
 impl LineReader {
     fn new(input: Input, line_ending: LineEnding) -> Self {
-        Self { input, line_ending }
+        Self { line_ending, input }
     }
 
     fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
@@ -61,12 +85,74 @@ impl LineReader {
     }
 }
 
-fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
-    let delim = match opts.get_one::<String>(options::DELIMITER).unwrap().as_str() {
-        "" => "\0",
-        delim => delim,
-    };
+impl OrderChecker {
+    fn new(file_num: FileNumber, check_order: bool) -> Self {
+        Self {
+            last_line: Vec::new(),
+            file_num,
+            check_order,
+            has_error: false,
+        }
+    }
+
+    fn verify_order(&mut self, current_line: &[u8]) -> bool {
+        if self.last_line.is_empty() {
+            self.last_line = current_line.to_vec();
+            return true;
+        }
+
+        let is_ordered = current_line >= &self.last_line;
+        if !is_ordered && !self.has_error {
+            eprintln!(
+                "comm: file {} is not in sorted order",
+                self.file_num.as_str()
+            );
+            self.has_error = true;
+        }
+
+        self.last_line = current_line.to_vec();
+        is_ordered || !self.check_order
+    }
+}
+
+// Check if two files are identical by comparing their contents
+pub fn are_files_identical(path1: &str, path2: &str) -> io::Result<bool> {
+    // First compare file sizes
+    let metadata1 = metadata(path1)?;
+    let metadata2 = metadata(path2)?;
+
+    if metadata1.len() != metadata2.len() {
+        return Ok(false);
+    }
+
+    let file1 = File::open(path1)?;
+    let file2 = File::open(path2)?;
+
+    let mut reader1 = BufReader::new(file1);
+    let mut reader2 = BufReader::new(file2);
+
+    let mut buffer1 = [0; 8192];
+    let mut buffer2 = [0; 8192];
+
+    loop {
+        let bytes1 = reader1.read(&mut buffer1)?;
+        let bytes2 = reader2.read(&mut buffer2)?;
+
+        if bytes1 != bytes2 {
+            return Ok(false);
+        }
+
+        if bytes1 == 0 {
+            return Ok(true);
+        }
+
+        if buffer1[..bytes1] != buffer2[..bytes2] {
+            return Ok(false);
+        }
+    }
+}
 
+fn comm(a: &mut LineReader, b: &mut LineReader, delim: &str, opts: &ArgMatches) -> UResult<()> {
     let width_col_1 = usize::from(!opts.get_flag(options::COLUMN_1));
     let width_col_2 = usize::from(!opts.get_flag(options::COLUMN_2));
 
@@ -82,6 +168,26 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
     let mut total_col_2 = 0;
     let mut total_col_3 = 0;
 
+    let check_order = opts.get_flag(options::CHECK_ORDER);
+    let no_check_order = opts.get_flag(options::NO_CHECK_ORDER);
+
+    // Determine if we should perform order checking
+    let should_check_order = !no_check_order
+        && (check_order
+            || if let (Some(file1), Some(file2)) = (
+                opts.get_one::<String>(options::FILE_1),
+                opts.get_one::<String>(options::FILE_2),
+            ) {
+                !(paths_refer_to_same_file(file1, file2, true)
+                    || are_files_identical(file1, file2).unwrap_or(false))
+            } else {
+                true
+            });
+
+    let mut checker1 = OrderChecker::new(FileNumber::One, check_order);
+    let mut checker2 = OrderChecker::new(FileNumber::Two, check_order);
+    let mut input_error = false;
+
     while na.is_ok() || nb.is_ok() {
         let ord = match (na.is_ok(), nb.is_ok()) {
             (false, true) => Ordering::Greater,
@@ -97,6 +203,9 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
 
         match ord {
             Ordering::Less => {
+                if should_check_order && !checker1.verify_order(ra) {
+                    break;
+                }
                 if !opts.get_flag(options::COLUMN_1) {
                     print!("{}", String::from_utf8_lossy(ra));
                 }
@@ -105,6 +214,9 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
                 total_col_1 += 1;
             }
             Ordering::Greater => {
+                if should_check_order && !checker2.verify_order(rb) {
+                    break;
+                }
                 if !opts.get_flag(options::COLUMN_2) {
                     print!("{delim_col_2}{}", String::from_utf8_lossy(rb));
                 }
@@ -113,6 +225,10 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
                 total_col_2 += 1;
             }
             Ordering::Equal => {
+                if should_check_order && (!checker1.verify_order(ra) || !checker2.verify_order(rb))
+                {
+                    break;
+                }
                 if !opts.get_flag(options::COLUMN_3) {
                     print!("{delim_col_3}{}", String::from_utf8_lossy(ra));
                 }
@@ -123,19 +239,37 @@ fn comm(a: &mut LineReader, b: &mut LineReader, opts: &ArgMatches) {
                 total_col_3 += 1;
             }
         }
+
+        // Track if we've seen any order errors
+        if (checker1.has_error || checker2.has_error) && !input_error && !check_order {
+            input_error = true;
+        }
     }
 
     if opts.get_flag(options::TOTAL) {
         let line_ending = LineEnding::from_zero_flag(opts.get_flag(options::ZERO_TERMINATED));
         print!("{total_col_1}{delim}{total_col_2}{delim}{total_col_3}{delim}total{line_ending}");
     }
+
+    if should_check_order && (checker1.has_error || checker2.has_error) {
+        // Print the input error message once at the end
+        if input_error {
+            eprintln!("comm: input is not in sorted order");
+        }
+        Err(USimpleError::new(1, ""))
+    } else {
+        Ok(())
+    }
 }
 
 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))?;
+        if metadata(name)?.is_dir() {
+            return Err(io::Error::other("Is a directory"));
+        }
+        let f = File::open(name)?;
         Ok(LineReader::new(
             Input::FileIn(BufReader::new(f)),
             line_ending,
@@ -145,8 +279,6 @@ fn open_file(name: &str, line_ending: LineEnding) -> io::Result<LineReader> {
 
 #[uucore::main]
 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_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
     let filename1 = matches.get_one::<String>(options::FILE_1).unwrap();
@@ -154,16 +286,38 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     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(())
+    // Due to default_value(), there must be at least one value here, thus unwrap() must not panic.
+    let all_delimiters = matches
+        .get_many::<String>(options::DELIMITER)
+        .unwrap()
+        .map(String::from)
+        .collect::<Vec<_>>();
+    for delim in &all_delimiters[1..] {
+        // Note that this check is very different from ".conflicts_with_self(true).action(ArgAction::Set)",
+        // as this accepts duplicate *identical* arguments.
+        if delim != &all_delimiters[0] {
+            // Note: This intentionally deviate from the GNU error message by inserting the word "conflicting".
+            return Err(USimpleError::new(
+                1,
+                "multiple conflicting output delimiters specified",
+            ));
+        }
+    }
+    let delim = match &*all_delimiters[0] {
+        "" => "\0",
+        delim => delim,
+    };
+
+    comm(&mut f1, &mut f2, delim, &matches)
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::COLUMN_1)
                 .short('1')
@@ -188,6 +342,8 @@ pub fn uu_app() -> Command {
                 .help("separate columns with STR")
                 .value_name("STR")
                 .default_value(options::DELIMITER_DEFAULT)
+                .allow_hyphen_values(true)
+                .action(ArgAction::Append)
                 .hide_default_value(true),
         )
         .arg(
@@ -214,4 +370,17 @@ pub fn uu_app() -> Command {
                 .help("output a summary")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::CHECK_ORDER)
+                .long(options::CHECK_ORDER)
+                .help("check that the input is correctly sorted, even if all input lines are pairable")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::NO_CHECK_ORDER)
+                .long(options::NO_CHECK_ORDER)
+                .help("do not check that the input is correctly sorted")
+                .action(ArgAction::SetTrue)
+                .conflicts_with(options::CHECK_ORDER),
+        )
 }
diff --git a/src/uu/cp/Cargo.toml b/src/uu/cp/Cargo.toml
index 177525ff5f2..fd5b4696e03 100644
--- a/src/uu/cp/Cargo.toml
+++ b/src/uu/cp/Cargo.toml
@@ -1,19 +1,18 @@
 [package]
 name = "uu_cp"
-version = "0.0.21"
-authors = [
-  "Jordy Dickinson <jordy.dickinson@gmail.com>",
-  "Joshua S. Miller <jsmiller@uchicago.edu>",
-  "uutils developers",
-]
-license = "MIT"
 description = "cp ~ (uutils) copy SOURCE to DESTINATION"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cp"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/cp.rs"
@@ -22,12 +21,16 @@ path = "src/cp.rs"
 clap = { workspace = true }
 filetime = { workspace = true }
 libc = { workspace = true }
+linux-raw-sys = { workspace = true }
 quick-error = { workspace = true }
 selinux = { workspace = true, optional = true }
 uucore = { workspace = true, features = [
   "backup-control",
+  "buf-copy",
   "entries",
   "fs",
+  "fsxattr",
+  "parser",
   "perms",
   "mode",
   "update-control",
@@ -44,5 +47,5 @@ name = "cp"
 path = "src/main.rs"
 
 [features]
-feat_selinux = ["selinux"]
+feat_selinux = ["selinux", "uucore/selinux"]
 feat_acl = ["exacl"]
diff --git a/src/uu/cp/src/copydir.rs b/src/uu/cp/src/copydir.rs
index 430548d0cf3..d2e367c5c19 100644
--- a/src/uu/cp/src/copydir.rs
+++ b/src/uu/cp/src/copydir.rs
@@ -2,13 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore TODO canonicalizes direntry pathbuf symlinked
+// spell-checker:ignore TODO canonicalizes direntry pathbuf symlinked IRWXO IRWXG
 //! Recursively copy the contents of a directory.
 //!
 //! See the [`copy_directory`] function for more information.
 #[cfg(windows)]
 use std::borrow::Cow;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::env;
 use std::fs;
 use std::io;
@@ -17,15 +17,17 @@ use std::path::{Path, PathBuf, StripPrefixError};
 use indicatif::ProgressBar;
 use uucore::display::Quotable;
 use uucore::error::UIoError;
-use uucore::fs::{canonicalize, FileInformation, MissingHandling, ResolveMode};
+use uucore::fs::{
+    FileInformation, MissingHandling, ResolveMode, canonicalize, path_ends_with_terminator,
+};
 use uucore::show;
 use uucore::show_error;
 use uucore::uio_error;
 use walkdir::{DirEntry, WalkDir};
 
 use crate::{
-    aligned_ancestors, context_for, copy_attributes, copy_file, copy_link, preserve_hardlinks,
-    CopyResult, Error, Options,
+    CopyResult, Error, Options, aligned_ancestors, context_for, copy_attributes, copy_file,
+    copy_link,
 };
 
 /// Ensure a Windows path starts with a `\\?`.
@@ -40,8 +42,9 @@ fn adjust_canonicalization(p: &Path) -> Cow<Path> {
         .components()
         .next()
         .and_then(|comp| comp.as_os_str().to_str())
-        .map(|p_str| p_str.starts_with(VERBATIM_PREFIX) || p_str.starts_with(DEVICE_NS_PREFIX))
-        .unwrap_or_default();
+        .is_some_and(|p_str| {
+            p_str.starts_with(VERBATIM_PREFIX) || p_str.starts_with(DEVICE_NS_PREFIX)
+        });
 
     if has_prefix {
         p.into()
@@ -77,6 +80,12 @@ fn get_local_to_root_parent(
     }
 }
 
+/// Given an iterator, return all its items except the last.
+fn skip_last<T>(mut iter: impl Iterator<Item = T>) -> impl Iterator<Item = T> {
+    let last = iter.next();
+    iter.scan(last, |state, item| state.replace(item))
+}
+
 /// Paths that are invariant throughout the traversal when copying a directory.
 struct Context<'a> {
     /// The current working directory at the time of starting the traversal.
@@ -87,10 +96,13 @@ struct Context<'a> {
 
     /// The target path to which the directory will be copied.
     target: &'a Path,
+
+    /// The source path from which the directory will be copied.
+    root: &'a Path,
 }
 
 impl<'a> Context<'a> {
-    fn new(root: &'a Path, target: &'a Path) -> std::io::Result<Self> {
+    fn new(root: &'a Path, target: &'a Path) -> io::Result<Self> {
         let current_dir = env::current_dir()?;
         let root_path = current_dir.join(root);
         let root_parent = if target.exists() && !root.to_str().unwrap().ends_with("/.") {
@@ -102,6 +114,7 @@ impl<'a> Context<'a> {
             current_dir,
             root_parent,
             target,
+            root,
         })
     }
 }
@@ -156,11 +169,27 @@ struct Entry {
 }
 
 impl Entry {
-    fn new(context: &Context, direntry: &DirEntry) -> Result<Self, StripPrefixError> {
-        let source_relative = direntry.path().to_path_buf();
+    fn new<A: AsRef<Path>>(
+        context: &Context,
+        source: A,
+        no_target_dir: bool,
+    ) -> Result<Self, StripPrefixError> {
+        let source = source.as_ref();
+        let source_relative = source.to_path_buf();
         let source_absolute = context.current_dir.join(&source_relative);
-        let descendant =
+        let mut descendant =
             get_local_to_root_parent(&source_absolute, context.root_parent.as_deref())?;
+        if no_target_dir {
+            let source_is_dir = source.is_dir();
+            if path_ends_with_terminator(context.target) && source_is_dir {
+                if let Err(e) = fs::create_dir_all(context.target) {
+                    eprintln!("Failed to create directory: {e}");
+                }
+            } else {
+                descendant = descendant.strip_prefix(context.root)?.to_path_buf();
+            }
+        }
+
         let local_to_target = context.target.join(descendant);
         let target_is_file = context.target.is_file();
         Ok(Self {
@@ -172,35 +201,16 @@ impl Entry {
     }
 }
 
-/// Decide whether the given path ends with `/.`.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// assert!(ends_with_slash_dot("/."));
-/// assert!(ends_with_slash_dot("./."));
-/// assert!(ends_with_slash_dot("a/."));
-///
-/// assert!(!ends_with_slash_dot("."));
-/// assert!(!ends_with_slash_dot("./"));
-/// assert!(!ends_with_slash_dot("a/.."));
-/// ```
-fn ends_with_slash_dot<P>(path: P) -> bool
-where
-    P: AsRef<Path>,
-{
-    // `path.ends_with(".")` does not seem to work
-    path.as_ref().display().to_string().ends_with("/.")
-}
-
+#[allow(clippy::too_many_arguments)]
 /// Copy a single entry during a directory traversal.
 fn copy_direntry(
-    progress_bar: &Option<ProgressBar>,
+    progress_bar: Option<&ProgressBar>,
     entry: Entry,
     options: &Options,
     symlinked_files: &mut HashSet<FileInformation>,
     preserve_hard_links: bool,
-    hard_links: &mut Vec<(String, u64)>,
+    copied_destinations: &HashSet<PathBuf>,
+    copied_files: &mut HashMap<FileInformation, PathBuf>,
 ) -> CopyResult<()> {
     let Entry {
         source_absolute,
@@ -217,79 +227,54 @@ fn copy_direntry(
 
     // If the source is a directory and the destination does not
     // exist, ...
-    if source_absolute.is_dir()
-        && !ends_with_slash_dot(&source_absolute)
-        && !local_to_target.exists()
-    {
-        if target_is_file {
-            return Err("cannot overwrite non-directory with directory".into());
+    if source_absolute.is_dir() && !local_to_target.exists() {
+        return if target_is_file {
+            Err("cannot overwrite non-directory with directory".into())
         } else {
-            // TODO Since the calling code is traversing from the root
-            // of the directory structure, I don't think
-            // `create_dir_all()` will have any benefit over
-            // `create_dir()`, since all the ancestor directories
-            // should have already been created.
-            fs::create_dir_all(&local_to_target)?;
+            build_dir(&local_to_target, false, options, Some(&source_absolute))?;
             if options.verbose {
                 println!("{}", context_for(&source_relative, &local_to_target));
             }
-            return Ok(());
-        }
+            Ok(())
+        };
     }
 
     // If the source is not a directory, then we need to copy the file.
     if !source_absolute.is_dir() {
-        if preserve_hard_links {
-            let dest = local_to_target.as_path().to_path_buf();
-            let found_hard_link = preserve_hardlinks(hard_links, &source_absolute, &dest)?;
-            if !found_hard_link {
-                match copy_file(
-                    progress_bar,
-                    &source_absolute,
-                    local_to_target.as_path(),
-                    options,
-                    symlinked_files,
-                    false,
-                ) {
-                    Ok(_) => Ok(()),
-                    Err(err) => {
-                        if source_absolute.is_symlink() {
-                            // silent the error with a symlink
-                            // In case we do --archive, we might copy the symlink
-                            // before the file itself
-                            Ok(())
-                        } else {
-                            Err(err)
-                        }
+        if let Err(err) = copy_file(
+            progress_bar,
+            &source_absolute,
+            local_to_target.as_path(),
+            options,
+            symlinked_files,
+            copied_destinations,
+            copied_files,
+            false,
+        ) {
+            if preserve_hard_links {
+                if !source_absolute.is_symlink() {
+                    return Err(err);
+                }
+                // silent the error with a symlink
+                // In case we do --archive, we might copy the symlink
+                // before the file itself
+            } else {
+                // At this point, `path` is just a plain old file.
+                // Terminate this function immediately if there is any
+                // kind of error *except* a "permission denied" error.
+                //
+                // TODO What other kinds of errors, if any, should
+                // cause us to continue walking the directory?
+                match err {
+                    Error::IoErrContext(e, _) if e.kind() == io::ErrorKind::PermissionDenied => {
+                        show!(uio_error!(
+                            e,
+                            "cannot open {} for reading",
+                            source_relative.quote(),
+                        ));
                     }
-                }?;
-            }
-        } else {
-            // At this point, `path` is just a plain old file.
-            // Terminate this function immediately if there is any
-            // kind of error *except* a "permission denied" error.
-            //
-            // TODO What other kinds of errors, if any, should
-            // cause us to continue walking the directory?
-            match copy_file(
-                progress_bar,
-                &source_absolute,
-                local_to_target.as_path(),
-                options,
-                symlinked_files,
-                false,
-            ) {
-                Ok(_) => {}
-                Err(Error::IoErrContext(e, _))
-                    if e.kind() == std::io::ErrorKind::PermissionDenied =>
-                {
-                    show!(uio_error!(
-                        e,
-                        "cannot open {} for reading",
-                        source_relative.quote(),
-                    ));
+                    e => return Err(e),
                 }
-                Err(e) => return Err(e),
             }
         }
     }
@@ -304,18 +289,17 @@ fn copy_direntry(
 ///
 /// Any errors encountered copying files in the tree will be logged but
 /// will not cause a short-circuit.
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn copy_directory(
-    progress_bar: &Option<ProgressBar>,
+    progress_bar: Option<&ProgressBar>,
     root: &Path,
     target: &Path,
     options: &Options,
     symlinked_files: &mut HashSet<FileInformation>,
+    copied_destinations: &HashSet<PathBuf>,
+    copied_files: &mut HashMap<FileInformation, PathBuf>,
     source_in_command_line: bool,
 ) -> CopyResult<()> {
-    if !options.recursive {
-        return Err(format!("omitting directory {}", root.quote()).into());
-    }
-
     // if no-dereference is enabled and this is a symlink, copy it as a file
     if !options.dereference(source_in_command_line) && root.is_symlink() {
         return copy_file(
@@ -324,10 +308,16 @@ pub(crate) fn copy_directory(
             target,
             options,
             symlinked_files,
+            copied_destinations,
+            copied_files,
             source_in_command_line,
         );
     }
 
+    if !options.recursive {
+        return Err(format!("-r not specified; omitting directory {}", root.quote()).into());
+    }
+
     // check if root is a prefix of target
     if path_has_prefix(target, root)? {
         return Err(format!(
@@ -349,8 +339,7 @@ pub(crate) fn copy_directory(
     let tmp = if options.parents {
         if let Some(parent) = root.parent() {
             let new_target = target.join(parent);
-            std::fs::create_dir_all(&new_target)?;
-
+            build_dir(&new_target, true, options, None)?;
             if options.verbose {
                 // For example, if copying file `a/b/c` and its parents
                 // to directory `d/`, then print
@@ -372,7 +361,6 @@ pub(crate) fn copy_directory(
     };
     let target = tmp.as_path();
 
-    let mut hard_links: Vec<(String, u64)> = vec![];
     let preserve_hard_links = options.preserve_hard_links();
 
     // Collect some paths here that are invariant during the traversal
@@ -383,6 +371,9 @@ pub(crate) fn copy_directory(
         Err(e) => return Err(format!("failed to get current directory {e}").into()),
     };
 
+    // The directory we were in during the previous iteration
+    let mut last_iter: Option<DirEntry> = None;
+
     // Traverse the contents of the directory, copying each one.
     for direntry_result in WalkDir::new(root)
         .same_file_system(options.one_file_system)
@@ -390,30 +381,104 @@ pub(crate) fn copy_directory(
     {
         match direntry_result {
             Ok(direntry) => {
-                let entry = Entry::new(&context, &direntry)?;
+                let entry = Entry::new(&context, direntry.path(), options.no_target_dir)?;
+
                 copy_direntry(
                     progress_bar,
                     entry,
                     options,
                     symlinked_files,
                     preserve_hard_links,
-                    &mut hard_links,
+                    copied_destinations,
+                    copied_files,
                 )?;
+
+                // We omit certain permissions when creating directories
+                // to prevent other users from accessing them before they're done.
+                // We thus need to fix the permissions of each directory we copy
+                // once it's contents are ready.
+                // This "fixup" is implemented here in a memory-efficient manner.
+                //
+                // We detect iterations where we "walk up" the directory tree,
+                // and fix permissions on all the directories we exited.
+                // (Note that there can be more than one! We might step out of
+                // `./a/b/c` into `./a/`, in which case we'll need to fix the
+                // permissions of both `./a/b/c` and `./a/b`, in that order.)
+                if direntry.file_type().is_dir() {
+                    // If true, last_iter is not a parent of this iter.
+                    // The means we just exited a directory.
+                    let went_up = if let Some(last_iter) = &last_iter {
+                        last_iter.path().strip_prefix(direntry.path()).is_ok()
+                    } else {
+                        false
+                    };
+
+                    if went_up {
+                        // Compute the "difference" between `last_iter` and `direntry`.
+                        // For example, if...
+                        // - last_iter = `a/b/c/d`
+                        // - direntry = `a/b`
+                        // then diff = `c/d`
+                        //
+                        // All the unwraps() here are unreachable.
+                        let last_iter = last_iter.as_ref().unwrap();
+                        let diff = last_iter.path().strip_prefix(direntry.path()).unwrap();
+
+                        // Fix permissions for every entry in `diff`, inside-out.
+                        // We skip the last directory (which will be `.`) because
+                        // its permissions will be fixed when we walk _out_ of it.
+                        // (at this point, we might not be done copying `.`!)
+                        for p in skip_last(diff.ancestors()) {
+                            let src = direntry.path().join(p);
+                            let entry = Entry::new(&context, &src, options.no_target_dir)?;
+
+                            copy_attributes(
+                                &entry.source_absolute,
+                                &entry.local_to_target,
+                                &options.attributes,
+                            )?;
+                        }
+                    }
+
+                    last_iter = Some(direntry);
+                }
             }
+
             // Print an error message, but continue traversing the directory.
-            Err(e) => show_error!("{}", e),
+            Err(e) => show_error!("{e}"),
         }
     }
 
-    // Copy the attributes from the root directory to the target directory.
+    // Handle final directory permission fixes.
+    // This is almost the same as the permission-fixing code above,
+    // with minor differences (commented)
+    if let Some(last_iter) = last_iter {
+        let diff = last_iter.path().strip_prefix(root).unwrap();
+
+        // Do _not_ skip `.` this time, since we know we're done.
+        // This is where we fix the permissions of the top-level
+        // directory we just copied.
+        for p in diff.ancestors() {
+            let src = root.join(p);
+            let entry = Entry::new(&context, &src, options.no_target_dir)?;
+
+            copy_attributes(
+                &entry.source_absolute,
+                &entry.local_to_target,
+                &options.attributes,
+            )?;
+        }
+    }
+
+    // Also fix permissions for parent directories,
+    // if we were asked to create them.
     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)?;
+            if let Ok(src) = canonicalize(x, MissingHandling::Normal, ResolveMode::Physical) {
+                copy_attributes(&src, y, &options.attributes)?;
+            }
         }
-    } else {
-        copy_attributes(root, target, &options.attributes)?;
     }
 
     Ok(())
@@ -443,24 +508,61 @@ pub fn path_has_prefix(p1: &Path, p2: &Path) -> io::Result<bool> {
     Ok(pathbuf1.starts_with(pathbuf2))
 }
 
-#[cfg(test)]
-mod tests {
-    use super::ends_with_slash_dot;
-
-    #[test]
-    fn test_ends_with_slash_dot() {
-        assert!(ends_with_slash_dot("/."));
-        assert!(ends_with_slash_dot("./."));
-        assert!(ends_with_slash_dot("../."));
-        assert!(ends_with_slash_dot("a/."));
-        assert!(ends_with_slash_dot("/a/."));
-
-        assert!(!ends_with_slash_dot(""));
-        assert!(!ends_with_slash_dot("."));
-        assert!(!ends_with_slash_dot("./"));
-        assert!(!ends_with_slash_dot(".."));
-        assert!(!ends_with_slash_dot("/.."));
-        assert!(!ends_with_slash_dot("a/.."));
-        assert!(!ends_with_slash_dot("/a/.."));
+/// Builds a directory at the specified path with the given options.
+///
+/// # Notes
+/// - If `copy_attributes_from` is `Some`, the new directory's attributes will be
+///   copied from the provided file. Otherwise, the new directory will have the default
+///   attributes for the current user.
+/// - This method excludes certain permissions if ownership or special mode bits could
+///   potentially change. (See `test_dir_perm_race_with_preserve_mode_and_ownership``)
+/// - The `recursive` flag determines whether parent directories should be created
+///   if they do not already exist.
+// we need to allow unused_variable since `options` might be unused in non unix systems
+#[allow(unused_variables)]
+fn build_dir(
+    path: &PathBuf,
+    recursive: bool,
+    options: &Options,
+    copy_attributes_from: Option<&Path>,
+) -> CopyResult<()> {
+    let mut builder = fs::DirBuilder::new();
+    builder.recursive(recursive);
+
+    // To prevent unauthorized access before the folder is ready,
+    // exclude certain permissions if ownership or special mode bits
+    // could potentially change.
+    #[cfg(unix)]
+    {
+        use crate::Preserve;
+        use std::os::unix::fs::PermissionsExt;
+
+        // we need to allow trivial casts here because some systems like linux have u32 constants in
+        // in libc while others don't.
+        #[allow(clippy::unnecessary_cast)]
+        let mut excluded_perms = if matches!(options.attributes.ownership, Preserve::Yes { .. }) {
+            libc::S_IRWXG | libc::S_IRWXO // exclude rwx for group and other
+        } else if matches!(options.attributes.mode, Preserve::Yes { .. }) {
+            libc::S_IWGRP | libc::S_IWOTH //exclude w for group and other
+        } else {
+            0
+        } as u32;
+
+        let umask = if copy_attributes_from.is_some()
+            && matches!(options.attributes.mode, Preserve::Yes { .. })
+        {
+            !fs::symlink_metadata(copy_attributes_from.unwrap())?
+                .permissions()
+                .mode()
+        } else {
+            uucore::mode::get_umask()
+        };
+
+        excluded_perms |= umask;
+        let mode = !excluded_perms & 0o777; //use only the last three octet bits
+        std::os::unix::fs::DirBuilderExt::mode(&mut builder, mode);
     }
+
+    builder.create(path)?;
+    Ok(())
 }
diff --git a/src/uu/cp/src/cp.rs b/src/uu/cp/src/cp.rs
index 7dbf8aedb50..06f0b79657d 100644
--- a/src/uu/cp/src/cp.rs
+++ b/src/uu/cp/src/cp.rs
@@ -2,47 +2,42 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (ToDO) copydir ficlone fiemap ftruncate linkgs lstat nlink nlinks pathbuf pwrite reflink strs xattrs symlinked deduplicated advcpmv nushell
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::extra_unused_lifetimes)]
+// spell-checker:ignore (ToDO) copydir ficlone fiemap ftruncate linkgs lstat nlink nlinks pathbuf pwrite reflink strs xattrs symlinked deduplicated advcpmv nushell IRWXG IRWXO IRWXU IRWXUGO IRWXU IRWXG IRWXO IRWXUGO
 
 use quick_error::quick_error;
-use std::borrow::Cow;
 use std::cmp::Ordering;
-use std::collections::HashSet;
-use std::env;
-#[cfg(not(windows))]
-use std::ffi::CString;
-use std::fs::{self, File, OpenOptions};
+use std::collections::{HashMap, HashSet};
+use std::ffi::OsString;
+use std::fs::{self, Metadata, OpenOptions, Permissions};
 use std::io;
 #[cfg(unix)]
-use std::os::unix::ffi::OsStrExt;
-#[cfg(unix)]
 use std::os::unix::fs::{FileTypeExt, PermissionsExt};
 use std::path::{Path, PathBuf, StripPrefixError};
-use std::string::ToString;
+#[cfg(all(unix, not(target_os = "android")))]
+use uucore::fsxattr::copy_xattrs;
 
-use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::ValueParser, value_parser};
 use filetime::FileTime;
 use indicatif::{ProgressBar, ProgressStyle};
-#[cfg(unix)]
-use libc::mkfifo;
 use quick_error::ResultExt;
 
 use platform::copy_on_write;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UClapError, UError, UResult, UUsageError};
+use uucore::error::{UClapError, UError, UResult, UUsageError, set_exit_code};
+#[cfg(unix)]
+use uucore::fs::make_fifo;
 use uucore::fs::{
-    canonicalize, is_symlink_loop, paths_refer_to_same_file, FileInformation, MissingHandling,
-    ResolveMode,
+    FileInformation, MissingHandling, ResolveMode, are_hardlinks_to_same_file, canonicalize,
+    get_filename, is_symlink_loop, normalize_path, path_ends_with_terminator,
+    paths_refer_to_same_file,
 };
 use uucore::{backup_control, update_control};
 // These are exposed for projects (e.g. nushell) that want to create an `Options` value, which
 // requires these enum.
 pub use uucore::{backup_control::BackupMode, update_control::UpdateMode};
 use uucore::{
-    crash, format_usage, help_about, help_section, help_usage, prompt_yes, show_error,
-    show_warning, util_name,
+    format_usage, help_about, help_section, help_usage,
+    parser::shortcut_value_parser::ShortcutValueParser, prompt_yes, show_error, show_warning,
 };
 
 use crate::copydir::copy_directory;
@@ -54,11 +49,11 @@ quick_error! {
     #[derive(Debug)]
     pub enum Error {
         /// Simple io::Error wrapper
-        IoErr(err: io::Error) { from() source(err) display("{}", err)}
+        IoErr(err: io::Error) { from() source(err) display("{err}")}
 
         /// Wrapper for io::Error with path context
         IoErrContext(err: io::Error, path: String) {
-            display("{}: {}", path, err)
+            display("{path}: {err}")
             context(path: &'a str, err: io::Error) -> (err, path.to_owned())
             context(context: String, err: io::Error) -> (err, context)
             source(err)
@@ -66,7 +61,7 @@ quick_error! {
 
         /// General copy error
         Error(err: String) {
-            display("{}", err)
+            display("{err}")
             from(err: String) -> (err)
             from(err: &'static str) -> (err.to_string())
         }
@@ -76,25 +71,27 @@ quick_error! {
         NotAllFilesCopied {}
 
         /// Simple walkdir::Error wrapper
-        WalkDirErr(err: walkdir::Error) { from() display("{}", err) source(err) }
+        WalkDirErr(err: walkdir::Error) { from() display("{err}") source(err) }
 
         /// Simple std::path::StripPrefixError wrapper
         StripPrefixError(err: StripPrefixError) { from() }
 
         /// Result of a skipped file
-        /// Currently happens when "no" is selected in interactive mode
-        Skipped { }
+        /// Currently happens when "no" is selected in interactive mode or when
+        /// `no-clobber` flag is set and destination is already present.
+        /// `exit with error` is used to determine which exit code should be returned.
+        Skipped(exit_with_error:bool) { }
 
         /// Result of a skipped file
-        InvalidArgument(description: String) { display("{}", description) }
+        InvalidArgument(description: String) { display("{description}") }
 
         /// All standard options are included as an an implementation
         /// path, but those that are not implemented yet should return
         /// a NotImplemented error.
-        NotImplemented(opt: String) { display("Option '{}' not yet implemented.", opt) }
+        NotImplemented(opt: String) { display("Option '{opt}' not yet implemented.") }
 
         /// Invalid arguments to backup
-        Backup(description: String) { display("{}\nTry '{} --help' for more information.", description, uucore::execution_phrase()) }
+        Backup(description: String) { display("{description}\nTry '{} --help' for more information.", uucore::execution_phrase()) }
 
         NotADirectory(path: PathBuf) { display("'{}' is not a directory", path.display()) }
     }
@@ -109,15 +106,16 @@ impl UError for Error {
 pub type CopyResult<T> = Result<T, Error>;
 
 /// Specifies how to overwrite files.
-#[derive(Clone, Copy, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
 pub enum ClobberMode {
     Force,
     RemoveDestination,
+    #[default]
     Standard,
 }
 
 /// Specifies whether files should be overwritten.
-#[derive(Clone, Copy, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum OverwriteMode {
     /// [Default] Always overwrite existing files
     Clobber(ClobberMode),
@@ -127,32 +125,56 @@ pub enum OverwriteMode {
     NoClobber,
 }
 
+impl Default for OverwriteMode {
+    fn default() -> Self {
+        Self::Clobber(ClobberMode::default())
+    }
+}
+
 /// Possible arguments for `--reflink`.
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum ReflinkMode {
     Always,
     Auto,
     Never,
 }
 
+impl Default for ReflinkMode {
+    #[allow(clippy::derivable_impls)]
+    fn default() -> Self {
+        #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
+        {
+            ReflinkMode::Auto
+        }
+        #[cfg(not(any(target_os = "linux", target_os = "android", target_os = "macos")))]
+        {
+            ReflinkMode::Never
+        }
+    }
+}
+
 /// Possible arguments for `--sparse`.
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
 pub enum SparseMode {
     Always,
+    #[default]
     Auto,
     Never,
 }
 
 /// The expected file type of copy target
+#[derive(Copy, Clone)]
 pub enum TargetType {
     Directory,
     File,
 }
 
 /// Copy action to perform
+#[derive(Debug, Clone, Eq, PartialEq, Default)]
 pub enum CopyMode {
     Link,
     SymLink,
+    #[default]
     Copy,
     Update,
     AttrOnly,
@@ -171,7 +193,7 @@ pub enum CopyMode {
 /// For full compatibility with GNU, these options should also combine. We
 /// currently only do a best effort imitation of that behavior, because it is
 /// difficult to achieve in clap, especially with `--no-preserve`.
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct Attributes {
     #[cfg(unix)]
     pub ownership: Preserve,
@@ -182,9 +204,17 @@ pub struct Attributes {
     pub xattr: Preserve,
 }
 
+impl Default for Attributes {
+    fn default() -> Self {
+        Self::NONE
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Preserve {
-    No,
+    // explicit means whether the --no-preserve flag is used or not to distinguish out the default value.
+    // e.g. --no-preserve=mode means mode = No { explicit = true }
+    No { explicit: bool },
     Yes { required: bool },
 }
 
@@ -197,9 +227,9 @@ impl PartialOrd for Preserve {
 impl Ord for Preserve {
     fn cmp(&self, other: &Self) -> Ordering {
         match (self, other) {
-            (Self::No, Self::No) => Ordering::Equal,
-            (Self::Yes { .. }, Self::No) => Ordering::Greater,
-            (Self::No, Self::Yes { .. }) => Ordering::Less,
+            (Self::No { .. }, Self::No { .. }) => Ordering::Equal,
+            (Self::Yes { .. }, Self::No { .. }) => Ordering::Greater,
+            (Self::No { .. }, Self::Yes { .. }) => Ordering::Less,
             (
                 Self::Yes { required: req_self },
                 Self::Yes {
@@ -219,6 +249,7 @@ impl Ord for Preserve {
 ///
 /// The fields are documented with the arguments that determine their value.
 #[allow(dead_code)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Options {
     /// `--attributes-only`
     pub attributes_only: bool,
@@ -280,6 +311,47 @@ pub struct Options {
     pub verbose: bool,
     /// `-g`, `--progress`
     pub progress_bar: bool,
+    /// -Z
+    pub set_selinux_context: bool,
+    // --context
+    pub context: Option<String>,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            attributes_only: false,
+            backup: BackupMode::default(),
+            copy_contents: false,
+            cli_dereference: false,
+            copy_mode: CopyMode::default(),
+            dereference: false,
+            no_target_dir: false,
+            one_file_system: false,
+            overwrite: OverwriteMode::default(),
+            parents: false,
+            sparse_mode: SparseMode::default(),
+            strip_trailing_slashes: false,
+            reflink_mode: ReflinkMode::default(),
+            attributes: Attributes::default(),
+            recursive: false,
+            backup_suffix: backup_control::DEFAULT_BACKUP_SUFFIX.to_owned(),
+            target_dir: None,
+            update: UpdateMode::default(),
+            debug: false,
+            verbose: false,
+            progress_bar: false,
+            set_selinux_context: false,
+            context: None,
+        }
+    }
+}
+
+/// Enum representing if a file has been skipped.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum PerformedAction {
+    Copied,
+    Skipped,
 }
 
 /// Enum representing various debug states of the offload and reflink actions.
@@ -382,6 +454,7 @@ mod options {
     pub const RECURSIVE: &str = "recursive";
     pub const REFLINK: &str = "reflink";
     pub const REMOVE_DESTINATION: &str = "remove-destination";
+    pub const SELINUX: &str = "Z";
     pub const SPARSE: &str = "sparse";
     pub const STRIP_TRAILING_SLASHES: &str = "strip-trailing-slashes";
     pub const SYMBOLIC_LINK: &str = "symbolic-link";
@@ -396,22 +469,20 @@ static PRESERVABLE_ATTRIBUTES: &[&str] = &[
     "ownership",
     "timestamps",
     "context",
-    "link",
     "links",
     "xattr",
     "all",
 ];
 
 #[cfg(not(unix))]
-static PRESERVABLE_ATTRIBUTES: &[&str] = &[
-    "mode",
-    "timestamps",
-    "context",
-    "link",
-    "links",
-    "xattr",
-    "all",
-];
+static PRESERVABLE_ATTRIBUTES: &[&str] =
+    &["mode", "timestamps", "context", "links", "xattr", "all"];
+
+const PRESERVE_DEFAULT_VALUES: &str = if cfg!(unix) {
+    "mode,ownership,timestamp"
+} else {
+    "mode,timestamp"
+};
 
 pub fn uu_app() -> Command {
     const MODE_ARGS: &[&str] = &[
@@ -422,7 +493,7 @@ pub fn uu_app() -> Command {
         options::COPY_CONTENTS,
     ];
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(format!(
@@ -475,8 +546,8 @@ pub fn uu_app() -> Command {
         )
         .arg(
             Arg::new(options::RECURSIVE)
-                .short('r')
-                .visible_short_alias('R')
+                .short('R')
+                .visible_short_alias('r')
                 .long(options::RECURSIVE)
                 // --archive sets this option
                 .help("copy directories recursively")
@@ -543,7 +614,7 @@ pub fn uu_app() -> Command {
                 .overrides_with_all(MODE_ARGS)
                 .require_equals(true)
                 .default_missing_value("always")
-                .value_parser(["auto", "always", "never"])
+                .value_parser(ShortcutValueParser::new(["auto", "always", "never"]))
                 .num_args(0..=1)
                 .help("control clone/CoW copies. See below"),
         )
@@ -559,17 +630,11 @@ pub fn uu_app() -> Command {
                 .long(options::PRESERVE)
                 .action(ArgAction::Append)
                 .use_value_delimiter(true)
-                .value_parser(clap::builder::PossibleValuesParser::new(
-                    PRESERVABLE_ATTRIBUTES,
-                ))
+                .value_parser(ShortcutValueParser::new(PRESERVABLE_ATTRIBUTES))
                 .num_args(0..)
                 .require_equals(true)
                 .value_name("ATTR_LIST")
-                .overrides_with_all([
-                    options::ARCHIVE,
-                    options::PRESERVE_DEFAULT_ATTRIBUTES,
-                    options::NO_PRESERVE,
-                ])
+                .default_missing_value(PRESERVE_DEFAULT_VALUES)
                 // -d sets this option
                 // --archive sets this option
                 .help(
@@ -581,19 +646,18 @@ pub fn uu_app() -> Command {
             Arg::new(options::PRESERVE_DEFAULT_ATTRIBUTES)
                 .short('p')
                 .long(options::PRESERVE_DEFAULT_ATTRIBUTES)
-                .overrides_with_all([options::PRESERVE, options::NO_PRESERVE, options::ARCHIVE])
                 .help("same as --preserve=mode,ownership(unix only),timestamps")
                 .action(ArgAction::SetTrue),
         )
         .arg(
             Arg::new(options::NO_PRESERVE)
                 .long(options::NO_PRESERVE)
+                .action(ArgAction::Append)
+                .use_value_delimiter(true)
+                .value_parser(ShortcutValueParser::new(PRESERVABLE_ATTRIBUTES))
+                .num_args(0..)
+                .require_equals(true)
                 .value_name("ATTR_LIST")
-                .overrides_with_all([
-                    options::PRESERVE_DEFAULT_ATTRIBUTES,
-                    options::PRESERVE,
-                    options::ARCHIVE,
-                ])
                 .help("don't preserve the specified attributes"),
         )
         .arg(
@@ -630,11 +694,6 @@ pub fn uu_app() -> Command {
             Arg::new(options::ARCHIVE)
                 .short('a')
                 .long(options::ARCHIVE)
-                .overrides_with_all([
-                    options::PRESERVE_DEFAULT_ATTRIBUTES,
-                    options::PRESERVE,
-                    options::NO_PRESERVE,
-                ])
                 .help("Same as -dR --preserve=all")
                 .action(ArgAction::SetTrue),
         )
@@ -655,44 +714,56 @@ pub fn uu_app() -> Command {
             Arg::new(options::SPARSE)
                 .long(options::SPARSE)
                 .value_name("WHEN")
-                .value_parser(["never", "auto", "always"])
+                .value_parser(ShortcutValueParser::new(["never", "auto", "always"]))
                 .help("control creation of sparse files. See below"),
         )
-        // TODO: implement the following args
         .arg(
-            Arg::new(options::COPY_CONTENTS)
-                .long(options::COPY_CONTENTS)
-                .overrides_with(options::ATTRIBUTES_ONLY)
-                .help("NotImplemented: copy contents of special files when recursive")
+            Arg::new(options::SELINUX)
+                .short('Z')
+                .help("set SELinux security context of destination file to default type")
                 .action(ArgAction::SetTrue),
         )
         .arg(
             Arg::new(options::CONTEXT)
                 .long(options::CONTEXT)
                 .value_name("CTX")
+                .value_parser(value_parser!(String))
                 .help(
-                    "NotImplemented: set SELinux security context of destination file to \
-                    default type",
-                ),
+                    "like -Z, or if CTX is specified then set the SELinux or SMACK security \
+                    context to CTX",
+                )
+                .num_args(0..=1)
+                .require_equals(true)
+                .default_missing_value(""),
         )
-        // END TODO
         .arg(
             // The 'g' short flag is modeled after advcpmv
             // See this repo: https://github.com/jarun/advcpmv
             Arg::new(options::PROGRESS_BAR)
                 .long(options::PROGRESS_BAR)
                 .short('g')
-                .action(clap::ArgAction::SetTrue)
+                .action(ArgAction::SetTrue)
                 .help(
                     "Display a progress bar. \n\
                 Note: this feature is not supported by GNU coreutils.",
                 ),
         )
+        // TODO: implement the following args
+        .arg(
+            Arg::new(options::COPY_CONTENTS)
+                .long(options::COPY_CONTENTS)
+                .overrides_with(options::ATTRIBUTES_ONLY)
+                .help("NotImplemented: copy contents of special files when recursive")
+                .action(ArgAction::SetTrue),
+        )
+        // END TODO
         .arg(
             Arg::new(options::PATHS)
                 .action(ArgAction::Append)
+                .num_args(1..)
+                .required(true)
                 .value_hint(clap::ValueHint::AnyPath)
-                .value_parser(ValueParser::path_buf()),
+                .value_parser(ValueParser::os_string()),
         )
 }
 
@@ -714,7 +785,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     } else if let Ok(mut matches) = matches {
         let options = Options::from_matches(&matches)?;
 
-        if options.overwrite == OverwriteMode::NoClobber && options.backup != BackupMode::NoBackup {
+        if options.overwrite == OverwriteMode::NoClobber && options.backup != BackupMode::None {
             return Err(UUsageError::new(
                 EXIT_ERR,
                 "options --backup and --no-clobber are mutually exclusive",
@@ -722,8 +793,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
 
         let paths: Vec<PathBuf> = matches
-            .remove_many::<PathBuf>(options::PATHS)
-            .map(|v| v.collect())
+            .remove_many::<OsString>(options::PATHS)
+            .map(|v| v.map(PathBuf::from).collect())
             .unwrap_or_default();
 
         let (sources, target) = parse_path_args(paths, &options)?;
@@ -734,7 +805,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 // code should still be EXIT_ERR as does GNU cp
                 Error::NotAllFilesCopied => {}
                 // Else we caught a fatal bubbled-up error, log it to stderr
-                _ => show_error!("{}", error),
+                _ => show_error!("{error}"),
             };
             set_exit_code(EXIT_ERR);
         }
@@ -780,7 +851,11 @@ impl CopyMode {
         {
             Self::Update
         } else if matches.get_flag(options::ATTRIBUTES_ONLY) {
-            Self::AttrOnly
+            if matches.get_flag(options::REMOVE_DESTINATION) {
+                Self::Copy
+            } else {
+                Self::AttrOnly
+            }
         } else {
             Self::Copy
         }
@@ -800,7 +875,7 @@ impl Attributes {
             }
             #[cfg(not(feature = "feat_selinux"))]
             {
-                Preserve::No
+                Preserve::No { explicit: false }
             }
         },
         links: Preserve::Yes { required: true },
@@ -809,12 +884,12 @@ impl Attributes {
 
     pub const NONE: Self = Self {
         #[cfg(unix)]
-        ownership: Preserve::No,
-        mode: Preserve::No,
-        timestamps: Preserve::No,
-        context: Preserve::No,
-        links: Preserve::No,
-        xattr: Preserve::No,
+        ownership: Preserve::No { explicit: false },
+        mode: Preserve::No { explicit: false },
+        timestamps: Preserve::No { explicit: false },
+        context: Preserve::No { explicit: false },
+        links: Preserve::No { explicit: false },
+        xattr: Preserve::No { explicit: false },
     };
 
     // TODO: ownership is required if the user is root, for non-root users it's not required.
@@ -823,6 +898,7 @@ impl Attributes {
         ownership: Preserve::Yes { required: true },
         mode: Preserve::Yes { required: true },
         timestamps: Preserve::Yes { required: true },
+        xattr: Preserve::Yes { required: true },
         ..Self::NONE
     };
 
@@ -843,6 +919,27 @@ impl Attributes {
         }
     }
 
+    /// Set the field to Preserve::NO { explicit: true } if the corresponding field
+    /// in other is set to Preserve::Yes { .. }.
+    pub fn diff(self, other: &Self) -> Self {
+        fn update_preserve_field(current: Preserve, other: Preserve) -> Preserve {
+            if matches!(other, Preserve::Yes { .. }) {
+                Preserve::No { explicit: true }
+            } else {
+                current
+            }
+        }
+        Self {
+            #[cfg(unix)]
+            ownership: update_preserve_field(self.ownership, other.ownership),
+            mode: update_preserve_field(self.mode, other.mode),
+            timestamps: update_preserve_field(self.timestamps, other.timestamps),
+            context: update_preserve_field(self.context, other.context),
+            links: update_preserve_field(self.links, other.links),
+            xattr: update_preserve_field(self.xattr, other.xattr),
+        }
+    }
+
     pub fn parse_iter<T>(values: impl Iterator<Item = T>) -> Result<Self, Error>
     where
         T: AsRef<str>,
@@ -892,7 +989,6 @@ impl Options {
         let not_implemented_opts = vec![
             #[cfg(not(any(windows, unix)))]
             options::ONE_FILE_SYSTEM,
-            options::CONTEXT,
             #[cfg(windows)]
             options::FORCE,
         ];
@@ -914,6 +1010,16 @@ impl Options {
         };
         let update_mode = update_control::determine_update_mode(matches);
 
+        if backup_mode != BackupMode::None
+            && matches
+                .get_one::<String>(update_control::arguments::OPT_UPDATE)
+                .is_some_and(|v| v == "none" || v == "none-fail")
+        {
+            return Err(Error::InvalidArgument(
+                "--backup is mutually exclusive with -n or --update=none-fail".to_string(),
+            ));
+        }
+
         let backup_suffix = backup_control::determine_backup_suffix(matches);
 
         let overwrite = OverwriteMode::from_matches(matches);
@@ -929,27 +1035,89 @@ impl Options {
                 return Err(Error::NotADirectory(dir.clone()));
             }
         };
+        // cp follows POSIX conventions for overriding options such as "-a",
+        // "-d", "--preserve", and "--no-preserve". We can use clap's
+        // override-all behavior to achieve this, but there's a challenge: when
+        // clap overrides an argument, it removes all traces of it from the
+        // match. This poses a problem because flags like "-a" expand to "-dR
+        // --preserve=all", and we only want to override the "--preserve=all"
+        // part. Additionally, we need to handle multiple occurrences of the
+        // same flags. To address this, we create an overriding order from the
+        // matches here.
+        let mut overriding_order: Vec<(usize, &str, Vec<&String>)> = vec![];
+        // We iterate through each overriding option, adding each occurrence of
+        // the option along with its value and index as a tuple, and push it to
+        // `overriding_order`.
+        for option in [
+            options::PRESERVE,
+            options::NO_PRESERVE,
+            options::ARCHIVE,
+            options::PRESERVE_DEFAULT_ATTRIBUTES,
+            options::NO_DEREFERENCE_PRESERVE_LINKS,
+        ] {
+            if let (Ok(Some(val)), Some(index)) = (
+                matches.try_get_one::<bool>(option),
+                // even though it says in the doc that `index_of` would give us
+                // the first index of the argument, when it comes to flag it
+                // gives us the last index where the flag appeared (probably
+                // because it overrides itself). Since it is a flag and it would
+                // have same value across the occurrences we just need the last
+                // index.
+                matches.index_of(option),
+            ) {
+                if *val {
+                    overriding_order.push((index, option, vec![]));
+                }
+            } else if let (Some(occurrences), Some(mut indices)) = (
+                matches.get_occurrences::<String>(option),
+                matches.indices_of(option),
+            ) {
+                occurrences.for_each(|val| {
+                    if let Some(index) = indices.next() {
+                        let val = val.collect::<Vec<&String>>();
+                        // As mentioned in the documentation of the indices_of
+                        // function, it provides the indices of the individual
+                        // values. Therefore, to get the index of the first
+                        // value of the next occurrence in the next iteration,
+                        // we need to advance the indices iterator by the length
+                        // of the current occurrence's values.
+                        for _ in 1..val.len() {
+                            indices.next();
+                        }
+                        overriding_order.push((index, option, val));
+                    }
+                });
+            }
+        }
+        overriding_order.sort_by(|a, b| a.0.cmp(&b.0));
 
-        // Parse attributes to preserve
-        let attributes = if let Some(attribute_strs) = matches.get_many::<String>(options::PRESERVE)
-        {
-            if attribute_strs.len() == 0 {
-                Attributes::DEFAULT
-            } else {
-                Attributes::parse_iter(attribute_strs)?
+        let mut attributes = Attributes::NONE;
+
+        // Iterate through the `overriding_order` and adjust the attributes accordingly.
+        for (_, option, val) in overriding_order {
+            match option {
+                options::ARCHIVE => {
+                    attributes = Attributes::ALL;
+                }
+                options::PRESERVE_DEFAULT_ATTRIBUTES => {
+                    attributes = attributes.union(&Attributes::DEFAULT);
+                }
+                options::NO_DEREFERENCE_PRESERVE_LINKS => {
+                    attributes = attributes.union(&Attributes::LINKS);
+                }
+                options::PRESERVE => {
+                    attributes = attributes.union(&Attributes::parse_iter(val.into_iter())?);
+                }
+                options::NO_PRESERVE => {
+                    if !val.is_empty() {
+                        attributes = attributes.diff(&Attributes::parse_iter(val.into_iter())?);
+                    }
+                }
+                _ => (),
             }
-        } else if matches.get_flag(options::ARCHIVE) {
-            // --archive is used. Same as --preserve=all
-            Attributes::ALL
-        } else if matches.get_flag(options::NO_DEREFERENCE_PRESERVE_LINKS) {
-            Attributes::LINKS
-        } else if matches.get_flag(options::PRESERVE_DEFAULT_ATTRIBUTES) {
-            Attributes::DEFAULT
-        } else {
-            Attributes::NONE
-        };
+        }
 
-        #[cfg(not(feature = "feat_selinux"))]
+        #[cfg(not(feature = "selinux"))]
         if let Preserve::Yes { required } = attributes.context {
             let selinux_disabled_error =
                 Error::Error("SELinux was not enabled during the compile time!".to_string());
@@ -960,6 +1128,15 @@ impl Options {
             }
         }
 
+        // Extract the SELinux related flags and options
+        let set_selinux_context = matches.get_flag(options::SELINUX);
+
+        let context = if matches.contains_id(options::CONTEXT) {
+            matches.get_one::<String>(options::CONTEXT).cloned()
+        } else {
+            None
+        };
+
         let options = Self {
             attributes_only: matches.get_flag(options::ATTRIBUTES_ONLY),
             copy_contents: matches.get_flag(options::COPY_CONTENTS),
@@ -969,7 +1146,9 @@ impl Options {
             dereference: !(matches.get_flag(options::NO_DEREFERENCE)
                 || matches.get_flag(options::NO_DEREFERENCE_PRESERVE_LINKS)
                 || matches.get_flag(options::ARCHIVE)
-                || recursive)
+                // cp normally follows the link only when not copying recursively or when
+                // --link (-l) is used
+                || (recursive && CopyMode::from_matches(matches)!= CopyMode::Link ))
                 || matches.get_flag(options::DEREFERENCE),
             one_file_system: matches.get_flag(options::ONE_FILE_SYSTEM),
             parents: matches.get_flag(options::PARENTS),
@@ -991,18 +1170,7 @@ impl Options {
                         }
                     }
                 } else {
-                    #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
-                    {
-                        ReflinkMode::Auto
-                    }
-                    #[cfg(not(any(
-                        target_os = "linux",
-                        target_os = "android",
-                        target_os = "macos"
-                    )))]
-                    {
-                        ReflinkMode::Never
-                    }
+                    ReflinkMode::default()
                 }
             },
             sparse_mode: {
@@ -1029,6 +1197,8 @@ impl Options {
             recursive,
             target_dir,
             progress_bar: matches.get_flag(options::PROGRESS_BAR),
+            set_selinux_context: set_selinux_context || context.is_some(),
+            context,
         };
 
         Ok(options)
@@ -1040,11 +1210,25 @@ impl Options {
 
     fn preserve_hard_links(&self) -> bool {
         match self.attributes.links {
-            Preserve::No => false,
+            Preserve::No { .. } => false,
             Preserve::Yes { .. } => true,
         }
     }
 
+    #[cfg(unix)]
+    fn preserve_mode(&self) -> (bool, bool) {
+        match self.attributes.mode {
+            Preserve::No { explicit } => {
+                if explicit {
+                    (false, true)
+                } else {
+                    (false, false)
+                }
+            }
+            Preserve::Yes { .. } => (true, false),
+        }
+    }
+
     /// Whether to force overwriting the destination file.
     fn force(&self) -> bool {
         matches!(self.overwrite, OverwriteMode::Clobber(ClobberMode::Force))
@@ -1073,12 +1257,19 @@ fn parse_path_args(
     if paths.is_empty() {
         // No files specified
         return Err("missing file operand".into());
+    } else if paths.len() == 1 && options.target_dir.is_none() {
+        // Only one file specified
+        return Err(format!(
+            "missing destination file operand after {}",
+            paths[0].display().to_string().quote()
+        )
+        .into());
     }
 
     // Return an error if the user requested to copy more than one
     // file source to a file target
     if options.no_target_dir && options.target_dir.is_none() && paths.len() > 2 {
-        return Err(format!("extra operand {:?}", paths[2]).into());
+        return Err(format!("extra operand {:}", paths[2].display().to_string().quote()).into());
     }
 
     let target = match options.target_dir {
@@ -1095,6 +1286,9 @@ fn parse_path_args(
     };
 
     if options.strip_trailing_slashes {
+        // clippy::assigning_clones added with Rust 1.78
+        // Rust version = 1.76 on OpenBSD stable/7.5
+        #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
         for source in &mut paths {
             *source = source.components().as_path().to_owned();
         }
@@ -1103,67 +1297,6 @@ fn parse_path_args(
     Ok((paths, target))
 }
 
-/// Get the inode information for a file.
-fn get_inode(file_info: &FileInformation) -> u64 {
-    #[cfg(unix)]
-    let result = file_info.inode();
-    #[cfg(windows)]
-    let result = file_info.file_index();
-    result
-}
-
-#[cfg(target_os = "redox")]
-fn preserve_hardlinks(
-    hard_links: &mut Vec<(String, u64)>,
-    source: &std::path::Path,
-    dest: &std::path::Path,
-    found_hard_link: &mut bool,
-) -> CopyResult<()> {
-    // Redox does not currently support hard links
-    Ok(())
-}
-
-/// Hard link a pair of files if needed _and_ record if this pair is a new hard link.
-#[cfg(not(target_os = "redox"))]
-fn preserve_hardlinks(
-    hard_links: &mut Vec<(String, u64)>,
-    source: &std::path::Path,
-    dest: &std::path::Path,
-) -> CopyResult<bool> {
-    let info = FileInformation::from_path(source, false)
-        .context(format!("cannot stat {}", source.quote()))?;
-    let inode = get_inode(&info);
-    let nlinks = info.number_of_links();
-    let mut found_hard_link = false;
-    #[allow(clippy::explicit_iter_loop)]
-    for (link, link_inode) in hard_links.iter() {
-        if *link_inode == inode {
-            // Consider the following files:
-            //
-            // * `src/f` - a regular file
-            // * `src/link` - a hard link to `src/f`
-            // * `dest/src/f` - a different regular file
-            //
-            // In this scenario, if we do `cp -a src/ dest/`, it is
-            // possible that the order of traversal causes `src/link`
-            // to get copied first (to `dest/src/link`). In that case,
-            // in order to make sure `dest/src/link` is a hard link to
-            // `dest/src/f` and `dest/src/f` has the contents of
-            // `src/f`, we delete the existing file to allow the hard
-            // linking.
-            if file_or_link_exists(dest) && file_or_link_exists(Path::new(link)) {
-                std::fs::remove_file(dest)?;
-            }
-            std::fs::hard_link(link, dest).unwrap();
-            found_hard_link = true;
-        }
-    }
-    if !found_hard_link && nlinks > 1 {
-        hard_links.push((dest.to_str().unwrap().to_string(), inode));
-    }
-    Ok(found_hard_link)
-}
-
 /// When handling errors, we don't always want to show them to the user. This function handles that.
 fn show_error_if_needed(error: &Error) {
     match error {
@@ -1172,12 +1305,12 @@ fn show_error_if_needed(error: &Error) {
         Error::NotAllFilesCopied => {
             // Need to return an error code
         }
-        Error::Skipped => {
+        Error::Skipped(_) => {
             // touch a b && echo "n"|cp -i a b && echo $?
             // should return an error from GNU 9.2
         }
         _ => {
-            show_error!("{}", error);
+            show_error!("{error}");
         }
     }
 }
@@ -1192,14 +1325,22 @@ pub fn copy(sources: &[PathBuf], target: &Path, options: &Options) -> CopyResult
     let target_type = TargetType::determine(sources, target);
     verify_target_type(target, &target_type)?;
 
-    let preserve_hard_links = options.preserve_hard_links();
-
-    let mut hard_links: Vec<(String, u64)> = vec![];
-
     let mut non_fatal_errors = false;
     let mut seen_sources = HashSet::with_capacity(sources.len());
     let mut symlinked_files = HashSet::new();
 
+    // to remember the copied files for further usage.
+    // the FileInformation implemented the Hash trait by using
+    // 1. inode number
+    // 2. device number
+    // the combination of a file's inode number and device number is unique throughout all the file systems.
+    //
+    // key is the source file's information and the value is the destination filepath.
+    let mut copied_files: HashMap<FileInformation, PathBuf> = HashMap::with_capacity(sources.len());
+    // remember the copied destinations for further usage.
+    // we can't use copied_files as it is because the key is the source file's information.
+    let mut copied_destinations: HashSet<PathBuf> = HashSet::with_capacity(sources.len());
+
     let progress_bar = if options.progress_bar {
         let pb = ProgressBar::new(disk_usage(sources, options.recursive)?)
             .with_style(
@@ -1216,31 +1357,58 @@ pub fn copy(sources: &[PathBuf], target: &Path, options: &Options) -> CopyResult
     };
 
     for source in sources {
-        if seen_sources.contains(source) {
-            // FIXME: compare sources by the actual file they point to, not their path. (e.g. dir/file == dir/../dir/file in most cases)
-            show_warning!("source {} specified more than once", source.quote());
-        } else {
-            let found_hard_link = if preserve_hard_links && !source.is_dir() {
-                let dest = construct_dest_path(source, target, &target_type, options)?;
-                preserve_hardlinks(&mut hard_links, source, &dest)?
+        let normalized_source = normalize_path(source);
+        if options.backup == BackupMode::None && seen_sources.contains(&normalized_source) {
+            let file_type = if source.symlink_metadata()?.file_type().is_dir() {
+                "directory"
             } else {
-                false
+                "file"
             };
-            if !found_hard_link {
-                if let Err(error) = copy_source(
-                    &progress_bar,
-                    source,
-                    target,
-                    &target_type,
-                    options,
-                    &mut symlinked_files,
-                ) {
-                    show_error_if_needed(&error);
+            show_warning!(
+                "source {file_type} {} specified more than once",
+                source.quote()
+            );
+        } else {
+            let dest = construct_dest_path(source, target, target_type, options)
+                .unwrap_or_else(|_| target.to_path_buf());
+
+            if fs::metadata(&dest).is_ok()
+                && !fs::symlink_metadata(&dest)?.file_type().is_symlink()
+                // if both `source` and `dest` are symlinks, it should be considered as an overwrite.
+                || fs::metadata(source).is_ok()
+                    && fs::symlink_metadata(source)?.file_type().is_symlink()
+                || matches!(options.copy_mode, CopyMode::SymLink)
+            {
+                // There is already a file and it isn't a symlink (managed in a different place)
+                if copied_destinations.contains(&dest) && options.backup != BackupMode::Numbered {
+                    // If the target file was already created in this cp call, do not overwrite
+                    return Err(Error::Error(format!(
+                        "will not overwrite just-created '{}' with '{}'",
+                        dest.display(),
+                        source.display()
+                    )));
+                }
+            }
+
+            if let Err(error) = copy_source(
+                progress_bar.as_ref(),
+                source,
+                target,
+                target_type,
+                options,
+                &mut symlinked_files,
+                &copied_destinations,
+                &mut copied_files,
+            ) {
+                show_error_if_needed(&error);
+                if !matches!(error, Error::Skipped(false)) {
                     non_fatal_errors = true;
                 }
+            } else {
+                copied_destinations.insert(dest.clone());
             }
-            seen_sources.insert(source);
         }
+        seen_sources.insert(normalized_source);
     }
 
     if let Some(pb) = progress_bar {
@@ -1257,7 +1425,7 @@ pub fn copy(sources: &[PathBuf], target: &Path, options: &Options) -> CopyResult
 fn construct_dest_path(
     source_path: &Path,
     target: &Path,
-    target_type: &TargetType,
+    target_type: TargetType,
     options: &Options,
 ) -> CopyResult<PathBuf> {
     if options.no_target_dir && target.is_dir() {
@@ -1272,10 +1440,14 @@ fn construct_dest_path(
         return Err("with --parents, the destination must be a directory".into());
     }
 
-    Ok(match *target_type {
+    Ok(match target_type {
         TargetType::Directory => {
             let root = if options.parents {
-                Path::new("")
+                if source_path.has_root() && cfg!(unix) {
+                    Path::new("/")
+                } else {
+                    Path::new("")
+                }
             } else {
                 source_path.parent().unwrap_or(source_path)
             };
@@ -1284,19 +1456,30 @@ fn construct_dest_path(
         TargetType::File => target.to_path_buf(),
     })
 }
-
+#[allow(clippy::too_many_arguments)]
 fn copy_source(
-    progress_bar: &Option<ProgressBar>,
+    progress_bar: Option<&ProgressBar>,
     source: &Path,
     target: &Path,
-    target_type: &TargetType,
+    target_type: TargetType,
     options: &Options,
     symlinked_files: &mut HashSet<FileInformation>,
+    copied_destinations: &HashSet<PathBuf>,
+    copied_files: &mut HashMap<FileInformation, PathBuf>,
 ) -> CopyResult<()> {
     let source_path = Path::new(&source);
     if source_path.is_dir() {
         // Copy as directory
-        copy_directory(progress_bar, source, target, options, symlinked_files, true)
+        copy_directory(
+            progress_bar,
+            source,
+            target,
+            options,
+            symlinked_files,
+            copied_destinations,
+            copied_files,
+            true,
+        )
     } else {
         // Copy as file
         let dest = construct_dest_path(source_path, target, target_type, options)?;
@@ -1306,36 +1489,99 @@ fn copy_source(
             dest.as_path(),
             options,
             symlinked_files,
+            copied_destinations,
+            copied_files,
             true,
         );
         if options.parents {
             for (x, y) in aligned_ancestors(source, dest.as_path()) {
-                copy_attributes(x, y, &options.attributes)?;
+                if let Ok(src) = canonicalize(x, MissingHandling::Normal, ResolveMode::Physical) {
+                    copy_attributes(&src, y, &options.attributes)?;
+                }
             }
         }
         res
     }
 }
 
+/// If `path` does not have `S_IWUSR` set, returns a tuple of the file's
+/// mode in octal (index 0) and human-readable (index 1) formats.
+///
+/// If the destination of a copy operation is a file that is not writeable to
+/// the owner (bit `S_IWUSR`), extra information needs to be added to the
+/// interactive mode prompt: the mode (permissions) of the file in octal and
+/// human-readable format.
+// TODO
+// The destination metadata can be read multiple times in the course of a single execution of `cp`.
+// This fix adds yet another metadata read.
+// Should this metadata be read once and then reused throughout the execution?
+// https://github.com/uutils/coreutils/issues/6658
+fn file_mode_for_interactive_overwrite(
+    #[cfg_attr(not(unix), allow(unused_variables))] path: &Path,
+) -> Option<(String, String)> {
+    // Retain outer braces to ensure only one branch is included
+    {
+        #[cfg(unix)]
+        {
+            use libc::{S_IWUSR, mode_t};
+            use std::os::unix::prelude::MetadataExt;
+
+            match path.metadata() {
+                Ok(me) => {
+                    // Cast is necessary on some platforms
+                    let mode: mode_t = me.mode() as mode_t;
+
+                    // It looks like this extra information is added to the prompt iff the file's user write bit is 0
+                    //  write permission, owner
+                    if uucore::has!(mode, S_IWUSR) {
+                        None
+                    } else {
+                        // Discard leading digits
+                        let mode_without_leading_digits = mode & 0o7777;
+
+                        Some((
+                            format!("{mode_without_leading_digits:04o}"),
+                            uucore::fs::display_permissions_unix(mode, false),
+                        ))
+                    }
+                }
+                // TODO: How should failure to read the metadata be handled? Ignoring for now.
+                Err(_) => None,
+            }
+        }
+
+        #[cfg(not(unix))]
+        {
+            None
+        }
+    }
+}
+
 impl OverwriteMode {
-    fn verify(&self, path: &Path, verbose: bool) -> CopyResult<()> {
+    fn verify(&self, path: &Path, debug: bool) -> CopyResult<()> {
         match *self {
             Self::NoClobber => {
-                if verbose {
+                if debug {
                     println!("skipped {}", path.quote());
-                } else {
-                    eprintln!("{}: not replacing {}", util_name(), path.quote());
                 }
-                Err(Error::NotAllFilesCopied)
+                Err(Error::Skipped(false))
             }
             Self::Interactive(_) => {
-                if prompt_yes!("overwrite {}?", path.quote()) {
+                let prompt_yes_result = if let Some((octal, human_readable)) =
+                    file_mode_for_interactive_overwrite(path)
+                {
+                    prompt_yes!(
+                        "replace {}, overriding mode {octal} ({human_readable})?",
+                        path.quote()
+                    )
+                } else {
+                    prompt_yes!("overwrite {}?", path.quote())
+                };
+
+                if prompt_yes_result {
                     Ok(())
                 } else {
-                    if verbose {
-                        println!("skipped {}", path.quote());
-                    }
-                    Err(Error::Skipped)
+                    Err(Error::Skipped(true))
                 }
             }
             Self::Clobber(_) => Ok(()),
@@ -1348,7 +1594,7 @@ impl OverwriteMode {
 /// If it's required, then the error is thrown.
 fn handle_preserve<F: Fn() -> CopyResult<()>>(p: &Preserve, f: F) -> CopyResult<()> {
     match p {
-        Preserve::No => {}
+        Preserve::No { .. } => {}
         Preserve::Yes { required } => {
             let result = f();
             if *required {
@@ -1361,6 +1607,42 @@ fn handle_preserve<F: Fn() -> CopyResult<()>>(p: &Preserve, f: F) -> CopyResult<
     Ok(())
 }
 
+/// Copies extended attributes (xattrs) from `source` to `dest`, ensuring that `dest` is temporarily
+/// user-writable if needed and restoring its original permissions afterward. This avoids “Operation
+/// not permitted� errors on read-only files. Returns an error if permission or metadata operations fail,
+/// or if xattr copying fails.
+#[cfg(all(unix, not(target_os = "android")))]
+fn copy_extended_attrs(source: &Path, dest: &Path) -> CopyResult<()> {
+    let metadata = fs::symlink_metadata(dest)?;
+
+    // Check if the destination file is currently read-only for the user.
+    let mut perms = metadata.permissions();
+    let was_readonly = perms.readonly();
+
+    // Temporarily grant user write if it was read-only.
+    if was_readonly {
+        #[allow(clippy::permissions_set_readonly_false)]
+        perms.set_readonly(false);
+        fs::set_permissions(dest, perms)?;
+    }
+
+    // Perform the xattr copy and capture any potential error,
+    // so we can restore permissions before returning.
+    let copy_xattrs_result = copy_xattrs(source, dest);
+
+    // Restore read-only if we changed it.
+    if was_readonly {
+        let mut revert_perms = fs::symlink_metadata(dest)?.permissions();
+        revert_perms.set_readonly(true);
+        fs::set_permissions(dest, revert_perms)?;
+    }
+
+    // If copying xattrs failed, propagate that error now.
+    copy_xattrs_result?;
+
+    Ok(())
+}
+
 /// Copy the specified attributes from one path to another.
 pub(crate) fn copy_attributes(
     source: &Path,
@@ -1374,14 +1656,14 @@ pub(crate) fn copy_attributes(
     #[cfg(unix)]
     handle_preserve(&attributes.ownership, || -> CopyResult<()> {
         use std::os::unix::prelude::MetadataExt;
-        use uucore::perms::wrap_chown;
         use uucore::perms::Verbosity;
         use uucore::perms::VerbosityLevel;
+        use uucore::perms::wrap_chown;
 
         let dest_uid = source_metadata.uid();
         let dest_gid = source_metadata.gid();
-
-        wrap_chown(
+        // gnu compatibility: cp doesn't report an error if it fails to set the ownership.
+        let _ = wrap_chown(
             dest,
             &dest.symlink_metadata().context(context)?,
             Some(dest_uid),
@@ -1389,11 +1671,9 @@ pub(crate) fn copy_attributes(
             false,
             Verbosity {
                 groups_only: false,
-                level: VerbosityLevel::Normal,
+                level: VerbosityLevel::Silent,
             },
-        )
-        .map_err(Error::Error)?;
-
+        );
         Ok(())
     })?;
 
@@ -1427,39 +1707,33 @@ pub(crate) fn copy_attributes(
         Ok(())
     })?;
 
-    #[cfg(feature = "feat_selinux")]
+    #[cfg(feature = "selinux")]
     handle_preserve(&attributes.context, || -> CopyResult<()> {
-        let context = selinux::SecurityContext::of_path(source, false, false).map_err(|e| {
-            format!(
-                "failed to get security context of {}: {}",
-                source.display(),
-                e
-            )
-        })?;
-        if let Some(context) = context {
-            context.set_for_path(dest, false, false).map_err(|e| {
-                format!(
-                    "failed to set security context for {}: {}",
-                    dest.display(),
-                    e
-                )
-            })?;
+        // Get the source context and apply it to the destination
+        if let Ok(context) = selinux::SecurityContext::of_path(source, false, false) {
+            if let Some(context) = context {
+                if let Err(e) = context.set_for_path(dest, false, false) {
+                    return Err(Error::Error(format!(
+                        "failed to set the security context of {}: {e}",
+                        dest.display()
+                    )));
+                }
+            }
+        } else {
+            return Err(Error::Error(format!(
+                "failed to get security context of {}",
+                source.display()
+            )));
         }
-
         Ok(())
     })?;
 
     handle_preserve(&attributes.xattr, || -> CopyResult<()> {
-        #[cfg(unix)]
+        #[cfg(all(unix, not(target_os = "android")))]
         {
-            let xattrs = xattr::list(source)?;
-            for attr in xattrs {
-                if let Some(attr_value) = xattr::get(source, attr.clone())? {
-                    xattr::set(dest, attr, &attr_value[..])?;
-                }
-            }
+            copy_extended_attrs(source, dest)?;
         }
-        #[cfg(not(unix))]
+        #[cfg(not(all(unix, not(target_os = "android"))))]
         {
             // The documentation for GNU cp states:
             //
@@ -1482,16 +1756,23 @@ pub(crate) fn copy_attributes(
 fn symlink_file(
     source: &Path,
     dest: &Path,
-    context: &str,
     symlinked_files: &mut HashSet<FileInformation>,
 ) -> CopyResult<()> {
     #[cfg(not(windows))]
     {
-        std::os::unix::fs::symlink(source, dest).context(context)?;
+        std::os::unix::fs::symlink(source, dest).context(format!(
+            "cannot create symlink {} to {}",
+            get_filename(dest).unwrap_or("invalid file name").quote(),
+            get_filename(source).unwrap_or("invalid file name").quote()
+        ))?;
     }
     #[cfg(windows)]
     {
-        std::os::windows::fs::symlink_file(source, dest).context(context)?;
+        std::os::windows::fs::symlink_file(source, dest).context(format!(
+            "cannot create symlink {} to {}",
+            get_filename(dest).unwrap_or("invalid file name").quote(),
+            get_filename(source).unwrap_or("invalid file name").quote()
+        ))?;
     }
     if let Ok(file_info) = FileInformation::from_path(dest, false) {
         symlinked_files.insert(file_info);
@@ -1503,10 +1784,15 @@ fn context_for(src: &Path, dest: &Path) -> String {
     format!("{} -> {}", src.quote(), dest.quote())
 }
 
-/// Implements a simple backup copy for the destination file.
+/// Implements a simple backup copy for the destination file .
+/// if is_dest_symlink flag is set to true dest will be renamed to backup_path
 /// TODO: for the backup, should this function be replaced by `copy_file(...)`?
-fn backup_dest(dest: &Path, backup_path: &Path) -> CopyResult<PathBuf> {
-    fs::copy(dest, backup_path)?;
+fn backup_dest(dest: &Path, backup_path: &Path, is_dest_symlink: bool) -> CopyResult<PathBuf> {
+    if is_dest_symlink {
+        fs::rename(dest, backup_path)?;
+    } else {
+        fs::copy(dest, backup_path)?;
+    }
     Ok(backup_path.into())
 }
 
@@ -1515,7 +1801,7 @@ fn backup_dest(dest: &Path, backup_path: &Path) -> CopyResult<PathBuf> {
 ///
 /// Copying to the same file is only allowed if both `--backup` and
 /// `--force` are specified and the file is a regular file.
-fn is_forbidden_copy_to_same_file(
+fn is_forbidden_to_copy_to_same_file(
     source: &Path,
     dest: &Path,
     options: &Options,
@@ -1523,10 +1809,44 @@ fn is_forbidden_copy_to_same_file(
 ) -> bool {
     // TODO To match the behavior of GNU cp, we also need to check
     // that the file is a regular file.
+    let source_is_symlink = source.is_symlink();
+    let dest_is_symlink = dest.is_symlink();
+    // only disable dereference if both source and dest is symlink and dereference flag is disabled
     let dereference_to_compare =
-        options.dereference(source_in_command_line) || !source.is_symlink();
-    paths_refer_to_same_file(source, dest, dereference_to_compare)
-        && !(options.force() && options.backup != BackupMode::NoBackup)
+        options.dereference(source_in_command_line) || (!source_is_symlink || !dest_is_symlink);
+    if !paths_refer_to_same_file(source, dest, dereference_to_compare) {
+        return false;
+    }
+    if options.backup != BackupMode::None {
+        if options.force() && !source_is_symlink {
+            return false;
+        }
+        if source_is_symlink && !options.dereference {
+            return false;
+        }
+        if dest_is_symlink {
+            return false;
+        }
+        if !dest_is_symlink && !source_is_symlink && dest != source {
+            return false;
+        }
+    }
+    if options.copy_mode == CopyMode::Link {
+        return false;
+    }
+    if options.copy_mode == CopyMode::SymLink && dest_is_symlink {
+        return false;
+    }
+    // If source and dest are both the same symlink but with different names, then allow the copy.
+    // This can occur, for example, if source and dest are both hardlinks to the same symlink.
+    if dest_is_symlink
+        && source_is_symlink
+        && source.file_name() != dest.file_name()
+        && !options.dereference
+    {
+        return false;
+    }
+    true
 }
 
 /// Back up, remove, or leave intact the destination file, depending on the options.
@@ -1535,15 +1855,26 @@ fn handle_existing_dest(
     dest: &Path,
     options: &Options,
     source_in_command_line: bool,
+    copied_files: &HashMap<FileInformation, PathBuf>,
 ) -> CopyResult<()> {
     // Disallow copying a file to itself, unless `--force` and
     // `--backup` are both specified.
-    if is_forbidden_copy_to_same_file(source, dest, options, source_in_command_line) {
+    if is_forbidden_to_copy_to_same_file(source, dest, options, source_in_command_line) {
         return Err(format!("{} and {} are the same file", source.quote(), dest.quote()).into());
     }
 
-    options.overwrite.verify(dest, options.verbose)?;
+    if options.update == UpdateMode::None {
+        if options.debug {
+            println!("skipped {}", dest.quote());
+        }
+        return Err(Error::Skipped(false));
+    }
+
+    if options.update != UpdateMode::IfOlder {
+        options.overwrite.verify(dest, options.debug)?;
+    }
 
+    let mut is_dest_removed = false;
     let backup_path = backup_control::get_backup_path(options.backup, dest, &options.backup_suffix);
     if let Some(backup_path) = backup_path {
         if paths_refer_to_same_file(source, &backup_path, true) {
@@ -1554,22 +1885,80 @@ fn handle_existing_dest(
             )
             .into());
         } else {
-            backup_dest(dest, &backup_path)?;
+            is_dest_removed = dest.is_symlink();
+            backup_dest(dest, &backup_path, is_dest_removed)?;
         }
     }
-    match options.overwrite {
-        // FIXME: print that the file was removed if --verbose is enabled
-        OverwriteMode::Clobber(ClobberMode::Force) => {
-            if is_symlink_loop(dest) || fs::metadata(dest)?.permissions().readonly() {
-                fs::remove_file(dest)?;
+    if !is_dest_removed {
+        delete_dest_if_needed_and_allowed(
+            source,
+            dest,
+            options,
+            source_in_command_line,
+            copied_files,
+        )?;
+    }
+
+    Ok(())
+}
+
+/// Checks if:
+/// * `dest` needs to be deleted before the copy operation can proceed
+/// * the provided options allow this deletion
+///
+/// If so, deletes `dest`.
+fn delete_dest_if_needed_and_allowed(
+    source: &Path,
+    dest: &Path,
+    options: &Options,
+    source_in_command_line: bool,
+    copied_files: &HashMap<FileInformation, PathBuf>,
+) -> CopyResult<()> {
+    let delete_dest = match options.overwrite {
+        OverwriteMode::Clobber(cl) | OverwriteMode::Interactive(cl) => {
+            match cl {
+                // FIXME: print that the file was removed if --verbose is enabled
+                ClobberMode::Force => {
+                    // TODO
+                    // Using `readonly` here to check if `dest` needs to be deleted is not correct:
+                    // "On Unix-based platforms this checks if any of the owner, group or others write permission bits are set. It does not check if the current user is in the file's assigned group. It also does not check ACLs. Therefore the return value of this function cannot be relied upon to predict whether attempts to read or write the file will actually succeed."
+                    // This results in some copy operations failing, because this necessary deletion is being skipped.
+                    is_symlink_loop(dest) || fs::metadata(dest)?.permissions().readonly()
+                }
+                ClobberMode::RemoveDestination => true,
+                ClobberMode::Standard => {
+                    // Consider the following files:
+                    //
+                    // * `src/f` - a regular file
+                    // * `src/link` - a hard link to `src/f`
+                    // * `dest/src/f` - a different regular file
+                    //
+                    // In this scenario, if we do `cp -a src/ dest/`, it is
+                    // possible that the order of traversal causes `src/link`
+                    // to get copied first (to `dest/src/link`). In that case,
+                    // in order to make sure `dest/src/link` is a hard link to
+                    // `dest/src/f` and `dest/src/f` has the contents of
+                    // `src/f`, we delete the existing file to allow the hard
+                    // linking.
+                    options.preserve_hard_links() &&
+                            // only try to remove dest file only if the current source
+                            // is hardlink to a file that is already copied
+                            copied_files.contains_key(
+                                &FileInformation::from_path(
+                                    source,
+                                    options.dereference(source_in_command_line)
+                                ).context(format!("cannot stat {}", source.quote()))?
+                            )
+                }
             }
         }
-        OverwriteMode::Clobber(ClobberMode::RemoveDestination) => {
-            fs::remove_file(dest)?;
-        }
-        _ => (),
+        OverwriteMode::NoClobber => false,
     };
 
+    if delete_dest {
+        fs::remove_file(dest)?;
+    }
+
     Ok(())
 }
 
@@ -1609,7 +1998,7 @@ fn aligned_ancestors<'a>(source: &'a Path, dest: &'a Path) -> Vec<(&'a Path, &'a
     // Get the matching number of elements from the ancestors of the
     // destination path (for example, get "d/a" and "d/a/b").
     let k = source_ancestors.len();
-    let dest_ancestors = &dest_ancestors[1..1 + k];
+    let dest_ancestors = &dest_ancestors[1..=k];
 
     // Now we have two slices of the same length, so we zip them.
     let mut result = vec![];
@@ -1623,143 +2012,61 @@ fn aligned_ancestors<'a>(source: &'a Path, dest: &'a Path) -> Vec<(&'a Path, &'a
     result
 }
 
-/// Copy the a file from `source` to `dest`. `source` will be dereferenced if
-/// `options.dereference` is set to true. `dest` will be dereferenced only if
-/// the source was not a symlink.
-///
-/// Behavior when copying to existing files is contingent on the
-/// `options.overwrite` mode. If a file is skipped, the return type
-/// should be `Error:Skipped`
-///
-/// 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>,
+fn print_verbose_output(
+    parents: bool,
+    progress_bar: Option<&ProgressBar>,
     source: &Path,
     dest: &Path,
-    options: &Options,
-    symlinked_files: &mut HashSet<FileInformation>,
-    source_in_command_line: bool,
-) -> CopyResult<()> {
-    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(());
-    }
-
-    // Fail if dest is a dangling symlink or a symlink this program created previously
-    if dest.is_symlink() {
-        if FileInformation::from_path(dest, false)
-            .map(|info| symlinked_files.contains(&info))
-            .unwrap_or(false)
-        {
-            return Err(Error::Error(format!(
-                "will not copy '{}' through just-created symlink '{}'",
-                source.display(),
-                dest.display()
-            )));
-        }
-        let copy_contents = options.dereference(source_in_command_line) || !source.is_symlink();
-        if copy_contents
-            && !dest.exists()
-            && !matches!(
-                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 '{}'",
-                dest.display()
-            )));
-        }
-    }
-
-    if file_or_link_exists(dest) {
-        handle_existing_dest(source, dest, options, source_in_command_line)?;
+) {
+    if let Some(pb) = progress_bar {
+        // Suspend (hide) the progress bar so the println won't overlap with the progress bar.
+        pb.suspend(|| {
+            print_paths(parents, source, dest);
+        });
+    } else {
+        print_paths(parents, source, dest);
     }
+}
 
-    if options.verbose {
-        if let Some(pb) = progress_bar {
-            // Suspend (hide) the progress bar so the println won't overlap with the progress bar.
-            pb.suspend(|| {
-                if options.parents {
-                    // For example, if copying file `a/b/c` and its parents
-                    // to directory `d/`, then print
-                    //
-                    //     a -> d/a
-                    //     a/b -> d/a/b
-                    //
-                    for (x, y) in aligned_ancestors(source, dest) {
-                        println!("{} -> {}", x.display(), y.display());
-                    }
-                }
-
-                println!("{}", context_for(source, dest));
-            });
-        } else {
-            if options.parents {
-                // For example, if copying file `a/b/c` and its parents
-                // to directory `d/`, then print
-                //
-                //     a -> d/a
-                //     a/b -> d/a/b
-                //
-                for (x, y) in aligned_ancestors(source, dest) {
-                    println!("{} -> {}", x.display(), y.display());
-                }
-            }
-
-            println!("{}", context_for(source, dest));
+fn print_paths(parents: bool, source: &Path, dest: &Path) {
+    if parents {
+        // For example, if copying file `a/b/c` and its parents
+        // to directory `d/`, then print
+        //
+        //     a -> d/a
+        //     a/b -> d/a/b
+        //
+        for (x, y) in aligned_ancestors(source, dest) {
+            println!("{} -> {}", x.display(), y.display());
         }
     }
 
-    // Calculate the context upfront before canonicalizing the path
-    let context = context_for(source, dest);
-    let context = context.as_str();
-
-    let source_metadata = {
-        let result = if options.dereference(source_in_command_line) {
-            fs::metadata(source)
-        } else {
-            fs::symlink_metadata(source)
-        };
-        result.context(context)?
-    };
-    let source_file_type = source_metadata.file_type();
-    let source_is_symlink = source_file_type.is_symlink();
-
-    #[cfg(unix)]
-    let source_is_fifo = source_file_type.is_fifo();
-    #[cfg(not(unix))]
-    let source_is_fifo = false;
-
-    let dest_permissions = if dest.exists() {
-        dest.symlink_metadata().context(context)?.permissions()
-    } else {
-        #[allow(unused_mut)]
-        let mut permissions = source_metadata.permissions();
-        #[cfg(unix)]
-        {
-            use uucore::mode::get_umask;
-
-            let mut mode = permissions.mode();
-
-            // remove sticky bit, suid and gid bit
-            const SPECIAL_PERMS_MASK: u32 = 0o7000;
-            mode &= !SPECIAL_PERMS_MASK;
-
-            // apply umask
-            mode &= !get_umask();
+    println!("{}", context_for(source, dest));
+}
 
-            permissions.set_mode(mode);
-        }
-        permissions
-    };
+/// Handles the copy mode for a file copy operation.
+///
+/// This function determines how to copy a file based on the provided options.
+/// It supports different copy modes, including hard linking, copying, symbolic linking, updating, and attribute-only copying.
+/// It also handles file backups, overwriting, and dereferencing based on the provided options.
+///
+/// # Returns
+///
+/// * `Ok(())` - The file was copied successfully.
+/// * `Err(CopyError)` - An error occurred while copying the file.
+#[allow(clippy::too_many_arguments)]
+fn handle_copy_mode(
+    source: &Path,
+    dest: &Path,
+    options: &Options,
+    context: &str,
+    source_metadata: &Metadata,
+    symlinked_files: &mut HashSet<FileInformation>,
+    source_in_command_line: bool,
+    source_is_fifo: bool,
+    #[cfg(unix)] source_is_stream: bool,
+) -> CopyResult<PerformedAction> {
+    let source_is_symlink = source_metadata.is_symlink();
 
     match options.copy_mode {
         CopyMode::Link => {
@@ -1767,7 +2074,7 @@ fn copy_file(
                 let backup_path =
                     backup_control::get_backup_path(options.backup, dest, &options.backup_suffix);
                 if let Some(backup_path) = backup_path {
-                    backup_dest(dest, &backup_path)?;
+                    backup_dest(dest, &backup_path, dest.is_symlink())?;
                     fs::remove_file(dest)?;
                 }
                 if options.overwrite == OverwriteMode::Clobber(ClobberMode::Force) {
@@ -1781,7 +2088,11 @@ fn copy_file(
             } else {
                 fs::hard_link(source, dest)
             }
-            .context(context)?;
+            .context(format!(
+                "cannot create hard link {} to {}",
+                get_filename(dest).unwrap_or("invalid file name").quote(),
+                get_filename(source).unwrap_or("invalid file name").quote()
+            ))?;
         }
         CopyMode::Copy => {
             copy_helper(
@@ -1792,18 +2103,20 @@ fn copy_file(
                 source_is_symlink,
                 source_is_fifo,
                 symlinked_files,
+                #[cfg(unix)]
+                source_is_stream,
             )?;
         }
         CopyMode::SymLink => {
             if dest.exists() && options.overwrite == OverwriteMode::Clobber(ClobberMode::Force) {
                 fs::remove_file(dest)?;
             }
-            symlink_file(source, dest, context, symlinked_files)?;
+            symlink_file(source, dest, symlinked_files)?;
         }
         CopyMode::Update => {
             if dest.exists() {
                 match options.update {
-                    update_control::UpdateMode::ReplaceAll => {
+                    UpdateMode::All => {
                         copy_helper(
                             source,
                             dest,
@@ -1812,17 +2125,30 @@ fn copy_file(
                             source_is_symlink,
                             source_is_fifo,
                             symlinked_files,
+                            #[cfg(unix)]
+                            source_is_stream,
                         )?;
                     }
-                    update_control::UpdateMode::ReplaceNone => return Ok(()),
-                    update_control::UpdateMode::ReplaceIfOlder => {
+                    UpdateMode::None => {
+                        if options.debug {
+                            println!("skipped {}", dest.quote());
+                        }
+
+                        return Ok(PerformedAction::Skipped);
+                    }
+                    UpdateMode::NoneFail => {
+                        return Err(Error::Error(format!("not replacing '{}'", dest.display())));
+                    }
+                    UpdateMode::IfOlder => {
                         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(());
+                            return Ok(PerformedAction::Skipped);
                         } else {
+                            options.overwrite.verify(dest, options.debug)?;
+
                             copy_helper(
                                 source,
                                 dest,
@@ -1831,6 +2157,8 @@ fn copy_file(
                                 source_is_symlink,
                                 source_is_fifo,
                                 symlinked_files,
+                                #[cfg(unix)]
+                                source_is_stream,
                             )?;
                         }
                     }
@@ -1844,6 +2172,8 @@ fn copy_file(
                     source_is_symlink,
                     source_is_fifo,
                     symlinked_files,
+                    #[cfg(unix)]
+                    source_is_stream,
                 )?;
             }
         }
@@ -1857,8 +2187,251 @@ fn copy_file(
         }
     };
 
+    Ok(PerformedAction::Copied)
+}
+
+/// Calculates the permissions for the destination file in a copy operation.
+///
+/// If the destination file already exists, its current permissions are returned.
+/// If the destination file does not exist, the source file's permissions are used,
+/// with the `no-preserve` option and the umask taken into account on Unix platforms.
+/// # Returns
+///
+/// * `Ok(Permissions)` - The calculated permissions for the destination file.
+/// * `Err(CopyError)` - An error occurred while getting the metadata of the destination file.
+///
+// Allow unused variables for Windows (on options)
+#[allow(unused_variables)]
+fn calculate_dest_permissions(
+    dest: &Path,
+    source_metadata: &Metadata,
+    options: &Options,
+    context: &str,
+) -> CopyResult<Permissions> {
+    if dest.exists() {
+        Ok(dest.symlink_metadata().context(context)?.permissions())
+    } else {
+        #[cfg(unix)]
+        {
+            let mut permissions = source_metadata.permissions();
+            let mode = handle_no_preserve_mode(options, permissions.mode());
+
+            // Apply umask
+            use uucore::mode::get_umask;
+            let mode = mode & !get_umask();
+            permissions.set_mode(mode);
+            Ok(permissions)
+        }
+        #[cfg(not(unix))]
+        {
+            let permissions = source_metadata.permissions();
+            Ok(permissions)
+        }
+    }
+}
+
+/// Copy the a file from `source` to `dest`. `source` will be dereferenced if
+/// `options.dereference` is set to true. `dest` will be dereferenced only if
+/// the source was not a symlink.
+///
+/// Behavior when copying to existing files is contingent on the
+/// `options.overwrite` mode. If a file is skipped, the return type
+/// should be `Error:Skipped`
+///
+/// The original permissions of `source` will be copied to `dest`
+/// after a successful copy.
+#[allow(clippy::cognitive_complexity, clippy::too_many_arguments)]
+fn copy_file(
+    progress_bar: Option<&ProgressBar>,
+    source: &Path,
+    dest: &Path,
+    options: &Options,
+    symlinked_files: &mut HashSet<FileInformation>,
+    copied_destinations: &HashSet<PathBuf>,
+    copied_files: &mut HashMap<FileInformation, PathBuf>,
+    source_in_command_line: bool,
+) -> CopyResult<()> {
+    let source_is_symlink = source.is_symlink();
+    let dest_is_symlink = dest.is_symlink();
+    // Fail if dest is a dangling symlink or a symlink this program created previously
+    if dest_is_symlink {
+        if FileInformation::from_path(dest, false)
+            .map(|info| symlinked_files.contains(&info))
+            .unwrap_or(false)
+        {
+            return Err(Error::Error(format!(
+                "will not copy '{}' through just-created symlink '{}'",
+                source.display(),
+                dest.display()
+            )));
+        }
+        // Fail if cp tries to copy two sources of the same name into a single symlink
+        // Example: "cp file1 dir1/file1 tmp" where "tmp" is a directory containing a symlink "file1" pointing to a file named "foo".
+        // foo will contain the contents of "file1" and "dir1/file1" will not be copied over to "tmp/file1"
+        if copied_destinations.contains(dest) {
+            return Err(Error::Error(format!(
+                "will not copy '{}' through just-created symlink '{}'",
+                source.display(),
+                dest.display()
+            )));
+        }
+
+        let copy_contents = options.dereference(source_in_command_line) || !source_is_symlink;
+        if copy_contents
+            && !dest.exists()
+            && !matches!(
+                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 '{}'",
+                dest.display()
+            )));
+        }
+        if paths_refer_to_same_file(source, dest, true)
+            && matches!(
+                options.overwrite,
+                OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+            )
+            && options.backup == BackupMode::None
+        {
+            fs::remove_file(dest)?;
+        }
+    }
+
+    if are_hardlinks_to_same_file(source, dest)
+        && source != dest
+        && matches!(
+            options.overwrite,
+            OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+        )
+    {
+        fs::remove_file(dest)?;
+    }
+
+    if file_or_link_exists(dest)
+        && (!options.attributes_only
+            || matches!(
+                options.overwrite,
+                OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+            ))
+    {
+        if paths_refer_to_same_file(source, dest, true) && options.copy_mode == CopyMode::Link {
+            if source_is_symlink {
+                if !dest_is_symlink {
+                    return Ok(());
+                }
+                if !options.dereference {
+                    return Ok(());
+                }
+            } else if options.backup != BackupMode::None && !dest_is_symlink {
+                if source == dest {
+                    if !options.force() {
+                        return Ok(());
+                    }
+                } else {
+                    return Ok(());
+                }
+            }
+        }
+        handle_existing_dest(source, dest, options, source_in_command_line, copied_files)?;
+        if are_hardlinks_to_same_file(source, dest) {
+            if options.copy_mode == CopyMode::Copy {
+                return Ok(());
+            }
+            if options.copy_mode == CopyMode::Link && (!source_is_symlink || !dest_is_symlink) {
+                return Ok(());
+            }
+        }
+    }
+
+    if options.attributes_only
+        && source_is_symlink
+        && !matches!(
+            options.overwrite,
+            OverwriteMode::Clobber(ClobberMode::RemoveDestination)
+        )
+    {
+        return Err(format!(
+            "cannot change attribute {}: Source file is a non regular file",
+            dest.quote()
+        )
+        .into());
+    }
+
+    if options.preserve_hard_links() {
+        // if we encounter a matching device/inode pair in the source tree
+        // we can arrange to create a hard link between the corresponding names
+        // in the destination tree.
+        if let Some(new_source) = copied_files.get(
+            &FileInformation::from_path(source, options.dereference(source_in_command_line))
+                .context(format!("cannot stat {}", source.quote()))?,
+        ) {
+            fs::hard_link(new_source, dest)?;
+
+            if options.verbose {
+                print_verbose_output(options.parents, progress_bar, source, dest);
+            }
+
+            return Ok(());
+        };
+    }
+
+    // Calculate the context upfront before canonicalizing the path
+    let context = context_for(source, dest);
+    let context = context.as_str();
+
+    let source_metadata = {
+        let result = if options.dereference(source_in_command_line) {
+            fs::metadata(source)
+        } else {
+            fs::symlink_metadata(source)
+        };
+        // this is just for gnu tests compatibility
+        result.map_err(|err| {
+            if err.to_string().contains("No such file or directory") {
+                return format!("cannot stat {}: No such file or directory", source.quote());
+            }
+            err.to_string()
+        })?
+    };
+
+    let dest_permissions = calculate_dest_permissions(dest, &source_metadata, options, context)?;
+
+    #[cfg(unix)]
+    let source_is_fifo = source_metadata.file_type().is_fifo();
+    #[cfg(not(unix))]
+    let source_is_fifo = false;
+
+    #[cfg(unix)]
+    let source_is_stream = source_is_fifo
+        || source_metadata.file_type().is_char_device()
+        || source_metadata.file_type().is_block_device();
+    #[cfg(not(unix))]
+    let source_is_stream = false;
+
+    let performed_action = handle_copy_mode(
+        source,
+        dest,
+        options,
+        context,
+        &source_metadata,
+        symlinked_files,
+        source_in_command_line,
+        source_is_fifo,
+        #[cfg(unix)]
+        source_is_stream,
+    )?;
+
+    if options.verbose && performed_action != PerformedAction::Skipped {
+        print_verbose_output(options.parents, progress_bar, source, dest);
+    }
+
     // TODO: implement something similar to gnu's lchown
-    if !dest.is_symlink() {
+    if !dest_is_symlink {
         // Here, to match GNU semantics, we quietly ignore an error
         // if a user does not have the correct ownership to modify
         // the permissions of a file.
@@ -1868,7 +2441,35 @@ fn copy_file(
         fs::set_permissions(dest, dest_permissions).ok();
     }
 
-    copy_attributes(source, dest, &options.attributes)?;
+    if options.dereference(source_in_command_line) {
+        if let Ok(src) = canonicalize(source, MissingHandling::Normal, ResolveMode::Physical) {
+            if src.exists() {
+                copy_attributes(&src, dest, &options.attributes)?;
+            }
+        }
+    } else if source_is_stream && source.exists() {
+        // Some stream files may not exist after we have copied it,
+        // like anonymous pipes. Thus, we can't really copy its
+        // attributes. However, this is already handled in the stream
+        // copy function (see `copy_stream` under platform/linux.rs).
+    } else {
+        copy_attributes(source, dest, &options.attributes)?;
+    }
+
+    #[cfg(feature = "selinux")]
+    if options.set_selinux_context && uucore::selinux::is_selinux_enabled() {
+        // Set the given selinux permissions on the copied file.
+        if let Err(e) =
+            uucore::selinux::set_selinux_security_context(dest, options.context.as_ref())
+        {
+            return Err(Error::Error(format!("SELinux error: {}", e)));
+        }
+    }
+
+    copied_files.insert(
+        FileInformation::from_path(source, options.dereference(source_in_command_line))?,
+        dest.to_path_buf(),
+    );
 
     if let Some(progress_bar) = progress_bar {
         progress_bar.inc(fs::metadata(source)?.len());
@@ -1877,8 +2478,54 @@ fn copy_file(
     Ok(())
 }
 
+#[cfg(unix)]
+fn handle_no_preserve_mode(options: &Options, org_mode: u32) -> u32 {
+    let (is_preserve_mode, is_explicit_no_preserve_mode) = options.preserve_mode();
+    if !is_preserve_mode {
+        use libc::{
+            S_IRGRP, S_IROTH, S_IRUSR, S_IRWXG, S_IRWXO, S_IRWXU, S_IWGRP, S_IWOTH, S_IWUSR,
+        };
+
+        #[cfg(not(any(
+            target_os = "android",
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "redox",
+        )))]
+        {
+            const MODE_RW_UGO: u32 = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+            const S_IRWXUGO: u32 = S_IRWXU | S_IRWXG | S_IRWXO;
+            return if is_explicit_no_preserve_mode {
+                MODE_RW_UGO
+            } else {
+                org_mode & S_IRWXUGO
+            };
+        }
+
+        #[cfg(any(
+            target_os = "android",
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "redox",
+        ))]
+        {
+            const MODE_RW_UGO: u32 =
+                (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) as u32;
+            const S_IRWXUGO: u32 = (S_IRWXU | S_IRWXG | S_IRWXO) as u32;
+            if is_explicit_no_preserve_mode {
+                return MODE_RW_UGO;
+            } else {
+                return org_mode & S_IRWXUGO;
+            };
+        }
+    }
+
+    org_mode
+}
+
 /// Copy the file from `source` to `dest` either using the normal `fs::copy` or a
 /// copy-on-write scheme if --reflink is specified and the filesystem supports it.
+#[allow(clippy::too_many_arguments)]
 fn copy_helper(
     source: &Path,
     dest: &Path,
@@ -1887,20 +2534,20 @@ fn copy_helper(
     source_is_symlink: bool,
     source_is_fifo: bool,
     symlinked_files: &mut HashSet<FileInformation>,
+    #[cfg(unix)] source_is_stream: bool,
 ) -> CopyResult<()> {
     if options.parents {
         let parent = dest.parent().unwrap_or(dest);
         fs::create_dir_all(parent)?;
     }
 
-    if source.as_os_str() == "/dev/null" {
-        /* workaround a limitation of fs::copy
-         * https://github.com/rust-lang/rust/issues/79390
-         */
-        File::create(dest).context(dest.display().to_string())?;
-    } else if source_is_fifo && options.recursive && !options.copy_contents {
+    if path_ends_with_terminator(dest) && !dest.is_dir() {
+        return Err(Error::NotADirectory(dest.to_path_buf()));
+    }
+
+    if source_is_fifo && options.recursive && !options.copy_contents {
         #[cfg(unix)]
-        copy_fifo(dest, options.overwrite, options.verbose)?;
+        copy_fifo(dest, options.overwrite, options.debug)?;
     } else if source_is_symlink {
         copy_link(source, dest, symlinked_files)?;
     } else {
@@ -1910,8 +2557,10 @@ fn copy_helper(
             options.reflink_mode,
             options.sparse_mode,
             context,
-            #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
+            #[cfg(unix)]
             source_is_fifo,
+            #[cfg(unix)]
+            source_is_stream,
         )?;
 
         if !options.attributes_only && options.debug {
@@ -1925,18 +2574,13 @@ 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, verbose: bool) -> CopyResult<()> {
+fn copy_fifo(dest: &Path, overwrite: OverwriteMode, debug: bool) -> CopyResult<()> {
     if dest.exists() {
-        overwrite.verify(dest, verbose)?;
+        overwrite.verify(dest, debug)?;
         fs::remove_file(dest)?;
     }
 
-    let name = CString::new(dest.as_os_str().as_bytes()).unwrap();
-    let err = unsafe { mkfifo(name.as_ptr(), 0o666) };
-    if err == -1 {
-        return Err(format!("cannot create fifo {}: File exists", dest.quote()).into());
-    }
-    Ok(())
+    make_fifo(dest).map_err(|_| format!("cannot create fifo {}: File exists", dest.quote()).into())
 }
 
 fn copy_link(
@@ -1946,24 +2590,12 @@ fn copy_link(
 ) -> CopyResult<()> {
     // Here, we will copy the symlink itself (actually, just recreate it)
     let link = fs::read_link(source)?;
-    let dest: Cow<'_, Path> = if dest.is_dir() {
-        match source.file_name() {
-            Some(name) => dest.join(name).into(),
-            None => crash!(
-                EXIT_ERR,
-                "cannot stat {}: No such file or directory",
-                source.quote()
-            ),
-        }
-    } else {
-        // we always need to remove the file to be able to create a symlink,
-        // even if it is writeable.
-        if dest.is_symlink() || dest.is_file() {
-            fs::remove_file(dest)?;
-        }
-        dest.into()
-    };
-    symlink_file(&link, &dest, &context_for(&link, &dest), symlinked_files)
+    // we always need to remove the file to be able to create a symlink,
+    // even if it is writeable.
+    if dest.is_symlink() || dest.is_file() {
+        fs::remove_file(dest)?;
+    }
+    symlink_file(&link, dest, symlinked_files)
 }
 
 /// Generate an error message if `target` is not the correct `target_type`
@@ -2036,7 +2668,7 @@ fn disk_usage_directory(p: &Path) -> io::Result<u64> {
 #[cfg(test)]
 mod tests {
 
-    use crate::{aligned_ancestors, localize_to_target};
+    use crate::{Attributes, Preserve, aligned_ancestors, localize_to_target};
     use std::path::Path;
 
     #[test]
@@ -2058,4 +2690,52 @@ mod tests {
         ];
         assert_eq!(actual, expected);
     }
+    #[test]
+    fn test_diff_attrs() {
+        assert_eq!(
+            Attributes::ALL.diff(&Attributes {
+                context: Preserve::Yes { required: true },
+                xattr: Preserve::Yes { required: true },
+                ..Attributes::ALL
+            }),
+            Attributes {
+                #[cfg(unix)]
+                ownership: Preserve::No { explicit: true },
+                mode: Preserve::No { explicit: true },
+                timestamps: Preserve::No { explicit: true },
+                context: Preserve::No { explicit: true },
+                links: Preserve::No { explicit: true },
+                xattr: Preserve::No { explicit: true }
+            }
+        );
+        assert_eq!(
+            Attributes {
+                context: Preserve::Yes { required: true },
+                xattr: Preserve::Yes { required: true },
+                ..Attributes::ALL
+            }
+            .diff(&Attributes::NONE),
+            Attributes {
+                context: Preserve::Yes { required: true },
+                xattr: Preserve::Yes { required: true },
+                ..Attributes::ALL
+            }
+        );
+        assert_eq!(
+            Attributes::NONE.diff(&Attributes {
+                context: Preserve::Yes { required: true },
+                xattr: Preserve::Yes { required: true },
+                ..Attributes::ALL
+            }),
+            Attributes {
+                #[cfg(unix)]
+                ownership: Preserve::No { explicit: true },
+                mode: Preserve::No { explicit: true },
+                timestamps: Preserve::No { explicit: true },
+                context: Preserve::No { explicit: true },
+                links: Preserve::No { explicit: true },
+                xattr: Preserve::No { explicit: true }
+            }
+        );
+    }
 }
diff --git a/src/uu/cp/src/platform/linux.rs b/src/uu/cp/src/platform/linux.rs
index 674e66ea575..9bf257f8276 100644
--- a/src/uu/cp/src/platform/linux.rs
+++ b/src/uu/cp/src/platform/linux.rs
@@ -2,12 +2,17 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore ficlone reflink ftruncate pwrite fiemap
+// spell-checker:ignore ficlone reflink ftruncate pwrite fiemap lseek
+
+use libc::{SEEK_DATA, SEEK_HOLE};
 use std::fs::{File, OpenOptions};
 use std::io::Read;
-use std::os::unix::fs::OpenOptionsExt;
+use std::os::unix::fs::FileExt;
+use std::os::unix::fs::MetadataExt;
+use std::os::unix::fs::{FileTypeExt, OpenOptionsExt};
 use std::os::unix::io::AsRawFd;
 use std::path::Path;
+use uucore::buf_copy;
 
 use quick_error::ResultExt;
 
@@ -15,15 +20,6 @@ use uucore::mode::get_umask;
 
 use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
 
-// From /usr/include/linux/fs.h:
-// #define FICLONE		_IOW(0x94, 9, int)
-// Use a macro as libc::ioctl expects u32 or u64 depending on the arch
-macro_rules! FICLONE {
-    () => {
-        0x40049409
-    };
-}
-
 /// The fallback behavior for [`clone`] on failed system call.
 #[derive(Clone, Copy)]
 enum CloneFallback {
@@ -32,6 +28,25 @@ enum CloneFallback {
 
     /// Use [`std::fs::copy`].
     FSCopy,
+
+    /// Use sparse_copy
+    SparseCopy,
+
+    /// Use sparse_copy_without_hole
+    SparseCopyWithoutHole,
+}
+
+/// Type of method used for copying files
+#[derive(Clone, Copy)]
+enum CopyMethod {
+    /// Do a sparse copy
+    SparseCopy,
+    /// Use [`std::fs::copy`].
+    FSCopy,
+    /// Default (can either be sparse_copy or FSCopy)
+    Default,
+    /// Use sparse_copy_without_hole
+    SparseCopyWithoutHole,
 }
 
 /// Use the Linux `ioctl_ficlone` API to do a copy-on-write clone.
@@ -46,24 +61,126 @@ where
     let dst_file = File::create(&dest)?;
     let src_fd = src_file.as_raw_fd();
     let dst_fd = dst_file.as_raw_fd();
-    let result = unsafe { libc::ioctl(dst_fd, FICLONE!(), src_fd) };
+    // Using .try_into().unwrap() is required as glibc, musl & android all have different type for ioctl()
+    #[allow(clippy::unnecessary_fallible_conversions)]
+    let result = unsafe {
+        libc::ioctl(
+            dst_fd,
+            linux_raw_sys::ioctl::FICLONE.try_into().unwrap(),
+            src_fd,
+        )
+    };
     if result == 0 {
         return Ok(());
     }
     match fallback {
         CloneFallback::Error => Err(std::io::Error::last_os_error()),
         CloneFallback::FSCopy => std::fs::copy(source, dest).map(|_| ()),
+        CloneFallback::SparseCopy => sparse_copy(source, dest),
+        CloneFallback::SparseCopyWithoutHole => sparse_copy_without_hole(source, dest),
     }
 }
 
+/// Checks whether a file contains any non null bytes i.e. any byte != 0x0
+/// This function returns a tuple of (bool, u64, u64) signifying a tuple of (whether a file has
+/// data, its size, no of blocks it has allocated in disk)
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn check_for_data(source: &Path) -> Result<(bool, u64, u64), std::io::Error> {
+    let mut src_file = File::open(source)?;
+    let metadata = src_file.metadata()?;
+
+    let size = metadata.size();
+    let blocks = metadata.blocks();
+    // checks edge case of virtual files in /proc which have a size of zero but contains data
+    if size == 0 {
+        let mut buf: Vec<u8> = vec![0; metadata.blksize() as usize]; // Directly use metadata.blksize()
+        let _ = src_file.read(&mut buf)?;
+        return Ok((buf.iter().any(|&x| x != 0x0), size, 0));
+    }
+
+    let src_fd = src_file.as_raw_fd();
+
+    let result = unsafe { libc::lseek(src_fd, 0, SEEK_DATA) };
+
+    match result {
+        -1 => Ok((false, size, blocks)), // No data found or end of file
+        _ if result >= 0 => Ok((true, size, blocks)), // Data found
+        _ => Err(std::io::Error::last_os_error()),
+    }
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+/// Checks whether a file is sparse i.e. it contains holes, uses the crude heuristic blocks < size / 512
+/// Reference:`<https://doc.rust-lang.org/std/os/unix/fs/trait.MetadataExt.html#tymethod.blocks>`
+fn check_sparse_detection(source: &Path) -> Result<bool, std::io::Error> {
+    let src_file = File::open(source)?;
+    let metadata = src_file.metadata()?;
+    let size = metadata.size();
+    let blocks = metadata.blocks();
+
+    if blocks < size / 512 {
+        return Ok(true);
+    }
+    Ok(false)
+}
+
+/// Optimized sparse_copy, doesn't create holes for large sequences of zeros in non sparse_files
+/// Used when --sparse=auto
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn sparse_copy_without_hole<P>(source: P, dest: P) -> std::io::Result<()>
+where
+    P: AsRef<Path>,
+{
+    let src_file = File::open(source)?;
+    let dst_file = File::create(dest)?;
+    let dst_fd = dst_file.as_raw_fd();
+
+    let size = src_file.metadata()?.size();
+    if unsafe { libc::ftruncate(dst_fd, size.try_into().unwrap()) } < 0 {
+        return Err(std::io::Error::last_os_error());
+    }
+    let src_fd = src_file.as_raw_fd();
+    let mut current_offset: isize = 0;
+    // Maximize the data read at once to 16 MiB to avoid memory hogging with large files
+    // 16 MiB chunks should saturate an SSD
+    let step = std::cmp::min(size, 16 * 1024 * 1024) as usize;
+    let mut buf: Vec<u8> = vec![0x0; step];
+    loop {
+        let result = unsafe { libc::lseek(src_fd, current_offset.try_into().unwrap(), SEEK_DATA) }
+            .try_into()
+            .unwrap();
+
+        current_offset = result;
+        let hole: isize =
+            unsafe { libc::lseek(src_fd, current_offset.try_into().unwrap(), SEEK_HOLE) }
+                .try_into()
+                .unwrap();
+        if result == -1 || hole == -1 {
+            break;
+        }
+        if result <= -2 || hole <= -2 {
+            return Err(std::io::Error::last_os_error());
+        }
+        let len: isize = hole - current_offset;
+        // Read and write data in chunks of `step` while reusing the same buffer
+        for i in (0..len).step_by(step) {
+            // Ensure we don't read past the end of the file or the start of the next hole
+            let read_len = std::cmp::min((len - i) as usize, step);
+            let buf = &mut buf[..read_len];
+            src_file.read_exact_at(buf, (current_offset + i) as u64)?;
+            dst_file.write_all_at(buf, (current_offset + i) as u64)?;
+        }
+        current_offset = hole;
+    }
+    Ok(())
+}
 /// Perform a sparse copy from one file to another.
+/// Creates a holes for large sequences of zeros in non_sparse_files, used for --sparse=always
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn sparse_copy<P>(source: P, dest: P) -> std::io::Result<()>
 where
     P: AsRef<Path>,
 {
-    use std::os::unix::prelude::MetadataExt;
-
     let mut src_file = File::open(source)?;
     let dst_file = File::create(dest)?;
     let dst_fd = dst_file.as_raw_fd();
@@ -82,23 +199,30 @@ where
     // https://www.kernel.org/doc/html/latest/filesystems/fiemap.html
     while current_offset < size {
         let this_read = src_file.read(&mut buf)?;
+        let buf = &buf[..this_read];
         if buf.iter().any(|&x| x != 0) {
-            unsafe {
-                libc::pwrite(
-                    dst_fd,
-                    buf.as_ptr() as *const libc::c_void,
-                    this_read,
-                    current_offset.try_into().unwrap(),
-                )
-            };
+            dst_file.write_all_at(buf, current_offset.try_into().unwrap())?;
         }
         current_offset += this_read;
     }
     Ok(())
 }
 
-/// Copy the contents of the given source FIFO to the given file.
-fn copy_fifo_contents<P>(source: P, dest: P) -> std::io::Result<u64>
+#[cfg(any(target_os = "linux", target_os = "android"))]
+/// Checks whether an existing destination is a fifo
+fn check_dest_is_fifo(dest: &Path) -> bool {
+    // If our destination file exists and its a fifo , we do a standard copy .
+    let file_type = std::fs::metadata(dest);
+    match file_type {
+        Ok(f) => f.file_type().is_fifo(),
+
+        _ => false,
+    }
+}
+
+/// Copy the contents of a stream from `source` to `dest`. The `if_fifo` argument is used to
+/// determine if we need to modify the file's attributes before and after copying.
+fn copy_stream<P>(source: P, dest: P, is_fifo: bool) -> std::io::Result<u64>
 where
     P: AsRef<Path>,
 {
@@ -127,8 +251,14 @@ where
         .write(true)
         .mode(mode)
         .open(&dest)?;
-    let num_bytes_copied = std::io::copy(&mut src_file, &mut dst_file)?;
-    dst_file.set_permissions(src_file.metadata()?.permissions())?;
+
+    let num_bytes_copied = buf_copy::copy_stream(&mut src_file, &mut dst_file)
+        .map_err(|_| std::io::Error::from(std::io::ErrorKind::Other))?;
+
+    if is_fifo {
+        dst_file.set_permissions(src_file.metadata()?.permissions())?;
+    }
+
     Ok(num_bytes_copied)
 }
 
@@ -145,41 +275,125 @@ pub(crate) fn copy_on_write(
     sparse_mode: SparseMode,
     context: &str,
     source_is_fifo: bool,
+    source_is_stream: bool,
 ) -> 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) => {
             copy_debug.sparse_detection = SparseDebug::Zeros;
-            copy_debug.offload = OffloadReflinkDebug::Avoided;
+            // Default SparseDebug val for SparseMode::Always
             copy_debug.reflink = OffloadReflinkDebug::No;
-            sparse_copy(source, dest)
+            if source_is_stream {
+                copy_debug.offload = OffloadReflinkDebug::Avoided;
+                copy_stream(source, dest, source_is_fifo).map(|_| ())
+            } else {
+                let mut copy_method = CopyMethod::Default;
+                let result = handle_reflink_never_sparse_always(source, dest);
+                if let Ok((debug, method)) = result {
+                    copy_debug = debug;
+                    copy_method = method;
+                }
+
+                match copy_method {
+                    CopyMethod::FSCopy => std::fs::copy(source, dest).map(|_| ()),
+                    _ => sparse_copy(source, dest),
+                }
+            }
         }
-        (ReflinkMode::Never, _) => {
-            copy_debug.sparse_detection = SparseDebug::No;
+        (ReflinkMode::Never, SparseMode::Never) => {
             copy_debug.reflink = OffloadReflinkDebug::No;
-            std::fs::copy(source, dest).map(|_| ())
+
+            if source_is_stream {
+                copy_debug.offload = OffloadReflinkDebug::Avoided;
+                copy_stream(source, dest, source_is_fifo).map(|_| ())
+            } else {
+                let result = handle_reflink_never_sparse_never(source);
+                if let Ok(debug) = result {
+                    copy_debug = debug;
+                }
+                std::fs::copy(source, dest).map(|_| ())
+            }
+        }
+        (ReflinkMode::Never, SparseMode::Auto) => {
+            copy_debug.reflink = OffloadReflinkDebug::No;
+
+            if source_is_stream {
+                copy_debug.offload = OffloadReflinkDebug::Avoided;
+                copy_stream(source, dest, source_is_fifo).map(|_| ())
+            } else {
+                let mut copy_method = CopyMethod::Default;
+                let result = handle_reflink_never_sparse_auto(source, dest);
+                if let Ok((debug, method)) = result {
+                    copy_debug = debug;
+                    copy_method = method;
+                }
+
+                match copy_method {
+                    CopyMethod::SparseCopyWithoutHole => sparse_copy_without_hole(source, dest),
+                    _ => 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)
+            copy_debug.sparse_detection = SparseDebug::Zeros; // Default SparseDebug val for
+            // SparseMode::Always
+            if source_is_stream {
+                copy_debug.offload = OffloadReflinkDebug::Avoided;
+                copy_stream(source, dest, source_is_fifo).map(|_| ())
+            } else {
+                let mut copy_method = CopyMethod::Default;
+                let result = handle_reflink_auto_sparse_always(source, dest);
+                if let Ok((debug, method)) = result {
+                    copy_debug = debug;
+                    copy_method = method;
+                }
+
+                match copy_method {
+                    CopyMethod::FSCopy => clone(source, dest, CloneFallback::FSCopy),
+                    _ => clone(source, dest, CloneFallback::SparseCopy),
+                }
+            }
         }
 
-        (ReflinkMode::Auto, _) => {
-            copy_debug.sparse_detection = SparseDebug::No;
-            copy_debug.reflink = OffloadReflinkDebug::Unsupported;
-            if source_is_fifo {
-                copy_fifo_contents(source, dest).map(|_| ())
+        (ReflinkMode::Auto, SparseMode::Never) => {
+            copy_debug.reflink = OffloadReflinkDebug::No;
+            if source_is_stream {
+                copy_debug.offload = OffloadReflinkDebug::Avoided;
+                copy_stream(source, dest, source_is_fifo).map(|_| ())
             } else {
+                let result = handle_reflink_auto_sparse_never(source);
+                if let Ok(debug) = result {
+                    copy_debug = debug;
+                }
+
                 clone(source, dest, CloneFallback::FSCopy)
             }
         }
+        (ReflinkMode::Auto, SparseMode::Auto) => {
+            if source_is_stream {
+                copy_debug.offload = OffloadReflinkDebug::Unsupported;
+                copy_stream(source, dest, source_is_fifo).map(|_| ())
+            } else {
+                let mut copy_method = CopyMethod::Default;
+                let result = handle_reflink_auto_sparse_auto(source, dest);
+                if let Ok((debug, method)) = result {
+                    copy_debug = debug;
+                    copy_method = method;
+                }
+
+                match copy_method {
+                    CopyMethod::SparseCopyWithoutHole => {
+                        clone(source, dest, CloneFallback::SparseCopyWithoutHole)
+                    }
+                    _ => clone(source, dest, CloneFallback::FSCopy),
+                }
+            }
+        }
+
         (ReflinkMode::Always, SparseMode::Auto) => {
             copy_debug.sparse_detection = SparseDebug::No;
             copy_debug.reflink = OffloadReflinkDebug::Yes;
@@ -187,9 +401,217 @@ pub(crate) fn copy_on_write(
             clone(source, dest, CloneFallback::Error)
         }
         (ReflinkMode::Always, _) => {
-            return Err("`--reflink=always` can be used only with --sparse=auto".into())
+            return Err("`--reflink=always` can be used only with --sparse=auto".into());
         }
     };
     result.context(context)?;
     Ok(copy_debug)
 }
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=always" and specifies what
+/// type of copy should be used
+fn handle_reflink_auto_sparse_always(
+    source: &Path,
+    dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::Unsupported,
+        sparse_detection: SparseDebug::Zeros,
+    };
+    let mut copy_method = CopyMethod::Default;
+    let (data_flag, size, blocks) = check_for_data(source)?;
+    let sparse_flag = check_sparse_detection(source)?;
+
+    if data_flag || size < 512 {
+        copy_debug.offload = OffloadReflinkDebug::Avoided;
+    }
+    match (sparse_flag, data_flag, blocks) {
+        (true, true, 0) => {
+            // Handling funny files with 0 block allocation but has data
+            // in it
+            copy_method = CopyMethod::FSCopy;
+            copy_debug.sparse_detection = SparseDebug::SeekHoleZeros;
+        }
+        (false, true, 0) => copy_method = CopyMethod::FSCopy,
+
+        (true, false, 0) => copy_debug.sparse_detection = SparseDebug::SeekHole,
+        (true, true, _) => copy_debug.sparse_detection = SparseDebug::SeekHoleZeros,
+
+        (true, false, _) => copy_debug.sparse_detection = SparseDebug::SeekHole,
+
+        (_, _, _) => (),
+    }
+    if check_dest_is_fifo(dest) {
+        copy_method = CopyMethod::FSCopy;
+    }
+    Ok((copy_debug, copy_method))
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=auto" and specifies what
+/// type of copy should be used
+fn handle_reflink_never_sparse_never(source: &Path) -> Result<CopyDebug, std::io::Error> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::No,
+        sparse_detection: SparseDebug::No,
+    };
+    let (data_flag, size, _blocks) = check_for_data(source)?;
+    let sparse_flag = check_sparse_detection(source)?;
+
+    if sparse_flag {
+        copy_debug.sparse_detection = SparseDebug::SeekHole;
+    }
+
+    if data_flag || size < 512 {
+        copy_debug.offload = OffloadReflinkDebug::Avoided;
+    }
+    Ok(copy_debug)
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=never", files will be copied
+/// through cloning them with fallback switching to std::fs::copy
+fn handle_reflink_auto_sparse_never(source: &Path) -> Result<CopyDebug, std::io::Error> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::No,
+        sparse_detection: SparseDebug::No,
+    };
+
+    let (data_flag, size, _blocks) = check_for_data(source)?;
+    let sparse_flag = check_sparse_detection(source)?;
+
+    if sparse_flag {
+        copy_debug.sparse_detection = SparseDebug::SeekHole;
+    }
+
+    if data_flag || size < 512 {
+        copy_debug.offload = OffloadReflinkDebug::Avoided;
+    }
+    Ok(copy_debug)
+}
+
+/// Handles debug results when flags are "--reflink=auto" and "--sparse=auto" and specifies what
+/// type of copy should be used
+fn handle_reflink_auto_sparse_auto(
+    source: &Path,
+    dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::Unsupported,
+        sparse_detection: SparseDebug::No,
+    };
+
+    let mut copy_method = CopyMethod::Default;
+    let (data_flag, size, blocks) = check_for_data(source)?;
+    let sparse_flag = check_sparse_detection(source)?;
+
+    if (data_flag && size != 0) || (size > 0 && size < 512) {
+        copy_debug.offload = OffloadReflinkDebug::Yes;
+    }
+
+    if data_flag && size == 0 {
+        // Handling /proc/ files
+        copy_debug.offload = OffloadReflinkDebug::Unsupported;
+    }
+    if sparse_flag {
+        if blocks == 0 && data_flag {
+            // Handling other "virtual" files
+            copy_debug.offload = OffloadReflinkDebug::Unsupported;
+
+            copy_method = CopyMethod::FSCopy; // Doing a standard copy for the virtual files
+        } else {
+            copy_method = CopyMethod::SparseCopyWithoutHole;
+        } // Since sparse_flag is true, sparse_detection shall be SeekHole for any non virtual
+        // regular sparse file and the file will be sparsely copied
+        copy_debug.sparse_detection = SparseDebug::SeekHole;
+    }
+
+    if check_dest_is_fifo(dest) {
+        copy_method = CopyMethod::FSCopy;
+    }
+    Ok((copy_debug, copy_method))
+}
+
+/// Handles debug results when flags are "--reflink=never" and "--sparse=auto" and specifies what
+/// type of copy should be used
+fn handle_reflink_never_sparse_auto(
+    source: &Path,
+    dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::No,
+        sparse_detection: SparseDebug::No,
+    };
+
+    let (data_flag, size, blocks) = check_for_data(source)?;
+    let sparse_flag = check_sparse_detection(source)?;
+
+    let mut copy_method = CopyMethod::Default;
+    if data_flag || size < 512 {
+        copy_debug.offload = OffloadReflinkDebug::Avoided;
+    }
+
+    if sparse_flag {
+        if blocks == 0 && data_flag {
+            copy_method = CopyMethod::FSCopy; // Handles virtual files which have size > 0 but no
+        // disk allocation
+        } else {
+            copy_method = CopyMethod::SparseCopyWithoutHole; // Handles regular sparse-files
+        }
+        copy_debug.sparse_detection = SparseDebug::SeekHole;
+    }
+
+    if check_dest_is_fifo(dest) {
+        copy_method = CopyMethod::FSCopy;
+    }
+    Ok((copy_debug, copy_method))
+}
+
+/// Handles debug results when flags are "--reflink=never" and "--sparse=always" and specifies what
+/// type of copy should be used
+fn handle_reflink_never_sparse_always(
+    source: &Path,
+    dest: &Path,
+) -> Result<(CopyDebug, CopyMethod), std::io::Error> {
+    let mut copy_debug = CopyDebug {
+        offload: OffloadReflinkDebug::Unknown,
+        reflink: OffloadReflinkDebug::No,
+        sparse_detection: SparseDebug::Zeros,
+    };
+    let mut copy_method = CopyMethod::SparseCopy;
+
+    let (data_flag, size, blocks) = check_for_data(source)?;
+    let sparse_flag = check_sparse_detection(source)?;
+
+    if data_flag || size < 512 {
+        copy_debug.offload = OffloadReflinkDebug::Avoided;
+    }
+    match (sparse_flag, data_flag, blocks) {
+        (true, true, 0) => {
+            // Handling funny files with 0 block allocation but has data
+            // in it, e.g. files in /sys and other virtual files
+            copy_method = CopyMethod::FSCopy;
+            copy_debug.sparse_detection = SparseDebug::SeekHoleZeros;
+        }
+        (false, true, 0) => copy_method = CopyMethod::FSCopy, // Handling data containing zero sized
+        // files in /proc
+        (true, false, 0) => copy_debug.sparse_detection = SparseDebug::SeekHole, // Handles files
+        // with 0 blocks allocated in disk and
+        (true, true, _) => copy_debug.sparse_detection = SparseDebug::SeekHoleZeros, // Any
+        // sparse_files with data in it will display SeekHoleZeros
+        (true, false, _) => {
+            copy_debug.offload = OffloadReflinkDebug::Unknown;
+            copy_debug.sparse_detection = SparseDebug::SeekHole;
+        }
+
+        (_, _, _) => (),
+    }
+    if check_dest_is_fifo(dest) {
+        copy_method = CopyMethod::FSCopy;
+    }
+
+    Ok((copy_debug, copy_method))
+}
diff --git a/src/uu/cp/src/platform/macos.rs b/src/uu/cp/src/platform/macos.rs
index 8c62c78d95d..35879c29df7 100644
--- a/src/uu/cp/src/platform/macos.rs
+++ b/src/uu/cp/src/platform/macos.rs
@@ -4,12 +4,14 @@
 // file that was distributed with this source code.
 // spell-checker:ignore reflink
 use std::ffi::CString;
-use std::fs::{self, File};
-use std::io;
+use std::fs::{self, File, OpenOptions};
 use std::os::unix::ffi::OsStrExt;
+use std::os::unix::fs::OpenOptionsExt;
 use std::path::Path;
 
 use quick_error::ResultExt;
+use uucore::buf_copy;
+use uucore::mode::get_umask;
 
 use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
 
@@ -24,6 +26,7 @@ pub(crate) fn copy_on_write(
     sparse_mode: SparseMode,
     context: &str,
     source_is_fifo: bool,
+    source_is_stream: bool,
 ) -> CopyResult<CopyDebug> {
     if sparse_mode != SparseMode::Auto {
         return Err("--sparse is only supported on linux".to_string().into());
@@ -63,8 +66,15 @@ pub(crate) fn copy_on_write(
             {
                 // clonefile(2) fails if the destination exists.  Remove it and try again.  Do not
                 // bother to check if removal worked because we're going to try to clone again.
-                let _ = fs::remove_file(dest);
-                error = pfn(src.as_ptr(), dst.as_ptr(), 0);
+                // first lets make sure the dest file is not read only
+                if fs::metadata(dest).is_ok_and(|md| !md.permissions().readonly()) {
+                    // remove and copy again
+                    // TODO: rewrite this to better match linux behavior
+                    // linux first opens the source file and destination file then uses the file
+                    // descriptors to do the clone.
+                    let _ = fs::remove_file(dest);
+                    error = pfn(src.as_ptr(), dst.as_ptr(), 0);
+                }
             }
         }
     }
@@ -74,14 +84,32 @@ pub(crate) fn copy_on_write(
         // support COW).
         match reflink_mode {
             ReflinkMode::Always => {
-                return Err(format!("failed to clone {source:?} from {dest:?}: {error}").into())
+                return Err(format!(
+                    "failed to clone {} from {}: {error}",
+                    source.display(),
+                    dest.display()
+                )
+                .into());
             }
             _ => {
                 copy_debug.reflink = OffloadReflinkDebug::Yes;
-                if source_is_fifo {
+                if source_is_stream {
                     let mut src_file = File::open(source)?;
-                    let mut dst_file = File::create(dest)?;
-                    io::copy(&mut src_file, &mut dst_file).context(context)?
+                    let mode = 0o622 & !get_umask();
+                    let mut dst_file = OpenOptions::new()
+                        .create(true)
+                        .write(true)
+                        .mode(mode)
+                        .open(dest)?;
+
+                    let context = buf_copy::copy_stream(&mut src_file, &mut dst_file)
+                        .map_err(|_| std::io::Error::from(std::io::ErrorKind::Other))
+                        .context(context)?;
+
+                    if source_is_fifo {
+                        dst_file.set_permissions(src_file.metadata()?.permissions())?;
+                    }
+                    context
                 } else {
                     fs::copy(source, dest).context(context)?
                 }
diff --git a/src/uu/cp/src/platform/mod.rs b/src/uu/cp/src/platform/mod.rs
index c7942706868..2071e928f41 100644
--- a/src/uu/cp/src/platform/mod.rs
+++ b/src/uu/cp/src/platform/mod.rs
@@ -2,6 +2,18 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+
+#[cfg(all(
+    unix,
+    not(any(target_os = "macos", target_os = "linux", target_os = "android"))
+))]
+mod other_unix;
+#[cfg(all(
+    unix,
+    not(any(target_os = "macos", target_os = "linux", target_os = "android"))
+))]
+pub(crate) use self::other_unix::copy_on_write;
+
 #[cfg(target_os = "macos")]
 mod macos;
 #[cfg(target_os = "macos")]
@@ -12,7 +24,13 @@ mod linux;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 pub(crate) use self::linux::copy_on_write;
 
-#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "macos")))]
+#[cfg(not(any(
+    unix,
+    any(target_os = "macos", target_os = "linux", target_os = "android")
+)))]
 mod other;
-#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "macos")))]
+#[cfg(not(any(
+    unix,
+    any(target_os = "macos", target_os = "linux", target_os = "android")
+)))]
 pub(crate) use self::other::copy_on_write;
diff --git a/src/uu/cp/src/platform/other_unix.rs b/src/uu/cp/src/platform/other_unix.rs
new file mode 100644
index 00000000000..aa8fed3fab1
--- /dev/null
+++ b/src/uu/cp/src/platform/other_unix.rs
@@ -0,0 +1,62 @@
+// 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.
+// spell-checker:ignore reflink
+use std::fs::{self, File, OpenOptions};
+use std::os::unix::fs::OpenOptionsExt;
+use std::path::Path;
+
+use quick_error::ResultExt;
+use uucore::buf_copy;
+use uucore::mode::get_umask;
+
+use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug, SparseMode};
+
+/// Copies `source` to `dest` for systems without copy-on-write
+pub(crate) fn copy_on_write(
+    source: &Path,
+    dest: &Path,
+    reflink_mode: ReflinkMode,
+    sparse_mode: SparseMode,
+    context: &str,
+    source_is_fifo: bool,
+    source_is_stream: bool,
+) -> CopyResult<CopyDebug> {
+    if reflink_mode != ReflinkMode::Never {
+        return Err("--reflink is only supported on linux and macOS"
+            .to_string()
+            .into());
+    }
+    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,
+    };
+
+    if source_is_stream {
+        let mut src_file = File::open(source)?;
+        let mode = 0o622 & !get_umask();
+        let mut dst_file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .mode(mode)
+            .open(dest)?;
+
+        buf_copy::copy_stream(&mut src_file, &mut dst_file)
+            .map_err(|_| std::io::Error::from(std::io::ErrorKind::Other))
+            .context(context)?;
+
+        if source_is_fifo {
+            dst_file.set_permissions(src_file.metadata()?.permissions())?;
+        }
+        return Ok(copy_debug);
+    }
+
+    fs::copy(source, dest).context(context)?;
+
+    Ok(copy_debug)
+}
diff --git a/src/uu/csplit/Cargo.toml b/src/uu/csplit/Cargo.toml
index ba051ff8ab4..508656f681d 100644
--- a/src/uu/csplit/Cargo.toml
+++ b/src/uu/csplit/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_csplit"
-version = "0.0.21"
-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"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ls"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/csplit.rs"
@@ -18,7 +21,7 @@ path = "src/csplit.rs"
 clap = { workspace = true }
 thiserror = { workspace = true }
 regex = { workspace = true }
-uucore = { workspace = true, features = ["entries", "fs"] }
+uucore = { workspace = true, features = ["entries", "fs", "format"] }
 
 [[bin]]
 name = "csplit"
diff --git a/src/uu/csplit/src/csplit.rs b/src/uu/csplit/src/csplit.rs
index 6c9a776c388..621823aebba 100644
--- a/src/uu/csplit/src/csplit.rs
+++ b/src/uu/csplit/src/csplit.rs
@@ -2,22 +2,21 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-#![crate_name = "uu_csplit"]
 // spell-checker:ignore rustdoc
 #![allow(rustdoc::private_intra_doc_links)]
 
 use std::cmp::Ordering;
-use std::io::{self, BufReader};
+use std::io::{self, BufReader, ErrorKind};
 use std::{
-    fs::{remove_file, File},
+    fs::{File, remove_file},
     io::{BufRead, BufWriter, Write},
 };
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use regex::Regex;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
-use uucore::{crash_if_err, format_usage, help_about, help_section, help_usage};
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 mod csplit_error;
 mod patterns;
@@ -44,7 +43,7 @@ mod options {
 
 /// Command line options for csplit.
 pub struct CsplitOptions {
-    split_name: crate::SplitName,
+    split_name: SplitName,
     keep_files: bool,
     quiet: bool,
     elide_empty_files: bool,
@@ -52,31 +51,51 @@ pub struct CsplitOptions {
 }
 
 impl CsplitOptions {
-    fn new(matches: &ArgMatches) -> Self {
+    fn new(matches: &ArgMatches) -> Result<Self, CsplitError> {
         let keep_files = matches.get_flag(options::KEEP_FILES);
         let quiet = matches.get_flag(options::QUIET);
         let elide_empty_files = matches.get_flag(options::ELIDE_EMPTY_FILES);
         let suppress_matched = matches.get_flag(options::SUPPRESS_MATCHED);
 
-        Self {
-            split_name: crash_if_err!(
-                1,
-                SplitName::new(
-                    matches
-                        .get_one::<String>(options::PREFIX)
-                        .map(|s| s.to_owned()),
-                    matches
-                        .get_one::<String>(options::SUFFIX_FORMAT)
-                        .map(|s| s.to_owned()),
-                    matches
-                        .get_one::<String>(options::DIGITS)
-                        .map(|s| s.to_owned())
-                )
-            ),
+        Ok(Self {
+            split_name: SplitName::new(
+                matches.get_one::<String>(options::PREFIX).cloned(),
+                matches.get_one::<String>(options::SUFFIX_FORMAT).cloned(),
+                matches.get_one::<String>(options::DIGITS).cloned(),
+            )?,
             keep_files,
             quiet,
             elide_empty_files,
             suppress_matched,
+        })
+    }
+}
+
+pub struct LinesWithNewlines<T: BufRead> {
+    inner: T,
+}
+
+impl<T: BufRead> LinesWithNewlines<T> {
+    fn new(s: T) -> Self {
+        Self { inner: s }
+    }
+}
+
+impl<T: BufRead> Iterator for LinesWithNewlines<T> {
+    type Item = io::Result<String>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        fn ret(v: Vec<u8>) -> io::Result<String> {
+            String::from_utf8(v).map_err(|_| {
+                io::Error::new(ErrorKind::InvalidData, "stream did not contain valid UTF-8")
+            })
+        }
+
+        let mut v = Vec::new();
+        match self.inner.read_until(b'\n', &mut v) {
+            Ok(0) => None,
+            Ok(_) => Some(ret(v)),
+            Err(e) => Some(Err(e)),
         }
     }
 }
@@ -93,27 +112,29 @@ impl CsplitOptions {
 /// - [`CsplitError::MatchNotFound`] if no line matched a regular expression.
 /// - [`CsplitError::MatchNotFoundOnRepetition`], like previous but after applying the pattern
 ///   more than once.
-pub fn csplit<T>(
-    options: &CsplitOptions,
-    patterns: Vec<patterns::Pattern>,
-    input: T,
-) -> Result<(), CsplitError>
+pub fn csplit<T>(options: &CsplitOptions, patterns: &[String], input: T) -> Result<(), CsplitError>
 where
     T: BufRead,
 {
-    let mut input_iter = InputSplitter::new(input.lines().enumerate());
+    let enumerated_input_lines = LinesWithNewlines::new(input)
+        .map(|line| line.map_err_context(|| "read error".to_string()))
+        .enumerate();
+    let mut input_iter = InputSplitter::new(enumerated_input_lines);
     let mut split_writer = SplitWriter::new(options);
+    let patterns: Vec<patterns::Pattern> = patterns::get_patterns(patterns)?;
     let ret = do_csplit(&mut split_writer, patterns, &mut input_iter);
 
-    // consume the rest
-    input_iter.rewind_buffer();
-    if let Some((_, line)) = input_iter.next() {
-        split_writer.new_writer()?;
-        split_writer.writeln(&line?)?;
-        for (_, line) in input_iter {
+    // consume the rest, unless there was an error
+    if ret.is_ok() {
+        input_iter.rewind_buffer();
+        if let Some((_, line)) = input_iter.next() {
+            split_writer.new_writer()?;
             split_writer.writeln(&line?)?;
+            for (_, line) in input_iter {
+                split_writer.writeln(&line?)?;
+            }
+            split_writer.finish_split();
         }
-        split_writer.finish_split();
     }
     // delete files on error by default
     if ret.is_err() && !options.keep_files {
@@ -128,7 +149,7 @@ fn do_csplit<I>(
     input_iter: &mut InputSplitter<I>,
 ) -> Result<(), CsplitError>
 where
-    I: Iterator<Item = (usize, io::Result<String>)>,
+    I: Iterator<Item = (usize, UResult<String>)>,
 {
     // split the file based on patterns
     for pattern in patterns {
@@ -205,16 +226,21 @@ struct SplitWriter<'a> {
     dev_null: bool,
 }
 
-impl<'a> Drop for SplitWriter<'a> {
+impl Drop for SplitWriter<'_> {
     fn drop(&mut self) {
         if self.options.elide_empty_files && self.size == 0 {
             let file_name = self.options.split_name.get(self.counter);
-            remove_file(file_name).expect("Failed to elide split");
+            // In the case of `echo a | csplit -z - %a%1`, the file
+            // `xx00` does not exist because the positive offset
+            // advanced past the end of the input. Since there is no
+            // file to remove in that case, `remove_file` would return
+            // an error, so we just ignore it.
+            let _ = remove_file(file_name);
         }
     }
 }
 
-impl<'a> SplitWriter<'a> {
+impl SplitWriter<'_> {
     fn new(options: &CsplitOptions) -> SplitWriter {
         SplitWriter {
             options,
@@ -245,7 +271,7 @@ impl<'a> SplitWriter<'a> {
         self.dev_null = true;
     }
 
-    /// Writes the line to the current split, appending a newline character.
+    /// Writes the line to the current split.
     /// If [`self.dev_null`] is true, then the line is discarded.
     ///
     /// # Errors
@@ -257,8 +283,7 @@ impl<'a> SplitWriter<'a> {
                 Some(ref mut current_writer) => {
                     let bytes = line.as_bytes();
                     current_writer.write_all(bytes)?;
-                    current_writer.write_all(b"\n")?;
-                    self.size += bytes.len() + 1;
+                    self.size += bytes.len();
                 }
                 None => panic!("trying to write to a split that was not created"),
             }
@@ -316,18 +341,18 @@ impl<'a> SplitWriter<'a> {
         input_iter: &mut InputSplitter<I>,
     ) -> Result<(), CsplitError>
     where
-        I: Iterator<Item = (usize, io::Result<String>)>,
+        I: Iterator<Item = (usize, UResult<String>)>,
     {
         input_iter.rewind_buffer();
         input_iter.set_size_of_buffer(1);
 
         let mut ret = Err(CsplitError::LineOutOfRange(pattern_as_str.to_string()));
         while let Some((ln, line)) = input_iter.next() {
-            let l = line?;
+            let line = line?;
             match n.cmp(&(&ln + 1)) {
                 Ordering::Less => {
                     assert!(
-                        input_iter.add_line_to_buffer(ln, l).is_none(),
+                        input_iter.add_line_to_buffer(ln, line).is_none(),
                         "the buffer is big enough to contain 1 line"
                     );
                     ret = Ok(());
@@ -336,7 +361,7 @@ impl<'a> SplitWriter<'a> {
                 Ordering::Equal => {
                     assert!(
                         self.options.suppress_matched
-                            || input_iter.add_line_to_buffer(ln, l).is_none(),
+                            || input_iter.add_line_to_buffer(ln, line).is_none(),
                         "the buffer is big enough to contain 1 line"
                     );
                     ret = Ok(());
@@ -344,7 +369,7 @@ impl<'a> SplitWriter<'a> {
                 }
                 Ordering::Greater => (),
             }
-            self.writeln(&l)?;
+            self.writeln(&line)?;
         }
         self.finish_split();
         ret
@@ -359,7 +384,7 @@ impl<'a> SplitWriter<'a> {
     /// In addition to errors reading/writing from/to a file, the following errors may be returned:
     /// - if no line matched, an [`CsplitError::MatchNotFound`].
     /// - if there are not enough lines to accommodate the offset, an
-    /// [`CsplitError::LineOutOfRange`].
+    ///   [`CsplitError::LineOutOfRange`].
     #[allow(clippy::cognitive_complexity)]
     fn do_to_match<I>(
         &mut self,
@@ -369,7 +394,7 @@ impl<'a> SplitWriter<'a> {
         input_iter: &mut InputSplitter<I>,
     ) -> Result<(), CsplitError>
     where
-        I: Iterator<Item = (usize, io::Result<String>)>,
+        I: Iterator<Item = (usize, UResult<String>)>,
     {
         if offset >= 0 {
             // The offset is zero or positive, no need for a buffer on the lines read.
@@ -381,18 +406,27 @@ impl<'a> SplitWriter<'a> {
             input_iter.set_size_of_buffer(1);
 
             while let Some((ln, line)) = input_iter.next() {
-                let l = line?;
-                if regex.is_match(&l) {
+                let line = line?;
+                let l = line
+                    .strip_suffix("\r\n")
+                    .unwrap_or_else(|| line.strip_suffix('\n').unwrap_or(&line));
+                if regex.is_match(l) {
+                    let mut next_line_suppress_matched = false;
                     match (self.options.suppress_matched, offset) {
                         // no offset, add the line to the next split
                         (false, 0) => {
                             assert!(
-                                input_iter.add_line_to_buffer(ln, l).is_none(),
+                                input_iter.add_line_to_buffer(ln, line).is_none(),
                                 "the buffer is big enough to contain 1 line"
                             );
                         }
                         // a positive offset, some more lines need to be added to the current split
-                        (false, _) => self.writeln(&l)?,
+                        (false, _) => self.writeln(&line)?,
+                        // suppress matched option true, but there is a positive offset, so the line is printed
+                        (true, 1..) => {
+                            next_line_suppress_matched = true;
+                            self.writeln(&line)?;
+                        }
                         _ => (),
                     };
                     offset -= 1;
@@ -413,9 +447,14 @@ impl<'a> SplitWriter<'a> {
                         offset -= 1;
                     }
                     self.finish_split();
+
+                    // if we have to suppress one line after we take the next and do nothing
+                    if next_line_suppress_matched {
+                        input_iter.next();
+                    }
                     return Ok(());
                 }
-                self.writeln(&l)?;
+                self.writeln(&line)?;
             }
         } else {
             // With a negative offset we use a buffer to keep the lines within the offset.
@@ -426,26 +465,35 @@ impl<'a> SplitWriter<'a> {
             let offset_usize = -offset as usize;
             input_iter.set_size_of_buffer(offset_usize);
             while let Some((ln, line)) = input_iter.next() {
-                let l = line?;
-                if regex.is_match(&l) {
+                let line = line?;
+                let l = line
+                    .strip_suffix("\r\n")
+                    .unwrap_or_else(|| line.strip_suffix('\n').unwrap_or(&line));
+                if regex.is_match(l) {
                     for line in input_iter.shrink_buffer_to_size() {
                         self.writeln(&line)?;
                     }
-                    if !self.options.suppress_matched {
+                    if self.options.suppress_matched {
+                        // since offset_usize is for sure greater than 0
+                        // the first element of the buffer should be removed and this
+                        // line inserted to be coherent with GNU implementation
+                        input_iter.add_line_to_buffer(ln, line);
+                    } else {
                         // add 1 to the buffer size to make place for the matched line
                         input_iter.set_size_of_buffer(offset_usize + 1);
                         assert!(
-                            input_iter.add_line_to_buffer(ln, l).is_none(),
+                            input_iter.add_line_to_buffer(ln, line).is_none(),
                             "should be big enough to hold every lines"
                         );
                     }
+
                     self.finish_split();
                     if input_iter.buffer_len() < offset_usize {
                         return Err(CsplitError::LineOutOfRange(pattern_as_str.to_string()));
                     }
                     return Ok(());
                 }
-                if let Some(line) = input_iter.add_line_to_buffer(ln, l) {
+                if let Some(line) = input_iter.add_line_to_buffer(ln, line) {
                     self.writeln(&line)?;
                 }
             }
@@ -464,7 +512,7 @@ impl<'a> SplitWriter<'a> {
 /// This is used to pass matching lines to the next split and to support patterns with a negative offset.
 struct InputSplitter<I>
 where
-    I: Iterator<Item = (usize, io::Result<String>)>,
+    I: Iterator<Item = (usize, UResult<String>)>,
 {
     iter: I,
     buffer: Vec<<I as Iterator>::Item>,
@@ -477,7 +525,7 @@ where
 
 impl<I> InputSplitter<I>
 where
-    I: Iterator<Item = (usize, io::Result<String>)>,
+    I: Iterator<Item = (usize, UResult<String>)>,
 {
     fn new(iter: I) -> Self {
         Self {
@@ -541,7 +589,7 @@ where
 
 impl<I> Iterator for InputSplitter<I>
 where
-    I: Iterator<Item = (usize, io::Result<String>)>,
+    I: Iterator<Item = (usize, UResult<String>)>,
 {
     type Item = <I as Iterator>::Item;
 
@@ -558,8 +606,6 @@ where
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     // get the file to split
@@ -571,29 +617,23 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .unwrap()
         .map(|s| s.to_string())
         .collect();
-    let patterns = patterns::get_patterns(&patterns[..])?;
-    let options = CsplitOptions::new(&matches);
+    let options = CsplitOptions::new(&matches)?;
     if file_name == "-" {
         let stdin = io::stdin();
-        Ok(csplit(&options, patterns, stdin.lock())?)
+        Ok(csplit(&options, &patterns, stdin.lock())?)
     } else {
         let file = File::open(file_name)
-            .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
-        let file_metadata = file
-            .metadata()
-            .map_err_context(|| format!("cannot access {}", file_name.quote()))?;
-        if !file_metadata.is_file() {
-            return Err(CsplitError::NotRegularFile(file_name.to_string()).into());
-        }
-        Ok(csplit(&options, patterns, BufReader::new(file))?)
+            .map_err_context(|| format!("cannot open {} for reading", file_name.quote()))?;
+        Ok(csplit(&options, &patterns, BufReader::new(file))?)
     }
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
+        .args_override_self(true)
         .infer_long_args(true)
         .arg(
             Arg::new(options::SUFFIX_FORMAT)
@@ -631,8 +671,9 @@ pub fn uu_app() -> Command {
         )
         .arg(
             Arg::new(options::QUIET)
-                .short('s')
+                .short('q')
                 .long(options::QUIET)
+                .visible_short_alias('s')
                 .visible_alias("silent")
                 .help("do not print counts of output file sizes")
                 .action(ArgAction::SetTrue),
@@ -653,7 +694,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::PATTERN)
                 .hide(true)
-                .action(clap::ArgAction::Append)
+                .action(ArgAction::Append)
                 .required(true),
         )
         .after_help(AFTER_HELP)
@@ -664,6 +705,7 @@ mod tests {
     use super::*;
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn input_splitter() {
         let input = vec![
             Ok(String::from("aaa")),
@@ -736,6 +778,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn input_splitter_interrupt_rewind() {
         let input = vec![
             Ok(String::from("aaa")),
diff --git a/src/uu/csplit/src/csplit_error.rs b/src/uu/csplit/src/csplit_error.rs
index 1559a29f8bc..a8c0fd1af08 100644
--- a/src/uu/csplit/src/csplit_error.rs
+++ b/src/uu/csplit/src/csplit_error.rs
@@ -12,7 +12,7 @@ use uucore::error::UError;
 #[derive(Debug, Error)]
 pub enum CsplitError {
     #[error("IO error: {}", _0)]
-    IoError(io::Error),
+    IoError(#[from] io::Error),
     #[error("{}: line number out of range", ._0.quote())]
     LineOutOfRange(String),
     #[error("{}: line number out of range on repetition {}", ._0.quote(), _1)]
@@ -21,7 +21,7 @@ pub enum CsplitError {
     MatchNotFound(String),
     #[error("{}: match not found on repetition {}", ._0.quote(), _1)]
     MatchNotFoundOnRepetition(String, usize),
-    #[error("line number must be greater than zero")]
+    #[error("0: line number must be greater than zero")]
     LineNumberIsZero,
     #[error("line number '{}' is smaller than preceding line number, {}", _0, _1)]
     LineNumberSmallerThanPrevious(usize, usize),
@@ -35,16 +35,21 @@ pub enum CsplitError {
     SuffixFormatTooManyPercents,
     #[error("{} is not a regular file", ._0.quote())]
     NotRegularFile(String),
+    #[error("{}", _0)]
+    UError(Box<dyn UError>),
 }
 
-impl From<io::Error> for CsplitError {
-    fn from(error: io::Error) -> Self {
-        Self::IoError(error)
+impl From<Box<dyn UError>> for CsplitError {
+    fn from(error: Box<dyn UError>) -> Self {
+        Self::UError(error)
     }
 }
 
 impl UError for CsplitError {
     fn code(&self) -> i32 {
-        1
+        match self {
+            Self::UError(e) => e.code(),
+            _ => 1,
+        }
     }
 }
diff --git a/src/uu/csplit/src/patterns.rs b/src/uu/csplit/src/patterns.rs
index fd96fd9fb9e..9326ea3795e 100644
--- a/src/uu/csplit/src/patterns.rs
+++ b/src/uu/csplit/src/patterns.rs
@@ -25,14 +25,14 @@ pub enum Pattern {
     SkipToMatch(Regex, i32, ExecutePattern),
 }
 
-impl ToString for Pattern {
-    fn to_string(&self) -> String {
+impl std::fmt::Display for Pattern {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::UpToLine(n, _) => n.to_string(),
-            Self::UpToMatch(regex, 0, _) => format!("/{}/", regex.as_str()),
-            Self::UpToMatch(regex, offset, _) => format!("/{}/{:+}", regex.as_str(), offset),
-            Self::SkipToMatch(regex, 0, _) => format!("%{}%", regex.as_str()),
-            Self::SkipToMatch(regex, offset, _) => format!("%{}%{:+}", regex.as_str(), offset),
+            Self::UpToLine(n, _) => write!(f, "{n}"),
+            Self::UpToMatch(regex, 0, _) => write!(f, "/{}/", regex.as_str()),
+            Self::UpToMatch(regex, offset, _) => write!(f, "/{}/{offset:+}", regex.as_str()),
+            Self::SkipToMatch(regex, 0, _) => write!(f, "%{}%", regex.as_str()),
+            Self::SkipToMatch(regex, offset, _) => write!(f, "%{}%{offset:+}", regex.as_str()),
         }
     }
 }
@@ -106,8 +106,8 @@ pub fn get_patterns(args: &[String]) -> Result<Vec<Pattern>, CsplitError> {
 fn extract_patterns(args: &[String]) -> Result<Vec<Pattern>, CsplitError> {
     let mut patterns = Vec::with_capacity(args.len());
     let to_match_reg =
-        Regex::new(r"^(/(?P<UPTO>.+)/|%(?P<SKIPTO>.+)%)(?P<OFFSET>[\+-]\d+)?$").unwrap();
-    let execute_ntimes_reg = Regex::new(r"^\{(?P<TIMES>\d+)|\*\}$").unwrap();
+        Regex::new(r"^(/(?P<UPTO>.+)/|%(?P<SKIPTO>.+)%)(?P<OFFSET>[\+-]?[0-9]+)?$").unwrap();
+    let execute_ntimes_reg = Regex::new(r"^\{(?P<TIMES>[0-9]+)|\*\}$").unwrap();
     let mut iter = args.iter().peekable();
 
     while let Some(arg) = iter.next() {
@@ -168,7 +168,7 @@ fn validate_line_numbers(patterns: &[Pattern]) -> Result<(), CsplitError> {
             (_, 0) => Err(CsplitError::LineNumberIsZero),
             // two consecutive numbers should not be equal
             (n, m) if n == m => {
-                show_warning!("line number '{}' is the same as preceding line number", n);
+                show_warning!("line number '{n}' is the same as preceding line number");
                 Ok(n)
             }
             // a number cannot be greater than the one that follows
@@ -196,7 +196,7 @@ mod tests {
             .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
         assert_eq!(patterns.len(), 3);
-        match patterns.get(0) {
+        match patterns.first() {
             Some(Pattern::UpToLine(24, ExecutePattern::Times(1))) => (),
             _ => panic!("expected UpToLine pattern"),
         };
@@ -211,6 +211,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn up_to_match_pattern() {
         let input: Vec<String> = vec![
             "/test1.*end$/",
@@ -218,15 +219,16 @@ mod tests {
             "{*}",
             "/test3.*end$/",
             "{4}",
-            "/test4.*end$/+3",
-            "/test5.*end$/-3",
+            "/test4.*end$/3",
+            "/test5.*end$/+3",
+            "/test6.*end$/-3",
         ]
         .into_iter()
         .map(|v| v.to_string())
         .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
-        assert_eq!(patterns.len(), 5);
-        match patterns.get(0) {
+        assert_eq!(patterns.len(), 6);
+        match patterns.first() {
             Some(Pattern::UpToMatch(reg, 0, ExecutePattern::Times(1))) => {
                 let parsed_reg = format!("{reg}");
                 assert_eq!(parsed_reg, "test1.*end$");
@@ -255,15 +257,23 @@ mod tests {
             _ => panic!("expected UpToMatch pattern"),
         };
         match patterns.get(4) {
-            Some(Pattern::UpToMatch(reg, -3, ExecutePattern::Times(1))) => {
+            Some(Pattern::UpToMatch(reg, 3, ExecutePattern::Times(1))) => {
                 let parsed_reg = format!("{reg}");
                 assert_eq!(parsed_reg, "test5.*end$");
             }
             _ => panic!("expected UpToMatch pattern"),
         };
+        match patterns.get(5) {
+            Some(Pattern::UpToMatch(reg, -3, ExecutePattern::Times(1))) => {
+                let parsed_reg = format!("{reg}");
+                assert_eq!(parsed_reg, "test6.*end$");
+            }
+            _ => panic!("expected UpToMatch pattern"),
+        };
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn skip_to_match_pattern() {
         let input: Vec<String> = vec![
             "%test1.*end$%",
@@ -271,15 +281,16 @@ mod tests {
             "{*}",
             "%test3.*end$%",
             "{4}",
-            "%test4.*end$%+3",
-            "%test5.*end$%-3",
+            "%test4.*end$%3",
+            "%test5.*end$%+3",
+            "%test6.*end$%-3",
         ]
         .into_iter()
         .map(|v| v.to_string())
         .collect();
         let patterns = get_patterns(input.as_slice()).unwrap();
-        assert_eq!(patterns.len(), 5);
-        match patterns.get(0) {
+        assert_eq!(patterns.len(), 6);
+        match patterns.first() {
             Some(Pattern::SkipToMatch(reg, 0, ExecutePattern::Times(1))) => {
                 let parsed_reg = format!("{reg}");
                 assert_eq!(parsed_reg, "test1.*end$");
@@ -308,12 +319,19 @@ mod tests {
             _ => panic!("expected SkipToMatch pattern"),
         };
         match patterns.get(4) {
-            Some(Pattern::SkipToMatch(reg, -3, ExecutePattern::Times(1))) => {
+            Some(Pattern::SkipToMatch(reg, 3, ExecutePattern::Times(1))) => {
                 let parsed_reg = format!("{reg}");
                 assert_eq!(parsed_reg, "test5.*end$");
             }
             _ => panic!("expected SkipToMatch pattern"),
         };
+        match patterns.get(5) {
+            Some(Pattern::SkipToMatch(reg, -3, ExecutePattern::Times(1))) => {
+                let parsed_reg = format!("{reg}");
+                assert_eq!(parsed_reg, "test6.*end$");
+            }
+            _ => panic!("expected SkipToMatch pattern"),
+        };
     }
 
     #[test]
diff --git a/src/uu/csplit/src/split_name.rs b/src/uu/csplit/src/split_name.rs
index 4d94b56a923..925ded4cc7b 100644
--- a/src/uu/csplit/src/split_name.rs
+++ b/src/uu/csplit/src/split_name.rs
@@ -4,21 +4,22 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (regex) diuox
 
-use regex::Regex;
+use uucore::format::{Format, FormatError, num_format::UnsignedInt};
 
 use crate::csplit_error::CsplitError;
 
 /// Computes the filename of a split, taking into consideration a possible user-defined suffix
 /// format.
 pub struct SplitName {
-    fn_split_name: Box<dyn Fn(usize) -> String>,
+    prefix: Vec<u8>,
+    format: Format<UnsignedInt, u64>,
 }
 
 impl SplitName {
     /// Creates a new SplitName with the given user-defined options:
     /// - `prefix_opt` specifies a prefix for all splits.
     /// - `format_opt` specifies a custom format for the suffix part of the filename, using the
-    /// `sprintf` format notation.
+    ///   `sprintf` format notation.
     /// - `n_digits_opt` defines the width of the split number.
     ///
     /// # Caveats
@@ -36,6 +37,7 @@ impl SplitName {
     ) -> Result<Self, CsplitError> {
         // get the prefix
         let prefix = prefix_opt.unwrap_or_else(|| "xx".to_string());
+
         // the width for the split offset
         let n_digits = n_digits_opt
             .map(|opt| {
@@ -44,120 +46,26 @@ impl SplitName {
             })
             .transpose()?
             .unwrap_or(2);
-        // translate the custom format into a function
-        let fn_split_name: Box<dyn Fn(usize) -> String> = match format_opt {
-            None => Box::new(move |n: usize| -> String { format!("{prefix}{n:0n_digits$}") }),
-            Some(custom) => {
-                let spec =
-                    Regex::new(r"(?P<ALL>%((?P<FLAG>[0#-])(?P<WIDTH>\d+)?)?(?P<TYPE>[diuoxX]))")
-                        .unwrap();
-                let mut captures_iter = spec.captures_iter(&custom);
-                let custom_fn: Box<dyn Fn(usize) -> String> = match captures_iter.next() {
-                    Some(captures) => {
-                        let all = captures.name("ALL").unwrap();
-                        let before = custom[0..all.start()].to_owned();
-                        let after = custom[all.end()..].to_owned();
-                        let width = match captures.name("WIDTH") {
-                            None => 0,
-                            Some(m) => m.as_str().parse::<usize>().unwrap(),
-                        };
-                        match (captures.name("FLAG"), captures.name("TYPE")) {
-                            (None, Some(ref t)) => match t.as_str() {
-                                "d" | "i" | "u" => Box::new(move |n: usize| -> String {
-                                    format!("{prefix}{before}{n}{after}")
-                                }),
-                                "o" => Box::new(move |n: usize| -> String {
-                                    format!("{prefix}{before}{n:o}{after}")
-                                }),
-                                "x" => Box::new(move |n: usize| -> String {
-                                    format!("{prefix}{before}{n:x}{after}")
-                                }),
-                                "X" => Box::new(move |n: usize| -> String {
-                                    format!("{prefix}{before}{n:X}{after}")
-                                }),
-                                _ => return Err(CsplitError::SuffixFormatIncorrect),
-                            },
-                            (Some(ref f), Some(ref t)) => {
-                                match (f.as_str(), t.as_str()) {
-                                    /*
-                                     * zero padding
-                                     */
-                                    // decimal
-                                    ("0", "d" | "i" | "u") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:0width$}{after}")
-                                    }),
-                                    // octal
-                                    ("0", "o") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:0width$o}{after}")
-                                    }),
-                                    // lower hexadecimal
-                                    ("0", "x") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:0width$x}{after}")
-                                    }),
-                                    // upper hexadecimal
-                                    ("0", "X") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:0width$X}{after}")
-                                    }),
-
-                                    /*
-                                     * Alternate form
-                                     */
-                                    // octal
-                                    ("#", "o") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:>#width$o}{after}")
-                                    }),
-                                    // lower hexadecimal
-                                    ("#", "x") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:>#width$x}{after}")
-                                    }),
-                                    // upper hexadecimal
-                                    ("#", "X") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:>#width$X}{after}")
-                                    }),
-
-                                    /*
-                                     * Left adjusted
-                                     */
-                                    // decimal
-                                    ("-", "d" | "i" | "u") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:<#width$}{after}")
-                                    }),
-                                    // octal
-                                    ("-", "o") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:<#width$o}{after}")
-                                    }),
-                                    // lower hexadecimal
-                                    ("-", "x") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:<#width$x}{after}")
-                                    }),
-                                    // upper hexadecimal
-                                    ("-", "X") => Box::new(move |n: usize| -> String {
-                                        format!("{prefix}{before}{n:<#width$X}{after}")
-                                    }),
-
-                                    _ => return Err(CsplitError::SuffixFormatIncorrect),
-                                }
-                            }
-                            _ => return Err(CsplitError::SuffixFormatIncorrect),
-                        }
-                    }
-                    None => return Err(CsplitError::SuffixFormatIncorrect),
-                };
-
-                // there cannot be more than one format pattern
-                if captures_iter.next().is_some() {
-                    return Err(CsplitError::SuffixFormatTooManyPercents);
-                }
-                custom_fn
-            }
-        };
 
-        Ok(Self { fn_split_name })
+        let format_string = format_opt.unwrap_or_else(|| format!("%0{n_digits}u"));
+
+        let format = match Format::<UnsignedInt, u64>::parse(format_string) {
+            Ok(format) => Ok(format),
+            Err(FormatError::TooManySpecs(_)) => Err(CsplitError::SuffixFormatTooManyPercents),
+            Err(_) => Err(CsplitError::SuffixFormatIncorrect),
+        }?;
+
+        Ok(Self {
+            prefix: prefix.as_bytes().to_owned(),
+            format,
+        })
     }
 
     /// Returns the filename of the i-th split.
     pub fn get(&self, n: usize) -> String {
-        (self.fn_split_name)(n)
+        let mut v = self.prefix.clone();
+        self.format.fmt(&mut v, n as u64).unwrap();
+        String::from_utf8_lossy(&v).to_string()
     }
 }
 
@@ -279,7 +187,7 @@ mod tests {
     #[test]
     fn alternate_form_octal() {
         let split_name = SplitName::new(None, Some(String::from("cst-%#10o-")), None).unwrap();
-        assert_eq!(split_name.get(42), "xxcst-      0o52-");
+        assert_eq!(split_name.get(42), "xxcst-       052-");
     }
 
     #[test]
@@ -291,7 +199,7 @@ mod tests {
     #[test]
     fn alternate_form_upper_hex() {
         let split_name = SplitName::new(None, Some(String::from("cst-%#10X-")), None).unwrap();
-        assert_eq!(split_name.get(42), "xxcst-      0x2A-");
+        assert_eq!(split_name.get(42), "xxcst-      0X2A-");
     }
 
     #[test]
@@ -315,19 +223,19 @@ mod tests {
     #[test]
     fn left_adjusted_octal() {
         let split_name = SplitName::new(None, Some(String::from("cst-%-10o-")), None).unwrap();
-        assert_eq!(split_name.get(42), "xxcst-0o52      -");
+        assert_eq!(split_name.get(42), "xxcst-52        -");
     }
 
     #[test]
     fn left_adjusted_lower_hex() {
         let split_name = SplitName::new(None, Some(String::from("cst-%-10x-")), None).unwrap();
-        assert_eq!(split_name.get(42), "xxcst-0x2a      -");
+        assert_eq!(split_name.get(42), "xxcst-2a        -");
     }
 
     #[test]
     fn left_adjusted_upper_hex() {
         let split_name = SplitName::new(None, Some(String::from("cst-%-10X-")), None).unwrap();
-        assert_eq!(split_name.get(42), "xxcst-0x2A      -");
+        assert_eq!(split_name.get(42), "xxcst-2A        -");
     }
 
     #[test]
diff --git a/src/uu/cut/Cargo.toml b/src/uu/cut/Cargo.toml
index affeb38058f..84fe09f23cf 100644
--- a/src/uu/cut/Cargo.toml
+++ b/src/uu/cut/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_cut"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "cut ~ (uutils) display byte/field columns of input lines"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/cut"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/cut.rs"
@@ -19,7 +22,6 @@ clap = { workspace = true }
 uucore = { workspace = true, features = ["ranges"] }
 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
index 972fcb6322e..5c21d23dcf9 100644
--- a/src/uu/cut/cut.md
+++ b/src/uu/cut/cut.md
@@ -3,7 +3,7 @@
 <!-- spell-checker:ignore sourcefile sourcefiles -->
 
 ```
-cut [-d|-w] [-s] [-z] [--output-delimiter] ((-f|-b|-c) {{sequence}}) {{sourcefile}}+
+cut OPTION... [FILE]...
 ```
 
 Prints specified byte or field columns from each line of stdin or the input files
diff --git a/src/uu/cut/src/cut.rs b/src/uu/cut/src/cut.rs
index 89128175354..49f5445f36f 100644
--- a/src/uu/cut/src/cut.rs
+++ b/src/uu/cut/src/cut.rs
@@ -6,19 +6,20 @@
 // spell-checker:ignore (ToDO) delim sourcefiles
 
 use bstr::io::BufReadExt;
-use clap::{crate_version, Arg, ArgAction, Command};
-use is_terminal::IsTerminal;
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::ValueParser};
+use std::ffi::OsString;
 use std::fs::File;
-use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
+use std::io::{BufRead, BufReader, BufWriter, IsTerminal, Read, Write, stdin, stdout};
 use std::path::Path;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError, set_exit_code};
 use uucore::line_ending::LineEnding;
+use uucore::os_str_as_bytes;
 
 use self::searcher::Searcher;
 use matcher::{ExactMatcher, Matcher, WhitespaceMatcher};
 use uucore::ranges::Range;
-use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_if_err};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_if_err};
 
 mod matcher;
 mod searcher;
@@ -27,34 +28,37 @@ 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>,
+struct Options<'a> {
+    out_delimiter: Option<&'a [u8]>,
     line_ending: LineEnding,
+    field_opts: Option<FieldOptions<'a>>,
 }
 
-enum Delimiter {
+enum Delimiter<'a> {
     Whitespace,
-    String(String), // FIXME: use char?
+    Slice(&'a [u8]),
 }
 
-struct FieldOptions {
-    delimiter: Delimiter,
-    out_delimiter: Option<String>,
+struct FieldOptions<'a> {
+    delimiter: Delimiter<'a>,
     only_delimited: bool,
-    line_ending: LineEnding,
 }
 
-enum Mode {
-    Bytes(Vec<Range>, Options),
-    Characters(Vec<Range>, Options),
-    Fields(Vec<Range>, FieldOptions),
+enum Mode<'a> {
+    Bytes(Vec<Range>, Options<'a>),
+    Characters(Vec<Range>, Options<'a>),
+    Fields(Vec<Range>, Options<'a>),
 }
 
-fn stdout_writer() -> Box<dyn Write> {
-    if std::io::stdout().is_terminal() {
-        Box::new(stdout())
-    } else {
-        Box::new(BufWriter::new(stdout())) as Box<dyn Write>
+impl Default for Delimiter<'_> {
+    fn default() -> Self {
+        Self::Slice(b"\t")
+    }
+}
+
+impl<'a> From<&'a OsString> for Delimiter<'a> {
+    fn from(s: &'a OsString) -> Self {
+        Self::Slice(os_str_as_bytes(s).unwrap())
     }
 }
 
@@ -66,15 +70,15 @@ fn list_to_ranges(list: &str, complement: bool) -> Result<Vec<Range>, String> {
     }
 }
 
-fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()> {
+fn cut_bytes<R: Read, W: Write>(
+    reader: R,
+    out: &mut W,
+    ranges: &[Range],
+    opts: &Options,
+) -> UResult<()> {
     let newline_char = opts.line_ending.into();
     let mut buf_in = BufReader::new(reader);
-    let mut out = stdout_writer();
-    let delim = opts
-        .out_delim
-        .as_ref()
-        .map_or("", String::as_str)
-        .as_bytes();
+    let out_delim = opts.out_delimiter.unwrap_or(b"\t");
 
     let result = buf_in.for_byte_record(newline_char, |line| {
         let mut print_delim = false;
@@ -83,8 +87,8 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()
                 break;
             }
             if print_delim {
-                out.write_all(delim)?;
-            } else if opts.out_delim.is_some() {
+                out.write_all(out_delim)?;
+            } else if opts.out_delimiter.is_some() {
                 print_delim = true;
             }
             // change `low` from 1-indexed value to 0-index value
@@ -104,16 +108,16 @@ fn cut_bytes<R: Read>(reader: R, ranges: &[Range], opts: &Options) -> UResult<()
 }
 
 // Output delimiter is explicitly specified
-fn cut_fields_explicit_out_delim<R: Read, M: Matcher>(
+fn cut_fields_explicit_out_delim<R: Read, W: Write, M: Matcher>(
     reader: R,
+    out: &mut W,
     matcher: &M,
     ranges: &[Range],
     only_delimited: bool,
     newline_char: u8,
-    out_delim: &str,
+    out_delim: &[u8],
 ) -> UResult<()> {
     let mut buf_in = BufReader::new(reader);
-    let mut out = stdout_writer();
 
     let result = buf_in.for_byte_record_with_terminator(newline_char, |line| {
         let mut fields_pos = 1;
@@ -123,8 +127,9 @@ fn cut_fields_explicit_out_delim<R: Read, M: Matcher>(
 
         if delim_search.peek().is_none() {
             if !only_delimited {
+                // Always write the entire line, even if it doesn't end with `newline_char`
                 out.write_all(line)?;
-                if line[line.len() - 1] != newline_char {
+                if line.is_empty() || line[line.len() - 1] != newline_char {
                     out.write_all(&[newline_char])?;
                 }
             }
@@ -146,7 +151,7 @@ fn cut_fields_explicit_out_delim<R: Read, M: Matcher>(
             for _ in 0..=high - low {
                 // skip printing delimiter if this is the first matching field for this line
                 if print_delim {
-                    out.write_all(out_delim.as_bytes())?;
+                    out.write_all(out_delim)?;
                 } else {
                     print_delim = true;
                 }
@@ -188,15 +193,15 @@ fn cut_fields_explicit_out_delim<R: Read, M: Matcher>(
 }
 
 // Output delimiter is the same as input delimiter
-fn cut_fields_implicit_out_delim<R: Read, M: Matcher>(
+fn cut_fields_implicit_out_delim<R: Read, W: Write, M: Matcher>(
     reader: R,
+    out: &mut W,
     matcher: &M,
     ranges: &[Range],
     only_delimited: bool,
     newline_char: u8,
 ) -> UResult<()> {
     let mut buf_in = BufReader::new(reader);
-    let mut out = stdout_writer();
 
     let result = buf_in.for_byte_record_with_terminator(newline_char, |line| {
         let mut fields_pos = 1;
@@ -206,8 +211,9 @@ fn cut_fields_implicit_out_delim<R: Read, M: Matcher>(
 
         if delim_search.peek().is_none() {
             if !only_delimited {
+                // Always write the entire line, even if it doesn't end with `newline_char`
                 out.write_all(line)?;
-                if line[line.len() - 1] != newline_char {
+                if line.is_empty() || line[line.len() - 1] != newline_char {
                     out.write_all(&[newline_char])?;
                 }
             }
@@ -257,39 +263,83 @@ fn cut_fields_implicit_out_delim<R: Read, M: Matcher>(
     Ok(())
 }
 
-fn cut_fields<R: Read>(reader: R, ranges: &[Range], opts: &FieldOptions) -> UResult<()> {
+// The input delimiter is identical to `newline_char`
+fn cut_fields_newline_char_delim<R: Read, W: Write>(
+    reader: R,
+    out: &mut W,
+    ranges: &[Range],
+    newline_char: u8,
+    out_delim: &[u8],
+) -> UResult<()> {
+    let buf_in = BufReader::new(reader);
+
+    let segments: Vec<_> = buf_in.split(newline_char).filter_map(|x| x.ok()).collect();
+    let mut print_delim = false;
+
+    for &Range { low, high } in ranges {
+        for i in low..=high {
+            // "- 1" is necessary because fields start from 1 whereas a Vec starts from 0
+            if let Some(segment) = segments.get(i - 1) {
+                if print_delim {
+                    out.write_all(out_delim)?;
+                } else {
+                    print_delim = true;
+                }
+                out.write_all(segment.as_slice())?;
+            } else {
+                break;
+            }
+        }
+    }
+    out.write_all(&[newline_char])?;
+    Ok(())
+}
+
+fn cut_fields<R: Read, W: Write>(
+    reader: R,
+    out: &mut W,
+    ranges: &[Range],
+    opts: &Options,
+) -> UResult<()> {
     let newline_char = opts.line_ending.into();
-    match opts.delimiter {
-        Delimiter::String(ref delim) => {
-            let matcher = ExactMatcher::new(delim.as_bytes());
+    let field_opts = opts.field_opts.as_ref().unwrap(); // it is safe to unwrap() here - field_opts will always be Some() for cut_fields() call
+    match field_opts.delimiter {
+        Delimiter::Slice(delim) if delim == [newline_char] => {
+            let out_delim = opts.out_delimiter.unwrap_or(delim);
+            cut_fields_newline_char_delim(reader, out, ranges, newline_char, out_delim)
+        }
+        Delimiter::Slice(delim) => {
+            let matcher = ExactMatcher::new(delim);
             match opts.out_delimiter {
-                Some(ref out_delim) => cut_fields_explicit_out_delim(
+                Some(out_delim) => cut_fields_explicit_out_delim(
                     reader,
+                    out,
                     &matcher,
                     ranges,
-                    opts.only_delimited,
+                    field_opts.only_delimited,
                     newline_char,
                     out_delim,
                 ),
                 None => cut_fields_implicit_out_delim(
                     reader,
+                    out,
                     &matcher,
                     ranges,
-                    opts.only_delimited,
+                    field_opts.only_delimited,
                     newline_char,
                 ),
             }
         }
         Delimiter::Whitespace => {
             let matcher = WhitespaceMatcher {};
-            let out_delim = opts.out_delimiter.as_deref().unwrap_or("\t");
             cut_fields_explicit_out_delim(
                 reader,
+                out,
                 &matcher,
                 ranges,
-                opts.only_delimited,
+                field_opts.only_delimited,
                 newline_char,
-                out_delim,
+                opts.out_delimiter.unwrap_or(b"\t"),
             )
         }
     }
@@ -302,6 +352,12 @@ fn cut_files(mut filenames: Vec<String>, mode: &Mode) {
         filenames.push("-".to_owned());
     }
 
+    let mut out: Box<dyn Write> = if stdout().is_terminal() {
+        Box::new(stdout())
+    } else {
+        Box::new(BufWriter::new(stdout())) as Box<dyn Write>
+    };
+
     for filename in &filenames {
         if filename == "-" {
             if stdin_read {
@@ -309,9 +365,9 @@ fn cut_files(mut filenames: Vec<String>, mode: &Mode) {
             }
 
             show_if_err!(match mode {
-                Mode::Bytes(ref ranges, ref opts) => cut_bytes(stdin(), ranges, opts),
-                Mode::Characters(ref ranges, ref opts) => cut_bytes(stdin(), ranges, opts),
-                Mode::Fields(ref ranges, ref opts) => cut_fields(stdin(), ranges, opts),
+                Mode::Bytes(ranges, opts) => cut_bytes(stdin(), &mut out, ranges, opts),
+                Mode::Characters(ranges, opts) => cut_bytes(stdin(), &mut out, ranges, opts),
+                Mode::Fields(ranges, opts) => cut_fields(stdin(), &mut out, ranges, opts),
             });
 
             stdin_read = true;
@@ -320,21 +376,78 @@ fn cut_files(mut filenames: Vec<String>, mode: &Mode) {
 
             if path.is_dir() {
                 show_error!("{}: Is a directory", filename.maybe_quote());
+                set_exit_code(1);
                 continue;
             }
 
-            show_if_err!(File::open(path)
-                .map_err_context(|| filename.maybe_quote().to_string())
-                .and_then(|file| {
-                    match &mode {
-                        Mode::Bytes(ranges, opts) | Mode::Characters(ranges, opts) => {
-                            cut_bytes(file, ranges, opts)
+            show_if_err!(
+                File::open(path)
+                    .map_err_context(|| filename.maybe_quote().to_string())
+                    .and_then(|file| {
+                        match &mode {
+                            Mode::Bytes(ranges, opts) | Mode::Characters(ranges, opts) => {
+                                cut_bytes(file, &mut out, ranges, opts)
+                            }
+                            Mode::Fields(ranges, opts) => cut_fields(file, &mut out, ranges, opts),
                         }
-                        Mode::Fields(ranges, opts) => cut_fields(file, ranges, opts),
-                    }
-                }));
+                    })
+            );
         }
     }
+
+    show_if_err!(out.flush().map_err_context(|| "write error".into()));
+}
+
+// Get delimiter and output delimiter from `-d`/`--delimiter` and `--output-delimiter` options respectively
+// Allow either delimiter to have a value that is neither UTF-8 nor ASCII to align with GNU behavior
+fn get_delimiters(matches: &ArgMatches) -> UResult<(Delimiter, Option<&[u8]>)> {
+    let whitespace_delimited = matches.get_flag(options::WHITESPACE_DELIMITED);
+    let delim_opt = matches.get_one::<OsString>(options::DELIMITER);
+    let delim = match delim_opt {
+        Some(_) if whitespace_delimited => {
+            return Err(USimpleError::new(
+                1,
+                "invalid input: Only one of --delimiter (-d) or -w option can be specified",
+            ));
+        }
+        Some(os_string) => {
+            if os_string == "''" || os_string.is_empty() {
+                // treat `''` as empty delimiter
+                Delimiter::Slice(b"\0")
+            } else {
+                // For delimiter `-d` option value - allow both UTF-8 (possibly multi-byte) characters
+                // and Non UTF-8 (and not ASCII) single byte "characters", like `b"\xAD"` to align with GNU behavior
+                let bytes = os_str_as_bytes(os_string)?;
+                if os_string.to_str().is_some_and(|s| s.chars().count() > 1)
+                    || os_string.to_str().is_none() && bytes.len() > 1
+                {
+                    return Err(USimpleError::new(
+                        1,
+                        "the delimiter must be a single character",
+                    ));
+                } else {
+                    Delimiter::from(os_string)
+                }
+            }
+        }
+        None => {
+            if whitespace_delimited {
+                Delimiter::Whitespace
+            } else {
+                Delimiter::default()
+            }
+        }
+    };
+    let out_delim = matches
+        .get_one::<OsString>(options::OUTPUT_DELIMITER)
+        .map(|os_string| {
+            if os_string.is_empty() || os_string == "''" {
+                b"\0"
+            } else {
+                os_str_as_bytes(os_string).unwrap()
+            }
+        });
+    Ok((delim, out_delim))
 }
 
 mod options {
@@ -352,116 +465,76 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
+    // GNU's `cut` supports `-d=` to set the delimiter to `=`.
+    // Clap parsing is limited in this situation, see:
+    // https://github.com/uutils/coreutils/issues/2424#issuecomment-863825242
+    let args: Vec<OsString> = args
+        .into_iter()
+        .map(|x| {
+            if x == "-d=" {
+                "--delimiter==".into()
+            } else {
+                x
+            }
+        })
+        .collect();
 
-    let delimiter_is_equal = args.contains(&"-d=".to_string()); // special case
     let matches = uu_app().try_get_matches_from(args)?;
 
     let complement = matches.get_flag(options::COMPLEMENT);
+    let only_delimited = matches.get_flag(options::ONLY_DELIMITED);
+
+    let (delimiter, out_delimiter) = get_delimiters(&matches)?;
+    let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
+
+    // Only one, and only one of cutting mode arguments, i.e. `-b`, `-c`, `-f`,
+    // is expected. The number of those arguments is used for parsing a cutting
+    // mode and handling the error cases.
+    let mode_args_count = [
+        matches.indices_of(options::BYTES),
+        matches.indices_of(options::CHARACTERS),
+        matches.indices_of(options::FIELDS),
+    ]
+    .into_iter()
+    .map(|indices| indices.unwrap_or_default().count())
+    .sum();
 
     let mode_parse = match (
+        mode_args_count,
         matches.get_one::<String>(options::BYTES),
         matches.get_one::<String>(options::CHARACTERS),
         matches.get_one::<String>(options::FIELDS),
     ) {
-        (Some(byte_ranges), None, None) => list_to_ranges(byte_ranges, complement).map(|ranges| {
+        (1, Some(byte_ranges), None, None) => list_to_ranges(byte_ranges, complement).map(|ranges| {
             Mode::Bytes(
                 ranges,
                 Options {
-                    out_delim: Some(
-                        matches
-                            .get_one::<String>(options::OUTPUT_DELIMITER)
-                            .map(|s| s.as_str())
-                            .unwrap_or_default()
-                            .to_owned(),
-                    ),
-                    line_ending: LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED)),
+                    out_delimiter,
+                    line_ending,
+                    field_opts: None,
                 },
             )
         }),
-        (None, Some(char_ranges), None) => list_to_ranges(char_ranges, complement).map(|ranges| {
+        (1, None, Some(char_ranges), None) => list_to_ranges(char_ranges, complement).map(|ranges| {
             Mode::Characters(
                 ranges,
                 Options {
-                    out_delim: Some(
-                        matches
-                            .get_one::<String>(options::OUTPUT_DELIMITER)
-                            .map(|s| s.as_str())
-                            .unwrap_or_default()
-                            .to_owned(),
-                    ),
-                    line_ending: LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED)),
+                    out_delimiter,
+                    line_ending,
+                    field_opts: None,
                 },
             )
         }),
-        (None, None, Some(field_ranges)) => {
-            list_to_ranges(field_ranges, complement).and_then(|ranges| {
-                let out_delim = match matches.get_one::<String>(options::OUTPUT_DELIMITER) {
-                    Some(s) => {
-                        if s.is_empty() {
-                            Some("\0".to_owned())
-                        } else {
-                            Some(s.to_owned())
-                        }
-                    }
-                    None => None,
-                };
-
-                let only_delimited = matches.get_flag(options::ONLY_DELIMITED);
-                let whitespace_delimited = matches.get_flag(options::WHITESPACE_DELIMITED);
-                let zero_terminated = matches.get_flag(options::ZERO_TERMINATED);
-                let line_ending = LineEnding::from_zero_flag(zero_terminated);
-
-                match matches.get_one::<String>(options::DELIMITER).map(|s| s.as_str()) {
-                    Some(_) if whitespace_delimited => {
-                            Err("invalid input: Only one of --delimiter (-d) or -w option can be specified".into())
-                        }
-                    Some(mut delim) => {
-                        // GNU's `cut` supports `-d=` to set the delimiter to `=`.
-                        // Clap parsing is limited in this situation, see:
-                        // https://github.com/uutils/coreutils/issues/2424#issuecomment-863825242
-                        if delimiter_is_equal {
-                            delim = "=";
-                        } else if delim == "''" {
-                            // treat `''` as empty delimiter
-                            delim = "";
-                        }
-                        if delim.chars().count() > 1 {
-                            Err("invalid input: The '--delimiter' ('-d') option expects empty or 1 character long, but was provided a value 2 characters or longer".into())
-                        } else {
-                            let delim = if delim.is_empty() {
-                                "\0".to_owned()
-                            } else {
-                                delim.to_owned()
-                            };
-
-                            Ok(Mode::Fields(
-                                ranges,
-                                FieldOptions {
-                                    delimiter: Delimiter::String(delim),
-                                    out_delimiter: out_delim,
-                                    only_delimited,
-                                    line_ending,
-                                },
-                            ))
-                        }
-                    }
-                    None => Ok(Mode::Fields(
-                        ranges,
-                        FieldOptions {
-                            delimiter: match whitespace_delimited {
-                                true => Delimiter::Whitespace,
-                                false => Delimiter::String("\t".to_owned()),
-                            },
-                            out_delimiter: out_delim,
-                            only_delimited,
-                            line_ending,
-                        },
-                    )),
-                }
-            })
-        }
-        (ref b, ref c, ref f) if b.is_some() || c.is_some() || f.is_some() => Err(
+        (1, None, None, Some(field_ranges)) => list_to_ranges(field_ranges, complement).map(|ranges| {
+            Mode::Fields(
+                ranges,
+                Options {
+                    out_delimiter,
+                    line_ending,
+                    field_opts: Some(FieldOptions { delimiter, only_delimited })},
+            )
+        }),
+        (2.., _, _, _) => Err(
             "invalid usage: expects no more than one of --fields (-f), --chars (-c) or --bytes (-b)".into()
         ),
         _ => Err("invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)".into()),
@@ -492,7 +565,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let files: Vec<String> = matches
         .get_many::<String>(options::FILE)
         .unwrap_or_default()
-        .map(|s| s.to_owned())
+        .cloned()
         .collect();
 
     match mode_parse {
@@ -506,18 +579,27 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .infer_long_args(true)
+        // While `args_override_self(true)` for some arguments, such as `-d`
+        // and `--output-delimiter`, is consistent to the behavior of GNU cut,
+        // arguments related to cutting mode, i.e. `-b`, `-c`, `-f`, should
+        // cause an error when there is more than one of them, as described in
+        // the manual of GNU cut: "Use one, and only one of -b, -c or -f".
+        // `ArgAction::Append` is used on `-b`, `-c`, `-f` arguments, so that
+        // the occurrences of those could be counted and be handled accordingly.
+        .args_override_self(true)
         .arg(
             Arg::new(options::BYTES)
                 .short('b')
                 .long(options::BYTES)
                 .help("filter byte columns from the input source")
                 .allow_hyphen_values(true)
-                .value_name("LIST"),
+                .value_name("LIST")
+                .action(ArgAction::Append),
         )
         .arg(
             Arg::new(options::CHARACTERS)
@@ -525,12 +607,14 @@ pub fn uu_app() -> Command {
                 .long(options::CHARACTERS)
                 .help("alias for character mode")
                 .allow_hyphen_values(true)
-                .value_name("LIST"),
+                .value_name("LIST")
+                .action(ArgAction::Append),
         )
         .arg(
             Arg::new(options::DELIMITER)
                 .short('d')
                 .long(options::DELIMITER)
+                .value_parser(ValueParser::os_string())
                 .help("specify the delimiter character that separates fields in the input source. Defaults to Tab.")
                 .value_name("DELIM"),
         )
@@ -547,7 +631,8 @@ pub fn uu_app() -> Command {
                 .long(options::FIELDS)
                 .help("filter field columns from the input source")
                 .allow_hyphen_values(true)
-                .value_name("LIST"),
+                .value_name("LIST")
+                .action(ArgAction::Append),
         )
         .arg(
             Arg::new(options::COMPLEMENT)
@@ -572,6 +657,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::OUTPUT_DELIMITER)
                 .long(options::OUTPUT_DELIMITER)
+                .value_parser(ValueParser::os_string())
                 .help("in field mode, replace the delimiter in output lines with this option's argument")
                 .value_name("NEW_DELIM"),
         )
diff --git a/src/uu/cut/src/matcher.rs b/src/uu/cut/src/matcher.rs
index 953e083b139..bb0c44d5bb4 100644
--- a/src/uu/cut/src/matcher.rs
+++ b/src/uu/cut/src/matcher.rs
@@ -23,7 +23,7 @@ impl<'a> ExactMatcher<'a> {
     }
 }
 
-impl<'a> Matcher for ExactMatcher<'a> {
+impl Matcher for ExactMatcher<'_> {
     fn next_match(&self, haystack: &[u8]) -> Option<(usize, usize)> {
         let mut pos = 0usize;
         loop {
diff --git a/src/uu/cut/src/searcher.rs b/src/uu/cut/src/searcher.rs
index 21424790eea..dc252d804f7 100644
--- a/src/uu/cut/src/searcher.rs
+++ b/src/uu/cut/src/searcher.rs
@@ -27,7 +27,7 @@ impl<'a, 'b, M: Matcher> Searcher<'a, 'b, M> {
 // Iterate over field delimiters
 // Returns (first, last) positions of each sequence, where `haystack[first..last]`
 // corresponds to the delimiter.
-impl<'a, 'b, M: Matcher> Iterator for Searcher<'a, 'b, M> {
+impl<M: Matcher> Iterator for Searcher<'_, '_, M> {
     type Item = (usize, usize);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -61,7 +61,7 @@ mod exact_searcher_tests {
         let matcher = ExactMatcher::new("a".as_bytes());
         let iter = Searcher::new(&matcher, "".as_bytes());
         let items: Vec<(usize, usize)> = iter.collect();
-        assert_eq!(vec![] as Vec<(usize, usize)>, items);
+        assert!(items.is_empty());
     }
 
     fn test_multibyte(line: &[u8], expected: &[(usize, usize)]) {
@@ -140,7 +140,7 @@ mod whitespace_searcher_tests {
         let matcher = WhitespaceMatcher {};
         let iter = Searcher::new(&matcher, "".as_bytes());
         let items: Vec<(usize, usize)> = iter.collect();
-        assert_eq!(vec![] as Vec<(usize, usize)>, items);
+        assert!(items.is_empty());
     }
 
     fn test_multispace(line: &[u8], expected: &[(usize, usize)]) {
diff --git a/src/uu/date/Cargo.toml b/src/uu/date/Cargo.toml
index 7590b0b746c..087d4befc7e 100644
--- a/src/uu/date/Cargo.toml
+++ b/src/uu/date/Cargo.toml
@@ -1,16 +1,19 @@
 # spell-checker:ignore datetime
 [package]
 name = "uu_date"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "date ~ (uutils) display or set the current time"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/date"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/date.rs"
@@ -18,7 +21,7 @@ path = "src/date.rs"
 [dependencies]
 chrono = { workspace = true }
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["custom-tz-fmt", "parser"] }
 parse_datetime = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
diff --git a/src/uu/date/date-usage.md b/src/uu/date/date-usage.md
index bf2dc469d3a..109bfd3988b 100644
--- a/src/uu/date/date-usage.md
+++ b/src/uu/date/date-usage.md
@@ -79,9 +79,3 @@ 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/src/date.rs b/src/uu/date/src/date.rs
index 745fd54239c..f4c9313cb62 100644
--- a/src/uu/date/src/date.rs
+++ b/src/uu/date/src/date.rs
@@ -6,24 +6,24 @@
 // spell-checker:ignore (chrono) Datelike Timelike ; (format) DATEFILE MMDDhhmm ; (vars) datetime datetimes
 
 use chrono::format::{Item, StrftimeItems};
-use chrono::{DateTime, Duration, FixedOffset, Local, Offset, Utc};
+use chrono::{DateTime, FixedOffset, Local, Offset, TimeDelta, Utc};
 #[cfg(windows)]
 use chrono::{Datelike, Timelike};
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 #[cfg(all(unix, not(target_os = "macos"), not(target_os = "redox")))]
-use libc::{clock_settime, timespec, CLOCK_REALTIME};
+use libc::{CLOCK_REALTIME, clock_settime, timespec};
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
+use uucore::custom_tz_fmt::custom_time_format;
 use uucore::display::Quotable;
-#[cfg(not(any(target_os = "redox")))]
 use uucore::error::FromIo;
 use uucore::error::{UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage, show};
 #[cfg(windows)]
 use windows_sys::Win32::{Foundation::SYSTEMTIME, System::SystemInformation::SetSystemTime};
 
-use uucore::shortcut_value_parser::ShortcutValueParser;
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 
 // Options
 const DATE: &str = "date";
@@ -92,7 +92,8 @@ enum DateSource {
     Now,
     Custom(String),
     File(PathBuf),
-    Human(Duration),
+    Stdin,
+    Human(TimeDelta),
 }
 
 enum Iso8601Format {
@@ -103,7 +104,7 @@ enum Iso8601Format {
     Ns,
 }
 
-impl<'a> From<&'a str> for Iso8601Format {
+impl From<&str> for Iso8601Format {
     fn from(s: &str) -> Self {
         match s {
             HOURS => Self::Hours,
@@ -123,7 +124,7 @@ enum Rfc3339Format {
     Ns,
 }
 
-impl<'a> From<&'a str> for Rfc3339Format {
+impl From<&str> for Rfc3339Format {
     fn from(s: &str) -> Self {
         match s {
             DATE => Self::Date,
@@ -166,13 +167,18 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     };
 
     let date_source = if let Some(date) = matches.get_one::<String>(OPT_DATE) {
-        if let Ok(duration) = parse_datetime::from_str(date.as_str()) {
+        let ref_time = Local::now();
+        if let Ok(new_time) = parse_datetime::parse_datetime_at_date(ref_time, date.as_str()) {
+            let duration = new_time.signed_duration_since(ref_time);
             DateSource::Human(duration)
         } else {
             DateSource::Custom(date.into())
         }
     } else if let Some(file) = matches.get_one::<String>(OPT_FILE) {
-        DateSource::File(file.into())
+        match file.as_ref() {
+            "-" => DateSource::Stdin,
+            _ => DateSource::File(file.into()),
+        }
     } else {
         DateSource::Now
     };
@@ -222,11 +228,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 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());
-                // double check the result is overflow or not of the current_time + relative_time
+                // Double check the result is overflow or not of the current_time + relative_time
                 // it may cause a panic of chrono::datetime::DateTime add
-                match current_time.checked_add_signed(relative_time) {
+                match now.checked_add_signed(relative_time) {
                     Some(date) => {
                         let iter = std::iter::once(Ok(date));
                         Box::new(iter)
@@ -234,11 +238,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                     None => {
                         return Err(USimpleError::new(
                             1,
-                            format!("invalid date {}", relative_time),
+                            format!("invalid date {relative_time}"),
                         ));
                     }
                 }
             }
+            DateSource::Stdin => {
+                let lines = BufReader::new(std::io::stdin()).lines();
+                let iter = lines.map_while(Result::ok).map(parse_date);
+                Box::new(iter)
+            }
             DateSource::File(ref path) => {
                 if path.is_dir() {
                     return Err(USimpleError::new(
@@ -264,18 +273,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         for date in dates {
             match date {
                 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")),
-                        ));
-                    }
+                    let format_string = custom_time_format(format_string);
                     // 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);
+                    let format_items = StrftimeItems::new(format_string.as_str());
                     if format_items.clone().any(|i| i == Item::Error) {
                         return Err(USimpleError::new(
                             1,
@@ -301,7 +302,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -310,6 +311,7 @@ pub fn uu_app() -> Command {
                 .short('d')
                 .long(OPT_DATE)
                 .value_name("STRING")
+                .allow_hyphen_values(true)
                 .help("display time described by STRING, not 'now'"),
         )
         .arg(
@@ -395,7 +397,7 @@ fn make_format_string(settings: &Settings) -> &str {
             Rfc3339Format::Ns => "%F %T.%f%:z",
         },
         Format::Custom(ref fmt) => fmt,
-        Format::Default => "%c",
+        Format::Default => "%a %b %e %X %Z %Y",
     }
 }
 
@@ -403,9 +405,8 @@ fn make_format_string(settings: &Settings) -> &str {
 /// If it fails, return a tuple of the `String` along with its `ParseError`.
 fn parse_date<S: AsRef<str> + Clone>(
     s: S,
-) -> Result<DateTime<FixedOffset>, (String, chrono::format::ParseError)> {
-    // TODO: The GNU date command can parse a wide variety of inputs.
-    s.as_ref().parse().map_err(|e| (s.as_ref().into(), e))
+) -> Result<DateTime<FixedOffset>, (String, parse_datetime::ParseDateTimeError)> {
+    parse_datetime::parse_datetime(s.as_ref()).map_err(|e| (s.as_ref().into(), e))
 }
 
 #[cfg(not(any(unix, windows)))]
diff --git a/src/uu/dd/Cargo.toml b/src/uu/dd/Cargo.toml
index 482128e1d08..04f05179926 100644
--- a/src/uu/dd/Cargo.toml
+++ b/src/uu/dd/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_dd"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "dd ~ (uutils) copy and convert files"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/dd"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/dd.rs"
@@ -18,13 +21,17 @@ path = "src/dd.rs"
 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"] }
+uucore = { workspace = true, features = [
+  "format",
+  "parser",
+  "quoting-style",
+  "fs",
+] }
+thiserror = { workspace = true }
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
 signal-hook = { workspace = true }
+nix = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "dd"
diff --git a/src/uu/dd/src/blocks.rs b/src/uu/dd/src/blocks.rs
index 8e5557a2c9b..b7449c98be7 100644
--- a/src/uu/dd/src/blocks.rs
+++ b/src/uu/dd/src/blocks.rs
@@ -133,7 +133,7 @@ mod tests {
         let buf = [0u8, 1u8, 2u8, 3u8];
         let res = block(&buf, 4, false, &mut rs);
 
-        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8],]);
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8]]);
     }
 
     #[test]
@@ -144,7 +144,7 @@ mod tests {
 
         assert_eq!(
             res,
-            vec![vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE],]
+            vec![vec![0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE]]
         );
     }
 
@@ -155,7 +155,7 @@ mod tests {
         let res = block(&buf, 4, false, &mut rs);
 
         // Commented section(s) should be truncated and appear for reference only.
-        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8 /*, 4u8*/],]);
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8 /*, 4u8*/]]);
         assert_eq!(rs.records_truncated, 1);
     }
 
@@ -238,7 +238,7 @@ mod tests {
         let buf = [0u8, 1u8, 2u8, 3u8, NEWLINE];
         let res = block(&buf, 4, false, &mut rs);
 
-        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8],]);
+        assert_eq!(res, vec![vec![0u8, 1u8, 2u8, 3u8]]);
     }
 
     #[test]
@@ -258,7 +258,7 @@ mod tests {
 
         assert_eq!(
             res,
-            vec![vec![0u8, 1u8, 2u8, SPACE], vec![SPACE, SPACE, SPACE, SPACE],]
+            vec![vec![0u8, 1u8, 2u8, SPACE], vec![SPACE, SPACE, SPACE, SPACE]]
         );
     }
 
@@ -270,7 +270,7 @@ mod tests {
 
         assert_eq!(
             res,
-            vec![vec![SPACE, SPACE, SPACE, SPACE], vec![0u8, 1u8, 2u8, 3u8],]
+            vec![vec![SPACE, SPACE, SPACE, SPACE], vec![0u8, 1u8, 2u8, 3u8]]
         );
     }
 
@@ -315,7 +315,7 @@ mod tests {
         let buf = [0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8];
         let res = unblock(&buf, 8);
 
-        assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, NEWLINE],);
+        assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, 4u8, 5u8, 6u8, 7u8, NEWLINE]);
     }
 
     #[test]
@@ -323,7 +323,7 @@ mod tests {
         let buf = [SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE];
         let res = unblock(&buf, 8);
 
-        assert_eq!(res, vec![NEWLINE],);
+        assert_eq!(res, vec![NEWLINE]);
     }
 
     #[test]
@@ -342,7 +342,7 @@ mod tests {
         let buf = [0u8, 1u8, 2u8, 3u8, SPACE, SPACE, SPACE, SPACE];
         let res = unblock(&buf, 8);
 
-        assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, NEWLINE],);
+        assert_eq!(res, vec![0u8, 1u8, 2u8, 3u8, NEWLINE]);
     }
 
     #[test]
diff --git a/src/uu/dd/src/bufferedoutput.rs b/src/uu/dd/src/bufferedoutput.rs
new file mode 100644
index 00000000000..6ac3b430046
--- /dev/null
+++ b/src/uu/dd/src/bufferedoutput.rs
@@ -0,0 +1,206 @@
+// 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.
+//
+// spell-checker:ignore wstat towrite cdefg bufferedoutput
+//! Buffer partial output blocks until they are completed.
+//!
+//! Use the [`BufferedOutput`] struct to create a buffered form of the
+//! [`Output`] writer.
+use crate::{Output, WriteStat};
+
+/// Buffer partial output blocks until they are completed.
+///
+/// Complete blocks are written immediately to the inner [`Output`],
+/// but partial blocks are stored in an internal buffer until they are
+/// completed.
+pub(crate) struct BufferedOutput<'a> {
+    /// The unbuffered inner block writer.
+    inner: Output<'a>,
+
+    /// The internal buffer that stores a partial block.
+    ///
+    /// The size of this buffer is always less than the output block
+    /// size (that is, the value of the `obs` command-line option).
+    buf: Vec<u8>,
+}
+
+impl<'a> BufferedOutput<'a> {
+    /// Add partial block buffering to the given block writer.
+    ///
+    /// The internal buffer size is at most the value of `obs` as
+    /// defined in `inner`.
+    pub(crate) fn new(inner: Output<'a>) -> Self {
+        let obs = inner.settings.obs;
+        Self {
+            inner,
+            buf: Vec::with_capacity(obs),
+        }
+    }
+
+    pub(crate) fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+        self.inner.discard_cache(offset, len);
+    }
+
+    /// Flush the partial block stored in the internal buffer.
+    pub(crate) fn flush(&mut self) -> std::io::Result<WriteStat> {
+        let wstat = self.inner.write_blocks(&self.buf)?;
+        let n = wstat.bytes_total.try_into().unwrap();
+        self.buf.drain(0..n);
+        Ok(wstat)
+    }
+
+    /// Synchronize the inner block writer.
+    pub(crate) fn sync(&mut self) -> std::io::Result<()> {
+        self.inner.sync()
+    }
+
+    /// Truncate the underlying file to the current stream position, if possible.
+    pub(crate) fn truncate(&mut self) -> std::io::Result<()> {
+        self.inner.dst.truncate()
+    }
+
+    /// Write the given bytes one block at a time.
+    ///
+    /// Only complete blocks will be written. Partial blocks will be
+    /// buffered until enough bytes have been provided to complete a
+    /// block. The returned [`WriteStat`] object will include the
+    /// number of blocks written during execution of this function.
+    pub(crate) fn write_blocks(&mut self, buf: &[u8]) -> std::io::Result<WriteStat> {
+        // Split the incoming buffer into two parts: the bytes to write
+        // and the bytes to buffer for next time.
+        //
+        // If `buf` does not include enough bytes to form a full block,
+        // just buffer the whole thing and write zero blocks.
+        let n = self.buf.len() + buf.len();
+        let rem = n % self.inner.settings.obs;
+        let i = buf.len().saturating_sub(rem);
+        let (to_write, to_buffer) = buf.split_at(i);
+
+        // Concatenate the old partial block with the new bytes to form
+        // some number of complete blocks.
+        self.buf.extend_from_slice(to_write);
+
+        // Write all complete blocks to the inner block writer.
+        //
+        // For example, if the output block size were 3, the buffered
+        // partial block were `b"ab"` and the new incoming bytes were
+        // `b"cdefg"`, then we would write blocks `b"abc"` and
+        // b`"def"` to the inner block writer.
+        let wstat = self.inner.write_blocks(&self.buf)?;
+
+        // Buffer any remaining bytes as a partial block.
+        //
+        // Continuing the example above, the last byte `b"g"` would be
+        // buffered as a partial block until the next call to
+        // `write_blocks()`.
+        self.buf.clear();
+        self.buf.extend_from_slice(to_buffer);
+
+        Ok(wstat)
+    }
+}
+
+#[cfg(unix)]
+#[cfg(test)]
+mod tests {
+    use crate::bufferedoutput::BufferedOutput;
+    use crate::{Dest, Output, Settings};
+
+    #[test]
+    fn test_buffered_output_write_blocks_empty() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput::new(inner);
+        let wstat = output.write_blocks(&[]).unwrap();
+        assert_eq!(wstat.writes_complete, 0);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 0);
+        assert_eq!(output.buf, vec![]);
+    }
+
+    #[test]
+    fn test_buffered_output_write_blocks_partial() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput::new(inner);
+        let wstat = output.write_blocks(b"ab").unwrap();
+        assert_eq!(wstat.writes_complete, 0);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 0);
+        assert_eq!(output.buf, b"ab");
+    }
+
+    #[test]
+    fn test_buffered_output_write_blocks_complete() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput::new(inner);
+        let wstat = output.write_blocks(b"abcd").unwrap();
+        assert_eq!(wstat.writes_complete, 1);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 3);
+        assert_eq!(output.buf, b"d");
+    }
+
+    #[test]
+    fn test_buffered_output_write_blocks_append() {
+        let settings = Settings {
+            obs: 3,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput {
+            inner,
+            buf: b"ab".to_vec(),
+        };
+        let wstat = output.write_blocks(b"cdefg").unwrap();
+        assert_eq!(wstat.writes_complete, 2);
+        assert_eq!(wstat.writes_partial, 0);
+        assert_eq!(wstat.bytes_total, 6);
+        assert_eq!(output.buf, b"g");
+    }
+
+    #[test]
+    fn test_buffered_output_flush() {
+        let settings = Settings {
+            obs: 10,
+            ..Default::default()
+        };
+        let inner = Output {
+            dst: Dest::Sink,
+            settings: &settings,
+        };
+        let mut output = BufferedOutput {
+            inner,
+            buf: b"abc".to_vec(),
+        };
+        let wstat = output.flush().unwrap();
+        assert_eq!(wstat.writes_complete, 0);
+        assert_eq!(wstat.writes_partial, 1);
+        assert_eq!(wstat.bytes_total, 3);
+        assert_eq!(output.buf, vec![]);
+    }
+}
diff --git a/src/uu/dd/src/dd.rs b/src/uu/dd/src/dd.rs
index 4ac2aa78006..4de05246f43 100644
--- a/src/uu/dd/src/dd.rs
+++ b/src/uu/dd/src/dd.rs
@@ -3,23 +3,27 @@
 // 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 fadvise Fadvise FADV DONTNEED ESPIPE
+// spell-checker:ignore fname, ftype, 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 bufferedoutput, SETFL
 
+mod blocks;
+mod bufferedoutput;
+mod conversion_tables;
 mod datastructures;
-use datastructures::*;
-
+mod numbers;
 mod parseargs;
-use parseargs::Parser;
-
-mod conversion_tables;
-
 mod progress;
-use progress::{gen_prog_updater, ProgUpdate, ReadStat, StatusLevel, WriteStat};
 
-mod blocks;
+use crate::bufferedoutput::BufferedOutput;
 use blocks::conv_block_unblock_helper;
-
-mod numbers;
+use datastructures::*;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use nix::fcntl::FcntlArg::F_SETFL;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use nix::fcntl::OFlag;
+use parseargs::Parser;
+use progress::ProgUpdateType;
+use progress::{ProgUpdate, ReadStat, StatusLevel, WriteStat, gen_prog_updater};
+use uucore::io::OwnedFileDescriptorOrHandle;
 
 use std::cmp;
 use std::env;
@@ -27,32 +31,36 @@ use std::ffi::OsString;
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read, Seek, SeekFrom, Stdout, Write};
 #[cfg(any(target_os = "linux", target_os = "android"))]
+use std::os::fd::AsFd;
+#[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},
 };
+#[cfg(windows)]
+use std::os::windows::{fs::MetadataExt, io::AsHandle};
 use std::path::Path;
-use std::sync::{
-    atomic::{AtomicBool, Ordering::Relaxed},
-    mpsc, Arc,
-};
+use std::sync::atomic::AtomicU8;
+use std::sync::{Arc, atomic::Ordering::Relaxed, mpsc};
 use std::thread;
 use std::time::{Duration, Instant};
 
-use clap::{crate_version, Arg, Command};
+use clap::{Arg, Command};
 use gcd::Gcd;
 #[cfg(target_os = "linux")]
 use nix::{
     errno::Errno,
-    fcntl::{posix_fadvise, PosixFadviseAdvice},
+    fcntl::{PosixFadviseAdvice, posix_fadvise},
 };
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
-use uucore::{format_usage, help_about, help_section, help_usage, show_error};
+#[cfg(unix)]
+use uucore::error::{USimpleError, set_exit_code};
 #[cfg(target_os = "linux")]
-use uucore::{show, show_if_err};
+use uucore::show_if_err;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 const ABOUT: &str = help_about!("dd.md");
 const AFTER_HELP: &str = help_section!("after help", "dd.md");
@@ -74,42 +82,71 @@ struct Settings {
     oconv: OConvFlags,
     oflags: OFlags,
     status: Option<StatusLevel>,
+    /// Whether the output writer should buffer partial blocks until complete.
+    buffered: bool,
 }
 
 /// A timer which triggers on a given interval
 ///
-/// After being constructed with [`Alarm::with_interval`], [`Alarm::is_triggered`]
-/// will return true once per the given [`Duration`].
+/// After being constructed with [`Alarm::with_interval`], [`Alarm::get_trigger`]
+/// will return [`ALARM_TRIGGER_TIMER`] once per the given [`Duration`].
+/// Alarm can be manually triggered with closure returned by [`Alarm::manual_trigger_fn`].
+/// [`Alarm::get_trigger`] will return [`ALARM_TRIGGER_SIGNAL`] in this case.
 ///
 /// Can be cloned, but the trigger status is shared across all instances so only
 /// the first caller each interval will yield true.
 ///
 /// When all instances are dropped the background thread will exit on the next interval.
-#[derive(Debug, Clone)]
 pub struct Alarm {
     interval: Duration,
-    trigger: Arc<AtomicBool>,
+    trigger: Arc<AtomicU8>,
 }
 
+pub const ALARM_TRIGGER_NONE: u8 = 0;
+pub const ALARM_TRIGGER_TIMER: u8 = 1;
+pub const ALARM_TRIGGER_SIGNAL: u8 = 2;
+
 impl Alarm {
+    /// use to construct alarm timer with duration
     pub fn with_interval(interval: Duration) -> Self {
-        let trigger = Arc::new(AtomicBool::default());
+        let trigger = Arc::new(AtomicU8::default());
 
         let weak_trigger = Arc::downgrade(&trigger);
         thread::spawn(move || {
             while let Some(trigger) = weak_trigger.upgrade() {
                 thread::sleep(interval);
-                trigger.store(true, Relaxed);
+                trigger.store(ALARM_TRIGGER_TIMER, Relaxed);
             }
         });
 
         Self { interval, trigger }
     }
 
-    pub fn is_triggered(&self) -> bool {
-        self.trigger.swap(false, Relaxed)
+    /// Returns a closure that allows to manually trigger the alarm
+    ///
+    /// This is useful for cases where more than one alarm even source exists
+    /// In case of `dd` there is the SIGUSR1/SIGINFO case where we want to
+    /// trigger an manual progress report.
+    pub fn manual_trigger_fn(&self) -> Box<dyn Send + Sync + Fn()> {
+        let weak_trigger = Arc::downgrade(&self.trigger);
+        Box::new(move || {
+            if let Some(trigger) = weak_trigger.upgrade() {
+                trigger.store(ALARM_TRIGGER_SIGNAL, Relaxed);
+            }
+        })
+    }
+
+    /// Use this function to poll for any pending alarm event
+    ///
+    /// Returns `ALARM_TRIGGER_NONE` for no pending event.
+    /// Returns `ALARM_TRIGGER_TIMER` if the event was triggered by timer
+    /// Returns `ALARM_TRIGGER_SIGNAL` if the event was triggered manually
+    /// by the closure returned from `manual_trigger_fn`
+    pub fn get_trigger(&self) -> u8 {
+        self.trigger.swap(ALARM_TRIGGER_NONE, Relaxed)
     }
 
+    // Getter function for the configured interval duration
     pub fn get_interval(&self) -> Duration {
         self.interval
     }
@@ -126,6 +163,12 @@ enum Num {
     Bytes(u64),
 }
 
+impl Default for Num {
+    fn default() -> Self {
+        Self::Blocks(0)
+    }
+}
+
 impl Num {
     fn force_bytes_if(self, force: bool) -> Self {
         match self {
@@ -181,7 +224,8 @@ impl Source {
     /// 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> {
+    fn len(&self) -> io::Result<i64> {
+        #[allow(clippy::match_wildcard_for_single_variants)]
         match self {
             Self::File(f) => Ok(f.metadata()?.len().try_into().unwrap_or(i64::MAX)),
             _ => Ok(0),
@@ -200,15 +244,26 @@ impl Source {
                 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)
+            Self::StdinFile(f) => {
+                if let Ok(Some(len)) = try_get_len_of_block_device(f) {
+                    if len < n {
+                        // GNU compatibility:
+                        // this case prints the stats but sets the exit code to 1
+                        show_error!("'standard input': cannot skip: Invalid argument");
+                        set_exit_code(1);
+                        return Ok(len);
+                    }
                 }
-                Ok(m) => Ok(m),
-                Err(e) => Err(e),
-            },
-            Self::File(f) => f.seek(io::SeekFrom::Start(n)),
+                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(SeekFrom::Current(n.try_into().unwrap())),
             #[cfg(unix)]
             Self::Fifo(f) => io::copy(&mut f.take(n), &mut io::sink()),
         }
@@ -222,10 +277,11 @@ impl Source {
     /// then this function returns an error.
     #[cfg(target_os = "linux")]
     fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) -> nix::Result<()> {
+        #[allow(clippy::match_wildcard_for_single_variants)]
         match self {
             Self::File(f) => {
                 let advice = PosixFadviseAdvice::POSIX_FADV_DONTNEED;
-                posix_fadvise(f.as_raw_fd(), offset, len, advice)
+                posix_fadvise(f.as_fd(), offset, len, advice)
             }
             _ => Err(Errno::ESPIPE), // "Illegal seek"
         }
@@ -264,9 +320,35 @@ 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());
+        let mut src = {
+            let f = File::from(io::stdin().as_handle().try_clone_to_owned()?);
+            let is_file = if let Ok(metadata) = f.metadata() {
+                // this hack is needed as there is no other way on windows
+                // to differentiate between the case where `seek` works
+                // on a file handle or not. i.e. when the handle is no real
+                // file but a pipe, `seek` is still successful, but following
+                // `read`s are not affected by the seek.
+                metadata.creation_time() != 0
+            } else {
+                false
+            };
+            if is_file {
+                Source::File(f)
+            } else {
+                Source::Stdin(io::stdin())
+            }
+        };
         #[cfg(unix)]
         let mut src = Source::stdin_as_file();
+        #[cfg(unix)]
+        if let Source::StdinFile(f) = &src {
+            if settings.iflags.directory && !f.metadata()?.is_dir() {
+                return Err(USimpleError::new(
+                    1,
+                    "setting flags for 'standard input': Not a directory",
+                ));
+            }
+        };
         if settings.skip > 0 {
             src.skip(settings.skip)?;
         }
@@ -339,14 +421,10 @@ fn make_linux_iflags(iflags: &IFlags) -> Option<libc::c_int> {
         flag |= libc::O_SYNC;
     }
 
-    if flag == 0 {
-        None
-    } else {
-        Some(flag)
-    }
+    if flag == 0 { None } else { Some(flag) }
 }
 
-impl<'a> Read for Input<'a> {
+impl Read for Input<'_> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let mut base_idx = 0;
         let target_len = buf.len();
@@ -369,7 +447,7 @@ impl<'a> Read for Input<'a> {
     }
 }
 
-impl<'a> Input<'a> {
+impl Input<'_> {
     /// Discard the system file cache for the given portion of the input.
     ///
     /// `offset` and `len` specify a contiguous portion of the input.
@@ -377,7 +455,7 @@ impl<'a> Input<'a> {
     /// 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)]
+    #[cfg_attr(not(target_os = "linux"), allow(clippy::unused_self, unused_variables))]
     fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
         #[cfg(target_os = "linux")]
         {
@@ -396,7 +474,7 @@ impl<'a> Input<'a> {
     /// Fills a given buffer.
     /// Reads in increments of 'self.ibs'.
     /// The start of each ibs-sized read follows the previous one.
-    fn fill_consecutive(&mut self, buf: &mut Vec<u8>) -> std::io::Result<ReadStat> {
+    fn fill_consecutive(&mut self, buf: &mut Vec<u8>) -> io::Result<ReadStat> {
         let mut reads_complete = 0;
         let mut reads_partial = 0;
         let mut bytes_total = 0;
@@ -427,7 +505,7 @@ impl<'a> Input<'a> {
     /// Fills a given buffer.
     /// Reads in increments of 'self.ibs'.
     /// The start of each ibs-sized read is aligned to multiples of ibs; remaining space is filled with the 'pad' byte.
-    fn fill_blocks(&mut self, buf: &mut Vec<u8>, pad: u8) -> std::io::Result<ReadStat> {
+    fn fill_blocks(&mut self, buf: &mut Vec<u8>, pad: u8) -> io::Result<ReadStat> {
         let mut reads_complete = 0;
         let mut reads_partial = 0;
         let mut base_idx = 0;
@@ -527,7 +605,19 @@ impl Dest {
     fn seek(&mut self, n: u64) -> io::Result<u64> {
         match self {
             Self::Stdout(stdout) => io::copy(&mut io::repeat(0).take(n), stdout),
-            Self::File(f, _) => f.seek(io::SeekFrom::Start(n)),
+            Self::File(f, _) => {
+                #[cfg(unix)]
+                if let Ok(Some(len)) = try_get_len_of_block_device(f) {
+                    if len < n {
+                        // GNU compatibility:
+                        // this case prints the stats but sets the exit code to 1
+                        show_error!("'standard output': cannot seek: Invalid argument");
+                        set_exit_code(1);
+                        return Ok(len);
+                    }
+                }
+                f.seek(SeekFrom::Current(n.try_into().unwrap()))
+            }
             #[cfg(unix)]
             Self::Fifo(f) => {
                 // Seeking in a named pipe means *reading* from the pipe.
@@ -540,6 +630,7 @@ impl Dest {
 
     /// Truncate the underlying file to the current stream position, if possible.
     fn truncate(&mut self) -> io::Result<()> {
+        #[allow(clippy::match_wildcard_for_single_variants)]
         match self {
             Self::File(f, _) => {
                 let pos = f.stream_position()?;
@@ -560,7 +651,7 @@ impl Dest {
         match self {
             Self::File(f, _) => {
                 let advice = PosixFadviseAdvice::POSIX_FADV_DONTNEED;
-                posix_fadvise(f.as_raw_fd(), offset, len, advice)
+                posix_fadvise(f.as_fd(), offset, len, advice)
             }
             _ => Err(Errno::ESPIPE), // "Illegal seek"
         }
@@ -569,7 +660,8 @@ impl Dest {
     /// 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> {
+    fn len(&self) -> io::Result<i64> {
+        #[allow(clippy::match_wildcard_for_single_variants)]
         match self {
             Self::File(f, _) => Ok(f.metadata()?.len().try_into().unwrap_or(i64::MAX)),
             _ => Ok(0),
@@ -590,7 +682,7 @@ impl Write for Dest {
                     .len()
                     .try_into()
                     .expect("Internal dd Error: Seek amount greater than signed 64-bit integer");
-                f.seek(io::SeekFrom::Current(seek_amt))?;
+                f.seek(SeekFrom::Current(seek_amt))?;
                 Ok(buf.len())
             }
             Self::File(f, _) => f.write(buf),
@@ -668,6 +760,11 @@ impl<'a> Output<'a> {
         if !settings.oconv.notrunc {
             dst.set_len(settings.seek).ok();
         }
+
+        Self::prepare_file(dst, settings)
+    }
+
+    fn prepare_file(dst: File, settings: &'a Settings) -> UResult<Self> {
         let density = if settings.oconv.sparse {
             Density::Sparse
         } else {
@@ -679,6 +776,24 @@ impl<'a> Output<'a> {
         Ok(Self { dst, settings })
     }
 
+    /// Instantiate this struct with file descriptor as a destination.
+    ///
+    /// This is useful e.g. for the case when the file descriptor was
+    /// already opened by the system (stdout) and has a state
+    /// (current position) that shall be used.
+    fn new_file_from_stdout(settings: &'a Settings) -> UResult<Self> {
+        let fx = OwnedFileDescriptorOrHandle::from(io::stdout())?;
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        if let Some(libc_flags) = make_linux_oflags(&settings.oflags) {
+            nix::fcntl::fcntl(
+                fx.as_raw().as_fd(),
+                F_SETFL(OFlag::from_bits_retain(libc_flags)),
+            )?;
+        }
+
+        Self::prepare_file(fx.into_file(), settings)
+    }
+
     /// Instantiate this struct with the given named pipe as a destination.
     #[cfg(unix)]
     fn new_fifo(filename: &Path, settings: &'a Settings) -> UResult<Self> {
@@ -715,22 +830,45 @@ impl<'a> Output<'a> {
     /// 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)]
+    #[cfg_attr(not(target_os = "linux"), allow(clippy::unused_self, 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()));
+            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")]
+        #[cfg(not(target_os = "linux"))]
         {
             // TODO Is there a way to discard filesystem cache on
             // these other operating systems?
         }
     }
 
+    /// writes a block of data. optionally retries when first try didn't complete
+    ///
+    /// this is needed by gnu-test: tests/dd/stats.s
+    /// the write can be interrupted by a system signal.
+    /// e.g. SIGUSR1 which is send to report status
+    /// without retry, the data might not be fully written to destination.
+    fn write_block(&mut self, chunk: &[u8]) -> io::Result<usize> {
+        let full_len = chunk.len();
+        let mut base_idx = 0;
+        loop {
+            match self.dst.write(&chunk[base_idx..]) {
+                Ok(wlen) => {
+                    base_idx += wlen;
+                    // take iflags.fullblock as oflags shall not have this option
+                    if (base_idx >= full_len) || !self.settings.iflags.fullblock {
+                        return Ok(base_idx);
+                    }
+                }
+                Err(e) if e.kind() == io::ErrorKind::Interrupted => continue,
+                Err(e) => return Err(e),
+            }
+        }
+    }
+
     /// Write the given bytes one block at a time.
     ///
     /// This may write partial blocks (for example, if the underlying
@@ -744,7 +882,7 @@ impl<'a> Output<'a> {
         let mut bytes_total = 0;
 
         for chunk in buf.chunks(self.settings.obs) {
-            let wlen = self.dst.write(chunk)?;
+            let wlen = self.write_block(chunk)?;
             if wlen < self.settings.obs {
                 writes_partial += 1;
             } else {
@@ -761,7 +899,7 @@ impl<'a> Output<'a> {
     }
 
     /// Flush the output to disk, if configured to do so.
-    fn sync(&mut self) -> std::io::Result<()> {
+    fn sync(&mut self) -> io::Result<()> {
         if self.settings.oconv.fsync {
             self.dst.fsync()
         } else if self.settings.oconv.fdatasync {
@@ -771,6 +909,91 @@ impl<'a> Output<'a> {
             Ok(())
         }
     }
+
+    /// Truncate the underlying file to the current stream position, if possible.
+    fn truncate(&mut self) -> io::Result<()> {
+        self.dst.truncate()
+    }
+}
+
+/// The block writer either with or without partial block buffering.
+enum BlockWriter<'a> {
+    /// Block writer with partial block buffering.
+    ///
+    /// Partial blocks are buffered until completed.
+    Buffered(BufferedOutput<'a>),
+
+    /// Block writer without partial block buffering.
+    ///
+    /// Partial blocks are written immediately.
+    Unbuffered(Output<'a>),
+}
+
+impl BlockWriter<'_> {
+    fn discard_cache(&self, offset: libc::off_t, len: libc::off_t) {
+        match self {
+            Self::Unbuffered(o) => o.discard_cache(offset, len),
+            Self::Buffered(o) => o.discard_cache(offset, len),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<WriteStat> {
+        match self {
+            Self::Unbuffered(_) => Ok(WriteStat::default()),
+            Self::Buffered(o) => o.flush(),
+        }
+    }
+
+    fn sync(&mut self) -> io::Result<()> {
+        match self {
+            Self::Unbuffered(o) => o.sync(),
+            Self::Buffered(o) => o.sync(),
+        }
+    }
+
+    /// Truncate the file to the final cursor location.
+    fn truncate(&mut self) {
+        // Calling `set_len()` may result in an error (for example,
+        // when calling it on `/dev/null`), but we don't want to
+        // terminate the process when that happens. Instead, we
+        // suppress the error by calling `Result::ok()`. This matches
+        // the behavior of GNU `dd` when given the command-line
+        // argument `of=/dev/null`.
+        match self {
+            Self::Unbuffered(o) => o.truncate().ok(),
+            Self::Buffered(o) => o.truncate().ok(),
+        };
+    }
+
+    fn write_blocks(&mut self, buf: &[u8]) -> io::Result<WriteStat> {
+        match self {
+            Self::Unbuffered(o) => o.write_blocks(buf),
+            Self::Buffered(o) => o.write_blocks(buf),
+        }
+    }
+}
+
+/// depending on the command line arguments, this function
+/// informs the OS to flush/discard the caches for input and/or output file.
+fn flush_caches_full_length(i: &Input, o: &Output) -> io::Result<()> {
+    // 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);
+    }
+
+    Ok(())
 }
 
 /// Copy the given input data to this output, consuming both.
@@ -784,7 +1007,7 @@ impl<'a> Output<'a> {
 ///
 /// If there is a problem reading from the input or writing to
 /// this output.
-fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
+fn dd_copy(mut i: Input, o: Output) -> io::Result<()> {
     // The read and write statistics.
     //
     // These objects are counters, initialized to zero. After each
@@ -821,6 +1044,9 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     let (prog_tx, rx) = mpsc::channel();
     let output_thread = thread::spawn(gen_prog_updater(rx, i.settings.status));
 
+    // Whether to truncate the output file after all blocks have been written.
+    let truncate = !o.settings.oconv.notrunc;
+
     // 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 {
@@ -829,23 +1055,16 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         // 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);
+        flush_caches_full_length(&i, &o)?;
+        return finalize(
+            BlockWriter::Unbuffered(o),
+            rstat,
+            wstat,
+            start,
+            &prog_tx,
+            output_thread,
+            truncate,
+        );
     };
 
     // Create a common buffer with a capacity of the block size.
@@ -858,6 +1077,18 @@ 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));
 
+    // The signal handler spawns an own thread that waits for signals.
+    // When the signal is received, it calls a handler function.
+    // We inject a handler function that manually triggers the alarm.
+    #[cfg(target_os = "linux")]
+    let signal_handler = progress::SignalHandler::install_signal_handler(alarm.manual_trigger_fn());
+    #[cfg(target_os = "linux")]
+    if let Err(e) = &signal_handler {
+        if Some(StatusLevel::None) != i.settings.status {
+            eprintln!("Internal dd Warning: Unable to register signal handler \n\t{e}");
+        }
+    }
+
     // Index in the input file where we are reading bytes and in
     // the output file where we are writing bytes.
     //
@@ -865,19 +1096,29 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     let mut read_offset = 0;
     let mut write_offset = 0;
 
+    let input_nocache = i.settings.iflags.nocache;
+    let output_nocache = o.settings.oflags.nocache;
+
+    // Add partial block buffering, if needed.
+    let mut o = if o.settings.buffered {
+        BlockWriter::Buffered(BufferedOutput::new(o))
+    } else {
+        BlockWriter::Unbuffered(o)
+    };
+
     // The main read/write loop.
     //
     // Each iteration reads blocks from the input and writes
     // blocks to this output. Read/write statistics are updated on
     // each iteration and cumulative statistics are reported to
     // the progress reporting thread.
-    while below_count_limit(&i.settings.count, &rstat, &wstat) {
+    while below_count_limit(i.settings.count, &rstat) {
         // Read a block from the input then write the block to the output.
         //
         // As an optimization, make an educated guess about the
         // best buffer size for reading based on the number of
         // blocks already read and the number of blocks remaining.
-        let loop_bsize = calc_loop_bsize(&i.settings.count, &rstat, &wstat, i.settings.ibs, bsize);
+        let loop_bsize = calc_loop_bsize(i.settings.count, &rstat, &wstat, i.settings.ibs, bsize);
         let rstat_update = read_helper(&mut i, &mut buf, loop_bsize)?;
         if rstat_update.is_empty() {
             break;
@@ -889,7 +1130,7 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         //
         // TODO Better error handling for overflowing `offset` and `len`.
         let read_len = rstat_update.bytes_total;
-        if i.settings.iflags.nocache {
+        if input_nocache {
             let offset = read_offset.try_into().unwrap();
             let len = read_len.try_into().unwrap();
             i.discard_cache(offset, len);
@@ -901,7 +1142,7 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         //
         // TODO Better error handling for overflowing `offset` and `len`.
         let write_len = wstat_update.bytes_total;
-        if o.settings.oflags.nocache {
+        if output_nocache {
             let offset = write_offset.try_into().unwrap();
             let len = write_len.try_into().unwrap();
             o.discard_cache(offset, len);
@@ -916,45 +1157,54 @@ fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
         // error.
         rstat += rstat_update;
         wstat += wstat_update;
-        if alarm.is_triggered() {
-            let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), false);
-            prog_tx.send(prog_update).unwrap_or(());
+        match alarm.get_trigger() {
+            ALARM_TRIGGER_NONE => {}
+            t @ (ALARM_TRIGGER_TIMER | ALARM_TRIGGER_SIGNAL) => {
+                let tp = match t {
+                    ALARM_TRIGGER_TIMER => ProgUpdateType::Periodic,
+                    _ => ProgUpdateType::Signal,
+                };
+                let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), tp);
+                prog_tx.send(prog_update).unwrap_or(());
+            }
+            _ => {}
         }
     }
-    finalize(&mut o, rstat, wstat, start, &prog_tx, output_thread)
+
+    finalize(o, rstat, wstat, start, &prog_tx, output_thread, truncate)
 }
 
 /// Flush output, print final stats, and join with the progress thread.
 fn finalize<T>(
-    output: &mut Output,
+    mut output: BlockWriter,
     rstat: ReadStat,
     wstat: WriteStat,
     start: Instant,
     prog_tx: &mpsc::Sender<ProgUpdate>,
     output_thread: thread::JoinHandle<T>,
-) -> std::io::Result<()> {
-    // Flush the output, if configured to do so.
+    truncate: bool,
+) -> io::Result<()> {
+    // Flush the output in case a partial write has been buffered but
+    // not yet written.
+    let wstat_update = output.flush()?;
+
+    // Sync the output, if configured to do so.
     output.sync()?;
 
     // Truncate the file to the final cursor location.
-    //
-    // Calling `set_len()` may result in an error (for example,
-    // when calling it on `/dev/null`), but we don't want to
-    // terminate the process when that happens. Instead, we
-    // suppress the error by calling `Result::ok()`. This matches
-    // the behavior of GNU `dd` when given the command-line
-    // argument `of=/dev/null`.
-    if !output.settings.oconv.notrunc {
-        output.dst.truncate().ok();
+    if truncate {
+        output.truncate();
     }
 
     // Print the final read/write statistics.
-    let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), true);
+    let wstat = wstat + wstat_update;
+    let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), ProgUpdateType::Final);
     prog_tx.send(prog_update).unwrap_or(());
     // Wait for the output thread to finish
     output_thread
         .join()
         .expect("Failed to join with the output thread.");
+
     Ok(())
 }
 
@@ -992,11 +1242,7 @@ fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
         flag |= libc::O_SYNC;
     }
 
-    if flag == 0 {
-        None
-    } else {
-        Some(flag)
-    }
+    if flag == 0 { None } else { Some(flag) }
 }
 
 /// Read from an input (that is, a source of bytes) into the given buffer.
@@ -1005,7 +1251,7 @@ fn make_linux_oflags(oflags: &OFlags) -> Option<libc::c_int> {
 /// `conv=swab` or `conv=block` command-line arguments. This function
 /// mutates the `buf` argument in-place. The returned [`ReadStat`]
 /// indicates how many blocks were read.
-fn read_helper(i: &mut Input, buf: &mut Vec<u8>, bsize: usize) -> std::io::Result<ReadStat> {
+fn read_helper(i: &mut Input, buf: &mut Vec<u8>, bsize: usize) -> io::Result<ReadStat> {
     // Local Helper Fns -------------------------------------------------
     fn perform_swab(buf: &mut [u8]) {
         for base in (1..buf.len()).step_by(2) {
@@ -1055,7 +1301,7 @@ fn calc_bsize(ibs: usize, obs: usize) -> usize {
 // Calculate the buffer size appropriate for this loop iteration, respecting
 // a count=N if present.
 fn calc_loop_bsize(
-    count: &Option<Num>,
+    count: Option<Num>,
     rstat: &ReadStat,
     wstat: &WriteStat,
     ibs: usize,
@@ -1068,7 +1314,7 @@ fn calc_loop_bsize(
             cmp::min(ideal_bsize as u64, rremain * ibs as u64) as usize
         }
         Some(Num::Bytes(bmax)) => {
-            let bmax: u128 = (*bmax).try_into().unwrap();
+            let bmax: u128 = bmax.into();
             let bremain: u128 = bmax - wstat.bytes_total;
             cmp::min(ideal_bsize as u128, bremain) as usize
         }
@@ -1078,16 +1324,10 @@ fn calc_loop_bsize(
 
 // Decide if the current progress is below a count=N limit or return
 // true if no such limit is set.
-fn below_count_limit(count: &Option<Num>, rstat: &ReadStat, wstat: &WriteStat) -> bool {
+fn below_count_limit(count: Option<Num>, rstat: &ReadStat) -> bool {
     match count {
-        Some(Num::Blocks(n)) => {
-            let n = *n;
-            rstat.reads_complete + rstat.reads_partial <= n
-        }
-        Some(Num::Bytes(n)) => {
-            let n = (*n).try_into().unwrap();
-            wstat.bytes_total <= n
-        }
+        Some(Num::Blocks(n)) => rstat.reads_complete + rstat.reads_partial < n,
+        Some(Num::Bytes(n)) => rstat.bytes_total < n,
         None => true,
     }
 }
@@ -1133,6 +1373,20 @@ fn is_stdout_redirected_to_seekable_file() -> bool {
     }
 }
 
+/// Try to get the len if it is a block device
+#[cfg(unix)]
+fn try_get_len_of_block_device(file: &mut File) -> io::Result<Option<u64>> {
+    let ftype = file.metadata()?.file_type();
+    if !ftype.is_block_device() {
+        return Ok(None);
+    }
+
+    // FIXME: this can be replaced by file.stream_len() when stable.
+    let len = file.seek(SeekFrom::End(0))?;
+    file.rewind()?;
+    Ok(Some(len))
+}
+
 /// Decide whether the named file is a named pipe, also known as a FIFO.
 #[cfg(unix)]
 fn is_fifo(filename: &str) -> bool {
@@ -1146,16 +1400,12 @@ fn is_fifo(filename: &str) -> bool {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let settings: Settings = Parser::new().parse(
-        &matches
+        matches
             .get_many::<String>(options::OPERANDS)
-            .unwrap_or_default()
-            .map(|s| s.as_ref())
-            .collect::<Vec<_>>()[..],
+            .unwrap_or_default(),
     )?;
 
     let i = match settings.infile {
@@ -1168,9 +1418,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         #[cfg(unix)]
         Some(ref outfile) if is_fifo(outfile) => Output::new_fifo(Path::new(&outfile), &settings)?,
         Some(ref outfile) => Output::new_file(Path::new(&outfile), &settings)?,
-        None if is_stdout_redirected_to_seekable_file() => {
-            Output::new_file(Path::new(&stdout_canonicalized()), &settings)?
-        }
+        None if is_stdout_redirected_to_seekable_file() => Output::new_file_from_stdout(&settings)?,
         None => Output::new_stdout(&settings)?,
     };
     dd_copy(i, o).map_err_context(|| "IO error".to_string())
@@ -1178,7 +1426,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
@@ -1188,7 +1436,7 @@ pub fn uu_app() -> Command {
 
 #[cfg(test)]
 mod tests {
-    use crate::{calc_bsize, Output, Parser};
+    use crate::{Output, Parser, calc_bsize};
 
     use std::path::Path;
 
@@ -1196,8 +1444,8 @@ mod tests {
     fn bsize_test_primes() {
         let (n, m) = (7901, 7919);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, n * m);
     }
@@ -1206,8 +1454,8 @@ mod tests {
     fn bsize_test_rel_prime_obs_greater() {
         let (n, m) = (7 * 5119, 13 * 5119);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, 7 * 13 * 5119);
     }
@@ -1216,8 +1464,8 @@ mod tests {
     fn bsize_test_rel_prime_ibs_greater() {
         let (n, m) = (13 * 5119, 7 * 5119);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, 7 * 13 * 5119);
     }
@@ -1226,8 +1474,8 @@ mod tests {
     fn bsize_test_3fac_rel_prime() {
         let (n, m) = (11 * 13 * 5119, 7 * 11 * 5119);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, 7 * 11 * 13 * 5119);
     }
@@ -1236,8 +1484,8 @@ mod tests {
     fn bsize_test_ibs_greater() {
         let (n, m) = (512 * 1024, 256 * 1024);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, n);
     }
@@ -1246,8 +1494,8 @@ mod tests {
     fn bsize_test_obs_greater() {
         let (n, m) = (256 * 1024, 512 * 1024);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, m);
     }
@@ -1256,8 +1504,8 @@ mod tests {
     fn bsize_test_bs_eq() {
         let (n, m) = (1024, 1024);
         let res = calc_bsize(n, m);
-        assert!(res % n == 0);
-        assert!(res % m == 0);
+        assert_eq!(res % n, 0);
+        assert_eq!(res % m, 0);
 
         assert_eq!(res, m);
     }
diff --git a/src/uu/dd/src/numbers.rs b/src/uu/dd/src/numbers.rs
index 2911f7e58c5..b66893d8d35 100644
--- a/src/uu/dd/src/numbers.rs
+++ b/src/uu/dd/src/numbers.rs
@@ -2,7 +2,8 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-/// Functions for formatting a number as a magnitude and a unit suffix.
+
+//! Functions for formatting a number as a magnitude and a unit suffix.
 
 /// The first ten powers of 1024.
 const IEC_BASES: [u128; 10] = [
@@ -82,14 +83,14 @@ pub(crate) fn to_magnitude_and_suffix(n: u128, suffix_type: SuffixType) -> Strin
     if quotient < 10.0 {
         format!("{quotient:.1} {suffix}")
     } else {
-        format!("{} {}", quotient.round(), suffix)
+        format!("{} {suffix}", quotient.round())
     }
 }
 
 #[cfg(test)]
 mod tests {
 
-    use crate::numbers::{to_magnitude_and_suffix, SuffixType};
+    use crate::numbers::{SuffixType, to_magnitude_and_suffix};
 
     #[test]
     fn test_to_magnitude_and_suffix_powers_of_1024() {
@@ -115,6 +116,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_to_magnitude_and_suffix_not_powers_of_1024() {
         assert_eq!(to_magnitude_and_suffix(1, SuffixType::Si), "1.0 B");
         assert_eq!(to_magnitude_and_suffix(999, SuffixType::Si), "999 B");
diff --git a/src/uu/dd/src/parseargs.rs b/src/uu/dd/src/parseargs.rs
index 53fae1b4b40..dd9a53fd884 100644
--- a/src/uu/dd/src/parseargs.rs
+++ b/src/uu/dd/src/parseargs.rs
@@ -9,67 +9,68 @@ mod unit_tests;
 
 use super::{ConversionMode, IConvFlags, IFlags, Num, OConvFlags, OFlags, Settings, StatusLevel};
 use crate::conversion_tables::ConversionTable;
-use std::error::Error;
+use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::UError;
-use uucore::parse_size::{ParseSizeError, Parser as SizeParser};
+use uucore::parser::parse_size::{ParseSizeError, Parser as SizeParser};
 use uucore::show_warning;
 
 /// Parser Errors describe errors with parser input
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Error)]
 pub enum ParseError {
+    #[error("Unrecognized operand '{0}'")]
     UnrecognizedOperand(String),
+    #[error("Only one of conv=ascii conv=ebcdic or conv=ibm may be specified")]
     MultipleFmtTable,
+    #[error("Only one of conv=lcase or conv=ucase may be specified")]
     MultipleUCaseLCase,
+    #[error("Only one of conv=block or conv=unblock may be specified")]
     MultipleBlockUnblock,
+    #[error("Only one ov conv=excl or conv=nocreat may be specified")]
     MultipleExclNoCreate,
+    #[error("invalid input flag: ‘{}’\nTry '{} --help' for more information.", .0, uucore::execution_phrase())]
     FlagNoMatch(String),
+    #[error("Unrecognized conv=CONV -> {0}")]
     ConvFlagNoMatch(String),
+    #[error("invalid number: ‘{0}’")]
     MultiplierStringParseFailure(String),
+    #[error("Multiplier string would overflow on current system -> {0}")]
     MultiplierStringOverflow(String),
+    #[error("conv=block or conv=unblock specified without cbs=N")]
     BlockUnblockWithoutCBS,
+    #[error("status=LEVEL not recognized -> {0}")]
     StatusLevelNotRecognized(String),
+    #[error("feature not implemented on this system -> {0}")]
     Unimplemented(String),
+    #[error("{0}=N cannot fit into memory")]
     BsOutOfRange(String),
+    #[error("invalid number: ‘{0}’")]
     InvalidNumber(String),
 }
 
 /// Contains a temporary state during parsing of the arguments
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Default)]
 pub struct Parser {
     infile: Option<String>,
     outfile: Option<String>,
-    ibs: usize,
-    obs: usize,
+    /// The block size option specified on the command-line, if any.
+    bs: Option<usize>,
+    /// The input block size option specified on the command-line, if any.
+    ibs: Option<usize>,
+    /// The output block size option specified on the command-line, if any.
+    obs: Option<usize>,
     cbs: Option<usize>,
     skip: Num,
     seek: Num,
     count: Option<Num>,
     conv: ConvFlags,
+    /// Whether a data-transforming `conv` option has been specified.
+    is_conv_specified: bool,
     iflag: IFlags,
     oflag: OFlags,
     status: Option<StatusLevel>,
 }
 
-impl Default for Parser {
-    fn default() -> Self {
-        Self {
-            ibs: 512,
-            obs: 512,
-            cbs: None,
-            infile: None,
-            outfile: None,
-            skip: Num::Blocks(0),
-            seek: Num::Blocks(0),
-            count: None,
-            conv: ConvFlags::default(),
-            iflag: IFlags::default(),
-            oflag: OFlags::default(),
-            status: None,
-        }
-    }
-}
-
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ConvFlags {
     ascii: bool,
@@ -125,13 +126,19 @@ impl Parser {
         Self::default()
     }
 
-    pub(crate) fn parse(self, operands: &[&str]) -> Result<Settings, ParseError> {
+    pub(crate) fn parse(
+        self,
+        operands: impl IntoIterator<Item: AsRef<str>>,
+    ) -> Result<Settings, ParseError> {
         self.read(operands)?.validate()
     }
 
-    pub(crate) fn read(mut self, operands: &[&str]) -> Result<Self, ParseError> {
+    pub(crate) fn read(
+        mut self,
+        operands: impl IntoIterator<Item: AsRef<str>>,
+    ) -> Result<Self, ParseError> {
         for operand in operands {
-            self.parse_operand(operand)?;
+            self.parse_operand(operand.as_ref())?;
         }
 
         Ok(self)
@@ -212,15 +219,34 @@ impl Parser {
             fsync: conv.fsync,
         };
 
+        // Input and output block sizes.
+        //
+        // The `bs` option takes precedence. If either is not
+        // provided, `ibs` and `obs` are each 512 bytes by default.
+        let (ibs, obs) = match self.bs {
+            None => (self.ibs.unwrap_or(512), self.obs.unwrap_or(512)),
+            Some(bs) => (bs, bs),
+        };
+
+        // Whether to buffer partial output blocks until they are completed.
+        //
+        // From the GNU `dd` documentation for the `bs=BYTES` option:
+        //
+        // > [...] if no data-transforming 'conv' option is specified,
+        // > input is copied to the output as soon as it's read, even if
+        // > it is smaller than the block size.
+        //
+        let buffered = self.bs.is_none() || self.is_conv_specified;
+
         let skip = self
             .skip
             .force_bytes_if(self.iflag.skip_bytes)
-            .to_bytes(self.ibs as u64);
+            .to_bytes(ibs as u64);
 
         let seek = self
             .seek
             .force_bytes_if(self.oflag.seek_bytes)
-            .to_bytes(self.obs as u64);
+            .to_bytes(obs as u64);
 
         let count = self.count.map(|c| c.force_bytes_if(self.iflag.count_bytes));
 
@@ -230,8 +256,9 @@ impl Parser {
             count,
             iconv,
             oconv,
-            ibs: self.ibs,
-            obs: self.obs,
+            ibs,
+            obs,
+            buffered,
             infile: self.infile,
             outfile: self.outfile,
             iflags: self.iflag,
@@ -244,18 +271,17 @@ impl Parser {
         match operand.split_once('=') {
             None => return Err(ParseError::UnrecognizedOperand(operand.to_string())),
             Some((k, v)) => match k {
-                "bs" => {
-                    let bs = Self::parse_bytes(k, v)?;
-                    self.ibs = bs;
-                    self.obs = bs;
-                }
+                "bs" => self.bs = Some(Self::parse_bytes(k, v)?),
                 "cbs" => self.cbs = Some(Self::parse_bytes(k, v)?),
-                "conv" => self.parse_conv_flags(v)?,
+                "conv" => {
+                    self.is_conv_specified = true;
+                    self.parse_conv_flags(v)?;
+                }
                 "count" => self.count = Some(Self::parse_n(v)?),
-                "ibs" => self.ibs = Self::parse_bytes(k, v)?,
+                "ibs" => self.ibs = Some(Self::parse_bytes(k, v)?),
                 "if" => self.infile = Some(v.to_string()),
                 "iflag" => self.parse_input_flags(v)?,
-                "obs" => self.obs = Self::parse_bytes(k, v)?,
+                "obs" => self.obs = Some(Self::parse_bytes(k, v)?),
                 "of" => self.outfile = Some(v.to_string()),
                 "oflag" => self.parse_output_flags(v)?,
                 "seek" | "oseek" => self.seek = Self::parse_n(v)?,
@@ -269,7 +295,7 @@ impl Parser {
 
     fn parse_n(val: &str) -> Result<Num, ParseError> {
         let n = parse_bytes_with_opt_multiplier(val)?;
-        Ok(if val.ends_with('B') {
+        Ok(if val.contains('B') {
             Num::Bytes(n)
         } else {
             Num::Blocks(n)
@@ -390,69 +416,6 @@ impl Parser {
     }
 }
 
-impl std::fmt::Display for ParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::UnrecognizedOperand(arg) => {
-                write!(f, "Unrecognized operand '{arg}'")
-            }
-            Self::MultipleFmtTable => {
-                write!(
-                    f,
-                    "Only one of conv=ascii conv=ebcdic or conv=ibm may be specified"
-                )
-            }
-            Self::MultipleUCaseLCase => {
-                write!(f, "Only one of conv=lcase or conv=ucase may be specified")
-            }
-            Self::MultipleBlockUnblock => {
-                write!(f, "Only one of conv=block or conv=unblock may be specified")
-            }
-            Self::MultipleExclNoCreate => {
-                write!(f, "Only one ov conv=excl or conv=nocreat may be specified")
-            }
-            Self::FlagNoMatch(arg) => {
-                // Additional message about 'dd --help' is displayed only in this situation.
-                write!(
-                    f,
-                    "invalid input flag: ‘{}’\nTry '{} --help' for more information.",
-                    arg,
-                    uucore::execution_phrase()
-                )
-            }
-            Self::ConvFlagNoMatch(arg) => {
-                write!(f, "Unrecognized conv=CONV -> {arg}")
-            }
-            Self::MultiplierStringParseFailure(arg) => {
-                write!(f, "Unrecognized byte multiplier -> {arg}")
-            }
-            Self::MultiplierStringOverflow(arg) => {
-                write!(
-                    f,
-                    "Multiplier string would overflow on current system -> {arg}"
-                )
-            }
-            Self::BlockUnblockWithoutCBS => {
-                write!(f, "conv=block or conv=unblock specified without cbs=N")
-            }
-            Self::StatusLevelNotRecognized(arg) => {
-                write!(f, "status=LEVEL not recognized -> {arg}")
-            }
-            Self::BsOutOfRange(arg) => {
-                write!(f, "{arg}=N cannot fit into memory")
-            }
-            Self::Unimplemented(arg) => {
-                write!(f, "feature not implemented on this system -> {arg}")
-            }
-            Self::InvalidNumber(arg) => {
-                write!(f, "invalid number: ‘{arg}’")
-            }
-        }
-    }
-}
-
-impl Error for ParseError {}
-
 impl UError for ParseError {
     fn code(&self) -> i32 {
         1
@@ -468,8 +431,9 @@ fn show_zero_multiplier_warning() {
 }
 
 /// Parse bytes using str::parse, then map error if needed.
-fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
-    s.parse()
+fn parse_bytes_only(s: &str, i: usize) -> Result<u64, ParseError> {
+    s[..i]
+        .parse()
         .map_err(|_| ParseError::MultiplierStringParseFailure(s.to_string()))
 }
 
@@ -484,6 +448,8 @@ fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
 /// 512. You can also use standard block size suffixes like `'k'` for
 /// 1024.
 ///
+/// If the number would be too large, return [`u64::MAX`] instead.
+///
 /// # Errors
 ///
 /// If a number cannot be parsed or if the multiplication would cause
@@ -501,21 +467,18 @@ fn parse_bytes_only(s: &str) -> Result<u64, ParseError> {
 fn parse_bytes_no_x(full: &str, s: &str) -> Result<u64, ParseError> {
     let parser = SizeParser {
         capital_b_bytes: true,
+        no_empty_numeric: true,
         ..Default::default()
     };
     let (num, multiplier) = match (s.find('c'), s.rfind('w'), s.rfind('b')) {
-        (None, None, None) => match parser.parse(s) {
+        (None, None, None) => match parser.parse_u64(s) {
             Ok(n) => (n, 1),
-            Err(ParseSizeError::InvalidSuffix(_) | ParseSizeError::ParseFailure(_)) => {
-                return Err(ParseError::InvalidNumber(full.to_string()))
-            }
-            Err(ParseSizeError::SizeTooBig(_)) => {
-                return Err(ParseError::MultiplierStringOverflow(full.to_string()))
-            }
+            Err(ParseSizeError::SizeTooBig(_)) => (u64::MAX, 1),
+            Err(_) => return Err(ParseError::InvalidNumber(full.to_string())),
         },
-        (Some(i), None, None) => (parse_bytes_only(&s[..i])?, 1),
-        (None, Some(i), None) => (parse_bytes_only(&s[..i])?, 2),
-        (None, None, Some(i)) => (parse_bytes_only(&s[..i])?, 512),
+        (Some(i), None, None) => (parse_bytes_only(s, i)?, 1),
+        (None, Some(i), None) => (parse_bytes_only(s, i)?, 2),
+        (None, None, Some(i)) => (parse_bytes_only(s, i)?, 512),
         _ => return Err(ParseError::MultiplierStringParseFailure(full.to_string())),
     };
     num.checked_mul(multiplier)
@@ -624,22 +587,42 @@ fn conversion_mode(
 #[cfg(test)]
 mod tests {
 
-    use crate::parseargs::parse_bytes_with_opt_multiplier;
+    use crate::Num;
+    use crate::parseargs::{Parser, parse_bytes_with_opt_multiplier};
+    use std::matches;
+    const BIG: &str = "9999999999999999999999999999999999999999999999999999999999999";
+
+    #[test]
+    fn test_parse_bytes_with_opt_multiplier_invalid() {
+        assert!(parse_bytes_with_opt_multiplier("123asdf").is_err());
+    }
 
     #[test]
-    fn test_parse_bytes_with_opt_multiplier() {
+    fn test_parse_bytes_with_opt_multiplier_without_x() {
         assert_eq!(parse_bytes_with_opt_multiplier("123").unwrap(), 123);
         assert_eq!(parse_bytes_with_opt_multiplier("123c").unwrap(), 123); // 123 * 1
         assert_eq!(parse_bytes_with_opt_multiplier("123w").unwrap(), 123 * 2);
         assert_eq!(parse_bytes_with_opt_multiplier("123b").unwrap(), 123 * 512);
-        assert_eq!(parse_bytes_with_opt_multiplier("123x3").unwrap(), 123 * 3);
         assert_eq!(parse_bytes_with_opt_multiplier("123k").unwrap(), 123 * 1024);
-        assert_eq!(parse_bytes_with_opt_multiplier("1x2x3").unwrap(), 6); // 1 * 2 * 3
+        assert_eq!(parse_bytes_with_opt_multiplier(BIG).unwrap(), u64::MAX);
+    }
 
+    #[test]
+    fn test_parse_bytes_with_opt_multiplier_with_x() {
+        assert_eq!(parse_bytes_with_opt_multiplier("123x3").unwrap(), 123 * 3);
+        assert_eq!(parse_bytes_with_opt_multiplier("1x2x3").unwrap(), 6); // 1 * 2 * 3
         assert_eq!(
             parse_bytes_with_opt_multiplier("1wx2cx3w").unwrap(),
             2 * 2 * (3 * 2) // (1 * 2) * (2 * 1) * (3 * 2)
         );
-        assert!(parse_bytes_with_opt_multiplier("123asdf").is_err());
+    }
+    #[test]
+    fn test_parse_n() {
+        for arg in ["1x8x4", "1c", "123b", "123w"] {
+            assert!(matches!(Parser::parse_n(arg), Ok(Num::Blocks(_))));
+        }
+        for arg in ["1Bx8x4", "2Bx8", "2Bx8B", "2x8B"] {
+            assert!(matches!(Parser::parse_n(arg), Ok(Num::Bytes(_))));
+        }
     }
 }
diff --git a/src/uu/dd/src/parseargs/unit_tests.rs b/src/uu/dd/src/parseargs/unit_tests.rs
index a190fd75bd2..cde0ef0cc1f 100644
--- a/src/uu/dd/src/parseargs/unit_tests.rs
+++ b/src/uu/dd/src/parseargs/unit_tests.rs
@@ -6,13 +6,14 @@
 
 use super::*;
 
+use crate::StatusLevel;
 use crate::conversion_tables::{
     ASCII_TO_EBCDIC_UCASE_TO_LCASE, ASCII_TO_IBM, EBCDIC_TO_ASCII_LCASE_TO_UCASE,
 };
 use crate::parseargs::Parser;
-use crate::StatusLevel;
 
 #[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[allow(clippy::useless_vec)]
 #[test]
 fn unimplemented_flags_should_error_non_linux() {
     let mut succeeded = Vec::new();
@@ -28,54 +29,38 @@ fn unimplemented_flags_should_error_non_linux() {
         "noctty",
         "nofollow",
     ] {
-        let args = vec![format!("iflag={}", flag)];
-
-        if Parser::new()
-            .parse(&args.iter().map(AsRef::as_ref).collect::<Vec<_>>()[..])
-            .is_ok()
-        {
-            succeeded.push(format!("iflag={}", flag));
+        let arg = format!("iflag={flag}");
+        if Parser::new().parse([&arg]).is_ok() {
+            succeeded.push(arg);
         }
 
-        let args = vec![format!("oflag={}", flag)];
-
-        if Parser::new()
-            .parse(&args.iter().map(AsRef::as_ref).collect::<Vec<_>>()[..])
-            .is_ok()
-        {
-            succeeded.push(format!("iflag={}", flag));
+        let arg = format!("oflag={flag}");
+        if Parser::new().parse([&arg]).is_ok() {
+            succeeded.push(arg);
         }
     }
 
     assert!(
         succeeded.is_empty(),
-        "The following flags did not panic as expected: {:?}",
-        succeeded
+        "The following flags did not panic as expected: {succeeded:?}",
     );
 }
 
 #[test]
+#[allow(clippy::useless_vec)]
 fn unimplemented_flags_should_error() {
     let mut succeeded = Vec::new();
 
     // The following flags are not implemented
     for flag in ["cio", "nolinks", "text", "binary"] {
-        let args = vec![format!("iflag={flag}")];
-
-        if Parser::new()
-            .parse(&args.iter().map(AsRef::as_ref).collect::<Vec<_>>()[..])
-            .is_ok()
-        {
-            succeeded.push(format!("iflag={flag}"));
+        let arg = format!("iflag={flag}");
+        if Parser::new().parse([&arg]).is_ok() {
+            succeeded.push(arg);
         }
 
-        let args = vec![format!("oflag={flag}")];
-
-        if Parser::new()
-            .parse(&args.iter().map(AsRef::as_ref).collect::<Vec<_>>()[..])
-            .is_ok()
-        {
-            succeeded.push(format!("iflag={flag}"));
+        let arg = format!("oflag={flag}");
+        if Parser::new().parse([&arg]).is_ok() {
+            succeeded.push(arg);
         }
     }
 
@@ -87,14 +72,14 @@ fn unimplemented_flags_should_error() {
 
 #[test]
 fn test_status_level_absent() {
-    let args = &["if=foo.file", "of=bar.file"];
+    let args = ["if=foo.file", "of=bar.file"];
 
     assert_eq!(Parser::new().parse(args).unwrap().status, None);
 }
 
 #[test]
 fn test_status_level_none() {
-    let args = &["status=none", "if=foo.file", "of=bar.file"];
+    let args = ["status=none", "if=foo.file", "of=bar.file"];
 
     assert_eq!(
         Parser::new().parse(args).unwrap().status,
@@ -103,8 +88,9 @@ fn test_status_level_none() {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_all_top_level_args_no_leading_dashes() {
-    let args = &[
+    let args = [
         "if=foo.file",
         "of=bar.file",
         "ibs=10",
@@ -154,7 +140,7 @@ fn test_all_top_level_args_no_leading_dashes() {
     );
 
     // no conv flags apply to output
-    assert_eq!(settings.oconv, OConvFlags::default(),);
+    assert_eq!(settings.oconv, OConvFlags::default());
 
     // iconv=count_bytes,skip_bytes
     assert_eq!(
@@ -179,7 +165,7 @@ fn test_all_top_level_args_no_leading_dashes() {
 
 #[test]
 fn test_status_level_progress() {
-    let args = &["if=foo.file", "of=bar.file", "status=progress"];
+    let args = ["if=foo.file", "of=bar.file", "status=progress"];
 
     let settings = Parser::new().parse(args).unwrap();
 
@@ -188,7 +174,7 @@ fn test_status_level_progress() {
 
 #[test]
 fn test_status_level_noxfer() {
-    let args = &["if=foo.file", "status=noxfer", "of=bar.file"];
+    let args = ["if=foo.file", "status=noxfer", "of=bar.file"];
 
     let settings = Parser::new().parse(args).unwrap();
 
@@ -197,7 +183,7 @@ fn test_status_level_noxfer() {
 
 #[test]
 fn test_multiple_flags_options() {
-    let args = &[
+    let args = [
         "iflag=fullblock,count_bytes",
         "iflag=skip_bytes",
         "oflag=append",
@@ -244,7 +230,7 @@ fn test_multiple_flags_options() {
 
 #[test]
 fn test_override_multiple_options() {
-    let args = &[
+    let args = [
         "if=foo.file",
         "if=correct.file",
         "of=bar.file",
@@ -286,31 +272,31 @@ fn test_override_multiple_options() {
 
 #[test]
 fn icf_ctable_error() {
-    let args = &["conv=ascii,ebcdic,ibm"];
+    let args = ["conv=ascii,ebcdic,ibm"];
     assert!(Parser::new().parse(args).is_err());
 }
 
 #[test]
 fn icf_case_error() {
-    let args = &["conv=ucase,lcase"];
+    let args = ["conv=ucase,lcase"];
     assert!(Parser::new().parse(args).is_err());
 }
 
 #[test]
 fn icf_block_error() {
-    let args = &["conv=block,unblock"];
+    let args = ["conv=block,unblock"];
     assert!(Parser::new().parse(args).is_err());
 }
 
 #[test]
 fn icf_creat_error() {
-    let args = &["conv=excl,nocreat"];
+    let args = ["conv=excl,nocreat"];
     assert!(Parser::new().parse(args).is_err());
 }
 
 #[test]
 fn parse_icf_token_ibm() {
-    let args = &["conv=ibm"];
+    let args = ["conv=ibm"];
     let settings = Parser::new().parse(args).unwrap();
 
     assert_eq!(
@@ -324,7 +310,7 @@ fn parse_icf_token_ibm() {
 
 #[test]
 fn parse_icf_tokens_elu() {
-    let args = &["conv=ebcdic,lcase"];
+    let args = ["conv=ebcdic,lcase"];
     let settings = Parser::new().parse(args).unwrap();
 
     assert_eq!(
@@ -338,7 +324,9 @@ fn parse_icf_tokens_elu() {
 
 #[test]
 fn parse_icf_tokens_remaining() {
-    let args = &["conv=ascii,ucase,block,sparse,swab,sync,noerror,excl,nocreat,notrunc,noerror,fdatasync,fsync"];
+    let args = [
+        "conv=ascii,ucase,block,sparse,swab,sync,noerror,excl,nocreat,notrunc,noerror,fdatasync,fsync",
+    ];
     assert_eq!(
         Parser::new().read(args),
         Ok(Parser {
@@ -357,6 +345,7 @@ fn parse_icf_tokens_remaining() {
                 fsync: true,
                 ..Default::default()
             },
+            is_conv_specified: true,
             ..Default::default()
         })
     );
@@ -364,7 +353,7 @@ fn parse_icf_tokens_remaining() {
 
 #[test]
 fn parse_iflag_tokens() {
-    let args = &["iflag=fullblock,count_bytes,skip_bytes"];
+    let args = ["iflag=fullblock,count_bytes,skip_bytes"];
     assert_eq!(
         Parser::new().read(args),
         Ok(Parser {
@@ -381,7 +370,7 @@ fn parse_iflag_tokens() {
 
 #[test]
 fn parse_oflag_tokens() {
-    let args = &["oflag=append,seek_bytes"];
+    let args = ["oflag=append,seek_bytes"];
     assert_eq!(
         Parser::new().read(args),
         Ok(Parser {
@@ -398,7 +387,7 @@ fn parse_oflag_tokens() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[test]
 fn parse_iflag_tokens_linux() {
-    let args = &["iflag=direct,directory,dsync,sync,nonblock,noatime,noctty,nofollow"];
+    let args = ["iflag=direct,directory,dsync,sync,nonblock,noatime,noctty,nofollow"];
     assert_eq!(
         Parser::new().read(args),
         Ok(Parser {
@@ -421,7 +410,7 @@ fn parse_iflag_tokens_linux() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[test]
 fn parse_oflag_tokens_linux() {
-    let args = &["oflag=direct,directory,dsync,sync,nonblock,noatime,noctty,nofollow"];
+    let args = ["oflag=direct,directory,dsync,sync,nonblock,noatime,noctty,nofollow"];
     assert_eq!(
         Parser::new().read(args),
         Ok(Parser {
@@ -504,14 +493,6 @@ mod test_64bit_arch {
     );
 }
 
-#[test]
-#[should_panic]
-fn test_overflow_panic() {
-    let bs_str = format!("{}KiB", u64::MAX);
-
-    parse_bytes_with_opt_multiplier(&bs_str).unwrap();
-}
-
 #[test]
 #[should_panic]
 fn test_neg_panic() {
diff --git a/src/uu/dd/src/progress.rs b/src/uu/dd/src/progress.rs
index 4fe04cb0e67..85f5fa85af8 100644
--- a/src/uu/dd/src/progress.rs
+++ b/src/uu/dd/src/progress.rs
@@ -11,26 +11,26 @@
 //! updater that runs in its own thread.
 use std::io::Write;
 use std::sync::mpsc;
+#[cfg(target_os = "linux")]
+use std::thread::JoinHandle;
 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.
 #[cfg(target_os = "linux")]
-use signal_hook::consts::signal;
-#[cfg(target_os = "linux")]
-use std::{
-    env,
-    error::Error,
-    sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    },
+use signal_hook::iterator::Handle;
+use uucore::{
+    error::UResult,
+    format::num_format::{FloatVariant, Formatter},
 };
 
+use crate::numbers::{SuffixType, to_magnitude_and_suffix};
+
+#[derive(PartialEq, Eq)]
+pub(crate) enum ProgUpdateType {
+    Periodic,
+    Signal,
+    Final,
+}
+
 /// Summary statistics for read and write progress of dd for a given duration.
 pub(crate) struct ProgUpdate {
     /// Read statistics.
@@ -51,7 +51,7 @@ pub(crate) struct ProgUpdate {
     /// The status of the write.
     ///
     /// True if the write is completed, false if still in-progress.
-    pub(crate) complete: bool,
+    pub(crate) update_type: ProgUpdateType,
 }
 
 impl ProgUpdate {
@@ -60,13 +60,13 @@ impl ProgUpdate {
         read_stat: ReadStat,
         write_stat: WriteStat,
         duration: Duration,
-        complete: bool,
+        update_type: ProgUpdateType,
     ) -> Self {
         Self {
             read_stat,
             write_stat,
             duration,
-            complete,
+            update_type,
         }
     }
 
@@ -152,7 +152,14 @@ impl ProgUpdate {
         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()])?;
+        let mut duration_str = Vec::new();
+        uucore::format::num_format::Float {
+            variant: FloatVariant::Shortest,
+            ..Default::default()
+        }
+        .fmt(&mut duration_str, &duration.into())?;
+        // We assume that printf will output valid UTF-8
+        let duration_str = std::str::from_utf8(&duration_str).unwrap();
 
         // If the number of bytes written is sufficiently large, then
         // print a more concise representation of the number, like
@@ -379,6 +386,17 @@ impl std::ops::AddAssign for WriteStat {
     }
 }
 
+impl std::ops::Add for WriteStat {
+    type Output = Self;
+    fn add(self, other: Self) -> Self {
+        Self {
+            writes_complete: self.writes_complete + other.writes_complete,
+            writes_partial: self.writes_partial + other.writes_partial,
+            bytes_total: self.bytes_total + other.bytes_total,
+        }
+    }
+}
+
 /// How much detail to report when printing transfer statistics.
 ///
 /// This corresponds to the available settings of the `status`
@@ -413,7 +431,7 @@ pub(crate) fn gen_prog_updater(
         let mut progress_printed = false;
         while let Ok(update) = rx.recv() {
             // Print the final read/write statistics.
-            if update.complete {
+            if update.update_type == ProgUpdateType::Final {
                 update.print_final_stats(print_level, progress_printed);
                 return;
             }
@@ -425,6 +443,49 @@ pub(crate) fn gen_prog_updater(
     }
 }
 
+/// signal handler listens for SIGUSR1 signal and runs provided closure.
+#[cfg(target_os = "linux")]
+pub(crate) struct SignalHandler {
+    handle: Handle,
+    thread: Option<JoinHandle<()>>,
+}
+
+#[cfg(target_os = "linux")]
+impl SignalHandler {
+    pub(crate) fn install_signal_handler(
+        f: Box<dyn Send + Sync + Fn()>,
+    ) -> Result<Self, std::io::Error> {
+        use signal_hook::consts::signal::*;
+        use signal_hook::iterator::Signals;
+
+        let mut signals = Signals::new([SIGUSR1])?;
+        let handle = signals.handle();
+        let thread = std::thread::spawn(move || {
+            for signal in &mut signals {
+                match signal {
+                    SIGUSR1 => (*f)(),
+                    _ => unreachable!(),
+                }
+            }
+        });
+
+        Ok(Self {
+            handle,
+            thread: Some(thread),
+        })
+    }
+}
+
+#[cfg(target_os = "linux")]
+impl Drop for SignalHandler {
+    fn drop(&mut self) {
+        self.handle.close();
+        if let Some(thread) = std::mem::take(&mut self.thread) {
+            thread.join().unwrap();
+        }
+    }
+}
+
 /// Return a closure that can be used in its own thread to print progress info.
 ///
 /// This function returns a closure that receives [`ProgUpdate`]
@@ -439,50 +500,31 @@ pub(crate) fn gen_prog_updater(
     rx: mpsc::Receiver<ProgUpdate>,
     print_level: Option<StatusLevel>,
 ) -> impl Fn() {
-    // TODO: SIGINFO: Trigger progress line reprint. BSD-style Linux only.
-    const SIGUSR1_USIZE: usize = signal::SIGUSR1 as usize;
-    fn posixly_correct() -> bool {
-        env::var("POSIXLY_CORRECT").is_ok()
-    }
-    fn register_linux_signal_handler(sigval: Arc<AtomicUsize>) -> Result<(), Box<dyn Error>> {
-        if !posixly_correct() {
-            signal_hook::flag::register_usize(signal::SIGUSR1, sigval, SIGUSR1_USIZE)?;
-        }
-
-        Ok(())
-    }
     // --------------------------------------------------------------
     move || {
-        let sigval = Arc::new(AtomicUsize::new(0));
-
-        register_linux_signal_handler(sigval.clone()).unwrap_or_else(|e| {
-            if Some(StatusLevel::None) != print_level {
-                eprintln!("Internal dd Warning: Unable to register signal handler \n\t{e}");
-            }
-        });
-
         // Holds the state of whether we have printed the current progress.
         // This is needed so that we know whether or not to print a newline
         // character before outputting non-progress data.
         let mut progress_printed = false;
         while let Ok(update) = rx.recv() {
-            // Print the final read/write statistics.
-            if update.complete {
-                update.print_final_stats(print_level, progress_printed);
-                return;
-            }
-            // (Re)print status line if progress is requested.
-            if Some(StatusLevel::Progress) == print_level && !update.complete {
-                update.reprint_prog_line();
-                progress_printed = true;
-            }
-            // Handle signals and set the signal to un-seen.
-            // This will print a maximum of 1 time per second, even though it
-            // should be printing on every SIGUSR1.
-            if let SIGUSR1_USIZE = sigval.swap(0, Ordering::Relaxed) {
-                update.print_transfer_stats(progress_printed);
-                // Reset the progress printed, since print_transfer_stats always prints a newline.
-                progress_printed = false;
+            match update.update_type {
+                ProgUpdateType::Final => {
+                    // Print the final read/write statistics.
+                    update.print_final_stats(print_level, progress_printed);
+                    return;
+                }
+                ProgUpdateType::Periodic => {
+                    // (Re)print status line if progress is requested.
+                    if Some(StatusLevel::Progress) == print_level {
+                        update.reprint_prog_line();
+                        progress_printed = true;
+                    }
+                }
+                ProgUpdateType::Signal => {
+                    update.print_transfer_stats(progress_printed);
+                    // Reset the progress printed, since print_transfer_stats always prints a newline.
+                    progress_printed = false;
+                }
             }
         }
     }
@@ -504,7 +546,7 @@ mod tests {
                 ..Default::default()
             },
             duration: Duration::new(1, 0), // one second
-            complete: false,
+            update_type: super::ProgUpdateType::Periodic,
         }
     }
 
@@ -513,7 +555,7 @@ mod tests {
             read_stat: ReadStat::default(),
             write_stat: WriteStat::default(),
             duration,
-            complete: false,
+            update_type: super::ProgUpdateType::Periodic,
         }
     }
 
@@ -538,12 +580,12 @@ mod tests {
         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;
+        let update_type = super::ProgUpdateType::Periodic;
         let prog_update = ProgUpdate {
             read_stat,
             write_stat,
             duration,
-            complete,
+            update_type,
         };
 
         let mut cursor = Cursor::new(vec![]);
@@ -560,7 +602,7 @@ mod tests {
             read_stat: ReadStat::default(),
             write_stat: WriteStat::default(),
             duration: Duration::new(1, 0), // one second
-            complete: false,
+            update_type: super::ProgUpdateType::Periodic,
         };
 
         let mut cursor = Cursor::new(vec![]);
@@ -616,7 +658,7 @@ mod tests {
             read_stat: ReadStat::default(),
             write_stat: WriteStat::default(),
             duration: Duration::new(1, 0), // one second
-            complete: false,
+            update_type: super::ProgUpdateType::Periodic,
         };
         let mut cursor = Cursor::new(vec![]);
         prog_update
@@ -637,7 +679,7 @@ mod tests {
             read_stat: ReadStat::default(),
             write_stat: WriteStat::default(),
             duration: Duration::new(1, 0), // one second
-            complete: false,
+            update_type: super::ProgUpdateType::Periodic,
         };
         let mut cursor = Cursor::new(vec![]);
         let rewrite = true;
diff --git a/src/uu/df/Cargo.toml b/src/uu/df/Cargo.toml
index b547a35d5ee..6585b0abc6a 100644
--- a/src/uu/df/Cargo.toml
+++ b/src/uu/df/Cargo.toml
@@ -1,26 +1,30 @@
 [package]
 name = "uu_df"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "df ~ (uutils) display file system information"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/df"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/df.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["libc", "fsext"] }
+uucore = { workspace = true, features = ["libc", "fsext", "parser"] }
 unicode-width = { workspace = true }
+thiserror = { workspace = true }
 
 [dev-dependencies]
-tempfile = "3"
+tempfile = { workspace = true }
 
 [[bin]]
 name = "df"
diff --git a/src/uu/df/src/blocks.rs b/src/uu/df/src/blocks.rs
index 9bc16b7820a..26b763cac1a 100644
--- a/src/uu/df/src/blocks.rs
+++ b/src/uu/df/src/blocks.rs
@@ -9,7 +9,7 @@ use std::{env, fmt};
 
 use uucore::{
     display::Quotable,
-    parse_size::{parse_size, ParseSizeError},
+    parser::parse_size::{ParseSizeError, parse_size_u64},
 };
 
 /// The first ten powers of 1024.
@@ -98,9 +98,9 @@ pub(crate) fn to_magnitude_and_suffix(n: u128, suffix_type: SuffixType) -> Strin
         if rem % (bases[i] / 10) == 0 {
             format!("{quot}.{tenths_place}{suffix}")
         } else if tenths_place + 1 == 10 || quot >= 10 {
-            format!("{}{}", quot + 1, suffix)
+            format!("{}{suffix}", quot + 1)
         } else {
-            format!("{}.{}{}", quot, tenths_place + 1, suffix)
+            format!("{quot}.{}{suffix}", tenths_place + 1)
         }
     }
 }
@@ -165,7 +165,7 @@ impl Default for BlockSize {
 pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSizeError> {
     if matches.contains_id(OPT_BLOCKSIZE) {
         let s = matches.get_one::<String>(OPT_BLOCKSIZE).unwrap();
-        let bytes = parse_size(s)?;
+        let bytes = parse_size_u64(s)?;
 
         if bytes > 0 {
             Ok(BlockSize::Bytes(bytes))
@@ -184,11 +184,7 @@ pub(crate) fn read_block_size(matches: &ArgMatches) -> Result<BlockSize, ParseSi
 fn block_size_from_env() -> Option<u64> {
     for env_var in ["DF_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
         if let Ok(env_size) = env::var(env_var) {
-            if let Ok(size) = parse_size(&env_size) {
-                return Some(size);
-            } else {
-                return None;
-            }
+            return parse_size_u64(&env_size).ok();
         }
     }
 
@@ -216,7 +212,7 @@ mod tests {
 
     use std::env;
 
-    use crate::blocks::{to_magnitude_and_suffix, BlockSize, SuffixType};
+    use crate::blocks::{BlockSize, SuffixType, to_magnitude_and_suffix};
 
     #[test]
     fn test_to_magnitude_and_suffix_powers_of_1024() {
@@ -239,6 +235,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_to_magnitude_and_suffix_not_powers_of_1024() {
         assert_eq!(to_magnitude_and_suffix(1, SuffixType::Si), "1B");
         assert_eq!(to_magnitude_and_suffix(999, SuffixType::Si), "999B");
@@ -293,8 +290,8 @@ mod tests {
     #[test]
     fn test_default_block_size() {
         assert_eq!(BlockSize::Bytes(1024), BlockSize::default());
-        env::set_var("POSIXLY_CORRECT", "1");
+        unsafe { env::set_var("POSIXLY_CORRECT", "1") };
         assert_eq!(BlockSize::Bytes(512), BlockSize::default());
-        env::remove_var("POSIXLY_CORRECT");
+        unsafe { env::remove_var("POSIXLY_CORRECT") };
     }
 }
diff --git a/src/uu/df/src/columns.rs b/src/uu/df/src/columns.rs
index 0659d7f7da7..0d2d121a3d1 100644
--- a/src/uu/df/src/columns.rs
+++ b/src/uu/df/src/columns.rs
@@ -4,7 +4,9 @@
 // file that was distributed with this source code.
 // spell-checker:ignore itotal iused iavail ipcent pcent squashfs
 use crate::{OPT_INODES, OPT_OUTPUT, OPT_PRINT_TYPE};
-use clap::{parser::ValueSource, ArgMatches};
+use clap::{ArgMatches, parser::ValueSource};
+use thiserror::Error;
+use uucore::display::Quotable;
 
 /// The columns in the output table produced by `df`.
 ///
@@ -56,9 +58,10 @@ pub(crate) enum Column {
 }
 
 /// An error while defining which columns to display in the output table.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub(crate) enum ColumnError {
     /// If a column appears more than once in the `--output` argument.
+    #[error("{}", .0.quote())]
     MultipleColumns(String),
 }
 
@@ -201,6 +204,7 @@ impl Column {
             // 14 = length of "Filesystem" plus 4 spaces
             Self::Source => 14,
             Self::Used => 5,
+            Self::Size => 5,
             // the shortest headers have a length of 4 chars so we use that as the minimum width
             _ => 4,
         }
diff --git a/src/uu/df/src/df.rs b/src/uu/df/src/df.rs
index 78325f3d2ad..9e2bb6920af 100644
--- a/src/uu/df/src/df.rs
+++ b/src/uu/df/src/df.rs
@@ -12,22 +12,21 @@ use blocks::HumanReadable;
 use clap::builder::ValueParser;
 use table::HeaderMode;
 use uucore::display::Quotable;
-use uucore::error::FromIo;
-use uucore::error::{UError, UResult, USimpleError};
-use uucore::fsext::{read_fs_list, MountInfo};
-use uucore::parse_size::ParseSizeError;
+use uucore::error::{UError, UResult, USimpleError, get_exit_code};
+use uucore::fsext::{MountInfo, read_fs_list};
+use uucore::parser::parse_size::ParseSizeError;
 use uucore::{format_usage, help_about, help_section, help_usage, show};
 
-use clap::{crate_version, parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command, parser::ValueSource};
 
-use std::error::Error;
 use std::ffi::OsString;
-use std::fmt;
 use std::path::Path;
+use thiserror::Error;
 
-use crate::blocks::{read_block_size, BlockSize};
+use crate::blocks::{BlockSize, read_block_size};
 use crate::columns::{Column, ColumnError};
 use crate::filesystem::Filesystem;
+use crate::filesystem::FsError;
 use crate::table::Table;
 
 const ABOUT: &str = help_about!("df.md");
@@ -114,52 +113,32 @@ impl Default for Options {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum OptionsError {
+    // TODO This needs to vary based on whether `--block-size`
+    // or `-B` were provided.
+    #[error("--block-size argument '{0}' too large")]
     BlockSizeTooLarge(String),
+    // TODO This needs to vary based on whether `--block-size`
+    // or `-B` were provided.,
+    #[error("invalid --block-size argument {0}")]
     InvalidBlockSize(String),
+    // TODO This needs to vary based on whether `--block-size`
+    // or `-B` were provided.
+    #[error("invalid suffix in --block-size argument {0}")]
     InvalidSuffix(String),
 
     /// An error getting the columns to display in the output table.
+    #[error("option --output: field {0} used more than once")]
     ColumnError(ColumnError),
 
+    #[error("{}", .0.iter()
+            .map(|t| format!("file system type {} both selected and excluded", t.quote()))
+            .collect::<Vec<_>>()
+            .join(format!("\n{}: ", uucore::util_name()).as_str()))]
     FilesystemTypeBothSelectedAndExcluded(Vec<String>),
 }
 
-impl fmt::Display for OptionsError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            // TODO This needs to vary based on whether `--block-size`
-            // or `-B` were provided.
-            Self::BlockSizeTooLarge(s) => {
-                write!(f, "--block-size argument {} too large", s.quote())
-            }
-            // TODO This needs to vary based on whether `--block-size`
-            // or `-B` were provided.
-            Self::InvalidBlockSize(s) => write!(f, "invalid --block-size argument {s}"),
-            // TODO This needs to vary based on whether `--block-size`
-            // or `-B` were provided.
-            Self::InvalidSuffix(s) => write!(f, "invalid suffix in --block-size argument {s}"),
-            Self::ColumnError(ColumnError::MultipleColumns(s)) => write!(
-                f,
-                "option --output: field {} used more than once",
-                s.quote()
-            ),
-            #[allow(clippy::print_in_format_impl)]
-            Self::FilesystemTypeBothSelectedAndExcluded(types) => {
-                for t in types {
-                    eprintln!(
-                        "{}: file system type {} both selected and excluded",
-                        uucore::util_name(),
-                        t.quote()
-                    );
-                }
-                Ok(())
-            }
-        }
-    }
-}
-
 impl Options {
     /// Convert command-line arguments into [`Options`].
     fn from(matches: &ArgMatches) -> Result<Self, OptionsError> {
@@ -189,6 +168,7 @@ impl Options {
                         .to_string(),
                 ),
                 ParseSizeError::ParseFailure(s) => OptionsError::InvalidBlockSize(s),
+                ParseSizeError::PhysicalMem(s) => OptionsError::InvalidBlockSize(s),
             })?,
             header_mode: {
                 if matches.get_flag(OPT_HUMAN_READABLE_BINARY)
@@ -242,7 +222,10 @@ fn is_included(mi: &MountInfo, opt: &Options) -> bool {
     }
 
     // Don't show pseudo filesystems unless `--all` has been given.
-    if mi.dummy && !opt.show_all_fs {
+    // The "lofs" filesystem is a loopback
+    // filesystem present on Solaris and FreeBSD systems. It
+    // is similar to a symbolic link.
+    if (mi.dummy || mi.fs_type == "lofs") && !opt.show_all_fs {
         return false;
     }
 
@@ -305,38 +288,14 @@ fn is_best(previous: &[MountInfo], mi: &MountInfo) -> bool {
     true
 }
 
-/// Keep only the specified subset of [`MountInfo`] instances.
-///
-/// The `opt` argument specifies a variety of ways of excluding
-/// [`MountInfo`] instances; see [`Options`] for more information.
-///
-/// Finally, if there are duplicate entries, the one with the shorter
-/// path is kept.
-
-fn filter_mount_list(vmi: Vec<MountInfo>, opt: &Options) -> Vec<MountInfo> {
-    let mut result = vec![];
-    for mi in vmi {
-        // TODO The running time of the `is_best()` function is linear
-        // in the length of `result`. That makes the running time of
-        // this loop quadratic in the length of `vmi`. This could be
-        // improved by a more efficient implementation of `is_best()`,
-        // but `vmi` is probably not very long in practice.
-        if is_included(&mi, opt) && is_best(&result, &mi) {
-            result.push(mi);
-        }
-    }
-    result
-}
-
 /// Get all currently mounted filesystems.
 ///
 /// `opt` excludes certain filesystems from consideration and allows for the synchronization of filesystems before running; see
 /// [`Options`] for more information.
-
-fn get_all_filesystems(opt: &Options) -> Result<Vec<Filesystem>, std::io::Error> {
+fn get_all_filesystems(opt: &Options) -> UResult<Vec<Filesystem>> {
     // Run a sync call before any operation if so instructed.
     if opt.sync {
-        #[cfg(not(windows))]
+        #[cfg(not(any(windows, target_os = "redox")))]
         unsafe {
             #[cfg(not(target_os = "android"))]
             uucore::libc::sync();
@@ -345,88 +304,102 @@ fn get_all_filesystems(opt: &Options) -> Result<Vec<Filesystem>, std::io::Error>
         }
     }
 
-    // The list of all mounted filesystems.
-    //
-    // Filesystems excluded by the command-line options are
-    // not considered.
-    let mounts: Vec<MountInfo> = filter_mount_list(read_fs_list()?, opt);
+    let mut mounts = vec![];
+    for mi in read_fs_list()? {
+        // TODO The running time of the `is_best()` function is linear
+        // in the length of `result`. That makes the running time of
+        // this loop quadratic in the length of `vmi`. This could be
+        // improved by a more efficient implementation of `is_best()`,
+        // but `vmi` is probably not very long in practice.
+        if is_included(&mi, opt) && is_best(&mounts, &mi) {
+            mounts.push(mi);
+        }
+    }
 
     // Convert each `MountInfo` into a `Filesystem`, which contains
     // both the mount information and usage information.
-    Ok(mounts
-        .into_iter()
-        .filter_map(|m| Filesystem::new(m, None))
-        .filter(|fs| opt.show_all_fs || fs.usage.blocks > 0)
-        .collect())
+    #[cfg(not(windows))]
+    {
+        let maybe_mount = |m| Filesystem::from_mount(&mounts, &m, None).ok();
+        Ok(mounts
+            .clone()
+            .into_iter()
+            .filter_map(maybe_mount)
+            .filter(|fs| opt.show_all_fs || fs.usage.blocks > 0)
+            .collect())
+    }
+    #[cfg(windows)]
+    {
+        let maybe_mount = |m| Filesystem::from_mount(&m, None).ok();
+        Ok(mounts
+            .into_iter()
+            .filter_map(maybe_mount)
+            .filter(|fs| opt.show_all_fs || fs.usage.blocks > 0)
+            .collect())
+    }
 }
 
 /// For each path, get the filesystem that contains that path.
-fn get_named_filesystems<P>(paths: &[P], opt: &Options) -> Result<Vec<Filesystem>, std::io::Error>
+fn get_named_filesystems<P>(paths: &[P], opt: &Options) -> UResult<Vec<Filesystem>>
 where
     P: AsRef<Path>,
 {
     // The list of all mounted filesystems.
-    //
-    // Filesystems marked as `dummy` or of type "lofs" are not
-    // considered. The "lofs" filesystem is a loopback
-    // filesystem present on Solaris and FreeBSD systems. It
-    // is similar to a symbolic link.
-    let mounts: Vec<MountInfo> = filter_mount_list(read_fs_list()?, opt)
-        .into_iter()
-        .filter(|mi| mi.fs_type != "lofs" && !mi.dummy)
-        .collect();
+    let mounts: Vec<MountInfo> = read_fs_list()?;
 
     let mut result = vec![];
 
-    // this happens if the file system type doesn't exist
-    if mounts.is_empty() {
-        show!(USimpleError::new(1, "no file systems processed"));
-        return Ok(result);
-    }
-
     // Convert each path into a `Filesystem`, which contains
     // both the mount information and usage information.
     for path in paths {
         match Filesystem::from_path(&mounts, path) {
-            Some(fs) => result.push(fs),
-            None => {
-                // this happens if specified file system type != file system type of the file
-                if path.as_ref().exists() {
-                    show!(USimpleError::new(1, "no file systems processed"));
-                } else {
-                    show!(USimpleError::new(
-                        1,
-                        format!("{}: No such file or directory", path.as_ref().display())
-                    ));
+            Ok(fs) => {
+                if is_included(&fs.mount_info, opt) {
+                    result.push(fs);
                 }
             }
+            Err(FsError::InvalidPath) => {
+                show!(USimpleError::new(
+                    1,
+                    format!("{}: No such file or directory", path.as_ref().display())
+                ));
+            }
+            Err(FsError::MountMissing) => {
+                show!(USimpleError::new(1, "no file systems processed"));
+            }
+            #[cfg(not(windows))]
+            Err(FsError::OverMounted) => {
+                show!(USimpleError::new(
+                    1,
+                    format!(
+                        "cannot access {}: over-mounted by another device",
+                        path.as_ref().quote()
+                    )
+                ));
+            }
         }
     }
+    if get_exit_code() == 0 && result.is_empty() {
+        show!(USimpleError::new(1, "no file systems processed"));
+        return Ok(result);
+    }
+
     Ok(result)
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum DfError {
     /// A problem while parsing command-line options.
+    #[error("{}", .0)]
     OptionsError(OptionsError),
 }
 
-impl Error for DfError {}
-
 impl UError for DfError {
     fn usage(&self) -> bool {
         matches!(self, Self::OptionsError(OptionsError::ColumnError(_)))
     }
 }
 
-impl fmt::Display for DfError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::OptionsError(e) => e.fmt(f),
-        }
-    }
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
@@ -443,8 +416,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     // Get the list of filesystems to display in the output table.
     let filesystems: Vec<Filesystem> = match matches.get_many::<String>(OPT_PATHS) {
         None => {
-            let filesystems = get_all_filesystems(&opt)
-                .map_err_context(|| "cannot read table of mounted file systems".into())?;
+            let filesystems = get_all_filesystems(&opt).map_err(|e| {
+                let context = "cannot read table of mounted file systems";
+                USimpleError::new(e.code(), format!("{context}: {e}"))
+            })?;
 
             if filesystems.is_empty() {
                 return Err(USimpleError::new(1, "no file systems processed"));
@@ -454,8 +429,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
         Some(paths) => {
             let paths: Vec<_> = paths.collect();
-            let filesystems = get_named_filesystems(&paths, &opt)
-                .map_err_context(|| "cannot read table of mounted file systems".into())?;
+            let filesystems = get_named_filesystems(&paths, &opt).map_err(|e| {
+                let context = "cannot read table of mounted file systems";
+                USimpleError::new(e.code(), format!("{context}: {e}"))
+            })?;
 
             // This can happen if paths are given as command-line arguments
             // but none of the paths exist.
@@ -474,7 +451,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
@@ -724,7 +701,7 @@ mod tests {
 
     mod is_included {
 
-        use crate::{is_included, Options};
+        use crate::{Options, is_included};
         use uucore::fsext::MountInfo;
 
         /// Instantiate a [`MountInfo`] with the given fields.
@@ -858,16 +835,4 @@ mod tests {
             assert!(is_included(&m, &opt));
         }
     }
-
-    mod filter_mount_list {
-
-        use crate::{filter_mount_list, Options};
-
-        #[test]
-        fn test_empty() {
-            let opt = Options::default();
-            let mount_infos = vec![];
-            assert!(filter_mount_list(mount_infos, &opt).is_empty());
-        }
-    }
 }
diff --git a/src/uu/df/src/filesystem.rs b/src/uu/df/src/filesystem.rs
index ef5107958a2..43b1deb36c2 100644
--- a/src/uu/df/src/filesystem.rs
+++ b/src/uu/df/src/filesystem.rs
@@ -37,6 +37,33 @@ pub(crate) struct Filesystem {
     pub usage: FsUsage,
 }
 
+#[derive(Debug, PartialEq)]
+pub(crate) enum FsError {
+    #[cfg(not(windows))]
+    OverMounted,
+    InvalidPath,
+    MountMissing,
+}
+
+/// Check whether `mount` has been over-mounted.
+///
+/// `mount` is considered over-mounted if it there is an element in
+/// `mounts` after mount that has the same mount_dir.
+#[cfg(not(windows))]
+fn is_over_mounted(mounts: &[MountInfo], mount: &MountInfo) -> bool {
+    let last_mount_for_dir = mounts
+        .iter()
+        .filter(|m| m.mount_dir == mount.mount_dir)
+        .next_back();
+
+    if let Some(lmi) = last_mount_for_dir {
+        lmi.dev_name != mount.dev_name
+    } else {
+        // Should be unreachable if `mount` is in `mounts`
+        false
+    }
+}
+
 /// Find the mount info that best matches a given filesystem path.
 ///
 /// This function returns the element of `mounts` on which `path` is
@@ -56,14 +83,16 @@ fn mount_info_from_path<P>(
     path: P,
     // This is really only used for testing purposes.
     canonicalize: bool,
-) -> Option<&MountInfo>
+) -> Result<&MountInfo, FsError>
 where
     P: AsRef<Path>,
 {
     // TODO Refactor this function with `Stater::find_mount_point()`
     // in the `stat` crate.
     let path = if canonicalize {
-        path.as_ref().canonicalize().ok()?
+        path.as_ref()
+            .canonicalize()
+            .map_err(|_| FsError::InvalidPath)?
     } else {
         path.as_ref().to_path_buf()
     };
@@ -82,12 +111,14 @@ where
         .find(|m| m.1.eq(&path))
         .map(|m| m.0);
 
-    maybe_mount_point.or_else(|| {
-        mounts
-            .iter()
-            .filter(|mi| path.starts_with(&mi.mount_dir))
-            .max_by_key(|mi| mi.mount_dir.len())
-    })
+    maybe_mount_point
+        .or_else(|| {
+            mounts
+                .iter()
+                .filter(|mi| path.starts_with(&mi.mount_dir))
+                .max_by_key(|mi| mi.mount_dir.len())
+        })
+        .ok_or(FsError::MountMissing)
 }
 
 impl Filesystem {
@@ -109,14 +140,35 @@ impl Filesystem {
         #[cfg(unix)]
         let usage = FsUsage::new(statfs(_stat_path).ok()?);
         #[cfg(windows)]
-        let usage = FsUsage::new(Path::new(&_stat_path));
+        let usage = FsUsage::new(Path::new(&_stat_path)).ok()?;
         Some(Self {
+            file,
             mount_info,
             usage,
-            file,
         })
     }
 
+    /// Find and create the filesystem from the given mount
+    /// after checking that the it hasn't been over-mounted
+    #[cfg(not(windows))]
+    pub(crate) fn from_mount(
+        mounts: &[MountInfo],
+        mount: &MountInfo,
+        file: Option<String>,
+    ) -> Result<Self, FsError> {
+        if is_over_mounted(mounts, mount) {
+            Err(FsError::OverMounted)
+        } else {
+            Self::new(mount.clone(), file).ok_or(FsError::MountMissing)
+        }
+    }
+
+    /// Find and create the filesystem from the given mount.
+    #[cfg(windows)]
+    pub(crate) fn from_mount(mount: &MountInfo, file: Option<String>) -> Result<Self, FsError> {
+        Self::new(mount.clone(), file).ok_or(FsError::MountMissing)
+    }
+
     /// Find and create the filesystem that best matches a given path.
     ///
     /// This function returns a new `Filesystem` derived from the
@@ -133,16 +185,18 @@ impl Filesystem {
     /// * [`Path::canonicalize`]
     /// * [`MountInfo::mount_dir`]
     ///
-    pub(crate) fn from_path<P>(mounts: &[MountInfo], path: P) -> Option<Self>
+    pub(crate) fn from_path<P>(mounts: &[MountInfo], path: P) -> Result<Self, FsError>
     where
         P: AsRef<Path>,
     {
         let file = path.as_ref().display().to_string();
         let canonicalize = true;
-        let mount_info = mount_info_from_path(mounts, path, canonicalize)?;
-        // TODO Make it so that we do not need to clone the `mount_info`.
-        let mount_info = (*mount_info).clone();
-        Self::new(mount_info, Some(file))
+
+        let result = mount_info_from_path(mounts, path, canonicalize);
+        #[cfg(windows)]
+        return result.and_then(|mount_info| Self::from_mount(mount_info, Some(file)));
+        #[cfg(not(windows))]
+        return result.and_then(|mount_info| Self::from_mount(mounts, mount_info, Some(file)));
     }
 }
 
@@ -153,7 +207,7 @@ mod tests {
 
         use uucore::fsext::MountInfo;
 
-        use crate::filesystem::mount_info_from_path;
+        use crate::filesystem::{FsError, mount_info_from_path};
 
         // Create a fake `MountInfo` with the given directory name.
         fn mount_info(mount_dir: &str) -> MountInfo {
@@ -183,7 +237,19 @@ mod tests {
 
         #[test]
         fn test_empty_mounts() {
-            assert!(mount_info_from_path(&[], "/", false).is_none());
+            assert_eq!(
+                mount_info_from_path(&[], "/", false).unwrap_err(),
+                FsError::MountMissing
+            );
+        }
+
+        #[test]
+        fn test_bad_path() {
+            assert_eq!(
+                // This path better not exist....
+                mount_info_from_path(&[], "/non-existent-path", true).unwrap_err(),
+                FsError::InvalidPath
+            );
         }
 
         #[test]
@@ -210,16 +276,25 @@ mod tests {
         #[test]
         fn test_no_match() {
             let mounts = [mount_info("/foo")];
-            assert!(mount_info_from_path(&mounts, "/bar", false).is_none());
+            assert_eq!(
+                mount_info_from_path(&mounts, "/bar", false).unwrap_err(),
+                FsError::MountMissing
+            );
         }
 
         #[test]
         fn test_partial_match() {
             let mounts = [mount_info("/foo/bar")];
-            assert!(mount_info_from_path(&mounts, "/foo/baz", false).is_none());
+            assert_eq!(
+                mount_info_from_path(&mounts, "/foo/baz", false).unwrap_err(),
+                FsError::MountMissing
+            );
         }
 
         #[test]
+        // clippy::assigning_clones added with Rust 1.78
+        // Rust version = 1.76 on OpenBSD stable/7.5
+        #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
         fn test_dev_name_match() {
             let tmp = tempfile::TempDir::new().expect("Failed to create temp dir");
             let dev_name = std::fs::canonicalize(tmp.path())
@@ -234,4 +309,52 @@ mod tests {
             assert!(mount_info_eq(actual, &mounts[0]));
         }
     }
+
+    #[cfg(not(windows))]
+    mod over_mount {
+        use crate::filesystem::{Filesystem, FsError, is_over_mounted};
+        use uucore::fsext::MountInfo;
+
+        fn mount_info_with_dev_name(mount_dir: &str, dev_name: Option<&str>) -> MountInfo {
+            MountInfo {
+                dev_id: String::default(),
+                dev_name: dev_name.map(String::from).unwrap_or_default(),
+                fs_type: String::default(),
+                mount_dir: String::from(mount_dir),
+                mount_option: String::default(),
+                mount_root: String::default(),
+                remote: Default::default(),
+                dummy: Default::default(),
+            }
+        }
+
+        #[test]
+        fn test_over_mount() {
+            let mount_info1 = mount_info_with_dev_name("/foo", Some("dev_name_1"));
+            let mount_info2 = mount_info_with_dev_name("/foo", Some("dev_name_2"));
+            let mounts = [mount_info1, mount_info2];
+            assert!(is_over_mounted(&mounts, &mounts[0]));
+        }
+
+        #[test]
+        fn test_over_mount_not_over_mounted() {
+            let mount_info1 = mount_info_with_dev_name("/foo", Some("dev_name_1"));
+            let mount_info2 = mount_info_with_dev_name("/foo", Some("dev_name_2"));
+            let mounts = [mount_info1, mount_info2];
+            assert!(!is_over_mounted(&mounts, &mounts[1]));
+        }
+
+        #[test]
+        fn test_from_mount_over_mounted() {
+            let mount_info1 = mount_info_with_dev_name("/foo", Some("dev_name_1"));
+            let mount_info2 = mount_info_with_dev_name("/foo", Some("dev_name_2"));
+
+            let mounts = [mount_info1, mount_info2];
+
+            assert_eq!(
+                Filesystem::from_mount(&mounts, &mounts[0], None).unwrap_err(),
+                FsError::OverMounted
+            );
+        }
+    }
 }
diff --git a/src/uu/df/src/table.rs b/src/uu/df/src/table.rs
index 4c3d08f4533..be7eb8557f9 100644
--- a/src/uu/df/src/table.rs
+++ b/src/uu/df/src/table.rs
@@ -2,14 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore tmpfs Pcent Itotal Iused Iavail Ipcent
+// spell-checker:ignore tmpfs Pcent Itotal Iused Iavail Ipcent nosuid nodev
 //! The filesystem usage data table.
 //!
 //! A table ([`Table`]) comprises a header row ([`Header`]) and a
 //! collection of data rows ([`Row`]), one per filesystem.
 use unicode_width::UnicodeWidthStr;
 
-use crate::blocks::{to_magnitude_and_suffix, SuffixType};
+use crate::blocks::{SuffixType, to_magnitude_and_suffix};
 use crate::columns::{Alignment, Column};
 use crate::filesystem::Filesystem;
 use crate::{BlockSize, Options};
@@ -58,13 +58,13 @@ pub(crate) struct Row {
     bytes_capacity: Option<f64>,
 
     /// Total number of inodes in the filesystem.
-    inodes: u64,
+    inodes: u128,
 
     /// Number of used inodes.
-    inodes_used: u64,
+    inodes_used: u128,
 
     /// Number of free inodes.
-    inodes_free: u64,
+    inodes_free: u128,
 
     /// Percentage of inodes that are used, given as a float between 0 and 1.
     ///
@@ -152,8 +152,10 @@ impl From<Filesystem> for Row {
             ffree,
             ..
         } = fs.usage;
-        let bused = blocks - bfree;
-        let fused = files - ffree;
+
+        // On Windows WSL, files can be less than ffree. Protect such cases via saturating_sub.
+        let bused = blocks.saturating_sub(bfree);
+        let fused = files.saturating_sub(ffree);
         Self {
             file: fs.file,
             fs_device: dev_name,
@@ -176,9 +178,9 @@ impl From<Filesystem> for Row {
             } else {
                 Some(bavail as f64 / ((bused + bavail) as f64))
             },
-            inodes: files,
-            inodes_used: fused,
-            inodes_free: ffree,
+            inodes: files as u128,
+            inodes_used: fused as u128,
+            inodes_free: ffree as u128,
             inodes_usage: if files == 0 {
                 None
             } else {
@@ -233,9 +235,9 @@ impl<'a> RowFormatter<'a> {
     /// Get a string giving the scaled version of the input number.
     ///
     /// The scaling factor is defined in the `options` field.
-    fn scaled_inodes(&self, size: u64) -> String {
+    fn scaled_inodes(&self, size: u128) -> String {
         if let Some(h) = self.options.human_readable {
-            to_magnitude_and_suffix(size.into(), SuffixType::HumanReadable(h))
+            to_magnitude_and_suffix(size, SuffixType::HumanReadable(h))
         } else {
             size.to_string()
         }
@@ -393,12 +395,6 @@ impl Table {
                 let values = fmt.get_values();
                 total += row;
 
-                for (i, value) in values.iter().enumerate() {
-                    if UnicodeWidthStr::width(value.as_str()) > widths[i] {
-                        widths[i] = UnicodeWidthStr::width(value.as_str());
-                    }
-                }
-
                 rows.push(values);
             }
         }
@@ -408,6 +404,16 @@ impl Table {
             rows.push(total_row.get_values());
         }
 
+        // extend the column widths (in chars) for long values in rows
+        // do it here, after total row was added to the list of rows
+        for row in &rows {
+            for (i, value) in row.iter().enumerate() {
+                if UnicodeWidthStr::width(value.as_str()) > widths[i] {
+                    widths[i] = UnicodeWidthStr::width(value.as_str());
+                }
+            }
+        }
+
         Self {
             rows,
             widths,
@@ -464,9 +470,11 @@ impl fmt::Display for Table {
 #[cfg(test)]
 mod tests {
 
+    use std::vec;
+
     use crate::blocks::HumanReadable;
     use crate::columns::Column;
-    use crate::table::{Header, HeaderMode, Row, RowFormatter};
+    use crate::table::{Header, HeaderMode, Row, RowFormatter, Table};
     use crate::{BlockSize, Options};
 
     const COLUMNS_WITH_FS_TYPE: [Column; 7] = [
@@ -815,4 +823,120 @@ mod tests {
         assert_eq!(get_formatted_values(1000, 1000, 0), vec!("1", "1", "0"));
         assert_eq!(get_formatted_values(1001, 1000, 1), vec!("2", "1", "1"));
     }
+
+    #[test]
+    fn test_row_converter_with_invalid_numbers() {
+        // copy from wsl linux
+        let d = crate::Filesystem {
+            file: None,
+            mount_info: crate::MountInfo {
+                dev_id: "28".to_string(),
+                dev_name: "none".to_string(),
+                fs_type: "9p".to_string(),
+                mount_dir: "/usr/lib/wsl/drivers".to_string(),
+                mount_option: "ro,nosuid,nodev,noatime".to_string(),
+                mount_root: "/".to_string(),
+                remote: false,
+                dummy: false,
+            },
+            usage: crate::table::FsUsage {
+                blocksize: 4096,
+                blocks: 244_029_695,
+                bfree: 125_085_030,
+                bavail: 125_085_030,
+                bavail_top_bit_set: false,
+                files: 999,
+                ffree: 1_000_000,
+            },
+        };
+
+        let row = Row::from(d);
+
+        assert_eq!(row.inodes_used, 0);
+    }
+
+    #[test]
+    fn test_table_column_width_computation_include_total_row() {
+        let d1 = crate::Filesystem {
+            file: None,
+            mount_info: crate::MountInfo {
+                dev_id: "28".to_string(),
+                dev_name: "none".to_string(),
+                fs_type: "9p".to_string(),
+                mount_dir: "/usr/lib/wsl/drivers".to_string(),
+                mount_option: "ro,nosuid,nodev,noatime".to_string(),
+                mount_root: "/".to_string(),
+                remote: false,
+                dummy: false,
+            },
+            usage: crate::table::FsUsage {
+                blocksize: 4096,
+                blocks: 244_029_695,
+                bfree: 125_085_030,
+                bavail: 125_085_030,
+                bavail_top_bit_set: false,
+                files: 99_999_999_999,
+                ffree: 999_999,
+            },
+        };
+
+        let filesystems = vec![d1.clone(), d1];
+
+        let mut options = Options {
+            show_total: true,
+            columns: vec![
+                Column::Source,
+                Column::Itotal,
+                Column::Iused,
+                Column::Iavail,
+            ],
+            ..Default::default()
+        };
+
+        let table_w_total = Table::new(&options, filesystems.clone());
+        assert_eq!(
+            table_w_total.to_string(),
+            "Filesystem           Inodes        IUsed   IFree\n\
+             none            99999999999  99999000000  999999\n\
+             none            99999999999  99999000000  999999\n\
+             total          199999999998 199998000000 1999998"
+        );
+
+        options.show_total = false;
+
+        let table_w_o_total = Table::new(&options, filesystems);
+        assert_eq!(
+            table_w_o_total.to_string(),
+            "Filesystem          Inodes       IUsed  IFree\n\
+             none           99999999999 99999000000 999999\n\
+             none           99999999999 99999000000 999999"
+        );
+    }
+
+    #[test]
+    fn test_row_accumulation_u64_overflow() {
+        let total = u64::MAX as u128;
+        let used1 = 3000u128;
+        let used2 = 50000u128;
+
+        let mut row1 = Row {
+            inodes: total,
+            inodes_used: used1,
+            inodes_free: total - used1,
+            ..Default::default()
+        };
+
+        let row2 = Row {
+            inodes: total,
+            inodes_used: used2,
+            inodes_free: total - used2,
+            ..Default::default()
+        };
+
+        row1 += row2;
+
+        assert_eq!(row1.inodes, total * 2);
+        assert_eq!(row1.inodes_used, used1 + used2);
+        assert_eq!(row1.inodes_free, total * 2 - used1 - used2);
+    }
 }
diff --git a/src/uu/dir/Cargo.toml b/src/uu/dir/Cargo.toml
index 9cc5fbde4ca..9bbec793b40 100644
--- a/src/uu/dir/Cargo.toml
+++ b/src/uu/dir/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_dir"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "shortcut to ls -C -b"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ls"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/dir.rs"
 
 [dependencies]
 clap = { workspace = true, features = ["env"] }
-uucore = { workspace = true, features = ["entries", "fs"] }
+uucore = { workspace = true, features = ["entries", "fs", "quoting-style"] }
 uu_ls = { workspace = true }
 
 [[bin]]
diff --git a/src/uu/dir/src/dir.rs b/src/uu/dir/src/dir.rs
index e255295119a..0a8a71c228a 100644
--- a/src/uu/dir/src/dir.rs
+++ b/src/uu/dir/src/dir.rs
@@ -6,7 +6,7 @@
 use clap::Command;
 use std::ffi::OsString;
 use std::path::Path;
-use uu_ls::{options, Config, Format};
+use uu_ls::{Config, Format, options};
 use uucore::error::UResult;
 use uucore::quoting_style::{Quotes, QuotingStyle};
 
diff --git a/src/uu/dircolors/Cargo.toml b/src/uu/dircolors/Cargo.toml
index 9248f5ea12f..5403cd1b40f 100644
--- a/src/uu/dircolors/Cargo.toml
+++ b/src/uu/dircolors/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_dircolors"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "dircolors ~ (uutils) display commands to set LS_COLORS"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/dircolors"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/dircolors.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["colors", "parser"] }
 
 [[bin]]
 name = "dircolors"
diff --git a/src/uu/dircolors/README.md b/src/uu/dircolors/README.md
index ce8aa965f93..62944d4907b 100644
--- a/src/uu/dircolors/README.md
+++ b/src/uu/dircolors/README.md
@@ -15,4 +15,4 @@ Run the tests:
 cargo test --features "dircolors" --no-default-features
 ```
 
-Edit `/PATH_TO_COREUTILS/src/uu/dircolors/src/colors.rs` until the tests pass.
+Edit `/PATH_TO_COREUTILS/src/uu/dircolors/src/dircolors.rs` until the tests pass.
diff --git a/src/uu/dircolors/src/colors.rs b/src/uu/dircolors/src/colors.rs
deleted file mode 100644
index c0a981db89c..00000000000
--- a/src/uu/dircolors/src/colors.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-// 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.
-// spell-checker:ignore (ToDO) EIGHTBIT ETERM MULTIHARDLINK cpio dtterm jfbterm konsole kterm mlterm rmvb rxvt stat'able svgz tmux webm xspf COLORTERM tzst avif tzst mjpg mjpeg webp dpkg rpmnew rpmorig rpmsave
-
-pub const INTERNAL_DB: &str = r#"# Configuration file for dircolors, a utility to help you set the
-# LS_COLORS environment variable used by GNU ls with the --color option.
-# Copyright (C) 1996-2022 Free Software Foundation, Inc.
-# Copying and distribution of this file, with or without modification,
-# are permitted provided the copyright notice and this notice are preserved.
-# The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
-# slackware version of dircolors) are recognized but ignored.
-# Global config options can be specified before TERM or COLORTERM entries
-# Below are TERM or COLORTERM entries, which can be glob patterns, which
-# restrict following config to systems with matching environment variables.
-COLORTERM ?*
-TERM Eterm
-TERM ansi
-TERM *color*
-TERM con[0-9]*x[0-9]*
-TERM cons25
-TERM console
-TERM cygwin
-TERM *direct*
-TERM dtterm
-TERM gnome
-TERM hurd
-TERM jfbterm
-TERM konsole
-TERM kterm
-TERM linux
-TERM linux-c
-TERM mlterm
-TERM putty
-TERM rxvt*
-TERM screen*
-TERM st
-TERM terminator
-TERM tmux*
-TERM vt100
-TERM xterm*
-# Below are the color init strings for the basic file types.
-# One can use codes for 256 or more colors supported by modern terminals.
-# The default color codes use the capabilities of an 8 color terminal
-# with some additional attributes as per the following codes:
-# Attribute codes:
-# 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
-# Text color codes:
-# 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
-# Background color codes:
-# 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
-#NORMAL 00 # no color code at all
-#FILE 00 # regular file: use no color at all
-RESET 0 # reset to "normal" color
-DIR 01;34 # directory
-LINK 01;36 # symbolic link. (If you set this to 'target' instead of a
- # numerical value, the color is as for the file pointed to.)
-MULTIHARDLINK 00 # regular file with more than one link
-FIFO 40;33 # pipe
-SOCK 01;35 # socket
-DOOR 01;35 # door
-BLK 40;33;01 # block device driver
-CHR 40;33;01 # character device driver
-ORPHAN 40;31;01 # symlink to nonexistent file, or non-stat'able file ...
-MISSING 00 # ... and the files they point to
-SETUID 37;41 # file that is setuid (u+s)
-SETGID 30;43 # file that is setgid (g+s)
-CAPABILITY 00 # file with capability (very expensive to lookup)
-STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w)
-OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky
-STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable
-# This is for files with execute permission:
-EXEC 01;32
-# List any file extensions like '.gz' or '.tar' that you would like ls
-# to color below. Put the extension, a space, and the color init string.
-# (and any comments you want to add after a '#')
-# If you use DOS-style suffixes, you may want to uncomment the following:
-#.cmd 01;32 # executables (bright green)
-#.exe 01;32
-#.com 01;32
-#.btm 01;32
-#.bat 01;32
-# Or if you want to color scripts even if they do not have the
-# executable bit actually set.
-#.sh 01;32
-#.csh 01;32
- # archives or compressed (bright red)
-.tar 01;31
-.tgz 01;31
-.arc 01;31
-.arj 01;31
-.taz 01;31
-.lha 01;31
-.lz4 01;31
-.lzh 01;31
-.lzma 01;31
-.tlz 01;31
-.txz 01;31
-.tzo 01;31
-.t7z 01;31
-.zip 01;31
-.z 01;31
-.dz 01;31
-.gz 01;31
-.lrz 01;31
-.lz 01;31
-.lzo 01;31
-.xz 01;31
-.zst 01;31
-.tzst 01;31
-.bz2 01;31
-.bz 01;31
-.tbz 01;31
-.tbz2 01;31
-.tz 01;31
-.deb 01;31
-.rpm 01;31
-.jar 01;31
-.war 01;31
-.ear 01;31
-.sar 01;31
-.rar 01;31
-.alz 01;31
-.ace 01;31
-.zoo 01;31
-.cpio 01;31
-.7z 01;31
-.rz 01;31
-.cab 01;31
-.wim 01;31
-.swm 01;31
-.dwm 01;31
-.esd 01;31
-# image formats
-.avif 01;35
-.jpg 01;35
-.jpeg 01;35
-.mjpg 01;35
-.mjpeg 01;35
-.gif 01;35
-.bmp 01;35
-.pbm 01;35
-.pgm 01;35
-.ppm 01;35
-.tga 01;35
-.xbm 01;35
-.xpm 01;35
-.tif 01;35
-.tiff 01;35
-.png 01;35
-.svg 01;35
-.svgz 01;35
-.mng 01;35
-.pcx 01;35
-.mov 01;35
-.mpg 01;35
-.mpeg 01;35
-.m2v 01;35
-.mkv 01;35
-.webm 01;35
-.webp 01;35
-.ogm 01;35
-.mp4 01;35
-.m4v 01;35
-.mp4v 01;35
-.vob 01;35
-.qt 01;35
-.nuv 01;35
-.wmv 01;35
-.asf 01;35
-.rm 01;35
-.rmvb 01;35
-.flc 01;35
-.avi 01;35
-.fli 01;35
-.flv 01;35
-.gl 01;35
-.dl 01;35
-.xcf 01;35
-.xwd 01;35
-.yuv 01;35
-.cgm 01;35
-.emf 01;35
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
-.ogv 01;35
-.ogx 01;35
-# audio formats
-.aac 00;36
-.au 00;36
-.flac 00;36
-.m4a 00;36
-.mid 00;36
-.midi 00;36
-.mka 00;36
-.mp3 00;36
-.mpc 00;36
-.ogg 00;36
-.ra 00;36
-.wav 00;36
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
-.oga 00;36
-.opus 00;36
-.spx 00;36
-.xspf 00;36
-# backup files
-*~ 00;90
-*# 00;90
-.bak 00;90
-.old 00;90
-.orig 00;90
-.part 00;90
-.rej 00;90
-.swp 00;90
-.tmp 00;90
-.dpkg-dist 00;90
-.dpkg-old 00;90
-.ucf-dist 00;90
-.ucf-new 00;90
-.ucf-old 00;90
-.rpmnew 00;90
-.rpmorig 00;90
-.rpmsave 00;90
-# Subsequent TERM or COLORTERM entries, can be used to add / override
-# config specific to those matching environment variables."#;
diff --git a/src/uu/dircolors/src/dircolors.rs b/src/uu/dircolors/src/dircolors.rs
index 2e3087d810b..4fb9228eb5f 100644
--- a/src/uu/dircolors/src/dircolors.rs
+++ b/src/uu/dircolors/src/dircolors.rs
@@ -3,18 +3,20 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) clrtoeol dircolors eightbit endcode fnmatch leftcode multihardlink rightcode setenv sgid suid colorterm
+// spell-checker:ignore (ToDO) clrtoeol dircolors eightbit endcode fnmatch leftcode multihardlink rightcode setenv sgid suid colorterm disp
 
 use std::borrow::Borrow;
 use std::env;
+use std::fmt::Write as _;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::Path;
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
+use uucore::colors::{FILE_ATTRIBUTE_CODES, FILE_COLORS, FILE_TYPES, TERMS};
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::{help_about, help_section, help_usage};
+use uucore::{format_usage, help_about, help_section, help_usage, parser::parse_glob};
 
 mod options {
     pub const BOURNE_SHELL: &str = "bourne-shell";
@@ -28,9 +30,6 @@ const USAGE: &str = help_usage!("dircolors.md");
 const ABOUT: &str = help_about!("dircolors.md");
 const AFTER_HELP: &str = help_section!("after help", "dircolors.md");
 
-mod colors;
-use self::colors::INTERNAL_DB;
-
 #[derive(PartialEq, Eq, Debug)]
 pub enum OutputFmt {
     Shell,
@@ -57,10 +56,72 @@ pub fn guess_syntax() -> OutputFmt {
     }
 }
 
+fn get_colors_format_strings(fmt: &OutputFmt) -> (String, String) {
+    let prefix = match fmt {
+        OutputFmt::Shell => "LS_COLORS='".to_string(),
+        OutputFmt::CShell => "setenv LS_COLORS '".to_string(),
+        OutputFmt::Display => String::new(),
+        OutputFmt::Unknown => unreachable!(),
+    };
+
+    let suffix = match fmt {
+        OutputFmt::Shell => "';\nexport LS_COLORS".to_string(),
+        OutputFmt::CShell => "'".to_string(),
+        OutputFmt::Display => String::new(),
+        OutputFmt::Unknown => unreachable!(),
+    };
+
+    (prefix, suffix)
+}
+
+pub fn generate_type_output(fmt: &OutputFmt) -> String {
+    match fmt {
+        OutputFmt::Display => FILE_TYPES
+            .iter()
+            .map(|&(_, key, val)| format!("\x1b[{val}m{key}\t{val}\x1b[0m"))
+            .collect::<Vec<String>>()
+            .join("\n"),
+        _ => {
+            // Existing logic for other formats
+            FILE_TYPES
+                .iter()
+                .map(|&(_, v1, v2)| format!("{v1}={v2}"))
+                .collect::<Vec<String>>()
+                .join(":")
+        }
+    }
+}
+
+fn generate_ls_colors(fmt: &OutputFmt, sep: &str) -> String {
+    match fmt {
+        OutputFmt::Display => {
+            let mut display_parts = vec![];
+            let type_output = generate_type_output(fmt);
+            display_parts.push(type_output);
+            for &(extension, code) in FILE_COLORS {
+                let prefix = if extension.starts_with('*') { "" } else { "*" };
+                let formatted_extension = format!("\x1b[{code}m{prefix}{extension}\t{code}\x1b[0m");
+                display_parts.push(formatted_extension);
+            }
+            display_parts.join("\n")
+        }
+        _ => {
+            // existing logic for other formats
+            let mut parts = vec![];
+            for &(extension, code) in FILE_COLORS {
+                let prefix = if extension.starts_with('*') { "" } else { "*" };
+                let formatted_extension = format!("{prefix}{extension}");
+                parts.push(format!("{formatted_extension}={code}"));
+            }
+            let (prefix, suffix) = get_colors_format_strings(fmt);
+            let ls_colors = parts.join(sep);
+            format!("{prefix}{}:{ls_colors}:{suffix}", generate_type_output(fmt),)
+        }
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let files = matches
@@ -97,7 +158,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 ),
             ));
         }
-        println!("{INTERNAL_DB}");
+
+        println!("{}", generate_dircolors_config());
         return Ok(());
     }
 
@@ -125,7 +187,20 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let result;
     if files.is_empty() {
-        result = parse(INTERNAL_DB.lines(), &out_format, "");
+        println!("{}", generate_ls_colors(&out_format, ":"));
+        return Ok(());
+        /*
+        // Check if data is being piped into the program
+        if std::io::stdin().is_terminal() {
+            // No data piped, use default behavior
+            println!("{}", generate_ls_colors(&out_format, ":"));
+            return Ok(());
+        } else {
+            // Data is piped, process the input from stdin
+            let fin = BufReader::new(std::io::stdin());
+            result = parse(fin.lines().map_while(Result::ok), &out_format, "-");
+        }
+         */
     } else if files.len() > 1 {
         return Err(UUsageError::new(
             1,
@@ -133,6 +208,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     } else if files[0].eq("-") {
         let fin = BufReader::new(std::io::stdin());
+        // For example, for echo "owt 40;33"|dircolors -b -
         result = parse(fin.lines().map_while(Result::ok), &out_format, files[0]);
     } else {
         let path = Path::new(files[0]);
@@ -152,10 +228,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 );
             }
             Err(e) => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("{}: {}", path.maybe_quote(), e),
-                ));
+                return Err(USimpleError::new(1, format!("{}: {e}", path.maybe_quote())));
             }
         }
     }
@@ -171,10 +244,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
+        .args_override_self(true)
         .infer_long_args(true)
         .arg(
             Arg::new(options::BOURNE_SHELL)
@@ -276,69 +350,24 @@ enum ParseState {
     Pass,
 }
 
-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>
+fn parse<T>(user_input: T, fmt: &OutputFmt, fp: &str) -> Result<String, String>
 where
     T: IntoIterator,
     T::Item: Borrow<str>,
 {
-    // 1790 > $(dircolors | wc -m)
     let mut result = String::with_capacity(1790);
-    match fmt {
-        OutputFmt::Shell => result.push_str("LS_COLORS='"),
-        OutputFmt::CShell => result.push_str("setenv LS_COLORS '"),
-        OutputFmt::Display => (),
-        OutputFmt::Unknown => unreachable!(),
-    }
+    let (prefix, suffix) = get_colors_format_strings(fmt);
 
-    let mut table: HashMap<&str, &str> = HashMap::with_capacity(48);
-    table.insert("normal", "no");
-    table.insert("norm", "no");
-    table.insert("file", "fi");
-    table.insert("reset", "rs");
-    table.insert("dir", "di");
-    table.insert("lnk", "ln");
-    table.insert("link", "ln");
-    table.insert("symlink", "ln");
-    table.insert("orphan", "or");
-    table.insert("missing", "mi");
-    table.insert("fifo", "pi");
-    table.insert("pipe", "pi");
-    table.insert("sock", "so");
-    table.insert("blk", "bd");
-    table.insert("block", "bd");
-    table.insert("chr", "cd");
-    table.insert("char", "cd");
-    table.insert("door", "do");
-    table.insert("exec", "ex");
-    table.insert("left", "lc");
-    table.insert("leftcode", "lc");
-    table.insert("right", "rc");
-    table.insert("rightcode", "rc");
-    table.insert("end", "ec");
-    table.insert("endcode", "ec");
-    table.insert("suid", "su");
-    table.insert("setuid", "su");
-    table.insert("sgid", "sg");
-    table.insert("setgid", "sg");
-    table.insert("sticky", "st");
-    table.insert("other_writable", "ow");
-    table.insert("owr", "ow");
-    table.insert("sticky_other_writable", "tw");
-    table.insert("owt", "tw");
-    table.insert("capability", "ca");
-    table.insert("multihardlink", "mh");
-    table.insert("clrtoeol", "cl");
+    result.push_str(&prefix);
 
+    // Get environment variables once at the start
     let term = env::var("TERM").unwrap_or_else(|_| "none".to_owned());
-    let term = term.as_str();
+    let colorterm = env::var("COLORTERM").unwrap_or_default();
 
     let mut state = ParseState::Global;
+    let mut saw_colorterm_match = false;
 
-    for (num, line) in lines.into_iter().enumerate() {
+    for (num, line) in user_input.into_iter().enumerate() {
         let num = num + 1;
         let line = line.borrow().purify();
         if line.is_empty() {
@@ -350,71 +379,97 @@ where
         let (key, val) = line.split_two();
         if val.is_empty() {
             return Err(format!(
-                "{}:{}: invalid line;  missing second token",
+                // The double space is what GNU is doing
+                "{}:{num}: invalid line;  missing second token",
                 fp.maybe_quote(),
-                num
             ));
         }
-        let lower = key.to_lowercase();
 
-        if lower == "term" || lower == "colorterm" {
-            if term.fnmatch(val) {
-                state = ParseState::Matched;
-            } else if state != ParseState::Matched {
-                state = ParseState::Pass;
-            }
-        } else {
-            if state == ParseState::Matched {
-                // prevent subsequent mismatched TERM from
-                // cancelling the input
-                state = ParseState::Continue;
+        let lower = key.to_lowercase();
+        match lower.as_str() {
+            "term" => {
+                if term.fnmatch(val) {
+                    state = ParseState::Matched;
+                } else if state == ParseState::Global {
+                    state = ParseState::Pass;
+                }
             }
-            if state != ParseState::Pass {
-                if key.starts_with('.') {
-                    if *fmt == OutputFmt::Display {
-                        result.push_str(format!("\x1b[{val}m*{key}\t{val}\x1b[0m\n").as_str());
-                    } else {
-                        result.push_str(format!("*{key}={val}:").as_str());
-                    }
-                } else if key.starts_with('*') {
-                    if *fmt == OutputFmt::Display {
-                        result.push_str(format!("\x1b[{val}m{key}\t{val}\x1b[0m\n").as_str());
-                    } else {
-                        result.push_str(format!("{key}={val}:").as_str());
-                    }
-                } else if lower == "options" || lower == "color" || lower == "eightbit" {
-                    // Slackware only. Ignore
-                } else if let Some(s) = table.get(lower.as_str()) {
-                    if *fmt == OutputFmt::Display {
-                        result.push_str(format!("\x1b[{val}m{s}\t{val}\x1b[0m\n").as_str());
-                    } else {
-                        result.push_str(format!("{s}={val}:").as_str());
-                    }
+            "colorterm" => {
+                // For COLORTERM ?*, only match if COLORTERM is non-empty
+                let matches = if val == "?*" {
+                    !colorterm.is_empty()
                 } else {
-                    return Err(format!(
-                        "{}:{}: unrecognized keyword {}",
-                        fp.maybe_quote(),
-                        num,
-                        key
-                    ));
+                    colorterm.fnmatch(val)
+                };
+                if matches {
+                    state = ParseState::Matched;
+                    saw_colorterm_match = true;
+                } else if !saw_colorterm_match && state == ParseState::Global {
+                    state = ParseState::Pass;
+                }
+            }
+            _ => {
+                if state == ParseState::Matched {
+                    // prevent subsequent mismatched TERM from
+                    // cancelling the input
+                    state = ParseState::Continue;
+                }
+                if state != ParseState::Pass {
+                    append_entry(&mut result, fmt, key, &lower, val)?;
                 }
             }
         }
     }
 
-    match fmt {
-        OutputFmt::Shell => result.push_str("';\nexport LS_COLORS"),
-        OutputFmt::CShell => result.push('\''),
-        OutputFmt::Display => {
-            // remove latest "\n"
-            result.pop();
-        }
-        OutputFmt::Unknown => unreachable!(),
+    if fmt == &OutputFmt::Display {
+        // remove latest "\n"
+        result.pop();
     }
+    result.push_str(&suffix);
 
     Ok(result)
 }
 
+fn append_entry(
+    result: &mut String,
+    fmt: &OutputFmt,
+    key: &str,
+    lower: &str,
+    val: &str,
+) -> Result<(), String> {
+    if key.starts_with(['.', '*']) {
+        let entry = if key.starts_with('.') {
+            format!("*{key}")
+        } else {
+            key.to_string()
+        };
+        let disp = if *fmt == OutputFmt::Display {
+            format!("\x1b[{val}m{entry}\t{val}\x1b[0m\n")
+        } else {
+            format!("{entry}={val}:")
+        };
+        result.push_str(&disp);
+        return Ok(());
+    }
+
+    match lower {
+        "options" | "color" | "eightbit" => Ok(()), // Slackware only, ignore
+        _ => {
+            if let Some((_, s)) = FILE_ATTRIBUTE_CODES.iter().find(|&&(key, _)| key == lower) {
+                let disp = if *fmt == OutputFmt::Display {
+                    format!("\x1b[{val}m{s}\t{val}\x1b[0m\n")
+                } else {
+                    format!("{s}={val}:")
+                };
+                result.push_str(&disp);
+                Ok(())
+            } else {
+                Err(format!("unrecognized keyword {key}"))
+            }
+        }
+    }
+}
+
 /// Escape single quotes because they are not allowed between single quotes in shell code, and code
 /// enclosed by single quotes is what is returned by `parse()`.
 ///
@@ -428,7 +483,7 @@ fn escape(s: &str) -> String {
         match c {
             '\'' => result.push_str("'\\''"),
             ':' if previous != '\\' => result.push_str("\\:"),
-            _ => result.push_str(&c.to_string()),
+            _ => result.push(c),
         }
         previous = c;
     }
@@ -436,6 +491,58 @@ fn escape(s: &str) -> String {
     result
 }
 
+pub fn generate_dircolors_config() -> String {
+    let mut config = String::new();
+
+    config.push_str(
+        "\
+         # Configuration file for dircolors, a utility to help you set the\n\
+         # LS_COLORS environment variable used by GNU ls with the --color option.\n\
+         # The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the\n\
+         # slackware version of dircolors) are recognized but ignored.\n\
+         # Global config options can be specified before TERM or COLORTERM entries\n\
+         # Below are TERM or COLORTERM entries, which can be glob patterns, which\n\
+         # restrict following config to systems with matching environment variables.\n\
+        ",
+    );
+    config.push_str("COLORTERM ?*\n");
+    for term in TERMS {
+        let _ = writeln!(config, "TERM {term}");
+    }
+
+    config.push_str(
+        "\
+        # Below are the color init strings for the basic file types.\n\
+        # One can use codes for 256 or more colors supported by modern terminals.\n\
+        # The default color codes use the capabilities of an 8 color terminal\n\
+        # with some additional attributes as per the following codes:\n\
+        # Attribute codes:\n\
+        # 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed\n\
+        # Text color codes:\n\
+        # 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white\n\
+        # Background color codes:\n\
+        # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white\n\
+        #NORMAL 00 # no color code at all\n\
+        #FILE 00 # regular file: use no color at all\n\
+        ",
+    );
+
+    for (name, _, code) in FILE_TYPES {
+        let _ = writeln!(config, "{name} {code}");
+    }
+
+    config.push_str("# List any file extensions like '.gz' or '.tar' that you would like ls\n");
+    config.push_str("# to color below. Put the extension, a space, and the color init string.\n");
+
+    for (ext, color) in FILE_COLORS {
+        let _ = writeln!(config, "{ext} {color}");
+    }
+    config.push_str("# Subsequent TERM or COLORTERM entries, can be used to add / override\n");
+    config.push_str("# config specific to those matching environment variables.");
+
+    config
+}
+
 #[cfg(test)]
 mod tests {
     use super::escape;
diff --git a/src/uu/dirname/Cargo.toml b/src/uu/dirname/Cargo.toml
index 6de444499db..7e505a37b9f 100644
--- a/src/uu/dirname/Cargo.toml
+++ b/src/uu/dirname/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_dirname"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "dirname ~ (uutils) display parent directory of PATHNAME"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/dirname"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/dirname.rs"
diff --git a/src/uu/dirname/src/dirname.rs b/src/uu/dirname/src/dirname.rs
index 9a56e9f5bd6..de8740f8970 100644
--- a/src/uu/dirname/src/dirname.rs
+++ b/src/uu/dirname/src/dirname.rs
@@ -3,7 +3,7 @@
 // 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, Command};
+use clap::{Arg, ArgAction, Command};
 use std::path::Path;
 use uucore::display::print_verbatim;
 use uucore::error::{UResult, UUsageError};
@@ -21,8 +21,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
     let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO));
@@ -30,7 +28,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let dirnames: Vec<String> = matches
         .get_many::<String>(options::DIR)
         .unwrap_or_default()
-        .map(|s| s.to_owned())
+        .cloned()
         .collect();
 
     if dirnames.is_empty() {
@@ -64,8 +62,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .about(ABOUT)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
+        .args_override_self(true)
         .infer_long_args(true)
         .arg(
             Arg::new(options::ZERO)
diff --git a/src/uu/du/Cargo.toml b/src/uu/du/Cargo.toml
index c87595db6ca..5b0d3f5e8ea 100644
--- a/src/uu/du/Cargo.toml
+++ b/src/uu/du/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_du"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "du ~ (uutils) display disk usage"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/du"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/du.rs"
@@ -19,7 +22,8 @@ chrono = { workspace = true }
 # For the --exclude & --exclude-from options
 glob = { workspace = true }
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["format", "parser"] }
+thiserror = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-sys = { workspace = true, features = [
diff --git a/src/uu/du/src/du.rs b/src/uu/du/src/du.rs
index 5be2a8a2b34..0b268888136 100644
--- a/src/uu/du/src/du.rs
+++ b/src/uu/du/src/du.rs
@@ -3,47 +3,40 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use chrono::prelude::DateTime;
-use chrono::Local;
-use clap::ArgAction;
-use clap::{crate_version, Arg, ArgMatches, Command};
+use chrono::{DateTime, Local};
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::PossibleValue};
 use glob::Pattern;
 use std::collections::HashSet;
 use std::env;
-use std::fs;
-use std::fs::File;
 #[cfg(not(windows))]
 use std::fs::Metadata;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Result;
-use std::iter;
+use std::fs::{self, DirEntry, File};
+use std::io::{BufRead, BufReader};
 #[cfg(not(windows))]
 use std::os::unix::fs::MetadataExt;
 #[cfg(windows)]
 use std::os::windows::fs::MetadataExt;
 #[cfg(windows)]
 use std::os::windows::io::AsRawHandle;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use std::sync::mpsc;
+use std::thread;
 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::{set_exit_code, UError, UResult};
+use thiserror::Error;
+use uucore::display::{Quotable, print_verbatim};
+use uucore::error::{FromIo, UError, UResult, USimpleError, set_exit_code};
 use uucore::line_ending::LineEnding;
-use uucore::parse_glob;
-use uucore::parse_size::{parse_size, ParseSizeError};
-use uucore::{
-    crash, format_usage, help_about, help_section, help_usage, show, show_error, show_warning,
-};
+use uucore::parser::parse_glob;
+use uucore::parser::parse_size::{ParseSizeError, parse_size_u64};
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_warning};
 #[cfg(windows)]
 use windows_sys::Win32::Foundation::HANDLE;
 #[cfg(windows)]
 use windows_sys::Win32::Storage::FileSystem::{
-    FileIdInfo, FileStandardInfo, GetFileInformationByHandleEx, FILE_ID_128, FILE_ID_INFO,
-    FILE_STANDARD_INFO,
+    FILE_ID_128, FILE_ID_INFO, FILE_STANDARD_INFO, FileIdInfo, FileStandardInfo,
+    GetFileInformationByHandleEx,
 };
 
 mod options {
@@ -68,9 +61,11 @@ mod options {
     pub const ONE_FILE_SYSTEM: &str = "one-file-system";
     pub const DEREFERENCE: &str = "dereference";
     pub const DEREFERENCE_ARGS: &str = "dereference-args";
+    pub const NO_DEREFERENCE: &str = "no-dereference";
     pub const INODES: &str = "inodes";
     pub const EXCLUDE: &str = "exclude";
     pub const EXCLUDE_FROM: &str = "exclude-from";
+    pub const FILES0_FROM: &str = "files0-from";
     pub const VERBOSE: &str = "verbose";
     pub const FILE: &str = "FILE";
 }
@@ -79,27 +74,50 @@ const ABOUT: &str = help_about!("du.md");
 const AFTER_HELP: &str = help_section!("after help", "du.md");
 const USAGE: &str = help_usage!("du.md");
 
-// TODO: Support Z & Y (currently limited by size of u64)
-const UNITS: [(char, u32); 6] = [('E', 6), ('P', 5), ('T', 4), ('G', 3), ('M', 2), ('K', 1)];
-
-struct Options {
+struct TraversalOptions {
     all: bool,
-    max_depth: Option<usize>,
-    total: bool,
     separate_dirs: bool,
     one_file_system: bool,
     dereference: Deref,
-    inodes: bool,
+    count_links: bool,
     verbose: bool,
+    excludes: Vec<Pattern>,
 }
 
-#[derive(PartialEq)]
+struct StatPrinter {
+    total: bool,
+    inodes: bool,
+    max_depth: Option<usize>,
+    threshold: Option<Threshold>,
+    apparent_size: bool,
+    size_format: SizeFormat,
+    time: Option<Time>,
+    time_format: String,
+    line_ending: LineEnding,
+    summarize: bool,
+}
+
+#[derive(PartialEq, Clone)]
 enum Deref {
     All,
     Args(Vec<PathBuf>),
     None,
 }
 
+#[derive(Clone, Copy)]
+enum Time {
+    Accessed,
+    Modified,
+    Created,
+}
+
+#[derive(Clone)]
+enum SizeFormat {
+    HumanDecimal,
+    HumanBinary,
+    BlockSize(u64),
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 struct FileInfo {
     file_id: u128,
@@ -119,7 +137,11 @@ struct Stat {
 }
 
 impl Stat {
-    fn new(path: &Path, options: &Options) -> Result<Self> {
+    fn new(
+        path: &Path,
+        dir_entry: Option<&DirEntry>,
+        options: &TraversalOptions,
+    ) -> std::io::Result<Self> {
         // Determine whether to dereference (follow) the symbolic link
         let should_dereference = match &options.dereference {
             Deref::All => true,
@@ -130,45 +152,51 @@ impl Stat {
         let metadata = if should_dereference {
             // Get metadata, following symbolic links if necessary
             fs::metadata(path)
+        } else if let Some(dir_entry) = dir_entry {
+            // Get metadata directly from the DirEntry, which is faster on Windows
+            dir_entry.metadata()
         } else {
-            // Get metadata without following symbolic links
+            // Get metadata from the filesystem without following symbolic links
             fs::symlink_metadata(path)
         }?;
 
         #[cfg(not(windows))]
-        let file_info = FileInfo {
-            file_id: metadata.ino() as u128,
-            dev_id: metadata.dev(),
-        };
-        #[cfg(not(windows))]
-        return Ok(Self {
-            path: path.to_path_buf(),
-            is_dir: metadata.is_dir(),
-            size: if path.is_dir() { 0 } else { metadata.len() },
-            blocks: metadata.blocks(),
-            inodes: 1,
-            inode: Some(file_info),
-            created: birth_u64(&metadata),
-            accessed: metadata.atime() as u64,
-            modified: metadata.mtime() as u64,
-        });
+        {
+            let file_info = FileInfo {
+                file_id: metadata.ino() as u128,
+                dev_id: metadata.dev(),
+            };
+
+            Ok(Self {
+                path: path.to_path_buf(),
+                is_dir: metadata.is_dir(),
+                size: if metadata.is_dir() { 0 } else { metadata.len() },
+                blocks: metadata.blocks(),
+                inodes: 1,
+                inode: Some(file_info),
+                created: birth_u64(&metadata),
+                accessed: metadata.atime() as u64,
+                modified: metadata.mtime() as u64,
+            })
+        }
 
         #[cfg(windows)]
-        let size_on_disk = get_size_on_disk(path);
-        #[cfg(windows)]
-        let file_info = get_file_info(path);
-        #[cfg(windows)]
-        Ok(Self {
-            path: path.to_path_buf(),
-            is_dir: metadata.is_dir(),
-            size: if path.is_dir() { 0 } else { metadata.len() },
-            blocks: size_on_disk / 1024 * 2,
-            inode: file_info,
-            inodes: 1,
-            created: windows_creation_time_to_unix_time(metadata.creation_time()),
-            accessed: windows_time_to_unix_time(metadata.last_access_time()),
-            modified: windows_time_to_unix_time(metadata.last_write_time()),
-        })
+        {
+            let size_on_disk = get_size_on_disk(path);
+            let file_info = get_file_info(path);
+
+            Ok(Self {
+                path: path.to_path_buf(),
+                is_dir: metadata.is_dir(),
+                size: if metadata.is_dir() { 0 } else { metadata.len() },
+                blocks: size_on_disk / 1024 * 2,
+                inodes: 1,
+                inode: file_info,
+                created: windows_creation_time_to_unix_time(metadata.creation_time()),
+                accessed: windows_time_to_unix_time(metadata.last_access_time()),
+                modified: windows_time_to_unix_time(metadata.last_write_time()),
+            })
+        }
     }
 }
 
@@ -199,9 +227,8 @@ fn get_size_on_disk(path: &Path) -> u64 {
 
     // bind file so it stays in scope until end of function
     // if it goes out of scope the handle below becomes invalid
-    let file = match fs::File::open(path) {
-        Ok(file) => file,
-        Err(_) => return size_on_disk, // opening directories will fail
+    let Ok(file) = File::open(path) else {
+        return size_on_disk; // opening directories will fail
     };
 
     unsafe {
@@ -211,8 +238,8 @@ fn get_size_on_disk(path: &Path) -> u64 {
         let success = GetFileInformationByHandleEx(
             file.as_raw_handle() as HANDLE,
             FileStandardInfo,
-            file_info_ptr as _,
-            std::mem::size_of::<FILE_STANDARD_INFO>() as u32,
+            file_info_ptr.cast(),
+            size_of::<FILE_STANDARD_INFO>() as u32,
         );
 
         if success != 0 {
@@ -227,9 +254,8 @@ fn get_size_on_disk(path: &Path) -> u64 {
 fn get_file_info(path: &Path) -> Option<FileInfo> {
     let mut result = None;
 
-    let file = match fs::File::open(path) {
-        Ok(file) => file,
-        Err(_) => return result,
+    let Ok(file) = File::open(path) else {
+        return result;
     };
 
     unsafe {
@@ -239,8 +265,8 @@ fn get_file_info(path: &Path) -> Option<FileInfo> {
         let success = GetFileInformationByHandleEx(
             file.as_raw_handle() as HANDLE,
             FileIdInfo,
-            file_info_ptr as _,
-            std::mem::size_of::<FILE_ID_INFO>() as u32,
+            file_info_ptr.cast(),
+            size_of::<FILE_ID_INFO>() as u32,
         );
 
         if success != 0 {
@@ -254,69 +280,53 @@ fn get_file_info(path: &Path) -> Option<FileInfo> {
     result
 }
 
-fn read_block_size(s: Option<&str>) -> u64 {
+fn read_block_size(s: Option<&str>) -> UResult<u64> {
     if let Some(s) = s {
-        parse_size(s)
-            .unwrap_or_else(|e| crash!(1, "{}", format_error_message(&e, s, options::BLOCK_SIZE)))
+        parse_size_u64(s)
+            .map_err(|e| USimpleError::new(1, format_error_message(&e, s, options::BLOCK_SIZE)))
     } else {
         for env_var in ["DU_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"] {
             if let Ok(env_size) = env::var(env_var) {
-                if let Ok(v) = parse_size(&env_size) {
-                    return v;
+                if let Ok(v) = parse_size_u64(&env_size) {
+                    return Ok(v);
                 }
             }
         }
         if env::var("POSIXLY_CORRECT").is_ok() {
-            512
+            Ok(512)
         } else {
-            1024
+            Ok(1024)
         }
     }
 }
 
-fn choose_size(matches: &ArgMatches, stat: &Stat) -> u64 {
-    if matches.get_flag(options::INODES) {
-        stat.inodes
-    } else if matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES) {
-        stat.size
-    } else {
-        // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
-        // See: http://linux.die.net/man/2/stat
-        stat.blocks * 512
-    }
-}
-
 // 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,
+    options: &TraversalOptions,
     depth: usize,
-    inodes: &mut HashSet<FileInfo>,
-    exclude: &[Pattern],
-) -> Box<dyn DoubleEndedIterator<Item = Stat>> {
-    let mut stats = vec![];
-    let mut futures = vec![];
-
+    seen_inodes: &mut HashSet<FileInfo>,
+    print_tx: &mpsc::Sender<UResult<StatPrintInfo>>,
+) -> Result<Stat, Box<mpsc::SendError<UResult<StatPrintInfo>>>> {
     if my_stat.is_dir {
         let read = match fs::read_dir(&my_stat.path) {
             Ok(read) => read,
             Err(e) => {
-                show!(
-                    e.map_err_context(|| format!("cannot read directory {}", my_stat.path.quote()))
-                );
-                return Box::new(iter::once(my_stat));
+                print_tx.send(Err(e.map_err_context(|| {
+                    format!("cannot read directory {}", my_stat.path.quote())
+                })))?;
+                return Ok(my_stat);
             }
         };
 
         'file_loop: for f in read {
             match f {
                 Ok(entry) => {
-                    match Stat::new(&entry.path(), options) {
+                    match Stat::new(&entry.path(), Some(&entry), options) {
                         Ok(this_stat) => {
                             // We have an exclude list
-                            for pattern in exclude {
+                            for pattern in &options.excludes {
                                 // Look at all patterns with both short and long paths
                                 // if we have 'du foo' but search to exclude 'foo/bar'
                                 // we need the full path
@@ -333,11 +343,21 @@ fn du(
                             }
 
                             if let Some(inode) = this_stat.inode {
-                                if inodes.contains(&inode) {
+                                // Check if the inode has been seen before and if we should skip it
+                                if seen_inodes.contains(&inode)
+                                    && (!options.count_links || !options.all)
+                                {
+                                    // If `count_links` is enabled and `all` is not, increment the inode count
+                                    if options.count_links && !options.all {
+                                        my_stat.inodes += 1;
+                                    }
+                                    // Skip further processing for this inode
                                     continue;
                                 }
-                                inodes.insert(inode);
+                                // Mark this inode as seen
+                                seen_inodes.insert(inode);
                             }
+
                             if this_stat.is_dir {
                                 if options.one_file_system {
                                     if let (Some(this_inode), Some(my_inode)) =
@@ -348,129 +368,63 @@ fn du(
                                         }
                                     }
                                 }
-                                futures.push(du(this_stat, options, depth + 1, inodes, exclude));
+
+                                let this_stat =
+                                    du(this_stat, options, depth + 1, seen_inodes, print_tx)?;
+
+                                if !options.separate_dirs {
+                                    my_stat.size += this_stat.size;
+                                    my_stat.blocks += this_stat.blocks;
+                                    my_stat.inodes += this_stat.inodes;
+                                }
+                                print_tx.send(Ok(StatPrintInfo {
+                                    stat: this_stat,
+                                    depth: depth + 1,
+                                }))?;
                             } else {
                                 my_stat.size += this_stat.size;
                                 my_stat.blocks += this_stat.blocks;
                                 my_stat.inodes += 1;
                                 if options.all {
-                                    stats.push(this_stat);
+                                    print_tx.send(Ok(StatPrintInfo {
+                                        stat: this_stat,
+                                        depth: depth + 1,
+                                    }))?;
                                 }
                             }
                         }
-                        Err(e) => show!(
-                            e.map_err_context(|| format!("cannot access {}", entry.path().quote()))
-                        ),
+                        Err(e) => print_tx.send(Err(e.map_err_context(|| {
+                            format!("cannot access {}", entry.path().quote())
+                        })))?,
                     }
                 }
-                Err(error) => show_error!("{}", error),
+                Err(error) => print_tx.send(Err(error.into()))?,
             }
         }
     }
 
-    stats.extend(futures.into_iter().flatten().filter(|stat| {
-        if !options.separate_dirs && stat.path.parent().unwrap() == my_stat.path {
-            my_stat.size += stat.size;
-            my_stat.blocks += stat.blocks;
-            my_stat.inodes += stat.inodes;
-        }
-        options
-            .max_depth
-            .map_or(true, |max_depth| depth < max_depth)
-    }));
-    stats.push(my_stat);
-    Box::new(stats.into_iter())
-}
-
-fn convert_size_human(size: u64, multiplier: u64, _block_size: u64) -> String {
-    for &(unit, power) in &UNITS {
-        let limit = multiplier.pow(power);
-        if size >= limit {
-            return format!("{:.1}{}", (size as f64) / (limit as f64), unit);
-        }
-    }
-    if size == 0 {
-        return "0".to_string();
-    }
-    format!("{size}B")
-}
-
-fn convert_size_b(size: u64, _multiplier: u64, _block_size: u64) -> String {
-    format!("{}", ((size as f64) / (1_f64)).ceil())
-}
-
-fn convert_size_k(size: u64, multiplier: u64, _block_size: u64) -> String {
-    format!("{}", ((size as f64) / (multiplier as f64)).ceil())
-}
-
-fn convert_size_m(size: u64, multiplier: u64, _block_size: u64) -> String {
-    format!(
-        "{}",
-        ((size as f64) / ((multiplier * multiplier) as f64)).ceil()
-    )
-}
-
-fn convert_size_other(size: u64, _multiplier: u64, block_size: u64) -> String {
-    format!("{}", ((size as f64) / (block_size as f64)).ceil())
+    Ok(my_stat)
 }
 
-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)]
+#[derive(Debug, Error)]
 enum DuError {
+    #[error("invalid maximum depth {depth}", depth = .0.quote())]
     InvalidMaxDepthArg(String),
+
+    #[error("summarizing conflicts with --max-depth={depth}", depth = .0.maybe_quote())]
     SummarizeDepthConflict(String),
+
+    #[error("invalid argument {style} for 'time style'\nValid arguments are:\n- 'full-iso'\n- 'long-iso'\n- 'iso'\nTry '{help}' for more information.",
+           style = .0.quote(),
+           help = uucore::execution_phrase())]
     InvalidTimeStyleArg(String),
-    InvalidTimeArg(String),
-    InvalidGlob(String),
-}
 
-impl Display for DuError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::InvalidMaxDepthArg(s) => write!(f, "invalid maximum depth {}", s.quote()),
-            Self::SummarizeDepthConflict(s) => {
-                write!(
-                    f,
-                    "summarizing conflicts with --max-depth={}",
-                    s.maybe_quote()
-                )
-            }
-            Self::InvalidTimeStyleArg(s) => write!(
-                f,
-                "invalid argument {} for 'time style'
-Valid arguments are:
-- 'full-iso'
-- 'long-iso'
-- 'iso'
-Try '{} --help' for more information.",
-                s.quote(),
-                uucore::execution_phrase()
-            ),
-            Self::InvalidTimeArg(s) => write!(
-                f,
-                "Invalid argument {} for --time.
-'birth' and 'creation' arguments are not supported on this platform.",
-                s.quote()
-            ),
-            Self::InvalidGlob(s) => write!(f, "Invalid exclude syntax: {s}"),
-        }
-    }
-}
+    #[error("'birth' and 'creation' arguments for --time are not supported on this platform.")]
+    InvalidTimeArg,
 
-impl Error for DuError {}
+    #[error("Invalid exclude syntax: {0}")]
+    InvalidGlob(String),
+}
 
 impl UError for DuError {
     fn code(&self) -> i32 {
@@ -478,7 +432,7 @@ impl UError for DuError {
             Self::InvalidMaxDepthArg(_)
             | Self::SummarizeDepthConflict(_)
             | Self::InvalidTimeStyleArg(_)
-            | Self::InvalidTimeArg(_)
+            | Self::InvalidTimeArg
             | Self::InvalidGlob(_) => 1,
         }
     }
@@ -505,12 +459,12 @@ fn build_exclude_patterns(matches: &ArgMatches) -> UResult<Vec<Pattern>> {
     let excludes_iterator = matches
         .get_many::<String>(options::EXCLUDE)
         .unwrap_or_default()
-        .map(|v| v.to_owned());
+        .cloned();
 
     let mut exclude_patterns = Vec::new();
     for f in excludes_iterator.chain(exclude_from_iterator) {
         if matches.get_flag(options::VERBOSE) {
-            println!("adding {:?} to the exclude list ", &f);
+            println!("adding {f:?} to the exclude list ");
         }
         match parse_glob::from_str(&f) {
             Ok(glob) => exclude_patterns.push(glob),
@@ -520,15 +474,156 @@ fn build_exclude_patterns(matches: &ArgMatches) -> UResult<Vec<Pattern>> {
     Ok(exclude_patterns)
 }
 
+struct StatPrintInfo {
+    stat: Stat,
+    depth: usize,
+}
+
+impl StatPrinter {
+    fn choose_size(&self, stat: &Stat) -> u64 {
+        if self.inodes {
+            stat.inodes
+        } else if self.apparent_size {
+            stat.size
+        } else {
+            // The st_blocks field indicates the number of blocks allocated to the file, 512-byte units.
+            // See: http://linux.die.net/man/2/stat
+            stat.blocks * 512
+        }
+    }
+
+    fn print_stats(&self, rx: &mpsc::Receiver<UResult<StatPrintInfo>>) -> UResult<()> {
+        let mut grand_total = 0;
+        loop {
+            let received = rx.recv();
+
+            match received {
+                Ok(message) => match message {
+                    Ok(stat_info) => {
+                        let size = self.choose_size(&stat_info.stat);
+
+                        if stat_info.depth == 0 {
+                            grand_total += size;
+                        }
+
+                        if !self
+                            .threshold
+                            .is_some_and(|threshold| threshold.should_exclude(size))
+                            && self
+                                .max_depth
+                                .is_none_or(|max_depth| stat_info.depth <= max_depth)
+                            && (!self.summarize || stat_info.depth == 0)
+                        {
+                            self.print_stat(&stat_info.stat, size)?;
+                        }
+                    }
+                    Err(e) => show!(e),
+                },
+                Err(_) => break,
+            }
+        }
+
+        if self.total {
+            print!("{}\ttotal", self.convert_size(grand_total));
+            print!("{}", self.line_ending);
+        }
+
+        Ok(())
+    }
+
+    fn convert_size(&self, size: u64) -> String {
+        match self.size_format {
+            SizeFormat::HumanDecimal => uucore::format::human::human_readable(
+                size,
+                uucore::format::human::SizeFormat::Decimal,
+            ),
+            SizeFormat::HumanBinary => uucore::format::human::human_readable(
+                size,
+                uucore::format::human::SizeFormat::Binary,
+            ),
+            SizeFormat::BlockSize(block_size) => {
+                if self.inodes {
+                    // we ignore block size (-B) with --inodes
+                    size.to_string()
+                } else {
+                    size.div_ceil(block_size).to_string()
+                }
+            }
+        }
+    }
+
+    fn print_stat(&self, stat: &Stat, size: u64) -> UResult<()> {
+        if let Some(time) = self.time {
+            let secs = get_time_secs(time, stat)?;
+            let tm = DateTime::<Local>::from(UNIX_EPOCH + Duration::from_secs(secs));
+            let time_str = tm.format(&self.time_format).to_string();
+            print!("{}\t{time_str}\t", self.convert_size(size));
+        } else {
+            print!("{}\t", self.convert_size(size));
+        }
+
+        print_verbatim(&stat.path).unwrap();
+        print!("{}", self.line_ending);
+
+        Ok(())
+    }
+}
+
+// Read file paths from the specified file, separated by null characters
+fn read_files_from(file_name: &str) -> Result<Vec<PathBuf>, std::io::Error> {
+    let reader: Box<dyn BufRead> = if file_name == "-" {
+        // Read from standard input
+        Box::new(BufReader::new(std::io::stdin()))
+    } else {
+        // First, check if the file_name is a directory
+        let path = PathBuf::from(file_name);
+        if path.is_dir() {
+            return Err(std::io::Error::other(format!(
+                "{file_name}: read error: Is a directory"
+            )));
+        }
+
+        // Attempt to open the file and handle the error if it does not exist
+        match File::open(file_name) {
+            Ok(file) => Box::new(BufReader::new(file)),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                return Err(std::io::Error::other(format!(
+                    "cannot open '{file_name}' for reading: No such file or directory"
+                )));
+            }
+            Err(e) => return Err(e),
+        }
+    };
+
+    let mut paths = Vec::new();
+
+    for (i, line) in reader.split(b'\0').enumerate() {
+        let path = line?;
+
+        if path.is_empty() {
+            let line_number = i + 1;
+            show_error!("{file_name}:{line_number}: invalid zero-length file name");
+            set_exit_code(1);
+        } else {
+            let p = PathBuf::from(String::from_utf8_lossy(&path).to_string());
+            if !paths.contains(&p) {
+                paths.push(p);
+            }
+        }
+    }
+
+    Ok(paths)
+}
+
 #[uucore::main]
 #[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let summarize = matches.get_flag(options::SUMMARIZE);
 
+    let count_links = matches.get_flag(options::COUNT_LINKS);
+
     let max_depth = parse_depth(
         matches
             .get_one::<String>(options::MAX_DEPTH)
@@ -536,19 +631,66 @@ 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 files = if let Some(file_from) = matches.get_one::<String>(options::FILES0_FROM) {
+        if file_from == "-" && matches.get_one::<String>(options::FILE).is_some() {
+            return Err(std::io::Error::other(format!(
+                "extra operand {}\nfile operands cannot be combined with --files0-from",
+                matches.get_one::<String>(options::FILE).unwrap().quote()
+            ))
+            .into());
+        }
+
+        read_files_from(file_from)?
+    } else if let Some(files) = matches.get_many::<String>(options::FILE) {
+        let files = files.map(PathBuf::from);
+        if count_links {
+            files.collect()
+        } else {
+            // Deduplicate while preserving order
+            let mut seen = HashSet::new();
+            files
+                .filter(|path| seen.insert(path.clone()))
+                .collect::<Vec<_>>()
+        }
+    } else {
+        vec![PathBuf::from(".")]
+    };
+
+    let time = matches.contains_id(options::TIME).then(|| {
+        match matches.get_one::<String>(options::TIME).map(AsRef::as_ref) {
+            None | Some("ctime" | "status") => Time::Modified,
+            Some("access" | "atime" | "use") => Time::Accessed,
+            Some("birth" | "creation") => Time::Created,
+            _ => unreachable!("should be caught by clap"),
+        }
+    });
+
+    let size_format = if matches.get_flag(options::HUMAN_READABLE) {
+        SizeFormat::HumanBinary
+    } else if matches.get_flag(options::SI) {
+        SizeFormat::HumanDecimal
+    } else if matches.get_flag(options::BYTES) {
+        SizeFormat::BlockSize(1)
+    } else if matches.get_flag(options::BLOCK_SIZE_1K) {
+        SizeFormat::BlockSize(1024)
+    } else if matches.get_flag(options::BLOCK_SIZE_1M) {
+        SizeFormat::BlockSize(1024 * 1024)
+    } else {
+        let block_size_str = matches.get_one::<String>(options::BLOCK_SIZE);
+        let block_size = read_block_size(block_size_str.map(AsRef::as_ref))?;
+        if block_size == 0 {
+            return Err(std::io::Error::other(format!(
+                "invalid --{} argument {}",
+                options::BLOCK_SIZE,
+                block_size_str.map_or("???BUG", |v| v).quote()
+            ))
+            .into());
+        }
+        SizeFormat::BlockSize(block_size)
     };
 
-    let options = Options {
+    let traversal_options = TraversalOptions {
         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: if matches.get_flag(options::DEREFERENCE) {
@@ -559,59 +701,55 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         } else {
             Deref::None
         },
-        inodes: matches.get_flag(options::INODES),
+        count_links,
         verbose: matches.get_flag(options::VERBOSE),
+        excludes: build_exclude_patterns(&matches)?,
     };
 
-    if options.inodes
-        && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
-    {
-        show_warning!("options --apparent-size and -b are ineffective with --inodes");
-    }
-
-    let block_size = read_block_size(
-        matches
-            .get_one::<String>(options::BLOCK_SIZE)
-            .map(|s| s.as_str()),
-    );
-
-    let threshold = matches.get_one::<String>(options::THRESHOLD).map(|s| {
-        Threshold::from_str(s)
-            .unwrap_or_else(|e| crash!(1, "{}", format_error_message(&e, s, options::THRESHOLD)))
-    });
-
-    let multiplier: u64 = if matches.get_flag(options::SI) {
-        1000
+    let time_format = if time.is_some() {
+        parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?.to_string()
     } else {
-        1024
+        "%Y-%m-%d %H:%M".to_string()
     };
 
-    let convert_size_fn = get_convert_size_fn(&matches);
-
-    let convert_size = |size: u64| {
-        if options.inodes {
-            size.to_string()
-        } else {
-            convert_size_fn(size, multiplier, block_size)
-        }
+    let stat_printer = StatPrinter {
+        max_depth,
+        size_format,
+        summarize,
+        total: matches.get_flag(options::TOTAL),
+        inodes: matches.get_flag(options::INODES),
+        threshold: matches
+            .get_one::<String>(options::THRESHOLD)
+            .map(|s| {
+                Threshold::from_str(s).map_err(|e| {
+                    USimpleError::new(1, format_error_message(&e, s, options::THRESHOLD))
+                })
+            })
+            .transpose()?,
+        apparent_size: matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES),
+        time,
+        time_format,
+        line_ending: LineEnding::from_zero_flag(matches.get_flag(options::NULL)),
     };
 
-    let time_format_str =
-        parse_time_style(matches.get_one::<String>("time-style").map(|s| s.as_str()))?;
-
-    let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::NULL));
+    if stat_printer.inodes
+        && (matches.get_flag(options::APPARENT_SIZE) || matches.get_flag(options::BYTES))
+    {
+        show_warning!("options --apparent-size and -b are ineffective with --inodes");
+    }
 
-    let excludes = build_exclude_patterns(&matches)?;
+    // Use separate thread to print output, so we can print finished results while computation is still running
+    let (print_tx, rx) = mpsc::channel::<UResult<StatPrintInfo>>();
+    let printing_thread = thread::spawn(move || stat_printer.print_stats(&rx));
 
-    let mut grand_total = 0;
     'loop_file: for path in files {
         // Skip if we don't want to ignore anything
-        if !&excludes.is_empty() {
+        if !&traversal_options.excludes.is_empty() {
             let path_string = path.to_string_lossy();
-            for pattern in &excludes {
+            for pattern in &traversal_options.excludes {
                 if pattern.matches(&path_string) {
                     // if the directory is ignored, leave early
-                    if options.verbose {
+                    if traversal_options.verbose {
                         println!("{} ignored", path_string.quote());
                     }
                     continue 'loop_file;
@@ -620,79 +758,46 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
 
         // Check existence of path provided in argument
-        if let Ok(stat) = Stat::new(&path, &options) {
+        if let Ok(stat) = Stat::new(&path, None, &traversal_options) {
             // Kick off the computation of disk usage from the initial path
-            let mut inodes: HashSet<FileInfo> = HashSet::new();
+            let mut seen_inodes: HashSet<FileInfo> = HashSet::new();
             if let Some(inode) = stat.inode {
-                inodes.insert(inode);
+                seen_inodes.insert(inode);
             }
-            let iter = du(stat, &options, 0, &mut inodes, &excludes);
-
-            // Sum up all the returned `Stat`s and display results
-            let (_, len) = iter.size_hint();
-            let len = len.unwrap();
-            for (index, stat) in iter.enumerate() {
-                let size = choose_size(&matches, &stat);
+            let stat = du(stat, &traversal_options, 0, &mut seen_inodes, &print_tx)
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
 
-                if threshold.map_or(false, |threshold| threshold.should_exclude(size)) {
-                    continue;
-                }
-
-                if matches.contains_id(options::TIME) {
-                    let tm = {
-                        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 {
-                        let time_str = tm.format(time_format_str).to_string();
-                        print!("{}\t{}\t", convert_size(size), time_str);
-                        print_verbatim(stat.path).unwrap();
-                        print!("{line_ending}");
-                    }
-                } else if !summarize || index == len - 1 {
-                    print!("{}\t", convert_size(size));
-                    print_verbatim(stat.path).unwrap();
-                    print!("{line_ending}");
-                }
-                if options.total && index == (len - 1) {
-                    // The last element will be the total size of the the path under
-                    // path_string.  We add it to the grand total.
-                    grand_total += size;
-                }
-            }
+            print_tx
+                .send(Ok(StatPrintInfo { stat, depth: 0 }))
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
         } else {
-            show_error!(
-                "{}: {}",
-                path.to_string_lossy().maybe_quote(),
-                "No such file or directory"
-            );
-            set_exit_code(1);
+            print_tx
+                .send(Err(USimpleError::new(
+                    1,
+                    format!(
+                        "cannot access {}: No such file or directory",
+                        path.to_string_lossy().quote()
+                    ),
+                )))
+                .map_err(|e| USimpleError::new(1, e.to_string()))?;
         }
     }
 
-    if options.total {
-        print!("{}\ttotal", convert_size(grand_total));
-        print!("{line_ending}");
-    }
+    drop(print_tx);
+
+    printing_thread
+        .join()
+        .map_err(|_| USimpleError::new(1, "Printing thread panicked."))??;
 
     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 get_time_secs(time: Time, stat: &Stat) -> Result<u64, DuError> {
+    match time {
+        Time::Modified => Ok(stat.modified),
+        Time::Accessed => Ok(stat.accessed),
+        Time::Created => stat.created.ok_or(DuError::InvalidTimeArg),
+    }
 }
 
 fn parse_time_style(s: Option<&str>) -> UResult<&str> {
@@ -718,7 +823,7 @@ fn parse_depth(max_depth_str: Option<&str>, summarize: bool) -> UResult<Option<u
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -820,17 +925,19 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::DEREFERENCE_ARGS)
                 .short('D')
+                .visible_short_alias('H')
                 .long(options::DEREFERENCE_ARGS)
                 .help("follow only symlinks that are listed on the command line")
                 .action(ArgAction::SetTrue)
         )
-        // .arg(
-        //     Arg::new("no-dereference")
-        //         .short('P')
-        //         .long("no-dereference")
-        //         .help("don't follow any symbolic links (this is the default)")
-        //         .action(ArgAction::SetTrue),
-        // )
+         .arg(
+             Arg::new(options::NO_DEREFERENCE)
+                 .short('P')
+                 .long(options::NO_DEREFERENCE)
+                 .help("don't follow any symbolic links (this is the default)")
+                 .overrides_with(options::DEREFERENCE)
+                 .action(ArgAction::SetTrue),
+         )
         .arg(
             Arg::new(options::BLOCK_SIZE_1M)
                 .short('m')
@@ -904,13 +1011,25 @@ pub fn uu_app() -> Command {
                 .help("exclude files that match any pattern in FILE")
                 .action(ArgAction::Append)
         )
+        .arg(
+            Arg::new(options::FILES0_FROM)
+                .long("files0-from")
+                .value_name("FILE")
+                .value_hint(clap::ValueHint::FilePath)
+                .help("summarize device usage of the NUL-terminated file names specified in file F; if F is -, then read names from standard input")
+                .action(ArgAction::Append)
+        )
         .arg(
             Arg::new(options::TIME)
                 .long(options::TIME)
                 .value_name("WORD")
                 .require_equals(true)
                 .num_args(0..)
-                .value_parser(["atime", "access", "use", "ctime", "status", "birth", "creation"])
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("atime").alias("access").alias("use"),
+                    PossibleValue::new("ctime").alias("status"),
+                    PossibleValue::new("creation").alias("birth"),
+                ]))
                 .help(
                     "show time of the last modification of any file in the \
                     directory, or any of its subdirectories. If WORD is given, show time as WORD instead \
@@ -943,10 +1062,10 @@ enum Threshold {
 impl FromStr for Threshold {
     type Err = ParseSizeError;
 
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         let offset = usize::from(s.starts_with(&['-', '+'][..]));
 
-        let size = parse_size(&s[offset..])?;
+        let size = parse_size_u64(&s[offset..])?;
 
         if s.starts_with('-') {
             // Threshold of '-0' excludes everything besides 0 sized entries
@@ -975,10 +1094,12 @@ fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String
     // GNU's du echos affected flag, -B or --block-size (-t or --threshold), depending user's selection
     match error {
         ParseSizeError::InvalidSuffix(_) => {
-            format!("invalid suffix in --{} argument {}", option, s.quote())
+            format!("invalid suffix in --{option} argument {}", s.quote())
+        }
+        ParseSizeError::ParseFailure(_) | ParseSizeError::PhysicalMem(_) => {
+            format!("invalid --{option} argument {}", s.quote())
         }
-        ParseSizeError::ParseFailure(_) => format!("invalid --{} argument {}", option, s.quote()),
-        ParseSizeError::SizeTooBig(_) => format!("--{} argument {} too large", option, s.quote()),
+        ParseSizeError::SizeTooBig(_) => format!("--{option} argument {} too large", s.quote()),
     }
 }
 
@@ -989,13 +1110,9 @@ mod test_du {
 
     #[test]
     fn test_read_block_size() {
-        let test_data = [
-            (Some("1024".to_string()), 1024),
-            (Some("K".to_string()), 1024),
-            (None, 1024),
-        ];
+        let test_data = [Some("1024".to_string()), Some("K".to_string()), None];
         for it in &test_data {
-            assert_eq!(read_block_size(it.0.as_deref()), it.1);
+            assert!(matches!(read_block_size(it.as_deref()), Ok(1024)));
         }
     }
 }
diff --git a/src/uu/echo/Cargo.toml b/src/uu/echo/Cargo.toml
index 5d27bae1b64..80d56368749 100644
--- a/src/uu/echo/Cargo.toml
+++ b/src/uu/echo/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_echo"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "echo ~ (uutils) display TEXT"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/echo"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/echo.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["format"] }
 
 [[bin]]
 name = "echo"
diff --git a/src/uu/echo/echo.md b/src/uu/echo/echo.md
index 4330ecd8837..f6f6f37ffcd 100644
--- a/src/uu/echo/echo.md
+++ b/src/uu/echo/echo.md
@@ -12,15 +12,15 @@ 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
+- `\`       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)
diff --git a/src/uu/echo/src/echo.rs b/src/uu/echo/src/echo.rs
index cd9467714aa..4df76634843 100644
--- a/src/uu/echo/src/echo.rs
+++ b/src/uu/echo/src/echo.rs
@@ -3,11 +3,13 @@
 // 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, Command};
-use std::io::{self, Write};
-use std::iter::Peekable;
-use std::str::Chars;
-use uucore::error::{FromIo, UResult};
+use clap::builder::ValueParser;
+use clap::{Arg, ArgAction, Command};
+use std::env;
+use std::ffi::{OsStr, OsString};
+use std::io::{self, StdoutLock, Write};
+use uucore::error::{UResult, USimpleError};
+use uucore::format::{FormatChar, OctalParsing, parse_escape_only};
 use uucore::{format_usage, help_about, help_section, help_usage};
 
 const ABOUT: &str = help_about!("echo.md");
@@ -21,100 +23,124 @@ mod options {
     pub const DISABLE_BACKSLASH_ESCAPE: &str = "disable_backslash_escape";
 }
 
-fn parse_code(
-    input: &mut Peekable<Chars>,
-    base: u32,
-    max_digits: u32,
-    bits_per_digit: u32,
-) -> Option<char> {
-    let mut ret = 0x8000_0000;
-    for _ in 0..max_digits {
-        match input.peek().and_then(|c| c.to_digit(base)) {
-            Some(n) => ret = (ret << bits_per_digit) | n,
-            None => break,
-        }
-        input.next();
-    }
-    std::char::from_u32(ret)
+/// Holds the options for echo command:
+/// -n (disable newline)
+/// -e/-E (escape handling),
+struct EchoOptions {
+    /// -n flag option: if true, output a trailing newline (-n disables it)
+    /// Default: true
+    pub trailing_newline: bool,
+
+    /// -e enables escape interpretation, -E disables it
+    /// Default: false (escape interpretation disabled)
+    pub escape: bool,
 }
 
-fn print_escaped(input: &str, mut output: impl Write) -> io::Result<bool> {
-    let mut should_stop = false;
-
-    let mut buffer = ['\\'; 2];
-
-    // TODO `cargo +nightly clippy` complains that `.peek()` is never
-    // called on `iter`. However, `peek()` is called inside the
-    // `parse_code()` function that borrows `iter`.
-    let mut iter = input.chars().peekable();
-    while let Some(mut c) = iter.next() {
-        let mut start = 1;
-
-        if c == '\\' {
-            if let Some(next) = iter.next() {
-                c = match next {
-                    '\\' => '\\',
-                    'a' => '\x07',
-                    'b' => '\x08',
-                    'c' => {
-                        should_stop = true;
-                        break;
-                    }
-                    'e' => '\x1b',
-                    'f' => '\x0c',
-                    'n' => '\n',
-                    'r' => '\r',
-                    't' => '\t',
-                    'v' => '\x0b',
-                    'x' => parse_code(&mut iter, 16, 2, 4).unwrap_or_else(|| {
-                        start = 0;
-                        next
-                    }),
-                    '0' => parse_code(&mut iter, 8, 3, 3).unwrap_or('\0'),
-                    _ => {
-                        start = 0;
-                        next
-                    }
-                };
+/// Checks if an argument is a valid echo flag
+/// Returns true if valid echo flag found
+fn is_echo_flag(arg: &OsString, echo_options: &mut EchoOptions) -> bool {
+    let bytes = arg.as_encoded_bytes();
+    if bytes.first() == Some(&b'-') && arg != "-" {
+        // we initialize our local variables to the "current" options so we don't override
+        // previous found flags
+        let mut escape = echo_options.escape;
+        let mut trailing_newline = echo_options.trailing_newline;
+
+        // Process characters after the '-'
+        for c in &bytes[1..] {
+            match c {
+                b'e' => escape = true,
+                b'E' => escape = false,
+                b'n' => trailing_newline = false,
+                // if there is any char in an argument starting with '-' that doesn't match e/E/n
+                // present means that this argument is not a flag
+                _ => return false,
             }
         }
 
-        buffer[1] = c;
+        // we only override the options with flags being found once we parsed the whole argument
+        echo_options.escape = escape;
+        echo_options.trailing_newline = trailing_newline;
+        return true;
+    }
+
+    // argument doesn't start with '-' or is "-" => no flag
+    false
+}
 
-        // because printing char slices is apparently not available in the standard library
-        for ch in &buffer[start..] {
-            write!(output, "{ch}")?;
+/// Processes command line arguments, separating flags from normal arguments
+/// Returns:
+/// - Vector of non-flag arguments
+/// - trailing_newline: whether to print a trailing newline
+/// - escape: whether to process escape sequences
+fn filter_echo_flags(args: impl uucore::Args) -> (Vec<OsString>, bool, bool) {
+    let mut result = Vec::new();
+    let mut echo_options = EchoOptions {
+        trailing_newline: true,
+        escape: false,
+    };
+    let mut args_iter = args.into_iter();
+
+    // Process arguments until first non-flag is found
+    for arg in &mut args_iter {
+        // we parse flags and store options found in "echo_option". First is_echo_flag
+        // call to return false will break the loop and we will collect the remaining arguments
+        if !is_echo_flag(&arg, &mut echo_options) {
+            // First non-flag argument stops flag processing
+            result.push(arg);
+            break;
         }
     }
-
-    Ok(should_stop)
+    // Collect remaining arguments
+    for arg in args_iter {
+        result.push(arg);
+    }
+    (result, echo_options.trailing_newline, echo_options.escape)
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-    let matches = uu_app().get_matches_from(args);
-
-    let no_newline = matches.get_flag(options::NO_NEWLINE);
-    let escaped = matches.get_flag(options::ENABLE_BACKSLASH_ESCAPE);
-    let values: Vec<String> = match matches.get_many::<String>(options::STRING) {
-        Some(s) => s.map(|s| s.to_string()).collect(),
-        None => vec![String::new()],
+    // Check POSIX compatibility mode
+    let is_posixly_correct = env::var_os("POSIXLY_CORRECT").is_some();
+
+    let args_iter = args.skip(1);
+    let (args, trailing_newline, escaped) = if is_posixly_correct {
+        let mut args_iter = args_iter.peekable();
+
+        if args_iter.peek() == Some(&OsString::from("-n")) {
+            // if POSIXLY_CORRECT is set and the first argument is the "-n" flag
+            // we filter flags normally but 'escaped' is activated nonetheless
+            let (args, _, _) = filter_echo_flags(args_iter);
+            (args, false, true)
+        } else {
+            // if POSIXLY_CORRECT is set and the first argument is not the "-n" flag
+            // we just collect all arguments as every argument is considered an argument
+            let args: Vec<OsString> = args_iter.collect();
+            (args, true, true)
+        }
+    } else {
+        // if POSIXLY_CORRECT is not set we filter the flags normally
+        let (args, trailing_newline, escaped) = filter_echo_flags(args_iter);
+        (args, trailing_newline, escaped)
     };
 
-    execute(no_newline, escaped, &values)
-        .map_err_context(|| "could not write to stdout".to_string())
+    let mut stdout_lock = io::stdout().lock();
+    execute(&mut stdout_lock, args, trailing_newline, escaped)?;
+
+    Ok(())
 }
 
 pub fn uu_app() -> Command {
+    // Note: echo is different from the other utils in that it should **not**
+    // have `infer_long_args(true)`, because, for example, `--ver` should be
+    // printed as `--ver` and not show the version text.
     Command::new(uucore::util_name())
         // TrailingVarArg specifies the final positional argument is a VarArg
         // and it doesn't attempts the parse any further args.
         // Final argument must have multiple(true) or the usage string equivalent.
         .trailing_var_arg(true)
         .allow_hyphen_values(true)
-        .infer_long_args(true)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -128,38 +154,71 @@ pub fn uu_app() -> Command {
             Arg::new(options::ENABLE_BACKSLASH_ESCAPE)
                 .short('e')
                 .help("enable interpretation of backslash escapes")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::DISABLE_BACKSLASH_ESCAPE),
         )
         .arg(
             Arg::new(options::DISABLE_BACKSLASH_ESCAPE)
                 .short('E')
                 .help("disable interpretation of backslash escapes (default)")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::ENABLE_BACKSLASH_ESCAPE),
+        )
+        .arg(
+            Arg::new(options::STRING)
+                .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string()),
         )
-        .arg(Arg::new(options::STRING).action(ArgAction::Append))
 }
 
-fn execute(no_newline: bool, escaped: bool, free: &[String]) -> io::Result<()> {
-    let stdout = io::stdout();
-    let mut output = stdout.lock();
+fn execute(
+    stdout_lock: &mut StdoutLock,
+    arguments_after_options: Vec<OsString>,
+    trailing_newline: bool,
+    escaped: bool,
+) -> UResult<()> {
+    for (i, input) in arguments_after_options.into_iter().enumerate() {
+        let Some(bytes) = bytes_from_os_string(input.as_os_str()) else {
+            return Err(USimpleError::new(
+                1,
+                "Non-UTF-8 arguments provided, but this platform does not support them",
+            ));
+        };
 
-    for (i, input) in free.iter().enumerate() {
         if i > 0 {
-            write!(output, " ")?;
+            stdout_lock.write_all(b" ")?;
         }
+
         if escaped {
-            let should_stop = print_escaped(input, &mut output)?;
-            if should_stop {
-                break;
+            for item in parse_escape_only(bytes, OctalParsing::ThreeDigits) {
+                if item.write(&mut *stdout_lock)?.is_break() {
+                    return Ok(());
+                }
             }
         } else {
-            write!(output, "{input}")?;
+            stdout_lock.write_all(bytes)?;
         }
     }
 
-    if !no_newline {
-        writeln!(output)?;
+    if trailing_newline {
+        stdout_lock.write_all(b"\n")?;
     }
 
     Ok(())
 }
+
+fn bytes_from_os_string(input: &OsStr) -> Option<&[u8]> {
+    #[cfg(target_family = "unix")]
+    {
+        use std::os::unix::ffi::OsStrExt;
+
+        Some(input.as_bytes())
+    }
+
+    #[cfg(not(target_family = "unix"))]
+    {
+        // TODO
+        // Verify that this works correctly on these platforms
+        input.to_str().map(|st| st.as_bytes())
+    }
+}
diff --git a/src/uu/env/Cargo.toml b/src/uu/env/Cargo.toml
index b2854edbf05..c943ef4851a 100644
--- a/src/uu/env/Cargo.toml
+++ b/src/uu/env/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_env"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "env ~ (uutils) set each NAME to VALUE in the environment and run COMMAND"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/env"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/env.rs"
@@ -17,6 +20,7 @@ path = "src/env.rs"
 [dependencies]
 clap = { workspace = true }
 rust-ini = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true, features = ["signals"] }
 
 [target.'cfg(unix)'.dependencies]
diff --git a/src/uu/env/src/env.rs b/src/uu/env/src/env.rs
index e031e39e31f..51479b5902f 100644
--- a/src/uu/env/src/env.rs
+++ b/src/uu/env/src/env.rs
@@ -3,38 +3,106 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-/* last synced with: env (GNU coreutils) 8.13 */
-
 // spell-checker:ignore (ToDO) chdir execvp progname subcommand subcommands unsets setenv putenv spawnp SIGSEGV SIGBUS sigaction
 
-use clap::{crate_name, crate_version, Arg, ArgAction, Command};
+pub mod native_int_str;
+pub mod split_iterator;
+pub mod string_expander;
+pub mod string_parser;
+pub mod variable_parser;
+
+use clap::builder::ValueParser;
+use clap::{Arg, ArgAction, Command, crate_name};
 use ini::Ini;
+use native_int_str::{
+    Convert, NCvt, NativeIntStr, NativeIntString, NativeStr, from_native_int_representation_owned,
+};
 #[cfg(unix)]
-use nix::sys::signal::{raise, sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal};
+use nix::sys::signal::{
+    SaFlags, SigAction, SigHandler, SigHandler::SigIgn, SigSet, Signal, raise, sigaction, signal,
+};
 use std::borrow::Cow;
 use std::env;
+use std::ffi::{OsStr, OsString};
 use std::io::{self, Write};
-use std::iter::Iterator;
+
 #[cfg(unix)]
-use std::os::unix::process::ExitStatusExt;
-use std::process;
+use std::os::unix::ffi::OsStrExt;
+#[cfg(unix)]
+use std::os::unix::process::{CommandExt, ExitStatusExt};
+use std::process::{self};
 use uucore::display::Quotable;
-use uucore::error::{UClapError, UResult, USimpleError, UUsageError};
+use uucore::error::{ExitCode, UError, UResult, USimpleError, UUsageError};
 use uucore::line_ending::LineEnding;
+#[cfg(unix)]
+use uucore::signals::signal_by_name_or_value;
 use uucore::{format_usage, help_about, help_section, help_usage, show_warning};
 
+use thiserror::Error;
+
+#[derive(Debug, Error, PartialEq)]
+pub enum EnvError {
+    #[error("no terminating quote in -S string")]
+    EnvMissingClosingQuote(usize, char),
+    #[error("invalid backslash at end of string in -S")]
+    EnvInvalidBackslashAtEndOfStringInMinusS(usize, String),
+    #[error("'\\c' must not appear in double-quoted -S string")]
+    EnvBackslashCNotAllowedInDoubleQuotes(usize),
+    #[error("invalid sequence '\\{}' in -S",.1)]
+    EnvInvalidSequenceBackslashXInMinusS(usize, char),
+    #[error("Missing closing brace")]
+    EnvParsingOfVariableMissingClosingBrace(usize),
+    #[error("Missing variable name")]
+    EnvParsingOfMissingVariable(usize),
+    #[error("Missing closing brace after default value at {}",.0)]
+    EnvParsingOfVariableMissingClosingBraceAfterValue(usize),
+    #[error("Unexpected character: '{}', expected variable name must not start with 0..9",.1)]
+    EnvParsingOfVariableUnexpectedNumber(usize, String),
+    #[error("Unexpected character: '{}', expected a closing brace ('}}') or colon (':')",.1)]
+    EnvParsingOfVariableExceptedBraceOrColon(usize, String),
+    #[error("")]
+    EnvReachedEnd,
+    #[error("")]
+    EnvContinueWithDelimiter,
+    #[error("{}{:?}",.0,.1)]
+    EnvInternalError(usize, string_parser::Error),
+}
+
+impl From<string_parser::Error> for EnvError {
+    fn from(value: string_parser::Error) -> Self {
+        EnvError::EnvInternalError(value.peek_position, value)
+    }
+}
+
 const ABOUT: &str = help_about!("env.md");
 const USAGE: &str = help_usage!("env.md");
 const AFTER_HELP: &str = help_section!("after help", "env.md");
 
+mod options {
+    pub const IGNORE_ENVIRONMENT: &str = "ignore-environment";
+    pub const CHDIR: &str = "chdir";
+    pub const NULL: &str = "null";
+    pub const FILE: &str = "file";
+    pub const UNSET: &str = "unset";
+    pub const DEBUG: &str = "debug";
+    pub const SPLIT_STRING: &str = "split-string";
+    pub const ARGV0: &str = "argv0";
+    pub const IGNORE_SIGNAL: &str = "ignore-signal";
+}
+
+const ERROR_MSG_S_SHEBANG: &str = "use -[v]S to pass options in shebang lines";
+
 struct Options<'a> {
     ignore_env: bool,
     line_ending: LineEnding,
-    running_directory: Option<&'a str>,
-    files: Vec<&'a str>,
-    unsets: Vec<&'a str>,
-    sets: Vec<(&'a str, &'a str)>,
-    program: Vec<&'a str>,
+    running_directory: Option<&'a OsStr>,
+    files: Vec<&'a OsStr>,
+    unsets: Vec<&'a OsStr>,
+    sets: Vec<(Cow<'a, OsStr>, Cow<'a, OsStr>)>,
+    program: Vec<&'a OsStr>,
+    argv0: Option<&'a OsStr>,
+    #[cfg(unix)]
+    ignore_signal: Vec<usize>,
 }
 
 // print name=value env pairs on screen
@@ -43,17 +111,17 @@ fn print_env(line_ending: LineEnding) {
     let stdout_raw = io::stdout();
     let mut stdout = stdout_raw.lock();
     for (n, v) in env::vars() {
-        write!(stdout, "{}={}{}", n, v, line_ending).unwrap();
+        write!(stdout, "{n}={v}{line_ending}").unwrap();
     }
 }
 
-fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<bool> {
+fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<bool> {
     // is it a NAME=VALUE like opt ?
-    if let Some(idx) = opt.find('=') {
+    let wrap = NativeStr::<'a>::new(opt);
+    let split_o = wrap.split_once(&'=');
+    if let Some((name, value)) = split_o {
         // yes, so push name, value pair
-        let (name, value) = opt.split_at(idx);
-        opts.sets.push((name, &value['='.len_utf8()..]));
-
+        opts.sets.push((name, value));
         Ok(false)
     } else {
         // no, it's a program-like opt
@@ -61,7 +129,7 @@ fn parse_name_value_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<boo
     }
 }
 
-fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<()> {
+fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<()> {
     if opts.line_ending == LineEnding::Nul {
         Err(UUsageError::new(
             125,
@@ -73,6 +141,56 @@ fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a str) -> UResult<()> {
     }
 }
 
+#[cfg(unix)]
+fn parse_signal_value(signal_name: &str) -> UResult<usize> {
+    let signal_name_upcase = signal_name.to_uppercase();
+    let optional_signal_value = signal_by_name_or_value(&signal_name_upcase);
+    let error = USimpleError::new(125, format!("{}: invalid signal", signal_name.quote()));
+    match optional_signal_value {
+        Some(sig_val) => {
+            if sig_val == 0 {
+                Err(error)
+            } else {
+                Ok(sig_val)
+            }
+        }
+        None => Err(error),
+    }
+}
+
+#[cfg(unix)]
+fn parse_signal_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<()> {
+    if opt.is_empty() {
+        return Ok(());
+    }
+    let signals: Vec<&'a OsStr> = opt
+        .as_bytes()
+        .split(|&b| b == b',')
+        .map(OsStr::from_bytes)
+        .collect();
+
+    let mut sig_vec = Vec::with_capacity(signals.len());
+    for sig in signals {
+        if !sig.is_empty() {
+            sig_vec.push(sig);
+        }
+    }
+    for sig in sig_vec {
+        let Some(sig_str) = sig.to_str() else {
+            return Err(USimpleError::new(
+                1,
+                format!("{}: invalid signal", sig.quote()),
+            ));
+        };
+        let sig_val = parse_signal_value(sig_str)?;
+        if !opts.ignore_signal.contains(&sig_val) {
+            opts.ignore_signal.push(sig_val);
+        }
+    }
+
+    Ok(())
+}
+
 fn load_config_file(opts: &mut Options) -> UResult<()> {
     // NOTE: config files are parsed using an INI parser b/c it's available and compatible with ".env"-style files
     //   ... * but support for actual INI files, although working, is not intended, nor claimed
@@ -86,12 +204,14 @@ fn load_config_file(opts: &mut Options) -> UResult<()> {
         };
 
         let conf =
-            conf.map_err(|e| USimpleError::new(1, format!("{}: {}", file.maybe_quote(), e)))?;
+            conf.map_err(|e| USimpleError::new(1, format!("{}: {e}", file.maybe_quote())))?;
 
         for (_, prop) in &conf {
             // ignore all INI section lines (treat them as comments)
-            for (key, value) in prop.iter() {
-                env::set_var(key, value);
+            for (key, value) in prop {
+                unsafe {
+                    env::set_var(key, value);
+                }
             }
         }
     }
@@ -99,51 +219,35 @@ fn load_config_file(opts: &mut Options) -> UResult<()> {
     Ok(())
 }
 
-#[cfg(not(windows))]
-#[allow(clippy::ptr_arg)]
-fn build_command<'a, 'b>(args: &'a mut Vec<&'b str>) -> (Cow<'b, str>, &'a [&'b str]) {
-    let progname = Cow::from(args[0]);
-    (progname, &args[1..])
-}
-
-#[cfg(windows)]
-fn build_command<'a, 'b>(args: &'a mut Vec<&'b str>) -> (Cow<'b, str>, &'a [&'b str]) {
-    args.insert(0, "/d/c");
-    let progname = env::var("ComSpec")
-        .map(Cow::from)
-        .unwrap_or_else(|_| Cow::from("cmd"));
-
-    (progname, &args[..])
-}
-
 pub fn uu_app() -> Command {
     Command::new(crate_name!())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
         .infer_long_args(true)
         .trailing_var_arg(true)
         .arg(
-            Arg::new("ignore-environment")
+            Arg::new(options::IGNORE_ENVIRONMENT)
                 .short('i')
-                .long("ignore-environment")
+                .long(options::IGNORE_ENVIRONMENT)
                 .help("start with an empty environment")
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("chdir")
+            Arg::new(options::CHDIR)
                 .short('C') // GNU env compatibility
-                .long("chdir")
+                .long(options::CHDIR)
                 .number_of_values(1)
                 .value_name("DIR")
+                .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::DirPath)
                 .help("change working directory to DIR"),
         )
         .arg(
-            Arg::new("null")
+            Arg::new(options::NULL)
                 .short('0')
-                .long("null")
+                .long(options::NULL)
                 .help(
                     "end each output line with a 0 byte rather than a newline (only \
                 valid when printing the environment)",
@@ -151,11 +255,12 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("file")
+            Arg::new(options::FILE)
                 .short('f')
-                .long("file")
+                .long(options::FILE)
                 .value_name("PATH")
                 .value_hint(clap::ValueHint::FilePath)
+                .value_parser(ValueParser::os_string())
                 .action(ArgAction::Append)
                 .help(
                     "read and set variables from a \".env\"-style configuration file \
@@ -163,32 +268,406 @@ pub fn uu_app() -> Command {
                 ),
         )
         .arg(
-            Arg::new("unset")
+            Arg::new(options::UNSET)
                 .short('u')
-                .long("unset")
+                .long(options::UNSET)
                 .value_name("NAME")
                 .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
                 .help("remove variable from the environment"),
         )
-        .arg(Arg::new("vars").action(ArgAction::Append))
+        .arg(
+            Arg::new(options::DEBUG)
+                .short('v')
+                .long(options::DEBUG)
+                .action(ArgAction::Count)
+                .help("print verbose information for each processing step"),
+        )
+        .arg(
+            Arg::new(options::SPLIT_STRING) // split string handling is implemented directly, not using CLAP. But this entry here is needed for the help information output.
+                .short('S')
+                .long(options::SPLIT_STRING)
+                .value_name("S")
+                .action(ArgAction::Set)
+                .value_parser(ValueParser::os_string())
+                .help("process and split S into separate arguments; used to pass multiple arguments on shebang lines")
+        ).arg(
+            Arg::new(options::ARGV0)
+                .overrides_with(options::ARGV0)
+                .short('a')
+                .long(options::ARGV0)
+                .value_name("a")
+                .action(ArgAction::Set)
+                .value_parser(ValueParser::os_string())
+                .help("Override the zeroth argument passed to the command being executed. \
+                       Without this option a default value of `command` is used.")
+        )
+        .arg(
+            Arg::new("vars")
+                .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
+        )
+        .arg(
+            Arg::new(options::IGNORE_SIGNAL)
+                .long(options::IGNORE_SIGNAL)
+                .value_name("SIG")
+                .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
+                .help("set handling of SIG signal(s) to do nothing")
+        )
+}
+
+pub fn parse_args_from_str(text: &NativeIntStr) -> UResult<Vec<NativeIntString>> {
+    split_iterator::split(text).map_err(|e| match e {
+        EnvError::EnvBackslashCNotAllowedInDoubleQuotes(_) => USimpleError::new(125, e.to_string()),
+        EnvError::EnvInvalidBackslashAtEndOfStringInMinusS(_, _) => {
+            USimpleError::new(125, e.to_string())
+        }
+        EnvError::EnvInvalidSequenceBackslashXInMinusS(_, _) => {
+            USimpleError::new(125, e.to_string())
+        }
+        EnvError::EnvMissingClosingQuote(_, _) => USimpleError::new(125, e.to_string()),
+        EnvError::EnvParsingOfVariableMissingClosingBrace(pos) => {
+            USimpleError::new(125, format!("variable name issue (at {pos}): {e}"))
+        }
+        EnvError::EnvParsingOfMissingVariable(pos) => {
+            USimpleError::new(125, format!("variable name issue (at {pos}): {e}"))
+        }
+        EnvError::EnvParsingOfVariableMissingClosingBraceAfterValue(pos) => {
+            USimpleError::new(125, format!("variable name issue (at {pos}): {e}"))
+        }
+        EnvError::EnvParsingOfVariableUnexpectedNumber(pos, _) => {
+            USimpleError::new(125, format!("variable name issue (at {pos}): {e}"))
+        }
+        EnvError::EnvParsingOfVariableExceptedBraceOrColon(pos, _) => {
+            USimpleError::new(125, format!("variable name issue (at {pos}): {e}"))
+        }
+        _ => USimpleError::new(125, format!("Error: {e:?}")),
+    })
 }
 
-#[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)?;
+fn debug_print_args(args: &[OsString]) {
+    eprintln!("input args:");
+    for (i, arg) in args.iter().enumerate() {
+        eprintln!("arg[{i}]: {}", arg.quote());
+    }
+}
+
+fn check_and_handle_string_args(
+    arg: &OsString,
+    prefix_to_test: &str,
+    all_args: &mut Vec<OsString>,
+    do_debug_print_args: Option<&Vec<OsString>>,
+) -> UResult<bool> {
+    let native_arg = NCvt::convert(arg);
+    if let Some(remaining_arg) = native_arg.strip_prefix(&*NCvt::convert(prefix_to_test)) {
+        if let Some(input_args) = do_debug_print_args {
+            debug_print_args(input_args); // do it here, such that its also printed when we get an error/panic during parsing
+        }
+
+        let arg_strings = parse_args_from_str(remaining_arg)?;
+        all_args.extend(
+            arg_strings
+                .into_iter()
+                .map(from_native_int_representation_owned),
+        );
 
+        Ok(true)
+    } else {
+        Ok(false)
+    }
+}
+
+#[derive(Default)]
+struct EnvAppData {
+    do_debug_printing: bool,
+    do_input_debug_printing: Option<bool>,
+    had_string_argument: bool,
+}
+
+impl EnvAppData {
+    fn make_error_no_such_file_or_dir(&self, prog: &OsStr) -> Box<dyn UError> {
+        uucore::show_error!("{}: No such file or directory", prog.quote());
+        if !self.had_string_argument {
+            uucore::show_error!("{ERROR_MSG_S_SHEBANG}");
+        }
+        ExitCode::new(127)
+    }
+
+    fn process_all_string_arguments(
+        &mut self,
+        original_args: &Vec<OsString>,
+    ) -> UResult<Vec<OsString>> {
+        let mut all_args: Vec<OsString> = Vec::new();
+        let mut process_flags = true;
+        let mut expecting_arg = false;
+        // Leave out split-string since it's a special case below
+        let flags_with_args = [
+            options::ARGV0,
+            options::CHDIR,
+            options::FILE,
+            options::IGNORE_SIGNAL,
+            options::UNSET,
+        ];
+        let short_flags_with_args = ['a', 'C', 'f', 'u'];
+        for (n, arg) in original_args.iter().enumerate() {
+            let arg_str = arg.to_string_lossy();
+            // Stop processing env flags once we reach the command or -- argument
+            if 0 < n
+                && !expecting_arg
+                && (arg == "--" || !(arg_str.starts_with('-') || arg_str.contains('=')))
+            {
+                process_flags = false;
+            }
+            if !process_flags {
+                all_args.push(arg.clone());
+                continue;
+            }
+            expecting_arg = false;
+            match arg {
+                b if check_and_handle_string_args(b, "--split-string", &mut all_args, None)? => {
+                    self.had_string_argument = true;
+                }
+                b if check_and_handle_string_args(b, "-S", &mut all_args, None)? => {
+                    self.had_string_argument = true;
+                }
+                b if check_and_handle_string_args(b, "-vS", &mut all_args, None)? => {
+                    self.do_debug_printing = true;
+                    self.had_string_argument = true;
+                }
+                b if check_and_handle_string_args(
+                    b,
+                    "-vvS",
+                    &mut all_args,
+                    Some(original_args),
+                )? =>
+                {
+                    self.do_debug_printing = true;
+                    self.do_input_debug_printing = Some(false); // already done
+                    self.had_string_argument = true;
+                }
+                _ => {
+                    if let Some(flag) = arg_str.strip_prefix("--") {
+                        if flags_with_args.contains(&flag) {
+                            expecting_arg = true;
+                        }
+                    } else if let Some(flag) = arg_str.strip_prefix("-") {
+                        for c in flag.chars() {
+                            expecting_arg = short_flags_with_args.contains(&c);
+                        }
+                    }
+                    // Short unset option (-u) is not allowed to contain '='
+                    if arg_str.contains('=')
+                        && arg_str.starts_with("-u")
+                        && !arg_str.starts_with("--")
+                    {
+                        return Err(USimpleError::new(
+                            125,
+                            format!("cannot unset '{}': Invalid argument", &arg_str[2..]),
+                        ));
+                    }
+
+                    all_args.push(arg.clone());
+                }
+            }
+        }
+
+        Ok(all_args)
+    }
+
+    fn parse_arguments(
+        &mut self,
+        original_args: impl uucore::Args,
+    ) -> Result<(Vec<OsString>, clap::ArgMatches), Box<dyn UError>> {
+        let original_args: Vec<OsString> = original_args.collect();
+        let args = self.process_all_string_arguments(&original_args)?;
+        let app = uu_app();
+        let matches = app
+            .try_get_matches_from(args)
+            .map_err(|e| -> Box<dyn UError> {
+                match e.kind() {
+                    clap::error::ErrorKind::DisplayHelp
+                    | clap::error::ErrorKind::DisplayVersion => e.into(),
+                    _ => {
+                        // extent any real issue with parameter parsing by the ERROR_MSG_S_SHEBANG
+                        let s = format!("{e}");
+                        if !s.is_empty() {
+                            let s = s.trim_end();
+                            uucore::show_error!("{s}");
+                        }
+                        uucore::show_error!("{ERROR_MSG_S_SHEBANG}");
+                        ExitCode::new(125)
+                    }
+                }
+            })?;
+        Ok((original_args, matches))
+    }
+
+    fn run_env(&mut self, original_args: impl uucore::Args) -> UResult<()> {
+        let (original_args, matches) = self.parse_arguments(original_args)?;
+
+        self.do_debug_printing = self.do_debug_printing || (0 != matches.get_count("debug"));
+        self.do_input_debug_printing = self
+            .do_input_debug_printing
+            .or(Some(matches.get_count("debug") >= 2));
+        if let Some(value) = self.do_input_debug_printing {
+            if value {
+                debug_print_args(&original_args);
+                self.do_input_debug_printing = Some(false);
+            }
+        }
+
+        let mut opts = make_options(&matches)?;
+
+        apply_change_directory(&opts)?;
+
+        // NOTE: we manually set and unset the env vars below rather than using Command::env() to more
+        //       easily handle the case where no command is given
+
+        apply_removal_of_all_env_vars(&opts);
+
+        // load .env-style config file prior to those given on the command-line
+        load_config_file(&mut opts)?;
+
+        apply_unset_env_vars(&opts)?;
+
+        apply_specified_env_vars(&opts);
+
+        #[cfg(unix)]
+        apply_ignore_signal(&opts)?;
+
+        if opts.program.is_empty() {
+            // no program provided, so just dump all env vars to stdout
+            print_env(opts.line_ending);
+        } else {
+            return self.run_program(&opts, self.do_debug_printing);
+        }
+
+        Ok(())
+    }
+
+    fn run_program(
+        &mut self,
+        opts: &Options<'_>,
+        do_debug_printing: bool,
+    ) -> Result<(), Box<dyn UError>> {
+        let prog = Cow::from(opts.program[0]);
+        #[cfg(unix)]
+        let mut arg0 = prog.clone();
+        #[cfg(not(unix))]
+        let arg0 = prog.clone();
+        let args = &opts.program[1..];
+
+        /*
+         * On Unix-like systems Command::status either ends up calling either fork or posix_spawnp
+         * (which ends up calling clone). Keep using the current process would be ideal, but the
+         * standard library contains many checks and fail-safes to ensure the process ends up being
+         * created. This is much simpler than dealing with the hassles of calling execvp directly.
+         */
+        let mut cmd = process::Command::new(&*prog);
+        cmd.args(args);
+
+        if let Some(_argv0) = opts.argv0 {
+            #[cfg(unix)]
+            {
+                cmd.arg0(_argv0);
+                arg0 = Cow::Borrowed(_argv0);
+                if do_debug_printing {
+                    eprintln!("argv0:     {}", arg0.quote());
+                }
+            }
+
+            #[cfg(not(unix))]
+            return Err(USimpleError::new(
+                2,
+                "--argv0 is currently not supported on this platform",
+            ));
+        }
+
+        if do_debug_printing {
+            eprintln!("executing: {}", prog.maybe_quote());
+            let arg_prefix = "   arg";
+            eprintln!("{arg_prefix}[{}]= {}", 0, arg0.quote());
+            for (i, arg) in args.iter().enumerate() {
+                eprintln!("{arg_prefix}[{}]= {}", i + 1, arg.quote());
+            }
+        }
+
+        match cmd.status() {
+            Ok(exit) if !exit.success() => {
+                #[cfg(unix)]
+                if let Some(exit_code) = exit.code() {
+                    return Err(exit_code.into());
+                } else {
+                    // `exit.code()` returns `None` on Unix when the process is terminated by a signal.
+                    // See std::os::unix::process::ExitStatusExt for more information. This prints out
+                    // the interrupted process and the signal it received.
+                    let signal_code = exit.signal().unwrap();
+                    let signal = Signal::try_from(signal_code).unwrap();
+
+                    // We have to disable any handler that's installed by default.
+                    // This ensures that we exit on this signal.
+                    // For example, `SIGSEGV` and `SIGBUS` have default handlers installed in Rust.
+                    // We ignore the errors because there is not much we can do if that fails anyway.
+                    // SAFETY: The function is unsafe because installing functions is unsafe, but we are
+                    // just defaulting to default behavior and not installing a function. Hence, the call
+                    // is safe.
+                    let _ = unsafe {
+                        sigaction(
+                            signal,
+                            &SigAction::new(SigHandler::SigDfl, SaFlags::empty(), SigSet::all()),
+                        )
+                    };
+
+                    let _ = raise(signal);
+                }
+                return Err(exit.code().unwrap().into());
+            }
+            Err(ref err) => {
+                return match err.kind() {
+                    io::ErrorKind::NotFound | io::ErrorKind::InvalidInput => {
+                        Err(self.make_error_no_such_file_or_dir(&prog))
+                    }
+                    io::ErrorKind::PermissionDenied => {
+                        uucore::show_error!("{}: Permission denied", prog.quote());
+                        Err(126.into())
+                    }
+                    _ => {
+                        uucore::show_error!("unknown error: {err:?}");
+                        Err(126.into())
+                    }
+                };
+            }
+            Ok(_) => (),
+        }
+        Ok(())
+    }
+}
+
+fn apply_removal_of_all_env_vars(opts: &Options<'_>) {
+    // remove all env vars if told to ignore presets
+    if opts.ignore_env {
+        for (ref name, _) in env::vars_os() {
+            unsafe {
+                env::remove_var(name);
+            }
+        }
+    }
+}
+
+fn make_options(matches: &clap::ArgMatches) -> UResult<Options<'_>> {
     let ignore_env = matches.get_flag("ignore-environment");
     let line_ending = LineEnding::from_zero_flag(matches.get_flag("null"));
-    let running_directory = matches.get_one::<String>("chdir").map(|s| s.as_str());
-    let files = match matches.get_many::<String>("file") {
-        Some(v) => v.map(|s| s.as_str()).collect(),
+    let running_directory = matches.get_one::<OsString>("chdir").map(|s| s.as_os_str());
+    let files = match matches.get_many::<OsString>("file") {
+        Some(v) => v.map(|s| s.as_os_str()).collect(),
         None => Vec::with_capacity(0),
     };
-    let unsets = match matches.get_many::<String>("unset") {
-        Some(v) => v.map(|s| s.as_str()).collect(),
+    let unsets = match matches.get_many::<OsString>("unset") {
+        Some(v) => v.map(|s| s.as_os_str()).collect(),
         None => Vec::with_capacity(0),
     };
+    let argv0 = matches.get_one::<OsString>("argv0").map(|s| s.as_os_str());
 
     let mut opts = Options {
         ignore_env,
@@ -198,23 +677,20 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
         unsets,
         sets: vec![],
         program: vec![],
+        argv0,
+        #[cfg(unix)]
+        ignore_signal: vec![],
     };
 
-    // change directory
-    if let Some(d) = opts.running_directory {
-        match env::set_current_dir(d) {
-            Ok(()) => d,
-            Err(error) => {
-                return Err(USimpleError::new(
-                    125,
-                    format!("cannot change directory to \"{d}\": {error}"),
-                ));
-            }
-        };
+    #[cfg(unix)]
+    if let Some(iter) = matches.get_many::<OsString>("ignore-signal") {
+        for opt in iter {
+            parse_signal_opt(&mut opts, opt)?;
+        }
     }
 
     let mut begin_prog_opts = false;
-    if let Some(mut iter) = matches.get_many::<String>("vars") {
+    if let Some(mut iter) = matches.get_many::<OsString>("vars") {
         // read NAME=VALUE arguments (and up to a single program argument)
         while !begin_prog_opts {
             if let Some(opt) = iter.next() {
@@ -234,41 +710,54 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
         }
     }
 
-    // GNU env tests this behavior
-    if opts.program.is_empty() && running_directory.is_some() {
-        return Err(UUsageError::new(
-            125,
-            "must specify command with --chdir (-C)".to_string(),
-        ));
-    }
-
-    // NOTE: we manually set and unset the env vars below rather than using Command::env() to more
-    //       easily handle the case where no command is given
-
-    // remove all env vars if told to ignore presets
-    if opts.ignore_env {
-        for (ref name, _) in env::vars() {
-            env::remove_var(name);
-        }
-    }
-
-    // load .env-style config file prior to those given on the command-line
-    load_config_file(&mut opts)?;
+    Ok(opts)
+}
 
-    // unset specified env vars
+fn apply_unset_env_vars(opts: &Options<'_>) -> Result<(), Box<dyn UError>> {
     for name in &opts.unsets {
-        if name.is_empty() || name.contains(0 as char) || name.contains('=') {
+        let native_name = NativeStr::new(name);
+        if name.is_empty()
+            || native_name.contains(&'\0').unwrap()
+            || native_name.contains(&'=').unwrap()
+        {
             return Err(USimpleError::new(
                 125,
                 format!("cannot unset {}: Invalid argument", name.quote()),
             ));
         }
+        unsafe {
+            env::remove_var(name);
+        }
+    }
+    Ok(())
+}
+
+fn apply_change_directory(opts: &Options<'_>) -> Result<(), Box<dyn UError>> {
+    // GNU env tests this behavior
+    if opts.program.is_empty() && opts.running_directory.is_some() {
+        return Err(UUsageError::new(
+            125,
+            "must specify command with --chdir (-C)".to_string(),
+        ));
+    }
 
-        env::remove_var(name);
+    if let Some(d) = opts.running_directory {
+        match env::set_current_dir(d) {
+            Ok(()) => d,
+            Err(error) => {
+                return Err(USimpleError::new(
+                    125,
+                    format!("cannot change directory to {}: {error}", d.quote()),
+                ));
+            }
+        };
     }
+    Ok(())
+}
 
+fn apply_specified_env_vars(opts: &Options<'_>) {
     // set specified env vars
-    for &(name, val) in &opts.sets {
+    for (name, val) in &opts.sets {
         /*
          * set_var panics if name is an empty string
          * set_var internally calls setenv (on unix at least), while GNU env calls putenv instead.
@@ -295,63 +784,142 @@ fn run_env(args: impl uucore::Args) -> UResult<()> {
             show_warning!("no name specified for value {}", val.quote());
             continue;
         }
-        env::set_var(name, val);
+        unsafe {
+            env::set_var(name, val);
+        }
     }
+}
 
-    if opts.program.is_empty() {
-        // no program provided, so just dump all env vars to stdout
-        print_env(opts.line_ending);
-    } else {
-        // we need to execute a command
-        let (prog, args) = build_command(&mut opts.program);
-
-        /*
-         * On Unix-like systems Command::status either ends up calling either fork or posix_spawnp
-         * (which ends up calling clone). Keep using the current process would be ideal, but the
-         * standard library contains many checks and fail-safes to ensure the process ends up being
-         * created. This is much simpler than dealing with the hassles of calling execvp directly.
-         */
-        match process::Command::new(&*prog).args(args).status() {
-            Ok(exit) if !exit.success() => {
-                #[cfg(unix)]
-                if let Some(exit_code) = exit.code() {
-                    return Err(exit_code.into());
-                } else {
-                    // `exit.code()` returns `None` on Unix when the process is terminated by a signal.
-                    // See std::os::unix::process::ExitStatusExt for more information. This prints out
-                    // the interrupted process and the signal it received.
-                    let signal_code = exit.signal().unwrap();
-                    let signal = Signal::try_from(signal_code).unwrap();
-
-                    // We have to disable any handler that's installed by default.
-                    // This ensures that we exit on this signal.
-                    // For example, `SIGSEGV` and `SIGBUS` have default handlers installed in Rust.
-                    // We ignore the errors because there is not much we can do if that fails anyway.
-                    // SAFETY: The function is unsafe because installing functions is unsafe, but we are
-                    // just defaulting to default behavior and not installing a function. Hence, the call
-                    // is safe.
-                    let _ = unsafe {
-                        sigaction(
-                            signal,
-                            &SigAction::new(SigHandler::SigDfl, SaFlags::empty(), SigSet::all()),
-                        )
-                    };
+#[cfg(unix)]
+fn apply_ignore_signal(opts: &Options<'_>) -> UResult<()> {
+    for &sig_value in &opts.ignore_signal {
+        let sig: Signal = (sig_value as i32)
+            .try_into()
+            .map_err(|e| io::Error::from_raw_os_error(e as i32))?;
 
-                    let _ = raise(signal);
-                }
-                #[cfg(not(unix))]
-                return Err(exit.code().unwrap().into());
-            }
-            Err(ref err) if err.kind() == io::ErrorKind::NotFound => return Err(127.into()),
-            Err(_) => return Err(126.into()),
-            Ok(_) => (),
-        }
+        ignore_signal(sig)?;
     }
+    Ok(())
+}
 
+#[cfg(unix)]
+fn ignore_signal(sig: Signal) -> UResult<()> {
+    // SAFETY: This is safe because we write the handler for each signal only once, and therefore "the current handler is the default", as the documentation requires it.
+    let result = unsafe { signal(sig, SigIgn) };
+    if let Err(err) = result {
+        return Err(USimpleError::new(
+            125,
+            format!(
+                "failed to set signal action for signal {}: {}",
+                sig as i32,
+                err.desc()
+            ),
+        ));
+    }
     Ok(())
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    run_env(args)
+    EnvAppData::default().run_env(args)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_split_string_environment_vars_test() {
+        unsafe { env::set_var("FOO", "BAR") };
+        assert_eq!(
+            NCvt::convert(vec!["FOO=bar", "sh", "-c", "echo xBARx =$FOO="]),
+            parse_args_from_str(&NCvt::convert(r#"FOO=bar sh -c "echo x${FOO}x =\$FOO=""#))
+                .unwrap(),
+        );
+    }
+
+    #[test]
+    fn test_split_string_misc() {
+        assert_eq!(
+            NCvt::convert(vec!["A=B", "FOO=AR", "sh", "-c", "echo $A$FOO"]),
+            parse_args_from_str(&NCvt::convert(r#"A=B FOO=AR  sh -c "echo \$A\$FOO""#)).unwrap(),
+        );
+        assert_eq!(
+            NCvt::convert(vec!["A=B", "FOO=AR", "sh", "-c", "echo $A$FOO"]),
+            parse_args_from_str(&NCvt::convert(r"A=B FOO=AR  sh -c 'echo $A$FOO'")).unwrap()
+        );
+        assert_eq!(
+            NCvt::convert(vec!["A=B", "FOO=AR", "sh", "-c", "echo $A$FOO"]),
+            parse_args_from_str(&NCvt::convert(r"A=B FOO=AR  sh -c 'echo $A$FOO'")).unwrap()
+        );
+
+        assert_eq!(
+            NCvt::convert(vec!["-i", "A=B ' C"]),
+            parse_args_from_str(&NCvt::convert(r"-i A='B \' C'")).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_error_cases() {
+        // Test EnvBackslashCNotAllowedInDoubleQuotes
+        let result = parse_args_from_str(&NCvt::convert(r#"sh -c "echo \c""#));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "'\\c' must not appear in double-quoted -S string"
+        );
+
+        // Test EnvInvalidBackslashAtEndOfStringInMinusS
+        let result = parse_args_from_str(&NCvt::convert(r#"sh -c "echo \"#));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "no terminating quote in -S string"
+        );
+
+        // Test EnvInvalidSequenceBackslashXInMinusS
+        let result = parse_args_from_str(&NCvt::convert(r#"sh -c "echo \x""#));
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("invalid sequence '\\x' in -S")
+        );
+
+        // Test EnvMissingClosingQuote
+        let result = parse_args_from_str(&NCvt::convert(r#"sh -c "echo "#));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "no terminating quote in -S string"
+        );
+
+        // Test variable-related errors
+        let result = parse_args_from_str(&NCvt::convert(r"echo ${FOO"));
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("variable name issue (at 10): Missing closing brace")
+        );
+
+        let result = parse_args_from_str(&NCvt::convert(r"echo ${FOO:-value"));
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("variable name issue (at 17): Missing closing brace after default value")
+        );
+
+        let result = parse_args_from_str(&NCvt::convert(r"echo ${1FOO}"));
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("variable name issue (at 7): Unexpected character: '1', expected variable name must not start with 0..9"));
+
+        let result = parse_args_from_str(&NCvt::convert(r"echo ${FOO?}"));
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("variable name issue (at 10): Unexpected character: '?', expected a closing brace ('}') or colon (':')"));
+    }
 }
diff --git a/src/uu/env/src/native_int_str.rs b/src/uu/env/src/native_int_str.rs
new file mode 100644
index 00000000000..856948fc137
--- /dev/null
+++ b/src/uu/env/src/native_int_str.rs
@@ -0,0 +1,316 @@
+// 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.
+
+// This module contains classes and functions for dealing with the differences
+// between operating systems regarding the lossless processing of OsStr/OsString.
+// In contrast to existing crates with similar purpose, this module does not use any
+// `unsafe` features or functions.
+// Due to a suboptimal design aspect of OsStr/OsString on windows, we need to
+// encode/decode to wide chars on windows operating system.
+// This prevents borrowing from OsStr on windows. Anyway, if optimally used,#
+// this conversion needs to be done only once in the beginning and at the end.
+
+use std::ffi::OsString;
+#[cfg(not(target_os = "windows"))]
+use std::os::unix::ffi::{OsStrExt, OsStringExt};
+#[cfg(target_os = "windows")]
+use std::os::windows::prelude::*;
+use std::{borrow::Cow, ffi::OsStr};
+
+#[cfg(not(target_os = "windows"))]
+use u8 as NativeIntCharU;
+#[cfg(target_os = "windows")]
+use u16 as NativeIntCharU;
+
+pub type NativeCharInt = NativeIntCharU;
+pub type NativeIntStr = [NativeCharInt];
+pub type NativeIntString = Vec<NativeCharInt>;
+
+pub struct NCvt;
+
+pub trait Convert<From, To> {
+    fn convert(f: From) -> To;
+}
+
+// ================ str/String =================
+
+impl<'a> Convert<&'a str, Cow<'a, NativeIntStr>> for NCvt {
+    fn convert(f: &'a str) -> Cow<'a, NativeIntStr> {
+        #[cfg(target_os = "windows")]
+        {
+            Cow::Owned(f.encode_utf16().collect())
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        {
+            Cow::Borrowed(f.as_bytes())
+        }
+    }
+}
+
+impl<'a> Convert<&'a String, Cow<'a, NativeIntStr>> for NCvt {
+    fn convert(f: &'a String) -> Cow<'a, NativeIntStr> {
+        #[cfg(target_os = "windows")]
+        {
+            Cow::Owned(f.encode_utf16().collect())
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        {
+            Cow::Borrowed(f.as_bytes())
+        }
+    }
+}
+
+impl<'a> Convert<String, Cow<'a, NativeIntStr>> for NCvt {
+    fn convert(f: String) -> Cow<'a, NativeIntStr> {
+        #[cfg(target_os = "windows")]
+        {
+            Cow::Owned(f.encode_utf16().collect())
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        {
+            Cow::Owned(f.into_bytes())
+        }
+    }
+}
+
+// ================ OsStr/OsString =================
+
+impl<'a> Convert<&'a OsStr, Cow<'a, NativeIntStr>> for NCvt {
+    fn convert(f: &'a OsStr) -> Cow<'a, NativeIntStr> {
+        to_native_int_representation(f)
+    }
+}
+
+impl<'a> Convert<&'a OsString, Cow<'a, NativeIntStr>> for NCvt {
+    fn convert(f: &'a OsString) -> Cow<'a, NativeIntStr> {
+        to_native_int_representation(f)
+    }
+}
+
+impl<'a> Convert<OsString, Cow<'a, NativeIntStr>> for NCvt {
+    fn convert(f: OsString) -> Cow<'a, NativeIntStr> {
+        #[cfg(target_os = "windows")]
+        {
+            Cow::Owned(f.encode_wide().collect())
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        {
+            Cow::Owned(f.into_vec())
+        }
+    }
+}
+
+// ================ Vec<Str/String> =================
+
+impl<'a> Convert<&'a Vec<&'a str>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+    fn convert(f: &'a Vec<&'a str>) -> Vec<Cow<'a, NativeIntStr>> {
+        f.iter().map(|x| Self::convert(*x)).collect()
+    }
+}
+
+impl<'a> Convert<Vec<&'a str>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+    fn convert(f: Vec<&'a str>) -> Vec<Cow<'a, NativeIntStr>> {
+        f.iter().map(|x| Self::convert(*x)).collect()
+    }
+}
+
+impl<'a> Convert<&'a Vec<String>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+    fn convert(f: &'a Vec<String>) -> Vec<Cow<'a, NativeIntStr>> {
+        f.iter().map(Self::convert).collect()
+    }
+}
+
+impl<'a> Convert<Vec<String>, Vec<Cow<'a, NativeIntStr>>> for NCvt {
+    fn convert(f: Vec<String>) -> Vec<Cow<'a, NativeIntStr>> {
+        f.into_iter().map(Self::convert).collect()
+    }
+}
+
+pub fn to_native_int_representation(input: &OsStr) -> Cow<'_, NativeIntStr> {
+    #[cfg(target_os = "windows")]
+    {
+        Cow::Owned(input.encode_wide().collect())
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        Cow::Borrowed(input.as_bytes())
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)] // needed on windows
+pub fn from_native_int_representation(input: Cow<'_, NativeIntStr>) -> Cow<'_, OsStr> {
+    #[cfg(target_os = "windows")]
+    {
+        Cow::Owned(OsString::from_wide(&input))
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        match input {
+            Cow::Borrowed(borrow) => Cow::Borrowed(OsStr::from_bytes(borrow)),
+            Cow::Owned(own) => Cow::Owned(OsString::from_vec(own)),
+        }
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)] // needed on windows
+pub fn from_native_int_representation_owned(input: NativeIntString) -> OsString {
+    #[cfg(target_os = "windows")]
+    {
+        OsString::from_wide(&input)
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        OsString::from_vec(input)
+    }
+}
+
+pub fn get_single_native_int_value(c: &char) -> Option<NativeCharInt> {
+    #[cfg(target_os = "windows")]
+    {
+        let mut buf = [0u16, 0];
+        let s = c.encode_utf16(&mut buf);
+        if s.len() == 1 { Some(buf[0]) } else { None }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let mut buf = [0u8, 0, 0, 0];
+        let s = c.encode_utf8(&mut buf);
+        if s.len() == 1 { Some(buf[0]) } else { None }
+    }
+}
+
+pub fn get_char_from_native_int(ni: NativeCharInt) -> Option<(char, NativeCharInt)> {
+    let c_opt;
+    #[cfg(target_os = "windows")]
+    {
+        c_opt = char::decode_utf16([ni; 1]).next().unwrap().ok();
+    };
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        c_opt = std::str::from_utf8(&[ni; 1])
+            .ok()
+            .map(|x| x.chars().next().unwrap());
+    };
+
+    if let Some(c) = c_opt {
+        return Some((c, ni));
+    }
+
+    None
+}
+
+pub struct NativeStr<'a> {
+    native: Cow<'a, NativeIntStr>,
+}
+
+impl<'a> NativeStr<'a> {
+    pub fn new(str: &'a OsStr) -> Self {
+        Self {
+            native: to_native_int_representation(str),
+        }
+    }
+
+    pub fn native(&self) -> Cow<'a, NativeIntStr> {
+        self.native.clone()
+    }
+
+    pub fn into_native(self) -> Cow<'a, NativeIntStr> {
+        self.native
+    }
+
+    pub fn contains(&self, x: &char) -> Option<bool> {
+        let n_c = get_single_native_int_value(x)?;
+        Some(self.native.contains(&n_c))
+    }
+
+    pub fn slice(&self, from: usize, to: usize) -> Cow<'a, OsStr> {
+        let result = self.match_cow(|b| Ok::<_, ()>(&b[from..to]), |o| Ok(o[from..to].to_vec()));
+        result.unwrap()
+    }
+
+    pub fn split_once(&self, pred: &char) -> Option<(Cow<'a, OsStr>, Cow<'a, OsStr>)> {
+        let n_c = get_single_native_int_value(pred)?;
+        let p = self.native.iter().position(|&x| x == n_c)?;
+        let before = self.slice(0, p);
+        let after = self.slice(p + 1, self.native.len());
+        Some((before, after))
+    }
+
+    pub fn split_at(&self, pos: usize) -> (Cow<'a, OsStr>, Cow<'a, OsStr>) {
+        let before = self.slice(0, pos);
+        let after = self.slice(pos, self.native.len());
+        (before, after)
+    }
+
+    pub fn strip_prefix(&self, prefix: &OsStr) -> Option<Cow<'a, OsStr>> {
+        let n_prefix = to_native_int_representation(prefix);
+        let result = self.match_cow(
+            |b| b.strip_prefix(&*n_prefix).ok_or(()),
+            |o| o.strip_prefix(&*n_prefix).map(|x| x.to_vec()).ok_or(()),
+        );
+        result.ok()
+    }
+
+    pub fn strip_prefix_native(&self, prefix: &OsStr) -> Option<Cow<'a, NativeIntStr>> {
+        let n_prefix = to_native_int_representation(prefix);
+        let result = self.match_cow_native(
+            |b| b.strip_prefix(&*n_prefix).ok_or(()),
+            |o| o.strip_prefix(&*n_prefix).map(|x| x.to_vec()).ok_or(()),
+        );
+        result.ok()
+    }
+
+    fn match_cow<FnBorrow, FnOwned, Err>(
+        &self,
+        f_borrow: FnBorrow,
+        f_owned: FnOwned,
+    ) -> Result<Cow<'a, OsStr>, Err>
+    where
+        FnBorrow: FnOnce(&'a [NativeCharInt]) -> Result<&'a [NativeCharInt], Err>,
+        FnOwned: FnOnce(&Vec<NativeCharInt>) -> Result<Vec<NativeCharInt>, Err>,
+    {
+        match &self.native {
+            Cow::Borrowed(b) => {
+                let slice = f_borrow(b);
+                slice.map(|x| from_native_int_representation(Cow::Borrowed(x)))
+            }
+            Cow::Owned(o) => {
+                let slice = f_owned(o);
+                let os_str = slice.map(from_native_int_representation_owned);
+                os_str.map(Cow::Owned)
+            }
+        }
+    }
+
+    fn match_cow_native<FnBorrow, FnOwned, Err>(
+        &self,
+        f_borrow: FnBorrow,
+        f_owned: FnOwned,
+    ) -> Result<Cow<'a, NativeIntStr>, Err>
+    where
+        FnBorrow: FnOnce(&'a [NativeCharInt]) -> Result<&'a [NativeCharInt], Err>,
+        FnOwned: FnOnce(&Vec<NativeCharInt>) -> Result<Vec<NativeCharInt>, Err>,
+    {
+        match &self.native {
+            Cow::Borrowed(b) => {
+                let slice = f_borrow(b);
+                slice.map(Cow::Borrowed)
+            }
+            Cow::Owned(o) => {
+                let slice = f_owned(o);
+                slice.map(Cow::Owned)
+            }
+        }
+    }
+}
diff --git a/src/uu/env/src/split_iterator.rs b/src/uu/env/src/split_iterator.rs
new file mode 100644
index 00000000000..40e5e9dae63
--- /dev/null
+++ b/src/uu/env/src/split_iterator.rs
@@ -0,0 +1,374 @@
+// 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.
+//
+// This file is based on work from Tomasz MiÄ…sko who published it as "shell_words" crate,
+// licensed under the Apache License, Version 2.0 <LICENSE-APACHE>
+// or the MIT license <LICENSE-MIT>, at your option.
+//
+//! Process command line according to parsing rules of original GNU env.
+//! Even though it looks quite like a POSIX syntax, the original
+//! "shell_words" implementation had to be adapted significantly.
+//!
+//! Apart from the grammar differences, there is a new feature integrated: $VARIABLE expansion.
+//!
+//! [GNU env] <https://www.gnu.org/software/coreutils/manual/html_node/env-invocation.html#g_t_002dS_002f_002d_002dsplit_002dstring-syntax>
+// spell-checker:ignore (words) Tomasz MiÄ…sko rntfv FFFD varname
+
+#![forbid(unsafe_code)]
+
+use std::borrow::Cow;
+
+use crate::EnvError;
+use crate::native_int_str::NativeCharInt;
+use crate::native_int_str::NativeIntStr;
+use crate::native_int_str::NativeIntString;
+use crate::native_int_str::from_native_int_representation;
+use crate::string_expander::StringExpander;
+use crate::string_parser::StringParser;
+use crate::variable_parser::VariableParser;
+
+const BACKSLASH: char = '\\';
+const DOUBLE_QUOTES: char = '\"';
+const SINGLE_QUOTES: char = '\'';
+const NEW_LINE: char = '\n';
+const DOLLAR: char = '$';
+
+const REPLACEMENTS: [(char, char); 9] = [
+    ('r', '\r'),
+    ('n', '\n'),
+    ('t', '\t'),
+    ('f', '\x0C'),
+    ('v', '\x0B'),
+    ('_', ' '),
+    ('#', '#'),
+    ('$', '$'),
+    ('"', '"'),
+];
+
+const ASCII_WHITESPACE_CHARS: [char; 6] = [' ', '\t', '\r', '\n', '\x0B', '\x0C'];
+
+pub struct SplitIterator<'a> {
+    expander: StringExpander<'a>,
+    words: Vec<Vec<NativeCharInt>>,
+}
+
+impl<'a> SplitIterator<'a> {
+    pub fn new(s: &'a NativeIntStr) -> Self {
+        Self {
+            expander: StringExpander::new(s),
+            words: Vec::new(),
+        }
+    }
+
+    fn skip_one(&mut self) -> Result<(), EnvError> {
+        self.expander
+            .get_parser_mut()
+            .consume_one_ascii_or_all_non_ascii()?;
+        Ok(())
+    }
+
+    fn take_one(&mut self) -> Result<(), EnvError> {
+        Ok(self.expander.take_one()?)
+    }
+
+    fn get_current_char(&self) -> Option<char> {
+        self.expander.peek().ok()
+    }
+
+    fn push_char_to_word(&mut self, c: char) {
+        self.expander.put_one_char(c);
+    }
+
+    fn push_word_to_words(&mut self) {
+        let word = self.expander.take_collected_output();
+        self.words.push(word);
+    }
+
+    fn get_parser(&self) -> &StringParser<'a> {
+        self.expander.get_parser()
+    }
+
+    fn get_parser_mut(&mut self) -> &mut StringParser<'a> {
+        self.expander.get_parser_mut()
+    }
+
+    fn substitute_variable<'x>(&'x mut self) -> Result<(), EnvError> {
+        let mut var_parse = VariableParser::<'a, '_> {
+            parser: self.get_parser_mut(),
+        };
+
+        let (name, default) = var_parse.parse_variable()?;
+
+        let varname_os_str_cow = from_native_int_representation(Cow::Borrowed(name));
+        let value = std::env::var_os(varname_os_str_cow);
+        match (&value, default) {
+            (None, None) => {} // do nothing, just replace it with ""
+            (Some(value), _) => {
+                self.expander.put_string(value);
+            }
+            (None, Some(default)) => {
+                self.expander.put_native_string(default);
+            }
+        };
+
+        Ok(())
+    }
+
+    fn check_and_replace_ascii_escape_code(&mut self, c: char) -> Result<bool, EnvError> {
+        if let Some(replace) = REPLACEMENTS.iter().find(|&x| x.0 == c) {
+            self.skip_one()?;
+            self.push_char_to_word(replace.1);
+            return Ok(true);
+        }
+
+        Ok(false)
+    }
+
+    fn make_invalid_sequence_backslash_xin_minus_s(&self, c: char) -> EnvError {
+        EnvError::EnvInvalidSequenceBackslashXInMinusS(
+            self.expander.get_parser().get_peek_position(),
+            c,
+        )
+    }
+
+    fn state_root(&mut self) -> Result<(), EnvError> {
+        loop {
+            match self.state_delimiter() {
+                Err(EnvError::EnvContinueWithDelimiter) => {}
+                Err(EnvError::EnvReachedEnd) => return Ok(()),
+                result => return result,
+            }
+        }
+    }
+
+    fn state_delimiter(&mut self) -> Result<(), EnvError> {
+        loop {
+            match self.get_current_char() {
+                None => return Ok(()),
+                Some('#') => {
+                    self.skip_one()?;
+                    self.state_comment()?;
+                }
+                Some(BACKSLASH) => {
+                    self.skip_one()?;
+                    self.state_delimiter_backslash()?;
+                }
+                Some(c) if ASCII_WHITESPACE_CHARS.contains(&c) => {
+                    self.skip_one()?;
+                }
+                Some(_) => {
+                    // Don't consume char. Will be done in unquoted state.
+                    self.state_unquoted()?;
+                }
+            }
+        }
+    }
+
+    fn state_delimiter_backslash(&mut self) -> Result<(), EnvError> {
+        match self.get_current_char() {
+            None => Err(EnvError::EnvInvalidBackslashAtEndOfStringInMinusS(
+                self.get_parser().get_peek_position(),
+                "Delimiter".into(),
+            )),
+            Some('_' | NEW_LINE) => {
+                self.skip_one()?;
+                Ok(())
+            }
+            Some(DOLLAR | BACKSLASH | '#' | SINGLE_QUOTES | DOUBLE_QUOTES) => {
+                self.take_one()?;
+                self.state_unquoted()
+            }
+            Some('c') => Err(EnvError::EnvReachedEnd),
+            Some(c) if self.check_and_replace_ascii_escape_code(c)? => self.state_unquoted(),
+            Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+        }
+    }
+
+    fn state_unquoted(&mut self) -> Result<(), EnvError> {
+        loop {
+            match self.get_current_char() {
+                None => {
+                    self.push_word_to_words();
+                    return Err(EnvError::EnvReachedEnd);
+                }
+                Some(DOLLAR) => {
+                    self.substitute_variable()?;
+                }
+                Some(SINGLE_QUOTES) => {
+                    self.skip_one()?;
+                    self.state_single_quoted()?;
+                }
+                Some(DOUBLE_QUOTES) => {
+                    self.skip_one()?;
+                    self.state_double_quoted()?;
+                }
+                Some(BACKSLASH) => {
+                    self.skip_one()?;
+                    self.state_unquoted_backslash()?;
+                }
+                Some(c) if ASCII_WHITESPACE_CHARS.contains(&c) => {
+                    self.push_word_to_words();
+                    self.skip_one()?;
+                    return Ok(());
+                }
+                Some(_) => {
+                    self.take_one()?;
+                }
+            }
+        }
+    }
+
+    fn state_unquoted_backslash(&mut self) -> Result<(), EnvError> {
+        match self.get_current_char() {
+            None => Err(EnvError::EnvInvalidBackslashAtEndOfStringInMinusS(
+                self.get_parser().get_peek_position(),
+                "Unquoted".into(),
+            )),
+            Some(NEW_LINE) => {
+                self.skip_one()?;
+                Ok(())
+            }
+            Some('_') => {
+                self.skip_one()?;
+                self.push_word_to_words();
+                Err(EnvError::EnvContinueWithDelimiter)
+            }
+            Some('c') => {
+                self.push_word_to_words();
+                Err(EnvError::EnvReachedEnd)
+            }
+            Some(DOLLAR | BACKSLASH | SINGLE_QUOTES | DOUBLE_QUOTES) => {
+                self.take_one()?;
+                Ok(())
+            }
+            Some(c) if self.check_and_replace_ascii_escape_code(c)? => Ok(()),
+            Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+        }
+    }
+
+    fn state_single_quoted(&mut self) -> Result<(), EnvError> {
+        loop {
+            match self.get_current_char() {
+                None => {
+                    return Err(EnvError::EnvMissingClosingQuote(
+                        self.get_parser().get_peek_position(),
+                        '\'',
+                    ));
+                }
+                Some(SINGLE_QUOTES) => {
+                    self.skip_one()?;
+                    return Ok(());
+                }
+                Some(BACKSLASH) => {
+                    self.skip_one()?;
+                    self.split_single_quoted_backslash()?;
+                }
+                Some(_) => {
+                    self.take_one()?;
+                }
+            }
+        }
+    }
+
+    fn split_single_quoted_backslash(&mut self) -> Result<(), EnvError> {
+        match self.get_current_char() {
+            None => Err(EnvError::EnvMissingClosingQuote(
+                self.get_parser().get_peek_position(),
+                '\'',
+            )),
+            Some(NEW_LINE) => {
+                self.skip_one()?;
+                Ok(())
+            }
+            Some(SINGLE_QUOTES | BACKSLASH) => {
+                self.take_one()?;
+                Ok(())
+            }
+            Some(c) if REPLACEMENTS.iter().any(|&x| x.0 == c) => {
+                // See GNU test-suite e11: In single quotes, \t remains as it is.
+                // Comparing with GNU behavior: \a is not accepted and issues an error.
+                // So apparently only known sequences are allowed, even though they are not expanded.... bug of GNU?
+                self.push_char_to_word(BACKSLASH);
+                self.take_one()?;
+                Ok(())
+            }
+            Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+        }
+    }
+
+    fn state_double_quoted(&mut self) -> Result<(), EnvError> {
+        loop {
+            match self.get_current_char() {
+                None => {
+                    return Err(EnvError::EnvMissingClosingQuote(
+                        self.get_parser().get_peek_position(),
+                        '"',
+                    ));
+                }
+                Some(DOLLAR) => {
+                    self.substitute_variable()?;
+                }
+                Some(DOUBLE_QUOTES) => {
+                    self.skip_one()?;
+                    return Ok(());
+                }
+                Some(BACKSLASH) => {
+                    self.skip_one()?;
+                    self.state_double_quoted_backslash()?;
+                }
+                Some(_) => {
+                    self.take_one()?;
+                }
+            }
+        }
+    }
+
+    fn state_double_quoted_backslash(&mut self) -> Result<(), EnvError> {
+        match self.get_current_char() {
+            None => Err(EnvError::EnvMissingClosingQuote(
+                self.get_parser().get_peek_position(),
+                '"',
+            )),
+            Some(NEW_LINE) => {
+                self.skip_one()?;
+                Ok(())
+            }
+            Some(DOUBLE_QUOTES | DOLLAR | BACKSLASH) => {
+                self.take_one()?;
+                Ok(())
+            }
+            Some('c') => Err(EnvError::EnvBackslashCNotAllowedInDoubleQuotes(
+                self.get_parser().get_peek_position(),
+            )),
+            Some(c) if self.check_and_replace_ascii_escape_code(c)? => Ok(()),
+            Some(c) => Err(self.make_invalid_sequence_backslash_xin_minus_s(c)),
+        }
+    }
+
+    fn state_comment(&mut self) -> Result<(), EnvError> {
+        loop {
+            match self.get_current_char() {
+                None => return Err(EnvError::EnvReachedEnd),
+                Some(NEW_LINE) => {
+                    self.skip_one()?;
+                    return Ok(());
+                }
+                Some(_) => {
+                    self.get_parser_mut().skip_until_char_or_end(NEW_LINE);
+                }
+            }
+        }
+    }
+
+    pub fn split(mut self) -> Result<Vec<NativeIntString>, EnvError> {
+        self.state_root()?;
+        Ok(self.words)
+    }
+}
+
+pub fn split(s: &NativeIntStr) -> Result<Vec<NativeIntString>, EnvError> {
+    let split_args = SplitIterator::new(s).split()?;
+    Ok(split_args)
+}
diff --git a/src/uu/env/src/string_expander.rs b/src/uu/env/src/string_expander.rs
new file mode 100644
index 00000000000..48f98e1fe6f
--- /dev/null
+++ b/src/uu/env/src/string_expander.rs
@@ -0,0 +1,91 @@
+// 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.
+
+use std::{
+    ffi::{OsStr, OsString},
+    mem,
+};
+
+use crate::{
+    native_int_str::{NativeCharInt, NativeIntStr, to_native_int_representation},
+    string_parser::{Chunk, Error, StringParser},
+};
+
+/// This class makes parsing and word collection more convenient.
+///
+/// It manages an "output" buffer that is automatically filled.
+/// It provides "skip_one" and "take_one" that focus on
+/// working with ASCII separators. Thus they will skip or take
+/// all consecutive non-ascii char sequences at once.
+pub struct StringExpander<'a> {
+    parser: StringParser<'a>,
+    output: Vec<NativeCharInt>,
+}
+
+impl<'a> StringExpander<'a> {
+    pub fn new(input: &'a NativeIntStr) -> Self {
+        Self {
+            parser: StringParser::new(input),
+            output: Vec::default(),
+        }
+    }
+
+    pub fn new_at(input: &'a NativeIntStr, pos: usize) -> Self {
+        Self {
+            parser: StringParser::new_at(input, pos),
+            output: Vec::default(),
+        }
+    }
+
+    pub fn get_parser(&self) -> &StringParser<'a> {
+        &self.parser
+    }
+
+    pub fn get_parser_mut(&mut self) -> &mut StringParser<'a> {
+        &mut self.parser
+    }
+
+    pub fn peek(&self) -> Result<char, Error> {
+        self.parser.peek()
+    }
+
+    pub fn skip_one(&mut self) -> Result<(), Error> {
+        self.get_parser_mut().consume_one_ascii_or_all_non_ascii()?;
+        Ok(())
+    }
+
+    pub fn get_peek_position(&self) -> usize {
+        self.get_parser().get_peek_position()
+    }
+
+    pub fn take_one(&mut self) -> Result<(), Error> {
+        let chunks = self.parser.consume_one_ascii_or_all_non_ascii()?;
+        for chunk in chunks {
+            match chunk {
+                Chunk::InvalidEncoding(invalid) => self.output.extend(invalid),
+                Chunk::ValidSingleIntChar((_c, ni)) => self.output.push(ni),
+            }
+        }
+        Ok(())
+    }
+
+    pub fn put_one_char(&mut self, c: char) {
+        let os_str = OsString::from(c.to_string());
+        self.put_string(os_str);
+    }
+
+    pub fn put_string<S: AsRef<OsStr>>(&mut self, os_str: S) {
+        let native = to_native_int_representation(os_str.as_ref());
+        self.output.extend(&*native);
+    }
+
+    pub fn put_native_string(&mut self, n_str: &NativeIntStr) {
+        self.output.extend(n_str);
+    }
+
+    pub fn take_collected_output(&mut self) -> Vec<NativeCharInt> {
+        mem::take(&mut self.output)
+    }
+}
diff --git a/src/uu/env/src/string_parser.rs b/src/uu/env/src/string_parser.rs
new file mode 100644
index 00000000000..84eb346fa4c
--- /dev/null
+++ b/src/uu/env/src/string_parser.rs
@@ -0,0 +1,181 @@
+// 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.
+//
+// spell-checker:ignore (words) FFFD
+#![forbid(unsafe_code)]
+
+use std::{borrow::Cow, ffi::OsStr};
+
+use crate::native_int_str::{
+    NativeCharInt, NativeIntStr, from_native_int_representation, get_char_from_native_int,
+    get_single_native_int_value,
+};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    pub peek_position: usize,
+    pub err_type: ErrorType,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ErrorType {
+    EndOfInput,
+    InternalError,
+}
+
+/// Provides a valid char or a invalid sequence of bytes.
+///
+/// Invalid byte sequences can't be split in any meaningful way.
+/// Thus, they need to be consumed as one piece.
+pub enum Chunk<'a> {
+    InvalidEncoding(&'a NativeIntStr),
+    ValidSingleIntChar((char, NativeCharInt)),
+}
+
+/// This class makes parsing a OsString char by char more convenient.
+///
+/// It also allows to capturing of intermediate positions for later splitting.
+pub struct StringParser<'a> {
+    input: &'a NativeIntStr,
+    pointer: usize,
+    remaining: &'a NativeIntStr,
+}
+
+impl<'a> StringParser<'a> {
+    pub fn new(input: &'a NativeIntStr) -> Self {
+        let mut instance = Self {
+            input,
+            pointer: 0,
+            remaining: input,
+        };
+        instance.set_pointer(0);
+        instance
+    }
+
+    pub fn new_at(input: &'a NativeIntStr, pos: usize) -> Self {
+        let mut instance = Self::new(input);
+        instance.set_pointer(pos);
+        instance
+    }
+
+    pub fn get_input(&self) -> &'a NativeIntStr {
+        self.input
+    }
+
+    pub fn get_peek_position(&self) -> usize {
+        self.pointer
+    }
+
+    pub fn peek(&self) -> Result<char, Error> {
+        self.peek_char_at_pointer(self.pointer)
+    }
+
+    fn make_err(&self, err_type: ErrorType) -> Error {
+        Error {
+            peek_position: self.get_peek_position(),
+            err_type,
+        }
+    }
+
+    pub fn peek_char_at_pointer(&self, at_pointer: usize) -> Result<char, Error> {
+        let split = self.input.split_at(at_pointer).1;
+        if split.is_empty() {
+            return Err(self.make_err(ErrorType::EndOfInput));
+        }
+        if let Some((c, _ni)) = get_char_from_native_int(split[0]) {
+            Ok(c)
+        } else {
+            Ok('\u{FFFD}')
+        }
+    }
+
+    fn get_chunk_with_length_at(&self, pointer: usize) -> Result<(Chunk<'a>, usize), Error> {
+        let (_before, after) = self.input.split_at(pointer);
+        if after.is_empty() {
+            return Err(self.make_err(ErrorType::EndOfInput));
+        }
+
+        if let Some(c_ni) = get_char_from_native_int(after[0]) {
+            Ok((Chunk::ValidSingleIntChar(c_ni), 1))
+        } else {
+            let mut i = 1;
+            while i < after.len() {
+                if let Some(_c) = get_char_from_native_int(after[i]) {
+                    break;
+                }
+                i += 1;
+            }
+
+            let chunk = &after[0..i];
+            Ok((Chunk::InvalidEncoding(chunk), chunk.len()))
+        }
+    }
+
+    pub fn peek_chunk(&self) -> Option<Chunk<'a>> {
+        self.get_chunk_with_length_at(self.pointer)
+            .ok()
+            .map(|(chunk, _)| chunk)
+    }
+
+    pub fn consume_chunk(&mut self) -> Result<Chunk<'a>, Error> {
+        let (chunk, len) = self.get_chunk_with_length_at(self.pointer)?;
+        self.set_pointer(self.pointer + len);
+        Ok(chunk)
+    }
+
+    pub fn consume_one_ascii_or_all_non_ascii(&mut self) -> Result<Vec<Chunk<'a>>, Error> {
+        let mut result = Vec::<Chunk<'a>>::new();
+        loop {
+            let data = self.consume_chunk()?;
+            let was_ascii = if let Chunk::ValidSingleIntChar((c, _ni)) = &data {
+                c.is_ascii()
+            } else {
+                false
+            };
+            result.push(data);
+            if was_ascii {
+                return Ok(result);
+            }
+
+            match self.peek_chunk() {
+                Some(Chunk::ValidSingleIntChar((c, _ni))) if c.is_ascii() => return Ok(result),
+                None => return Ok(result),
+                _ => {}
+            }
+        }
+    }
+
+    pub fn skip_multiple(&mut self, skip_byte_count: usize) {
+        let end_ptr = self.pointer + skip_byte_count;
+        self.set_pointer(end_ptr);
+    }
+
+    pub fn skip_until_char_or_end(&mut self, c: char) {
+        let native_rep = get_single_native_int_value(&c).unwrap();
+        let pos = self.remaining.iter().position(|x| *x == native_rep);
+
+        if let Some(pos) = pos {
+            self.set_pointer(self.pointer + pos);
+        } else {
+            self.set_pointer(self.input.len());
+        }
+    }
+
+    pub fn substring(&self, range: &std::ops::Range<usize>) -> &'a NativeIntStr {
+        let (_before1, after1) = self.input.split_at(range.start);
+        let (middle, _after2) = after1.split_at(range.end - range.start);
+        middle
+    }
+
+    pub fn peek_remaining(&self) -> Cow<'a, OsStr> {
+        from_native_int_representation(Cow::Borrowed(self.remaining))
+    }
+
+    pub fn set_pointer(&mut self, new_pointer: usize) {
+        self.pointer = new_pointer;
+        let (_before, after) = self.input.split_at(self.pointer);
+        self.remaining = after;
+    }
+}
diff --git a/src/uu/env/src/variable_parser.rs b/src/uu/env/src/variable_parser.rs
new file mode 100644
index 00000000000..2555c709f43
--- /dev/null
+++ b/src/uu/env/src/variable_parser.rs
@@ -0,0 +1,159 @@
+// 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.
+
+use std::ops::Range;
+
+use crate::EnvError;
+use crate::{native_int_str::NativeIntStr, string_parser::StringParser};
+
+pub struct VariableParser<'a, 'b> {
+    pub parser: &'b mut StringParser<'a>,
+}
+
+impl<'a> VariableParser<'a, '_> {
+    fn get_current_char(&self) -> Option<char> {
+        self.parser.peek().ok()
+    }
+
+    fn check_variable_name_start(&self) -> Result<(), EnvError> {
+        if let Some(c) = self.get_current_char() {
+            if c.is_ascii_digit() {
+                return Err(EnvError::EnvParsingOfVariableUnexpectedNumber(
+                    self.parser.get_peek_position(),
+                    c.to_string(),
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    fn skip_one(&mut self) -> Result<(), EnvError> {
+        self.parser.consume_chunk()?;
+        Ok(())
+    }
+
+    fn parse_braced_variable_name(
+        &mut self,
+    ) -> Result<(&'a NativeIntStr, Option<&'a NativeIntStr>), EnvError> {
+        let pos_start = self.parser.get_peek_position();
+
+        self.check_variable_name_start()?;
+
+        let (varname_end, default_end);
+        loop {
+            match self.get_current_char() {
+                None => {
+                    return Err(EnvError::EnvParsingOfVariableMissingClosingBrace(
+                        self.parser.get_peek_position(),
+                    ));
+                }
+                Some(c) if !c.is_ascii() || c.is_ascii_alphanumeric() || c == '_' => {
+                    self.skip_one()?;
+                }
+                Some(':') => {
+                    varname_end = self.parser.get_peek_position();
+                    loop {
+                        match self.get_current_char() {
+                            None => {
+                                return Err(
+                                    EnvError::EnvParsingOfVariableMissingClosingBraceAfterValue(
+                                        self.parser.get_peek_position(),
+                                    ),
+                                );
+                            }
+                            Some('}') => {
+                                default_end = Some(self.parser.get_peek_position());
+                                self.skip_one()?;
+                                break;
+                            }
+                            Some(_) => {
+                                self.skip_one()?;
+                            }
+                        }
+                    }
+                    break;
+                }
+                Some('}') => {
+                    varname_end = self.parser.get_peek_position();
+                    default_end = None;
+                    self.skip_one()?;
+                    break;
+                }
+                Some(c) => {
+                    return Err(EnvError::EnvParsingOfVariableExceptedBraceOrColon(
+                        self.parser.get_peek_position(),
+                        c.to_string(),
+                    ));
+                }
+            };
+        }
+
+        let default_opt = if let Some(default_end) = default_end {
+            Some(self.parser.substring(&Range {
+                start: varname_end + 1,
+                end: default_end,
+            }))
+        } else {
+            None
+        };
+
+        let varname = self.parser.substring(&Range {
+            start: pos_start,
+            end: varname_end,
+        });
+
+        Ok((varname, default_opt))
+    }
+
+    fn parse_unbraced_variable_name(&mut self) -> Result<&'a NativeIntStr, EnvError> {
+        let pos_start = self.parser.get_peek_position();
+
+        self.check_variable_name_start()?;
+
+        loop {
+            match self.get_current_char() {
+                None => break,
+                Some(c) if c.is_ascii_alphanumeric() || c == '_' => {
+                    self.skip_one()?;
+                }
+                Some(_) => break,
+            };
+        }
+
+        let pos_end = self.parser.get_peek_position();
+
+        if pos_end == pos_start {
+            return Err(EnvError::EnvParsingOfMissingVariable(pos_start));
+        }
+
+        let varname = self.parser.substring(&Range {
+            start: pos_start,
+            end: pos_end,
+        });
+
+        Ok(varname)
+    }
+
+    pub fn parse_variable(
+        &mut self,
+    ) -> Result<(&'a NativeIntStr, Option<&'a NativeIntStr>), EnvError> {
+        self.skip_one()?;
+
+        let (name, default) = match self.get_current_char() {
+            None => {
+                return Err(EnvError::EnvParsingOfMissingVariable(
+                    self.parser.get_peek_position(),
+                ));
+            }
+            Some('{') => {
+                self.skip_one()?;
+                self.parse_braced_variable_name()?
+            }
+            Some(_) => (self.parse_unbraced_variable_name()?, None),
+        };
+
+        Ok((name, default))
+    }
+}
diff --git a/src/uu/expand/Cargo.toml b/src/uu/expand/Cargo.toml
index 58647d8e9d5..cd96b0278f7 100644
--- a/src/uu/expand/Cargo.toml
+++ b/src/uu/expand/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_expand"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "expand ~ (uutils) convert input tabs to spaces"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/expand"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/expand.rs"
@@ -18,6 +21,7 @@ path = "src/expand.rs"
 clap = { workspace = true }
 unicode-width = { workspace = true }
 uucore = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "expand"
diff --git a/src/uu/expand/src/expand.rs b/src/uu/expand/src/expand.rs
index 9294d1a8fa1..4c37393b4ac 100644
--- a/src/uu/expand/src/expand.rs
+++ b/src/uu/expand/src/expand.rs
@@ -5,17 +5,18 @@
 
 // spell-checker:ignore (ToDO) ctype cwidth iflag nbytes nspaces nums tspaces uflag Preprocess
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
-use std::error::Error;
-use std::fmt;
+use clap::{Arg, ArgAction, ArgMatches, Command};
+use std::ffi::OsString;
 use std::fs::File;
-use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
+use std::io::{BufRead, BufReader, BufWriter, Read, Write, stdin, stdout};
 use std::num::IntErrorKind;
+use std::path::Path;
 use std::str::from_utf8;
+use thiserror::Error;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, format_usage, help_about, help_usage};
+use uucore::error::{FromIo, UError, UResult, set_exit_code};
+use uucore::{format_usage, help_about, help_usage, show_error};
 
 const ABOUT: &str = help_about!("expand.md");
 const USAGE: &str = help_usage!("expand.md");
@@ -59,43 +60,24 @@ fn is_digit_or_comma(c: char) -> bool {
 }
 
 /// Errors that can occur when parsing a `--tabs` argument.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum ParseError {
+    #[error("tab size contains invalid character(s): {}", .0.quote())]
     InvalidCharacter(String),
+    #[error("{} specifier not at start of number: {}", .0.quote(), .1.quote())]
     SpecifierNotAtStartOfNumber(String, String),
+    #[error("{} specifier only allowed with the last value", .0.quote())]
     SpecifierOnlyAllowedWithLastValue(String),
+    #[error("tab size cannot be 0")]
     TabSizeCannotBeZero,
+    #[error("tab stop is too large {}", .0.quote())]
     TabSizeTooLarge(String),
+    #[error("tab sizes must be ascending")]
     TabSizesMustBeAscending,
 }
 
-impl Error for ParseError {}
 impl UError for ParseError {}
 
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::InvalidCharacter(s) => {
-                write!(f, "tab size contains invalid character(s): {}", s.quote())
-            }
-            Self::SpecifierNotAtStartOfNumber(specifier, s) => write!(
-                f,
-                "{} specifier not at start of number: {}",
-                specifier.quote(),
-                s.quote(),
-            ),
-            Self::SpecifierOnlyAllowedWithLastValue(specifier) => write!(
-                f,
-                "{} specifier only allowed with the last value",
-                specifier.quote()
-            ),
-            Self::TabSizeCannotBeZero => write!(f, "tab size cannot be 0"),
-            Self::TabSizeTooLarge(s) => write!(f, "tab stop is too large {}", s.quote()),
-            Self::TabSizesMustBeAscending => write!(f, "tab sizes must be ascending"),
-        }
-    }
-}
-
 /// Parse a list of tabstops from a `--tabs` argument.
 ///
 /// This function returns both the vector of numbers appearing in the
@@ -163,14 +145,14 @@ fn tabstops_parse(s: &str) -> Result<(RemainingMode, Vec<usize>), ParseError> {
                             }
 
                             let s = s.trim_start_matches(char::is_numeric);
-                            if s.starts_with('/') || s.starts_with('+') {
-                                return Err(ParseError::SpecifierNotAtStartOfNumber(
+                            return if s.starts_with('/') || s.starts_with('+') {
+                                Err(ParseError::SpecifierNotAtStartOfNumber(
                                     s[0..1].to_string(),
                                     s.to_string(),
-                                ));
+                                ))
                             } else {
-                                return Err(ParseError::InvalidCharacter(s.to_string()));
-                            }
+                                Err(ParseError::InvalidCharacter(s.to_string()))
+                            };
                         }
                     }
                 }
@@ -242,18 +224,20 @@ impl Options {
 
 /// Preprocess command line arguments and expand shortcuts. For example, "-7" is expanded to
 /// "--tabs=7" and "-1,3" to "--tabs=1 --tabs=3".
-fn expand_shortcuts(args: &[String]) -> Vec<String> {
+fn expand_shortcuts(args: Vec<OsString>) -> Vec<OsString> {
     let mut processed_args = Vec::with_capacity(args.len());
 
     for arg in args {
-        if arg.starts_with('-') && arg[1..].chars().all(is_digit_or_comma) {
-            arg[1..]
-                .split(',')
-                .filter(|s| !s.is_empty())
-                .for_each(|s| processed_args.push(format!("--tabs={s}")));
-        } else {
-            processed_args.push(arg.to_string());
+        if let Some(arg) = arg.to_str() {
+            if arg.starts_with('-') && arg[1..].chars().all(is_digit_or_comma) {
+                arg[1..]
+                    .split(',')
+                    .filter(|s| !s.is_empty())
+                    .for_each(|s| processed_args.push(OsString::from(format!("--tabs={s}"))));
+                continue;
+            }
         }
+        processed_args.push(arg);
     }
 
     processed_args
@@ -261,20 +245,19 @@ fn expand_shortcuts(args: &[String]) -> Vec<String> {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app().try_get_matches_from(expand_shortcuts(&args))?;
+    let matches = uu_app().try_get_matches_from(expand_shortcuts(args.collect()))?;
 
-    expand(&Options::new(&matches)?).map_err_context(|| "failed to write output".to_string())
+    expand(&Options::new(&matches)?)
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::INITIAL)
                 .long(options::INITIAL)
@@ -308,16 +291,13 @@ pub fn uu_app() -> Command {
         )
 }
 
-fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
     let file_buf;
     if path == "-" {
-        BufReader::new(Box::new(stdin()) as Box<dyn Read>)
+        Ok(BufReader::new(Box::new(stdin()) as Box<dyn Read>))
     } else {
-        file_buf = match File::open(path) {
-            Ok(a) => a,
-            Err(e) => crash!(1, "{}: {}\n", path.maybe_quote(), e),
-        };
-        BufReader::new(Box::new(file_buf) as Box<dyn Read>)
+        file_buf = File::open(path).map_err_context(|| path.to_string())?;
+        Ok(BufReader::new(Box::new(file_buf) as Box<dyn Read>))
     }
 }
 
@@ -370,99 +350,123 @@ enum CharType {
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn expand(options: &Options) -> std::io::Result<()> {
-    use self::CharType::*;
-
-    let mut output = BufWriter::new(stdout());
-    let ts = options.tabstops.as_ref();
-    let mut buf = Vec::new();
-
-    for file in &options.files {
-        let mut fh = open(file);
-
-        while match fh.read_until(b'\n', &mut buf) {
-            Ok(s) => s > 0,
-            Err(_) => buf.is_empty(),
-        } {
-            let mut col = 0;
-            let mut byte = 0;
-            let mut init = true;
-
-            while byte < buf.len() {
-                let (ctype, cwidth, nbytes) = if options.uflag {
-                    let nbytes = char::from(buf[byte]).len_utf8();
-
-                    if byte + nbytes > buf.len() {
-                        // don't overrun buffer because of invalid UTF-8
+fn expand_line(
+    buf: &mut Vec<u8>,
+    output: &mut BufWriter<std::io::Stdout>,
+    tabstops: &[usize],
+    options: &Options,
+) -> std::io::Result<()> {
+    use self::CharType::{Backspace, Other, Tab};
+
+    let mut col = 0;
+    let mut byte = 0;
+    let mut init = true;
+
+    while byte < buf.len() {
+        let (ctype, cwidth, nbytes) = if options.uflag {
+            let nbytes = char::from(buf[byte]).len_utf8();
+
+            if byte + nbytes > buf.len() {
+                // don't overrun buffer because of invalid UTF-8
+                (Other, 1, 1)
+            } else if let Ok(t) = from_utf8(&buf[byte..byte + nbytes]) {
+                match t.chars().next() {
+                    Some('\t') => (Tab, 0, nbytes),
+                    Some('\x08') => (Backspace, 0, nbytes),
+                    Some(c) => (Other, UnicodeWidthChar::width(c).unwrap_or(0), nbytes),
+                    None => {
+                        // no valid char at start of t, so take 1 byte
                         (Other, 1, 1)
-                    } else if let Ok(t) = from_utf8(&buf[byte..byte + nbytes]) {
-                        match t.chars().next() {
-                            Some('\t') => (Tab, 0, nbytes),
-                            Some('\x08') => (Backspace, 0, nbytes),
-                            Some(c) => (Other, UnicodeWidthChar::width(c).unwrap_or(0), nbytes),
-                            None => {
-                                // no valid char at start of t, so take 1 byte
-                                (Other, 1, 1)
-                            }
-                        }
-                    } else {
-                        (Other, 1, 1) // implicit assumption: non-UTF-8 char is 1 col wide
                     }
+                }
+            } else {
+                (Other, 1, 1) // implicit assumption: non-UTF-8 char is 1 col wide
+            }
+        } else {
+            (
+                match buf[byte] {
+                    // always take exactly 1 byte in strict ASCII mode
+                    0x09 => Tab,
+                    0x08 => Backspace,
+                    _ => Other,
+                },
+                1,
+                1,
+            )
+        };
+
+        // figure out how many columns this char takes up
+        match ctype {
+            Tab => {
+                // figure out how many spaces to the next tabstop
+                let nts = next_tabstop(tabstops, col, &options.remaining_mode);
+                col += nts;
+
+                // now dump out either spaces if we're expanding, or a literal tab if we're not
+                if init || !options.iflag {
+                    if nts <= options.tspaces.len() {
+                        output.write_all(&options.tspaces.as_bytes()[..nts])?;
+                    } else {
+                        output.write_all(" ".repeat(nts).as_bytes())?;
+                    };
                 } else {
-                    (
-                        match buf[byte] {
-                            // always take exactly 1 byte in strict ASCII mode
-                            0x09 => Tab,
-                            0x08 => Backspace,
-                            _ => Other,
-                        },
-                        1,
-                        1,
-                    )
+                    output.write_all(&buf[byte..byte + nbytes])?;
+                }
+            }
+            _ => {
+                col = if ctype == Other {
+                    col + cwidth
+                } else if col > 0 {
+                    col - 1
+                } else {
+                    0
                 };
 
-                // figure out how many columns this char takes up
-                match ctype {
-                    Tab => {
-                        // figure out how many spaces to the next tabstop
-                        let nts = next_tabstop(ts, col, &options.remaining_mode);
-                        col += nts;
-
-                        // now dump out either spaces if we're expanding, or a literal tab if we're not
-                        if init || !options.iflag {
-                            if nts <= options.tspaces.len() {
-                                output.write_all(options.tspaces[..nts].as_bytes())?;
-                            } else {
-                                output.write_all(" ".repeat(nts).as_bytes())?;
-                            };
-                        } else {
-                            output.write_all(&buf[byte..byte + nbytes])?;
-                        }
-                    }
-                    _ => {
-                        col = if ctype == Other {
-                            col + cwidth
-                        } else if col > 0 {
-                            col - 1
-                        } else {
-                            0
-                        };
-
-                        // if we're writing anything other than a space, then we're
-                        // done with the line's leading spaces
-                        if buf[byte] != 0x20 {
-                            init = false;
-                        }
-
-                        output.write_all(&buf[byte..byte + nbytes])?;
-                    }
+                // if we're writing anything other than a space, then we're
+                // done with the line's leading spaces
+                if buf[byte] != 0x20 {
+                    init = false;
                 }
 
-                byte += nbytes; // advance the pointer
+                output.write_all(&buf[byte..byte + nbytes])?;
             }
+        }
+
+        byte += nbytes; // advance the pointer
+    }
+
+    output.flush()?;
+    buf.truncate(0); // clear the buffer
 
-            output.flush()?;
-            buf.truncate(0); // clear the buffer
+    Ok(())
+}
+
+fn expand(options: &Options) -> UResult<()> {
+    let mut output = BufWriter::new(stdout());
+    let ts = options.tabstops.as_ref();
+    let mut buf = Vec::new();
+
+    for file in &options.files {
+        if Path::new(file).is_dir() {
+            show_error!("{file}: Is a directory");
+            set_exit_code(1);
+            continue;
+        }
+        match open(file) {
+            Ok(mut fh) => {
+                while match fh.read_until(b'\n', &mut buf) {
+                    Ok(s) => s > 0,
+                    Err(_) => buf.is_empty(),
+                } {
+                    expand_line(&mut buf, &mut output, ts, options)
+                        .map_err_context(|| "failed to write output".to_string())?;
+                }
+            }
+            Err(e) => {
+                show_error!("{e}");
+                set_exit_code(1);
+                continue;
+            }
         }
     }
     Ok(())
@@ -472,8 +476,8 @@ fn expand(options: &Options) -> std::io::Result<()> {
 mod tests {
     use crate::is_digit_or_comma;
 
-    use super::next_tabstop;
     use super::RemainingMode;
+    use super::next_tabstop;
 
     #[test]
     fn test_next_tabstop_remaining_mode_none() {
diff --git a/src/uu/expr/Cargo.toml b/src/uu/expr/Cargo.toml
index ae31c66901a..00e3e3cab03 100644
--- a/src/uu/expr/Cargo.toml
+++ b/src/uu/expr/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_expr"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "expr ~ (uutils) display the value of EXPRESSION"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/expr"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/expr.rs"
@@ -20,6 +23,7 @@ num-bigint = { workspace = true }
 num-traits = { workspace = true }
 onig = { workspace = true }
 uucore = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "expr"
diff --git a/src/uu/expr/src/expr.rs b/src/uu/expr/src/expr.rs
index ea559090c92..6a4f9487bb0 100644
--- a/src/uu/expr/src/expr.rs
+++ b/src/uu/expr/src/expr.rs
@@ -3,14 +3,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, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
+use syntax_tree::{AstNode, is_truthy};
+use thiserror::Error;
 use uucore::{
-    error::{UResult, USimpleError},
+    display::Quotable,
+    error::{UError, UResult},
     format_usage, help_about, help_section, help_usage,
 };
 
 mod syntax_tree;
-mod tokens;
 
 mod options {
     pub const VERSION: &str = "version";
@@ -18,9 +20,53 @@ mod options {
     pub const EXPRESSION: &str = "expression";
 }
 
+pub type ExprResult<T> = Result<T, ExprError>;
+
+#[derive(Error, Clone, Debug, PartialEq, Eq)]
+pub enum ExprError {
+    #[error("syntax error: unexpected argument {}", .0.quote())]
+    UnexpectedArgument(String),
+    #[error("syntax error: missing argument after {}", .0.quote())]
+    MissingArgument(String),
+    #[error("non-integer argument")]
+    NonIntegerArgument,
+    #[error("missing operand")]
+    MissingOperand,
+    #[error("division by zero")]
+    DivisionByZero,
+    #[error("Invalid regex expression")]
+    InvalidRegexExpression,
+    #[error("syntax error: expecting ')' after {}", .0.quote())]
+    ExpectedClosingBraceAfter(String),
+    #[error("syntax error: expecting ')' instead of {}", .0.quote())]
+    ExpectedClosingBraceInsteadOf(String),
+    #[error("Unmatched ( or \\(")]
+    UnmatchedOpeningParenthesis,
+    #[error("Unmatched ) or \\)")]
+    UnmatchedClosingParenthesis,
+    #[error("Unmatched \\{{")]
+    UnmatchedOpeningBrace,
+    #[error("Invalid content of \\{{\\}}")]
+    InvalidBracketContent,
+    #[error("Trailing backslash")]
+    TrailingBackslash,
+    #[error("Regular expression too big")]
+    TooBigRangeQuantifierIndex,
+}
+
+impl UError for ExprError {
+    fn code(&self) -> i32 {
+        2
+    }
+
+    fn usage(&self) -> bool {
+        *self == Self::MissingOperand
+    }
+}
+
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(help_about!("expr.md"))
         .override_usage(format_usage(help_usage!("expr.md")))
         .after_help(help_section!("after help", "expr.md"))
@@ -48,37 +94,31 @@ pub fn uu_app() -> Command {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     // For expr utility we do not want getopts.
     // The following usage should work without escaping hyphens: `expr -15 = 1 +  2 \* \( 3 - -4 \)`
-    let matches = uu_app().try_get_matches_from(args)?;
-    let token_strings = matches
-        .get_many::<String>(options::EXPRESSION)
-        .map(|v| v.into_iter().map(|s| s.as_ref()).collect::<Vec<_>>())
-        .unwrap_or_default();
-
-    match process_expr(&token_strings[..]) {
-        Ok(expr_result) => print_expr_ok(&expr_result),
-        Err(expr_error) => Err(USimpleError::new(2, &expr_error)),
-    }
-}
+    let args: Vec<String> = args
+        .skip(1) // Skip binary name
+        .map(|a| a.to_string_lossy().to_string())
+        .collect();
 
-fn process_expr(token_strings: &[&str]) -> Result<String, String> {
-    let maybe_tokens = tokens::strings_to_tokens(token_strings);
-    let maybe_ast = syntax_tree::tokens_to_ast(maybe_tokens);
-    evaluate_ast(maybe_ast)
-}
-
-fn print_expr_ok(expr_result: &str) -> UResult<()> {
-    println!("{expr_result}");
-    if expr_result.parse::<i32>() == Ok(0) || expr_result.is_empty() {
-        Err(1.into())
+    if args.len() == 1 && args[0] == "--help" {
+        let _ = uu_app().print_help();
+    } else if args.len() == 1 && args[0] == "--version" {
+        println!("{} {}", uucore::util_name(), uucore::crate_version!());
     } else {
-        Ok(())
+        // The first argument may be "--" and should be be ignored.
+        let args = if !args.is_empty() && args[0] == "--" {
+            &args[1..]
+        } else {
+            &args
+        };
+
+        let res: String = AstNode::parse(args)?.eval()?.eval_as_string();
+        println!("{res}");
+        if !is_truthy(&res.into()) {
+            return Err(1.into());
+        }
     }
-}
 
-fn evaluate_ast(maybe_ast: Result<Box<syntax_tree::AstNode>, String>) -> Result<String, String> {
-    maybe_ast.and_then(|ast| ast.evaluate())
+    Ok(())
 }
diff --git a/src/uu/expr/src/syntax_tree.rs b/src/uu/expr/src/syntax_tree.rs
index 0e0795bd4fb..0950020c955 100644
--- a/src/uu/expr/src/syntax_tree.rs
+++ b/src/uu/expr/src/syntax_tree.rs
@@ -3,519 +3,1021 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-//!
-//! Here we employ shunting-yard algorithm for building AST from tokens according to operators' precedence and associative-ness.
-//! * `<https://en.wikipedia.org/wiki/Shunting-yard_algorithm>`
-//!
+// spell-checker:ignore (ToDO) ints paren prec multibytes
 
-// spell-checker:ignore (ToDO) binop binops ints paren prec multibytes
+use std::{cell::Cell, collections::BTreeMap};
 
-use num_bigint::BigInt;
-use num_traits::{One, Zero};
+use num_bigint::{BigInt, ParseBigIntError};
+use num_traits::ToPrimitive;
 use onig::{Regex, RegexOptions, Syntax};
 
-use crate::tokens::Token;
+use crate::{ExprError, ExprResult};
 
-type TokenStack = Vec<(usize, Token)>;
-pub type OperandsList = Vec<Box<AstNode>>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Relation(RelationOp),
+    Numeric(NumericOp),
+    String(StringOp),
+}
 
-#[derive(Debug)]
-pub enum AstNode {
-    Leaf {
-        token_idx: usize,
-        value: String,
-    },
-    Node {
-        token_idx: usize,
-        op_type: String,
-        operands: OperandsList,
-    },
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RelationOp {
+    Lt,
+    Leq,
+    Eq,
+    Neq,
+    Gt,
+    Geq,
 }
-impl AstNode {
-    fn debug_dump(&self) {
-        self.debug_dump_impl(1);
-    }
-    fn debug_dump_impl(&self, depth: usize) {
-        for _ in 0..depth {
-            print!("\t",);
-        }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NumericOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum StringOp {
+    Match,
+    Index,
+    And,
+    Or,
+}
+
+impl BinOp {
+    fn eval(
+        &self,
+        left: ExprResult<NumOrStr>,
+        right: ExprResult<NumOrStr>,
+    ) -> ExprResult<NumOrStr> {
         match self {
-            Self::Leaf { token_idx, value } => println!(
-                "Leaf( {} ) at #{} ( evaluate -> {:?} )",
-                value,
-                token_idx,
-                self.evaluate()
-            ),
-            Self::Node {
-                token_idx,
-                op_type,
-                operands,
-            } => {
-                println!(
-                    "Node( {} ) at #{} (evaluate -> {:?})",
-                    op_type,
-                    token_idx,
-                    self.evaluate()
-                );
-                for operand in operands {
-                    operand.debug_dump_impl(depth + 1);
-                }
-            }
+            Self::Relation(op) => op.eval(left, right),
+            Self::Numeric(op) => op.eval(left, right),
+            Self::String(op) => op.eval(left, right),
         }
     }
+}
 
-    fn new_node(token_idx: usize, op_type: &str, operands: OperandsList) -> Box<Self> {
-        Box::new(Self::Node {
-            token_idx,
-            op_type: op_type.into(),
-            operands,
-        })
+impl RelationOp {
+    fn eval(&self, a: ExprResult<NumOrStr>, b: ExprResult<NumOrStr>) -> ExprResult<NumOrStr> {
+        let a = a?;
+        let b = b?;
+        let b = if let (Ok(a), Ok(b)) = (&a.to_bigint(), &b.to_bigint()) {
+            match self {
+                Self::Lt => a < b,
+                Self::Leq => a <= b,
+                Self::Eq => a == b,
+                Self::Neq => a != b,
+                Self::Gt => a > b,
+                Self::Geq => a >= b,
+            }
+        } else {
+            // These comparisons should be using locale settings
+            let a = a.eval_as_string();
+            let b = b.eval_as_string();
+            match self {
+                Self::Lt => a < b,
+                Self::Leq => a <= b,
+                Self::Eq => a == b,
+                Self::Neq => a != b,
+                Self::Gt => a > b,
+                Self::Geq => a >= b,
+            }
+        };
+        if b { Ok(1.into()) } else { Ok(0.into()) }
     }
-    fn new_leaf(token_idx: usize, value: &str) -> Box<Self> {
-        Box::new(Self::Leaf {
-            token_idx,
-            value: value.into(),
-        })
+}
+
+impl NumericOp {
+    fn eval(
+        &self,
+        left: ExprResult<NumOrStr>,
+        right: ExprResult<NumOrStr>,
+    ) -> ExprResult<NumOrStr> {
+        let a = left?.eval_as_bigint()?;
+        let b = right?.eval_as_bigint()?;
+        Ok(NumOrStr::Num(match self {
+            Self::Add => a + b,
+            Self::Sub => a - b,
+            Self::Mul => a * b,
+            Self::Div => match a.checked_div(&b) {
+                Some(x) => x,
+                None => return Err(ExprError::DivisionByZero),
+            },
+            Self::Mod => {
+                if a.checked_div(&b).is_none() {
+                    return Err(ExprError::DivisionByZero);
+                };
+                a % b
+            }
+        }))
     }
-    pub fn evaluate(&self) -> Result<String, String> {
+}
+
+impl StringOp {
+    fn eval(
+        &self,
+        left: ExprResult<NumOrStr>,
+        right: ExprResult<NumOrStr>,
+    ) -> ExprResult<NumOrStr> {
         match self {
-            Self::Leaf { value, .. } => Ok(value.clone()),
-            Self::Node { op_type, .. } => match self.operand_values() {
-                Err(reason) => Err(reason),
-                Ok(operand_values) => match op_type.as_ref() {
-                    "+" => {
-                        infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a + b), &operand_values)
-                    }
-                    "-" => {
-                        infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a - b), &operand_values)
-                    }
-                    "*" => {
-                        infix_operator_two_ints(|a: BigInt, b: BigInt| Ok(a * b), &operand_values)
-                    }
-                    "/" => infix_operator_two_ints(
-                        |a: BigInt, b: BigInt| {
-                            if b.is_zero() {
-                                Err("division by zero".to_owned())
-                            } else {
-                                Ok(a / b)
-                            }
-                        },
-                        &operand_values,
-                    ),
-                    "%" => infix_operator_two_ints(
-                        |a: BigInt, b: BigInt| {
-                            if b.is_zero() {
-                                Err("division by zero".to_owned())
+            Self::Or => {
+                let left = left?;
+                if is_truthy(&left) {
+                    return Ok(left);
+                }
+                let right = right?;
+                if is_truthy(&right) {
+                    return Ok(right);
+                }
+                Ok(0.into())
+            }
+            Self::And => {
+                let left = left?;
+                if !is_truthy(&left) {
+                    return Ok(0.into());
+                }
+                let right = right?;
+                if !is_truthy(&right) {
+                    return Ok(0.into());
+                }
+                Ok(left)
+            }
+            Self::Match => {
+                let left = left?.eval_as_string();
+                let right = right?.eval_as_string();
+                check_posix_regex_errors(&right)?;
+
+                // Transpile the input pattern from BRE syntax to `onig` crate's `Syntax::grep`
+                let mut re_string = String::with_capacity(right.len() + 1);
+                let mut pattern_chars = right.chars().peekable();
+                let mut prev = '\0';
+                let mut prev_is_escaped = false;
+                let mut is_start_of_expression = true;
+
+                // All patterns are anchored so they begin with a caret (^)
+                if pattern_chars.peek() != Some(&'^') {
+                    re_string.push('^');
+                }
+
+                while let Some(curr) = pattern_chars.next() {
+                    let curr_is_escaped = prev == '\\' && !prev_is_escaped;
+                    let is_first_character = prev == '\0';
+
+                    match curr {
+                        // Character class negation "[^a]"
+                        // Explicitly escaped caret "\^"
+                        '^' if !is_start_of_expression && !matches!(prev, '[' | '\\') => {
+                            re_string.push_str(r"\^");
+                        }
+                        '$' if !curr_is_escaped && !is_end_of_expression(&pattern_chars) => {
+                            re_string.push_str(r"\$");
+                        }
+                        '\\' if !curr_is_escaped && pattern_chars.peek().is_none() => {
+                            return Err(ExprError::TrailingBackslash);
+                        }
+                        '{' if curr_is_escaped => {
+                            // Handle '{' literally at the start of an expression
+                            if is_start_of_expression {
+                                if re_string.ends_with('\\') {
+                                    let _ = re_string.pop();
+                                }
+                                re_string.push(curr);
                             } else {
-                                Ok(a % b)
+                                // Check if the following section is a valid range quantifier
+                                verify_range_quantifier(&pattern_chars)?;
+
+                                re_string.push(curr);
+                                // Set the lower bound of range quantifier to 0 if it is missing
+                                if pattern_chars.peek() == Some(&',') {
+                                    re_string.push('0');
+                                }
                             }
-                        },
-                        &operand_values,
-                    ),
-                    "=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a == b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a == b)),
-                        &operand_values,
-                    ),
-                    "!=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a != b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a != b)),
-                        &operand_values,
-                    ),
-                    "<" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a < b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a < b)),
-                        &operand_values,
-                    ),
-                    ">" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a > b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a > b)),
-                        &operand_values,
-                    ),
-                    "<=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a <= b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a <= b)),
-                        &operand_values,
-                    ),
-                    ">=" => infix_operator_two_ints_or_two_strings(
-                        |a: BigInt, b: BigInt| Ok(bool_as_int(a >= b)),
-                        |a: &String, b: &String| Ok(bool_as_string(a >= b)),
-                        &operand_values,
-                    ),
-                    "|" => Ok(infix_operator_or(&operand_values)),
-                    "&" => Ok(infix_operator_and(&operand_values)),
-                    ":" | "match" => operator_match(&operand_values),
-                    "length" => Ok(prefix_operator_length(&operand_values)),
-                    "index" => Ok(prefix_operator_index(&operand_values)),
-                    "substr" => Ok(prefix_operator_substr(&operand_values)),
-
-                    _ => Err(format!("operation not implemented: {op_type}")),
-                },
-            },
-        }
-    }
-    pub fn operand_values(&self) -> Result<Vec<String>, String> {
-        if let Self::Node { operands, .. } = self {
-            let mut out = Vec::with_capacity(operands.len());
-            for operand in operands {
-                let value = operand.evaluate()?;
-                out.push(value);
+                        }
+                        _ => re_string.push(curr),
+                    }
+
+                    // Capturing group "\(abc\)"
+                    // Alternative pattern "a\|b"
+                    is_start_of_expression = curr == '\\' && is_first_character
+                        || curr_is_escaped && matches!(curr, '(' | '|')
+                        || curr == '\\' && prev_is_escaped && matches!(prev, '(' | '|');
+
+                    prev_is_escaped = curr_is_escaped;
+                    prev = curr;
+                }
+
+                let re = Regex::with_options(
+                    &re_string,
+                    RegexOptions::REGEX_OPTION_SINGLELINE,
+                    Syntax::grep(),
+                )
+                .map_err(|error| match error.code() {
+                    // "invalid repeat range {lower,upper}"
+                    -123 => ExprError::InvalidBracketContent,
+                    // "too big number for repeat range"
+                    -201 => ExprError::TooBigRangeQuantifierIndex,
+                    _ => ExprError::InvalidRegexExpression,
+                })?;
+
+                Ok(if re.captures_len() > 0 {
+                    re.captures(&left)
+                        .and_then(|captures| captures.at(1))
+                        .unwrap_or("")
+                        .to_string()
+                } else {
+                    re.find(&left)
+                        .map_or("0".to_string(), |(start, end)| (end - start).to_string())
+                }
+                .into())
+            }
+            Self::Index => {
+                let left = left?.eval_as_string();
+                let right = right?.eval_as_string();
+                for (current_idx, ch_h) in left.chars().enumerate() {
+                    for ch_n in right.to_string().chars() {
+                        if ch_n == ch_h {
+                            return Ok((current_idx + 1).into());
+                        }
+                    }
+                }
+                Ok(0.into())
             }
-            Ok(out)
-        } else {
-            panic!("Invoked .operand_values(&self) not with ASTNode::Node")
         }
     }
 }
 
-pub fn tokens_to_ast(
-    maybe_tokens: Result<Vec<(usize, Token)>, String>,
-) -> Result<Box<AstNode>, String> {
-    maybe_tokens.and_then(|tokens| {
-        let mut out_stack: TokenStack = Vec::new();
-        let mut op_stack: TokenStack = Vec::new();
+/// Check if regex pattern character iterator is at the end of a regex expression or subexpression
+fn is_end_of_expression<I>(pattern_chars: &I) -> bool
+where
+    I: Iterator<Item = char> + Clone,
+{
+    let mut pattern_chars_clone = pattern_chars.clone();
+    match pattern_chars_clone.next() {
+        Some('\\') => matches!(pattern_chars_clone.next(), Some(')' | '|')),
+        None => true, // No characters left
+        _ => false,
+    }
+}
+
+/// Check if regex pattern character iterator is at the start of a valid range quantifier.
+/// The iterator's start position is expected to be after the opening brace.
+/// Range quantifier ends to closing brace.
+///
+/// # Examples of valid range quantifiers
+///
+/// - `r"\{3\}"`
+/// - `r"\{3,\}"`
+/// - `r"\{,6\}"`
+/// - `r"\{3,6\}"`
+/// - `r"\{,\}"`
+fn verify_range_quantifier<I>(pattern_chars: &I) -> Result<(), ExprError>
+where
+    I: Iterator<Item = char> + Clone,
+{
+    let mut pattern_chars_clone = pattern_chars.clone().peekable();
+    if pattern_chars_clone.peek().is_none() {
+        return Err(ExprError::UnmatchedOpeningBrace);
+    }
 
-        for (token_idx, token) in tokens {
-            push_token_to_either_stack(token_idx, &token, &mut out_stack, &mut op_stack)?;
+    // Parse the string between braces
+    let mut quantifier = String::new();
+    let mut prev = '\0';
+    let mut curr_is_escaped = false;
+    while let Some(curr) = pattern_chars_clone.next() {
+        curr_is_escaped = prev == '\\' && !curr_is_escaped;
+        if curr_is_escaped && curr == '}' {
+            break;
         }
-        move_rest_of_ops_to_out(&mut out_stack, &mut op_stack)?;
-        assert!(op_stack.is_empty());
-
-        maybe_dump_rpn(&out_stack);
-        let result = ast_from_rpn(&mut out_stack);
-        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(),
-            )
+        if pattern_chars_clone.peek().is_none() {
+            return Err(ExprError::UnmatchedOpeningBrace);
         }
-    })
-}
+        if prev != '\0' {
+            quantifier.push(prev);
+        }
+        prev = curr;
+    }
 
-fn maybe_dump_ast(result: &Result<Box<AstNode>, String>) {
-    use std::env;
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_AST") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_AST");
-            match result {
-                Ok(ast) => ast.debug_dump(),
-                Err(reason) => println!("\terr: {reason:?}"),
-            }
+    // Check if parsed quantifier is valid
+    let re = Regex::new(r"^([0-9]*,[0-9]*|[0-9]+)$").expect("valid regular expression");
+    if let Some(captures) = re.captures(&quantifier) {
+        let matched = captures.at(0).unwrap_or_default();
+        match matched.split_once(',') {
+            Some(("", "")) => Ok(()),
+            Some((x, "") | ("", x)) if x.parse::<i16>().is_ok() => Ok(()),
+            Some((_, "") | ("", _)) => Err(ExprError::TooBigRangeQuantifierIndex),
+            Some((f, l)) => match (f.parse::<i16>(), l.parse::<i16>()) {
+                (Ok(f), Ok(l)) if f > l => Err(ExprError::InvalidBracketContent),
+                (Ok(_), Ok(_)) => Ok(()),
+                _ => Err(ExprError::TooBigRangeQuantifierIndex),
+            },
+            None if matched.parse::<i16>().is_ok() => Ok(()),
+            None => Err(ExprError::TooBigRangeQuantifierIndex),
         }
+    } else {
+        Err(ExprError::InvalidBracketContent)
     }
 }
 
-#[allow(clippy::ptr_arg)]
-fn maybe_dump_rpn(rpn: &TokenStack) {
-    use std::env;
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_RPN") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_RPN");
-            for token in rpn {
-                println!("\t{token:?}");
+/// Check for errors in a supplied regular expression
+///
+/// GNU coreutils shows messages for invalid regular expressions
+/// differently from the oniguruma library used by the regex crate.
+/// This method attempts to do these checks manually in one pass
+/// through the regular expression.
+///
+/// This method is not comprehensively checking all cases in which
+/// a regular expression could be invalid; any cases not caught will
+/// result in a [ExprError::InvalidRegexExpression] when passing the
+/// regular expression through the Oniguruma bindings. This method is
+/// intended to just identify a few situations for which GNU coreutils
+/// has specific error messages.
+fn check_posix_regex_errors(pattern: &str) -> ExprResult<()> {
+    let mut escaped_parens: u64 = 0;
+    let mut prev = '\0';
+    let mut curr_is_escaped = false;
+
+    for curr in pattern.chars() {
+        curr_is_escaped = prev == '\\' && !curr_is_escaped;
+        match (curr_is_escaped, curr) {
+            (true, '(') => escaped_parens += 1,
+            (true, ')') => {
+                escaped_parens = escaped_parens
+                    .checked_sub(1)
+                    .ok_or(ExprError::UnmatchedClosingParenthesis)?;
             }
+            _ => {}
         }
+        prev = curr;
+    }
+
+    match escaped_parens {
+        0 => Ok(()),
+        _ => Err(ExprError::UnmatchedOpeningParenthesis),
     }
 }
 
-fn ast_from_rpn(rpn: &mut TokenStack) -> Result<Box<AstNode>, String> {
-    match rpn.pop() {
-        None => Err("syntax error (premature end of expression)".to_owned()),
+/// Precedence for infix binary operators
+const PRECEDENCE: &[&[(&str, BinOp)]] = &[
+    &[("|", BinOp::String(StringOp::Or))],
+    &[("&", BinOp::String(StringOp::And))],
+    &[
+        ("<", BinOp::Relation(RelationOp::Lt)),
+        ("<=", BinOp::Relation(RelationOp::Leq)),
+        ("=", BinOp::Relation(RelationOp::Eq)),
+        ("!=", BinOp::Relation(RelationOp::Neq)),
+        (">=", BinOp::Relation(RelationOp::Geq)),
+        (">", BinOp::Relation(RelationOp::Gt)),
+    ],
+    &[
+        ("+", BinOp::Numeric(NumericOp::Add)),
+        ("-", BinOp::Numeric(NumericOp::Sub)),
+    ],
+    &[
+        ("*", BinOp::Numeric(NumericOp::Mul)),
+        ("/", BinOp::Numeric(NumericOp::Div)),
+        ("%", BinOp::Numeric(NumericOp::Mod)),
+    ],
+    &[(":", BinOp::String(StringOp::Match))],
+];
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NumOrStr {
+    Num(BigInt),
+    Str(String),
+}
 
-        Some((token_idx, Token::Value { value })) => Ok(AstNode::new_leaf(token_idx, &value)),
+impl From<usize> for NumOrStr {
+    fn from(num: usize) -> Self {
+        Self::Num(BigInt::from(num))
+    }
+}
+
+impl From<BigInt> for NumOrStr {
+    fn from(num: BigInt) -> Self {
+        Self::Num(num)
+    }
+}
+
+impl From<String> for NumOrStr {
+    fn from(str: String) -> Self {
+        Self::Str(str)
+    }
+}
 
-        Some((token_idx, Token::InfixOp { value, .. })) => {
-            maybe_ast_node(token_idx, &value, 2, rpn)
+impl NumOrStr {
+    pub fn to_bigint(&self) -> Result<BigInt, ParseBigIntError> {
+        match self {
+            Self::Num(num) => Ok(num.clone()),
+            Self::Str(str) => str.parse::<BigInt>(),
         }
+    }
 
-        Some((token_idx, Token::PrefixOp { value, arity })) => {
-            maybe_ast_node(token_idx, &value, arity, rpn)
+    pub fn eval_as_bigint(self) -> ExprResult<BigInt> {
+        match self {
+            Self::Num(num) => Ok(num),
+            Self::Str(str) => str
+                .parse::<BigInt>()
+                .map_err(|_| ExprError::NonIntegerArgument),
         }
+    }
 
-        Some((token_idx, unexpected_token)) => {
-            panic!("unexpected token at #{token_idx} {unexpected_token:?}")
+    pub fn eval_as_string(self) -> String {
+        match self {
+            Self::Num(num) => num.to_string(),
+            Self::Str(str) => str,
         }
     }
 }
-fn maybe_ast_node(
-    token_idx: usize,
-    op_type: &str,
-    arity: usize,
-    rpn: &mut TokenStack,
-) -> Result<Box<AstNode>, String> {
-    let mut operands = Vec::with_capacity(arity);
-    for _ in 0..arity {
-        let operand = ast_from_rpn(rpn)?;
-        operands.push(operand);
-    }
-    operands.reverse();
-    Ok(AstNode::new_node(token_idx, op_type, operands))
+
+#[derive(Debug, Clone)]
+pub struct AstNode {
+    id: u32,
+    inner: AstNodeInner,
 }
 
-fn move_rest_of_ops_to_out(
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    loop {
-        match op_stack.pop() {
-            None => return Ok(()),
-            Some((token_idx, Token::ParOpen)) => {
-                return Err(format!(
-                    "syntax error (Mismatched open-parenthesis at #{token_idx})"
-                ))
-            }
-            Some((token_idx, Token::ParClose)) => {
-                return Err(format!(
-                    "syntax error (Mismatched close-parenthesis at #{token_idx})"
-                ))
+// We derive Eq and PartialEq only for tests because we want to ignore the id field.
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(Eq, PartialEq))]
+pub enum AstNodeInner {
+    Evaluated {
+        value: NumOrStr,
+    },
+    Leaf {
+        value: String,
+    },
+    BinOp {
+        op_type: BinOp,
+        left: Box<AstNode>,
+        right: Box<AstNode>,
+    },
+    Substr {
+        string: Box<AstNode>,
+        pos: Box<AstNode>,
+        length: Box<AstNode>,
+    },
+    Length {
+        string: Box<AstNode>,
+    },
+}
+
+impl AstNode {
+    pub fn parse(input: &[impl AsRef<str>]) -> ExprResult<Self> {
+        Parser::new(input).parse()
+    }
+
+    pub fn evaluated(self) -> ExprResult<Self> {
+        Ok(Self {
+            id: get_next_id(),
+            inner: AstNodeInner::Evaluated {
+                value: self.eval()?,
+            },
+        })
+    }
+
+    pub fn eval(&self) -> ExprResult<NumOrStr> {
+        // This function implements a recursive tree-walking algorithm, but uses an explicit
+        // stack approach instead of native recursion to avoid potential stack overflow
+        // on deeply nested expressions.
+
+        let mut stack = vec![self];
+        let mut result_stack = BTreeMap::new();
+
+        while let Some(node) = stack.pop() {
+            match &node.inner {
+                AstNodeInner::Evaluated { value, .. } => {
+                    result_stack.insert(node.id, Ok(value.clone()));
+                }
+                AstNodeInner::Leaf { value, .. } => {
+                    result_stack.insert(node.id, Ok(value.to_string().into()));
+                }
+                AstNodeInner::BinOp {
+                    op_type,
+                    left,
+                    right,
+                } => {
+                    let (Some(right), Some(left)) = (
+                        result_stack.remove(&right.id),
+                        result_stack.remove(&left.id),
+                    ) else {
+                        stack.push(node);
+                        stack.push(right);
+                        stack.push(left);
+                        continue;
+                    };
+
+                    let result = op_type.eval(left, right);
+                    result_stack.insert(node.id, result);
+                }
+                AstNodeInner::Substr {
+                    string,
+                    pos,
+                    length,
+                } => {
+                    let (Some(string), Some(pos), Some(length)) = (
+                        result_stack.remove(&string.id),
+                        result_stack.remove(&pos.id),
+                        result_stack.remove(&length.id),
+                    ) else {
+                        stack.push(node);
+                        stack.push(string);
+                        stack.push(pos);
+                        stack.push(length);
+                        continue;
+                    };
+
+                    let string: String = string?.eval_as_string();
+
+                    // The GNU docs say:
+                    //
+                    // > If either position or length is negative, zero, or
+                    // > non-numeric, returns the null string.
+                    //
+                    // So we coerce errors into 0 to make that the only case we
+                    // have to care about.
+                    let pos = pos?
+                        .eval_as_bigint()
+                        .ok()
+                        .and_then(|n| n.to_usize())
+                        .unwrap_or(0);
+                    let length = length?
+                        .eval_as_bigint()
+                        .ok()
+                        .and_then(|n| n.to_usize())
+                        .unwrap_or(0);
+
+                    if let (Some(pos), Some(_)) = (pos.checked_sub(1), length.checked_sub(1)) {
+                        let result = string.chars().skip(pos).take(length).collect::<String>();
+                        result_stack.insert(node.id, Ok(result.into()));
+                    } else {
+                        result_stack.insert(node.id, Ok(String::new().into()));
+                    }
+                }
+                AstNodeInner::Length { string } => {
+                    // Push onto the stack
+
+                    let Some(string) = result_stack.remove(&string.id) else {
+                        stack.push(node);
+                        stack.push(string);
+                        continue;
+                    };
+
+                    let length = string?.eval_as_string().chars().count();
+                    result_stack.insert(node.id, Ok(length.into()));
+                }
             }
-            Some(other) => out_stack.push(other),
         }
+
+        // The final result should be the only one left on the result stack
+        result_stack.remove(&self.id).unwrap()
     }
 }
 
-fn push_token_to_either_stack(
-    token_idx: usize,
-    token: &Token,
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    let result = match token {
-        Token::Value { .. } => {
-            out_stack.push((token_idx, token.clone()));
-            Ok(())
+thread_local! {
+    static NODE_ID: Cell<u32> = const { Cell::new(1) };
+}
+
+// We create unique identifiers for each node in the AST.
+// This is used to transform the recursive algorithm into an iterative one.
+// It is used to store the result of each node's evaluation in a BtreeMap.
+fn get_next_id() -> u32 {
+    NODE_ID.with(|id| {
+        let current = id.get();
+        id.set(current + 1);
+        current
+    })
+}
+
+struct Parser<'a, S: AsRef<str>> {
+    input: &'a [S],
+    index: usize,
+}
+
+impl<'a, S: AsRef<str>> Parser<'a, S> {
+    fn new(input: &'a [S]) -> Self {
+        Self { input, index: 0 }
+    }
+
+    fn next(&mut self) -> ExprResult<&'a str> {
+        let next = self.input.get(self.index);
+        if let Some(next) = next {
+            self.index += 1;
+            Ok(next.as_ref())
+        } else {
+            // The indexing won't panic, because we know that the input size
+            // is greater than zero.
+            Err(ExprError::MissingArgument(
+                self.input[self.index - 1].as_ref().into(),
+            ))
+        }
+    }
+
+    fn accept<T>(&mut self, f: impl Fn(&str) -> Option<T>) -> Option<T> {
+        let next = self.input.get(self.index)?;
+        let tok = f(next.as_ref());
+        if let Some(tok) = tok {
+            self.index += 1;
+            Some(tok)
+        } else {
+            None
+        }
+    }
+
+    fn parse(&mut self) -> ExprResult<AstNode> {
+        if self.input.is_empty() {
+            return Err(ExprError::MissingOperand);
         }
+        let res = self.parse_expression()?;
+        if let Some(arg) = self.input.get(self.index) {
+            return Err(ExprError::UnexpectedArgument(arg.as_ref().into()));
+        }
+        Ok(res)
+    }
+
+    fn parse_expression(&mut self) -> ExprResult<AstNode> {
+        self.parse_precedence(0)
+    }
 
-        Token::InfixOp { .. } => {
-            if op_stack.is_empty() {
-                op_stack.push((token_idx, token.clone()));
-                Ok(())
-            } else {
-                push_op_to_stack(token_idx, token, out_stack, op_stack)
+    fn parse_op(&mut self, precedence: usize) -> Option<BinOp> {
+        self.accept(|s| {
+            for (op_string, op) in PRECEDENCE[precedence] {
+                if s == *op_string {
+                    return Some(*op);
+                }
             }
+            None
+        })
+    }
+
+    fn parse_precedence(&mut self, precedence: usize) -> ExprResult<AstNode> {
+        if precedence >= PRECEDENCE.len() {
+            return self.parse_simple_expression();
         }
 
-        Token::PrefixOp { .. } | Token::ParOpen => {
-            op_stack.push((token_idx, token.clone()));
-            Ok(())
+        let mut left = self.parse_precedence(precedence + 1)?;
+        while let Some(op) = self.parse_op(precedence) {
+            let right = self.parse_precedence(precedence + 1)?;
+            left = AstNode {
+                id: get_next_id(),
+                inner: AstNodeInner::BinOp {
+                    op_type: op,
+                    left: Box::new(left),
+                    right: Box::new(right),
+                },
+            };
         }
+        Ok(left)
+    }
 
-        Token::ParClose => move_till_match_paren(out_stack, op_stack),
-    };
-    maybe_dump_shunting_yard_step(token_idx, token, out_stack, op_stack, &result);
-    result
+    fn parse_simple_expression(&mut self) -> ExprResult<AstNode> {
+        let first = self.next()?;
+        let inner = match first {
+            "match" => {
+                let left = self.parse_expression()?;
+                let right = self.parse_expression()?;
+                AstNodeInner::BinOp {
+                    op_type: BinOp::String(StringOp::Match),
+                    left: Box::new(left),
+                    right: Box::new(right),
+                }
+            }
+            "substr" => {
+                let string = self.parse_expression()?;
+                let pos = self.parse_expression()?;
+                let length = self.parse_expression()?;
+                AstNodeInner::Substr {
+                    string: Box::new(string),
+                    pos: Box::new(pos),
+                    length: Box::new(length),
+                }
+            }
+            "index" => {
+                let left = self.parse_expression()?;
+                let right = self.parse_expression()?;
+                AstNodeInner::BinOp {
+                    op_type: BinOp::String(StringOp::Index),
+                    left: Box::new(left),
+                    right: Box::new(right),
+                }
+            }
+            "length" => {
+                let string = self.parse_expression()?;
+                AstNodeInner::Length {
+                    string: Box::new(string),
+                }
+            }
+            "+" => AstNodeInner::Leaf {
+                value: self.next()?.into(),
+            },
+            "(" => {
+                // Evaluate the node just after parsing to we detect arithmetic
+                // errors before checking for the closing parenthesis.
+                let s = self.parse_expression()?.evaluated()?;
+
+                match self.next() {
+                    Ok(")") => {}
+                    // Since we have parsed at least a '(', there will be a token
+                    // at `self.index - 1`. So this indexing won't panic.
+                    Ok(_) => {
+                        return Err(ExprError::ExpectedClosingBraceInsteadOf(
+                            self.input[self.index - 1].as_ref().into(),
+                        ));
+                    }
+                    Err(ExprError::MissingArgument(_)) => {
+                        return Err(ExprError::ExpectedClosingBraceAfter(
+                            self.input[self.index - 1].as_ref().into(),
+                        ));
+                    }
+                    Err(e) => return Err(e),
+                }
+                s.inner
+            }
+            s => AstNodeInner::Leaf { value: s.into() },
+        };
+        Ok(AstNode {
+            id: get_next_id(),
+            inner,
+        })
+    }
 }
 
-#[allow(clippy::ptr_arg)]
-fn maybe_dump_shunting_yard_step(
-    token_idx: usize,
-    token: &Token,
-    out_stack: &TokenStack,
-    op_stack: &TokenStack,
-    result: &Result<(), String>,
-) {
-    use std::env;
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_SYA_STEP") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_SYA_STEP");
-            println!("\t{token_idx} => {token:?}");
-            println!("\t\tout: {out_stack:?}");
-            println!("\t\top : {op_stack:?}");
-            println!("\t\tresult: {result:?}");
+/// Determine whether `expr` should evaluate the string as "truthy"
+///
+/// Truthy strings are either empty or match the regex "-?0+".
+pub fn is_truthy(s: &NumOrStr) -> bool {
+    match s {
+        NumOrStr::Num(num) => num != &BigInt::from(0),
+        NumOrStr::Str(str) => {
+            // Edge case: `-` followed by nothing is truthy
+            if str == "-" {
+                return true;
+            }
+
+            let mut bytes = str.bytes();
+
+            // Empty string is falsy
+            let Some(first) = bytes.next() else {
+                return false;
+            };
+
+            let is_zero = (first == b'-' || first == b'0') && bytes.all(|b| b == b'0');
+            !is_zero
         }
     }
 }
 
-fn push_op_to_stack(
-    token_idx: usize,
-    token: &Token,
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    if let Token::InfixOp {
-        precedence: prec,
-        left_assoc: la,
-        ..
-    } = *token
-    {
-        loop {
-            match op_stack.last() {
-                None | Some(&(_, Token::ParOpen)) => {
-                    op_stack.push((token_idx, token.clone()));
-                    return Ok(());
-                }
+#[cfg(test)]
+mod test {
+    use crate::ExprError;
+    use crate::syntax_tree::verify_range_quantifier;
 
-                Some(&(
-                    _,
-                    Token::InfixOp {
-                        precedence: prev_prec,
-                        ..
-                    },
-                )) => {
-                    if la && prev_prec >= prec || !la && prev_prec > prec {
-                        out_stack.push(op_stack.pop().unwrap());
-                    } else {
-                        op_stack.push((token_idx, token.clone()));
-                        return Ok(());
-                    }
-                }
+    use super::{
+        AstNode, AstNodeInner, BinOp, NumericOp, RelationOp, StringOp, check_posix_regex_errors,
+        get_next_id,
+    };
 
-                Some(&(_, Token::PrefixOp { .. })) => {
-                    op_stack.push((token_idx, token.clone()));
-                    return Ok(());
-                }
+    impl PartialEq for AstNode {
+        fn eq(&self, other: &Self) -> bool {
+            self.inner == other.inner
+        }
+    }
 
-                Some(_) => panic!("Non-operator on op_stack"),
+    impl Eq for AstNode {}
+
+    impl From<&str> for AstNode {
+        fn from(value: &str) -> Self {
+            Self {
+                id: get_next_id(),
+                inner: AstNodeInner::Leaf {
+                    value: value.into(),
+                },
             }
         }
-    } else {
-        panic!("Expected infix-op")
     }
-}
 
-fn move_till_match_paren(
-    out_stack: &mut TokenStack,
-    op_stack: &mut TokenStack,
-) -> Result<(), String> {
-    loop {
-        let op = op_stack
-            .pop()
-            .ok_or_else(|| "syntax error (Mismatched close-parenthesis)".to_string())?;
-        match op {
-            (_, Token::ParOpen) => return Ok(()),
-            other => out_stack.push(other),
+    fn op(op_type: BinOp, left: impl Into<AstNode>, right: impl Into<AstNode>) -> AstNode {
+        AstNode {
+            id: get_next_id(),
+            inner: AstNodeInner::BinOp {
+                op_type,
+                left: Box::new(left.into()),
+                right: Box::new(right.into()),
+            },
         }
     }
-}
 
-fn infix_operator_two_ints<F>(f: F, values: &[String]) -> Result<String, String>
-where
-    F: Fn(BigInt, BigInt) -> Result<BigInt, String>,
-{
-    assert!(values.len() == 2);
-    if let Ok(left) = values[0].parse::<BigInt>() {
-        if let Ok(right) = values[1].parse::<BigInt>() {
-            return f(left, right).map(|big_int| big_int.to_string());
+    fn length(string: impl Into<AstNode>) -> AstNode {
+        AstNode {
+            id: get_next_id(),
+            inner: AstNodeInner::Length {
+                string: Box::new(string.into()),
+            },
         }
     }
-    Err("Expected an integer operand".to_string())
-}
 
-fn infix_operator_two_ints_or_two_strings<FI, FS>(
-    fi: FI,
-    fs: FS,
-    values: &[String],
-) -> Result<String, String>
-where
-    FI: Fn(BigInt, BigInt) -> Result<u8, String>,
-    FS: Fn(&String, &String) -> Result<String, String>,
-{
-    assert!(values.len() == 2);
-    if let (Some(a_int), Some(b_int)) = (
-        values[0].parse::<BigInt>().ok(),
-        values[1].parse::<BigInt>().ok(),
-    ) {
-        match fi(a_int, b_int) {
-            Ok(result) => Ok(result.to_string()),
-            Err(reason) => Err(reason),
+    fn substr(
+        string: impl Into<AstNode>,
+        pos: impl Into<AstNode>,
+        length: impl Into<AstNode>,
+    ) -> AstNode {
+        AstNode {
+            id: get_next_id(),
+            inner: AstNodeInner::Substr {
+                string: Box::new(string.into()),
+                pos: Box::new(pos.into()),
+                length: Box::new(length.into()),
+            },
         }
-    } else {
-        fs(&values[0], &values[1])
     }
-}
 
-fn infix_operator_or(values: &[String]) -> String {
-    assert!(values.len() == 2);
-    if value_as_bool(&values[0]) {
-        values[0].clone()
-    } else {
-        values[1].clone()
+    #[test]
+    fn infix_operators() {
+        let cases = [
+            ("|", BinOp::String(StringOp::Or)),
+            ("&", BinOp::String(StringOp::And)),
+            ("<", BinOp::Relation(RelationOp::Lt)),
+            ("<=", BinOp::Relation(RelationOp::Leq)),
+            ("=", BinOp::Relation(RelationOp::Eq)),
+            ("!=", BinOp::Relation(RelationOp::Neq)),
+            (">=", BinOp::Relation(RelationOp::Geq)),
+            (">", BinOp::Relation(RelationOp::Gt)),
+            ("+", BinOp::Numeric(NumericOp::Add)),
+            ("-", BinOp::Numeric(NumericOp::Sub)),
+            ("*", BinOp::Numeric(NumericOp::Mul)),
+            ("/", BinOp::Numeric(NumericOp::Div)),
+            ("%", BinOp::Numeric(NumericOp::Mod)),
+            (":", BinOp::String(StringOp::Match)),
+        ];
+        for (string, value) in cases {
+            assert_eq!(AstNode::parse(&["1", string, "2"]), Ok(op(value, "1", "2")));
+        }
     }
-}
 
-fn infix_operator_and(values: &[String]) -> String {
-    if value_as_bool(&values[0]) && value_as_bool(&values[1]) {
-        values[0].clone()
-    } else {
-        0.to_string()
+    #[test]
+    fn other_operators() {
+        assert_eq!(
+            AstNode::parse(&["match", "1", "2"]),
+            Ok(op(BinOp::String(StringOp::Match), "1", "2")),
+        );
+        assert_eq!(
+            AstNode::parse(&["index", "1", "2"]),
+            Ok(op(BinOp::String(StringOp::Index), "1", "2")),
+        );
+        assert_eq!(AstNode::parse(&["length", "1"]), Ok(length("1")));
+        assert_eq!(
+            AstNode::parse(&["substr", "1", "2", "3"]),
+            Ok(substr("1", "2", "3")),
+        );
     }
-}
 
-fn operator_match(values: &[String]) -> Result<String, String> {
-    assert!(values.len() == 2);
-    let re = Regex::with_options(&values[1], RegexOptions::REGEX_OPTION_NONE, Syntax::grep())
-        .map_err(|err| err.description().to_string())?;
-    Ok(if re.captures_len() > 0 {
-        re.captures(&values[0])
-            .map(|captures| captures.at(1).unwrap())
-            .unwrap_or("")
-            .to_string()
-    } else {
-        re.find(&values[0])
-            .map_or("0".to_string(), |(start, end)| (end - start).to_string())
-    })
-}
+    #[test]
+    fn precedence() {
+        assert_eq!(
+            AstNode::parse(&["1", "+", "2", "*", "3"]),
+            Ok(op(
+                BinOp::Numeric(NumericOp::Add),
+                "1",
+                op(BinOp::Numeric(NumericOp::Mul), "2", "3")
+            ))
+        );
+        assert_eq!(
+            AstNode::parse(&["(", "1", "+", "2", ")", "*", "3"]),
+            Ok(op(
+                BinOp::Numeric(NumericOp::Mul),
+                op(BinOp::Numeric(NumericOp::Add), "1", "2")
+                    .evaluated()
+                    .unwrap(),
+                "3"
+            ))
+        );
+        assert_eq!(
+            AstNode::parse(&["1", "*", "2", "+", "3"]),
+            Ok(op(
+                BinOp::Numeric(NumericOp::Add),
+                op(BinOp::Numeric(NumericOp::Mul), "1", "2"),
+                "3"
+            )),
+        );
+    }
 
-fn prefix_operator_length(values: &[String]) -> String {
-    assert!(values.len() == 1);
-    // Use chars().count() as we can have some multibytes chars
-    // See https://github.com/uutils/coreutils/issues/3132
-    values[0].chars().count().to_string()
-}
+    #[test]
+    fn missing_closing_parenthesis() {
+        assert_eq!(
+            AstNode::parse(&["(", "42"]),
+            Err(ExprError::ExpectedClosingBraceAfter("42".to_string()))
+        );
+        assert_eq!(
+            AstNode::parse(&["(", "42", "a"]),
+            Err(ExprError::ExpectedClosingBraceInsteadOf("a".to_string()))
+        );
+    }
 
-fn prefix_operator_index(values: &[String]) -> String {
-    assert!(values.len() == 2);
-    let haystack = &values[0];
-    let needles = &values[1];
+    #[test]
+    fn empty_substitution() {
+        // causes a panic in 0.0.25
+        let result = AstNode::parse(&["a", ":", r"\(b\)*"])
+            .unwrap()
+            .eval()
+            .unwrap();
+        assert_eq!(result.eval_as_string(), "");
+    }
 
-    for (current_idx, ch_h) in haystack.chars().enumerate() {
-        for ch_n in needles.chars() {
-            if ch_n == ch_h {
-                return (current_idx + 1).to_string();
-            }
-        }
+    #[test]
+    fn starting_stars_become_escaped() {
+        let result = AstNode::parse(&["cats", ":", r"*cats"])
+            .unwrap()
+            .eval()
+            .unwrap();
+        assert_eq!(result.eval_as_string(), "0");
+
+        let result = AstNode::parse(&["*cats", ":", r"*cats"])
+            .unwrap()
+            .eval()
+            .unwrap();
+        assert_eq!(result.eval_as_string(), "5");
     }
-    "0".to_string()
-}
 
-fn prefix_operator_substr(values: &[String]) -> String {
-    assert!(values.len() == 3);
-    let subj = &values[0];
-    let idx = match values[1]
-        .parse::<usize>()
-        .ok()
-        .and_then(|v| v.checked_sub(1))
-    {
-        Some(i) => i,
-        None => return String::new(),
-    };
-    let len = match values[2].parse::<usize>() {
-        Ok(i) => i,
-        Err(_) => return String::new(),
-    };
+    #[test]
+    fn only_match_in_beginning() {
+        let result = AstNode::parse(&["budget", ":", r"get"])
+            .unwrap()
+            .eval()
+            .unwrap();
+        assert_eq!(result.eval_as_string(), "0");
+    }
 
-    subj.chars().skip(idx).take(len).collect()
-}
+    #[test]
+    fn check_regex_valid() {
+        assert!(check_posix_regex_errors(r"(a+b) \(a* b\)").is_ok());
+    }
 
-fn bool_as_int(b: bool) -> u8 {
-    u8::from(b)
-}
-fn bool_as_string(b: bool) -> String {
-    if b {
-        "1".to_string()
-    } else {
-        "0".to_string()
+    #[test]
+    fn check_regex_simple_repeating_pattern() {
+        assert!(check_posix_regex_errors(r"\(a+b\)\{4\}").is_ok());
     }
-}
-fn value_as_bool(s: &str) -> bool {
-    if s.is_empty() {
-        return false;
+
+    #[test]
+    fn check_regex_missing_closing() {
+        assert_eq!(
+            check_posix_regex_errors(r"\(abc"),
+            Err(ExprError::UnmatchedOpeningParenthesis)
+        );
     }
-    match s.parse::<BigInt>() {
-        Ok(n) => n.is_one(),
-        Err(_) => true,
+
+    #[test]
+    fn check_regex_missing_opening() {
+        assert_eq!(
+            check_posix_regex_errors(r"abc\)"),
+            Err(ExprError::UnmatchedClosingParenthesis)
+        );
+    }
+
+    #[test]
+    fn test_is_valid_range_quantifier() {
+        assert!(verify_range_quantifier(&"3\\}".chars()).is_ok());
+        assert!(verify_range_quantifier(&"3,\\}".chars()).is_ok());
+        assert!(verify_range_quantifier(&",6\\}".chars()).is_ok());
+        assert!(verify_range_quantifier(&"3,6\\}".chars()).is_ok());
+        assert!(verify_range_quantifier(&",\\}".chars()).is_ok());
+        assert!(verify_range_quantifier(&"32767\\}anything".chars()).is_ok());
+        assert_eq!(
+            verify_range_quantifier(&"\\{3,6\\}".chars()),
+            Err(ExprError::InvalidBracketContent)
+        );
+        assert_eq!(
+            verify_range_quantifier(&"\\}".chars()),
+            Err(ExprError::InvalidBracketContent)
+        );
+        assert_eq!(
+            verify_range_quantifier(&"".chars()),
+            Err(ExprError::UnmatchedOpeningBrace)
+        );
+        assert_eq!(
+            verify_range_quantifier(&"3".chars()),
+            Err(ExprError::UnmatchedOpeningBrace)
+        );
+        assert_eq!(
+            verify_range_quantifier(&"3,".chars()),
+            Err(ExprError::UnmatchedOpeningBrace)
+        );
+        assert_eq!(
+            verify_range_quantifier(&",6".chars()),
+            Err(ExprError::UnmatchedOpeningBrace)
+        );
+        assert_eq!(
+            verify_range_quantifier(&"3,6".chars()),
+            Err(ExprError::UnmatchedOpeningBrace)
+        );
+        assert_eq!(
+            verify_range_quantifier(&",".chars()),
+            Err(ExprError::UnmatchedOpeningBrace)
+        );
+        assert_eq!(
+            verify_range_quantifier(&"32768\\}".chars()),
+            Err(ExprError::TooBigRangeQuantifierIndex)
+        );
     }
 }
diff --git a/src/uu/expr/src/tokens.rs b/src/uu/expr/src/tokens.rs
deleted file mode 100644
index b4e4c7da58d..00000000000
--- a/src/uu/expr/src/tokens.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-// 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.
-
-//!
-//! The following tokens are present in the expr grammar:
-//! * integer literal;
-//! * string literal;
-//! * infix binary operators;
-//! * prefix operators.
-//!
-//! According to the man-page of expr we have expression split into tokens (each token -- separate CLI-argument).
-//! Hence all we need is to map the strings into the Token structures, except for some ugly fiddling with +-escaping.
-//!
-
-// spell-checker:ignore (ToDO) paren
-
-use num_bigint::BigInt;
-
-#[derive(Debug, Clone)]
-pub enum Token {
-    Value {
-        value: String,
-    },
-
-    ParOpen,
-    ParClose,
-
-    InfixOp {
-        precedence: u8,
-        left_assoc: bool,
-        value: String,
-    },
-
-    PrefixOp {
-        arity: usize,
-        value: String,
-    },
-}
-impl Token {
-    fn new_infix_op(v: &str, left_assoc: bool, precedence: u8) -> Self {
-        Self::InfixOp {
-            left_assoc,
-            precedence,
-            value: v.into(),
-        }
-    }
-    fn new_value(v: &str) -> Self {
-        Self::Value { value: v.into() }
-    }
-
-    fn is_infix_plus(&self) -> bool {
-        match self {
-            Self::InfixOp { value, .. } => value == "+",
-            _ => false,
-        }
-    }
-    fn is_a_number(&self) -> bool {
-        match self {
-            Self::Value { value, .. } => value.parse::<BigInt>().is_ok(),
-            _ => false,
-        }
-    }
-    fn is_a_close_paren(&self) -> bool {
-        matches!(*self, Self::ParClose)
-    }
-}
-
-pub fn strings_to_tokens(strings: &[&str]) -> Result<Vec<(usize, Token)>, String> {
-    let mut tokens_acc = Vec::with_capacity(strings.len());
-    let mut tok_idx = 1;
-
-    for s in strings {
-        let token_if_not_escaped = match *s {
-            "(" => Token::ParOpen,
-            ")" => Token::ParClose,
-
-            "^" => Token::new_infix_op(s, false, 7),
-
-            ":" => Token::new_infix_op(s, true, 6),
-
-            "*" | "/" | "%" => Token::new_infix_op(s, true, 5),
-
-            "+" | "-" => Token::new_infix_op(s, true, 4),
-
-            "=" | "!=" | "<" | ">" | "<=" | ">=" => Token::new_infix_op(s, true, 3),
-
-            "&" => Token::new_infix_op(s, true, 2),
-
-            "|" => Token::new_infix_op(s, true, 1),
-
-            "match" | "index" => Token::PrefixOp {
-                arity: 2,
-                value: s.to_string(),
-            },
-            "substr" => Token::PrefixOp {
-                arity: 3,
-                value: s.to_string(),
-            },
-            "length" => Token::PrefixOp {
-                arity: 1,
-                value: s.to_string(),
-            },
-
-            _ => Token::new_value(s),
-        };
-        push_token_if_not_escaped(&mut tokens_acc, tok_idx, token_if_not_escaped, s);
-        tok_idx += 1;
-    }
-    maybe_dump_tokens_acc(&tokens_acc);
-
-    Ok(tokens_acc)
-}
-
-fn maybe_dump_tokens_acc(tokens_acc: &[(usize, Token)]) {
-    use std::env;
-
-    if let Ok(debug_var) = env::var("EXPR_DEBUG_TOKENS") {
-        if debug_var == "1" {
-            println!("EXPR_DEBUG_TOKENS");
-            for token in tokens_acc {
-                println!("\t{token:?}");
-            }
-        }
-    }
-}
-
-fn push_token_if_not_escaped(acc: &mut Vec<(usize, Token)>, tok_idx: usize, token: Token, s: &str) {
-    // Smells heuristics... :(
-    let prev_is_plus = match acc.last() {
-        None => false,
-        Some(t) => t.1.is_infix_plus(),
-    };
-    let should_use_as_escaped = if prev_is_plus && acc.len() >= 2 {
-        let pre_prev = &acc[acc.len() - 2];
-        !(pre_prev.1.is_a_number() || pre_prev.1.is_a_close_paren())
-    } else {
-        prev_is_plus
-    };
-
-    if should_use_as_escaped {
-        acc.pop();
-        acc.push((tok_idx, Token::new_value(s)));
-    } else {
-        acc.push((tok_idx, token));
-    }
-}
diff --git a/src/uu/factor/Cargo.toml b/src/uu/factor/Cargo.toml
index 57b5e9d54ad..2bc850250ae 100644
--- a/src/uu/factor/Cargo.toml
+++ b/src/uu/factor/Cargo.toml
@@ -1,33 +1,34 @@
 [package]
 name = "uu_factor"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "factor ~ (uutils) display the prime factors of each NUMBER"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [build-dependencies]
 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 }
-
-[dev-dependencies]
-quickcheck = "1.0.3"
+num-bigint = { workspace = true }
+num-prime = { workspace = true }
 
 [[bin]]
 name = "factor"
 path = "src/main.rs"
 
 [lib]
-path = "src/cli.rs"
+path = "src/factor.rs"
diff --git a/src/uu/factor/build.rs b/src/uu/factor/build.rs
deleted file mode 100644
index 8de0605a292..00000000000
--- a/src/uu/factor/build.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-// 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.
-
-//! Generate a table of the multiplicative inverses of p_i mod 2^64
-//! for the first 1027 odd primes (all 13 bit and smaller primes).
-//! You can supply a command line argument to override the default
-//! value of 1027 for the number of entries in the table.
-//!
-//! 2 has no multiplicative inverse mode 2^64 because 2 | 2^64,
-//! and in any case divisibility by two is trivial by checking the LSB.
-
-#![cfg_attr(test, allow(dead_code))]
-
-use std::env::{self, args};
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
-
-use self::sieve::Sieve;
-
-#[cfg(test)]
-use miller_rabin::is_prime;
-
-#[path = "src/numeric/modular_inverse.rs"]
-mod modular_inverse;
-#[allow(unused_imports)] // imports there are used, but invisible from build.rs
-#[path = "src/numeric/traits.rs"]
-mod traits;
-use modular_inverse::modular_inverse;
-
-mod sieve;
-
-#[cfg_attr(test, allow(dead_code))]
-fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let mut file = File::create(Path::new(&out_dir).join("prime_table.rs")).unwrap();
-
-    // By default, we print the multiplicative inverses mod 2^64 of the first 1k primes
-    const DEFAULT_SIZE: usize = 320;
-    let n = args()
-        .nth(1)
-        .and_then(|s| s.parse::<usize>().ok())
-        .unwrap_or(DEFAULT_SIZE);
-
-    write!(file, "{PREAMBLE}").unwrap();
-    let mut cols = 3;
-
-    // we want a total of n + 1 values
-    let mut primes = Sieve::odd_primes().take(n + 1);
-
-    // in each iteration of the for loop, we use the value yielded
-    // by the previous iteration. This leaves one value left at the
-    // end, which we call NEXT_PRIME.
-    let mut x = primes.next().unwrap();
-    for next in primes {
-        // format the table
-        let output = format!("({}, {}, {}),", x, modular_inverse(x), std::u64::MAX / x);
-        if cols + output.len() > MAX_WIDTH {
-            write!(file, "\n    {output}").unwrap();
-            cols = 4 + output.len();
-        } else {
-            write!(file, " {output}").unwrap();
-            cols += 1 + output.len();
-        }
-
-        x = next;
-    }
-
-    write!(
-        file,
-        "\n];\n\n#[allow(dead_code)]\npub const NEXT_PRIME: u64 = {x};\n"
-    )
-    .unwrap();
-}
-
-#[test]
-fn test_generator_is_prime() {
-    assert_eq!(Sieve::odd_primes.take(10_000).all(is_prime));
-}
-
-#[test]
-fn test_generator_10001() {
-    let prime_10001 = Sieve::primes().skip(10_000).next();
-    assert_eq!(prime_10001, Some(104_743));
-}
-
-const MAX_WIDTH: usize = 102;
-const PREAMBLE: &str = r##"/*
-* 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.
-*/
-
-// *** NOTE: this file was automatically generated.
-// Please do not edit by hand. Instead, modify and
-// re-run src/factor/gen_tables.rs.
-
-#[allow(clippy::unreadable_literal)]
-pub const PRIME_INVERSIONS_U64: &[(u64, u64, u64)] = &[
-   "##;
diff --git a/src/uu/factor/sieve.rs b/src/uu/factor/sieve.rs
deleted file mode 100644
index e2211ce051a..00000000000
--- a/src/uu/factor/sieve.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-// 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.
-
-// spell-checker:ignore (ToDO) filts, minidx, minkey paridx
-
-use std::iter::{Chain, Copied, Cycle};
-use std::slice::Iter;
-
-/// A lazy Sieve of Eratosthenes.
-///
-/// This is a reasonably efficient implementation based on
-/// O'Neill, M. E. "[The Genuine Sieve of Eratosthenes.](http://dx.doi.org/10.1017%2FS0956796808007004)"
-/// Journal of Functional Programming, Volume 19, Issue 1, 2009, pp.  95--106.
-#[derive(Default)]
-pub struct Sieve {
-    inner: Wheel,
-    filts: PrimeHeap,
-}
-
-impl Iterator for Sieve {
-    type Item = u64;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-
-    #[inline]
-    fn next(&mut self) -> Option<u64> {
-        for n in &mut self.inner {
-            let mut prime = true;
-            while let Some((next, inc)) = self.filts.peek() {
-                // need to keep checking the min element of the heap
-                // until we've found an element that's greater than n
-                if next > n {
-                    break; // next heap element is bigger than n
-                }
-
-                if next == n {
-                    // n == next, and is composite.
-                    prime = false;
-                }
-                // Increment the element in the prime heap.
-                self.filts.replace((next + inc, inc));
-            }
-
-            if prime {
-                // this is a prime; add it to the heap
-                self.filts.insert(n);
-                return Some(n);
-            }
-        }
-        None
-    }
-}
-
-impl Sieve {
-    fn new() -> Self {
-        Self::default()
-    }
-
-    #[allow(dead_code)]
-    #[inline]
-    pub fn primes() -> PrimeSieve {
-        INIT_PRIMES.iter().copied().chain(Self::new())
-    }
-
-    #[allow(dead_code)]
-    #[inline]
-    pub fn odd_primes() -> PrimeSieve {
-        INIT_PRIMES[1..].iter().copied().chain(Self::new())
-    }
-}
-
-pub type PrimeSieve = Chain<Copied<Iter<'static, u64>>, Sieve>;
-
-/// An iterator that generates an infinite list of numbers that are
-/// not divisible by any of 2, 3, 5, or 7.
-struct Wheel {
-    next: u64,
-    increment: Cycle<Iter<'static, u64>>,
-}
-
-impl Iterator for Wheel {
-    type Item = u64;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (1, None)
-    }
-
-    #[inline]
-    fn next(&mut self) -> Option<u64> {
-        let increment = self.increment.next().unwrap(); // infinite iterator, no check necessary
-        let ret = self.next;
-        self.next = ret + increment;
-        Some(ret)
-    }
-}
-
-impl Wheel {
-    #[inline]
-    fn new() -> Self {
-        Self {
-            next: 11u64,
-            increment: WHEEL_INCS.iter().cycle(),
-        }
-    }
-}
-
-impl Default for Wheel {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// The increments of a wheel of circumference 210
-/// (i.e., a wheel that skips all multiples of 2, 3, 5, 7)
-const WHEEL_INCS: &[u64] = &[
-    2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4, 2, 4, 2, 4, 8, 6, 4, 6, 2, 4, 6,
-    2, 6, 6, 4, 2, 4, 6, 2, 6, 4, 2, 4, 2, 10, 2, 10,
-];
-const INIT_PRIMES: &[u64] = &[2, 3, 5, 7];
-
-/// A min-heap of "infinite lists" of prime multiples, where a list is
-/// represented as (head, increment).
-#[derive(Debug, Default)]
-struct PrimeHeap {
-    data: Vec<(u64, u64)>,
-}
-
-impl PrimeHeap {
-    fn peek(&self) -> Option<(u64, u64)> {
-        if let Some(&(x, y)) = self.data.first() {
-            Some((x, y))
-        } else {
-            None
-        }
-    }
-
-    fn insert(&mut self, next: u64) {
-        let mut idx = self.data.len();
-        let key = next * next;
-
-        let item = (key, next);
-        self.data.push(item);
-        loop {
-            // break if we've bubbled to the top
-            if idx == 0 {
-                break;
-            }
-
-            let paridx = (idx - 1) / 2;
-            let (k, _) = self.data[paridx];
-            if key < k {
-                // bubble up, found a smaller key
-                self.data.swap(idx, paridx);
-                idx = paridx;
-            } else {
-                // otherwise, parent is smaller, so we're done
-                break;
-            }
-        }
-    }
-
-    fn remove(&mut self) -> (u64, u64) {
-        let ret = self.data.swap_remove(0);
-
-        let mut idx = 0;
-        let len = self.data.len();
-        let (key, _) = self.data[0];
-        loop {
-            let child1 = 2 * idx + 1;
-            let child2 = 2 * idx + 2;
-
-            // no more children
-            if child1 >= len {
-                break;
-            }
-
-            // find lesser child
-            let (c1key, _) = self.data[child1];
-            let (minidx, minkey) = if child2 >= len {
-                (child1, c1key)
-            } else {
-                let (c2key, _) = self.data[child2];
-                if c1key < c2key {
-                    (child1, c1key)
-                } else {
-                    (child2, c2key)
-                }
-            };
-
-            if minkey < key {
-                self.data.swap(minidx, idx);
-                idx = minidx;
-                continue;
-            }
-
-            // smaller than both children, so done
-            break;
-        }
-
-        ret
-    }
-
-    /// More efficient than inserting and removing in two steps
-    /// because we save one traversal of the heap.
-    fn replace(&mut self, next: (u64, u64)) -> (u64, u64) {
-        self.data.push(next);
-        self.remove()
-    }
-}
diff --git a/src/uu/factor/src/cli.rs b/src/uu/factor/src/cli.rs
deleted file mode 100644
index 63a0632a3b7..00000000000
--- a/src/uu/factor/src/cli.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-// 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.
-
-use std::io::BufRead;
-use std::io::{self, stdin, stdout, Write};
-
-mod factor;
-use clap::{crate_version, Arg, ArgAction, Command};
-pub use factor::*;
-use uucore::display::Quotable;
-use uucore::error::{set_exit_code, FromIo, UResult};
-use uucore::{format_usage, help_about, help_usage, show_error, show_warning};
-
-mod miller_rabin;
-pub mod numeric;
-mod rho;
-pub mod table;
-
-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";
-}
-
-fn print_factors_str(
-    num_str: &str,
-    w: &mut io::BufWriter<impl io::Write>,
-    print_exponents: bool,
-) -> io::Result<()> {
-    let x = match num_str.trim().parse::<u64>() {
-        Ok(x) => x,
-        Err(e) => {
-            // We return Ok() instead of Err(), because it's non-fatal and we should try the next
-            // number.
-            show_warning!("{}: {}", num_str.maybe_quote(), e);
-            set_exit_code(1);
-            return Ok(());
-        }
-    };
-
-    // 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!(w, "{}:{:#}", x, factor(x))?;
-    } else {
-        writeln!(w, "{}:{}", x, factor(x))?;
-    }
-    w.flush()
-}
-
-#[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());
-
-    if let Some(values) = matches.get_many::<String>(options::NUMBER) {
-        for number in values {
-            print_factors_str(number, &mut w, print_exponents)
-                .map_err_context(|| "write error".into())?;
-        }
-    } else {
-        let stdin = stdin();
-        let lines = stdin.lock().lines();
-        for line in lines {
-            for number in line.unwrap().split_whitespace() {
-                print_factors_str(number, &mut w, print_exponents)
-                    .map_err_context(|| "write error".into())?;
-            }
-        }
-    }
-
-    if let Err(e) = w.flush() {
-        show_error!("{}", e);
-    }
-
-    Ok(())
-}
-
-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 a7e848bb883..2c8d1661c05 100644
--- a/src/uu/factor/src/factor.rs
+++ b/src/uu/factor/src/factor.rs
@@ -3,301 +3,142 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use smallvec::SmallVec;
-use std::cell::RefCell;
-use std::fmt;
-
-use crate::numeric::{Arithmetic, Montgomery};
-use crate::{miller_rabin, rho, table};
-
-type Exponent = u8;
-
-#[derive(Clone, Debug, Default)]
-struct Decomposition(SmallVec<[(u64, Exponent); NUM_FACTORS_INLINE]>);
-
-// spell-checker:ignore (names) Erdős–Kac * Erdős Kac
-// The number of factors to inline directly into a `Decomposition` object.
-// As a consequence of the Erdős–Kac theorem, the average number of prime factors
-// of integers < 10²� ≃ 2�³ is 4, so we can use a slightly higher value.
-const NUM_FACTORS_INLINE: usize = 5;
-
-impl Decomposition {
-    fn one() -> Self {
-        Self::default()
-    }
-
-    fn add(&mut self, factor: u64, exp: Exponent) {
-        debug_assert!(exp > 0);
-
-        if let Some((_, e)) = self.0.iter_mut().find(|(f, _)| *f == factor) {
-            *e += exp;
-        } else {
-            self.0.push((factor, exp));
-        }
-    }
-
-    #[cfg(test)]
-    fn product(&self) -> u64 {
-        self.0
-            .iter()
-            .fold(1, |acc, (p, exp)| acc * p.pow(*exp as u32))
-    }
-
-    fn get(&self, p: u64) -> Option<&(u64, u8)> {
-        self.0.iter().find(|(q, _)| *q == p)
-    }
-}
-
-impl PartialEq for Decomposition {
-    fn eq(&self, other: &Self) -> bool {
-        for p in &self.0 {
-            if other.get(p.0) != Some(p) {
-                return false;
-            }
-        }
-
-        for p in &other.0 {
-            if self.get(p.0) != Some(p) {
-                return false;
-            }
-        }
-
-        true
-    }
+// spell-checker:ignore funcs
+
+use std::collections::BTreeMap;
+use std::io::BufRead;
+use std::io::{self, Write, stdin, stdout};
+
+use clap::{Arg, ArgAction, Command};
+use num_bigint::BigUint;
+use num_traits::FromPrimitive;
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult, USimpleError, set_exit_code};
+use uucore::{format_usage, help_about, help_usage, show_error, show_warning};
+
+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";
 }
-impl Eq for Decomposition {}
 
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Factors(RefCell<Decomposition>);
+fn print_factors_str(
+    num_str: &str,
+    w: &mut io::BufWriter<impl Write>,
+    print_exponents: bool,
+) -> UResult<()> {
+    let rx = num_str.trim().parse::<BigUint>();
+    let Ok(x) = rx else {
+        // return Ok(). it's non-fatal and we should try the next number.
+        show_warning!("{}: {}", num_str.maybe_quote(), rx.unwrap_err());
+        set_exit_code(1);
+        return Ok(());
+    };
 
-impl Factors {
-    pub fn one() -> Self {
-        Self(RefCell::new(Decomposition::one()))
-    }
+    let (factorization, remaining) = if x > BigUint::from_u32(1).unwrap() {
+        num_prime::nt_funcs::factors(x.clone(), None)
+    } else {
+        (BTreeMap::new(), None)
+    };
 
-    pub fn add(&mut self, prime: u64, exp: Exponent) {
-        debug_assert!(miller_rabin::is_prime(prime));
-        self.0.borrow_mut().add(prime, exp);
+    if let Some(_remaining) = remaining {
+        return Err(USimpleError::new(
+            1,
+            "Factorization incomplete. Remainders exists.",
+        ));
     }
 
-    pub fn push(&mut self, prime: u64) {
-        self.add(prime, 1);
-    }
+    write_result(w, &x, factorization, print_exponents).map_err_context(|| "write error".into())?;
 
-    #[cfg(test)]
-    fn product(&self) -> u64 {
-        self.0.borrow().product()
-    }
+    Ok(())
 }
 
-impl fmt::Display for Factors {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let v = &mut (self.0).borrow_mut().0;
-        v.sort_unstable();
-
-        let include_exponents = f.alternate();
-        for (p, exp) in v {
-            if include_exponents && *exp > 1 {
-                write!(f, " {p}^{exp}")?;
+fn write_result(
+    w: &mut io::BufWriter<impl Write>,
+    x: &BigUint,
+    factorization: BTreeMap<BigUint, usize>,
+    print_exponents: bool,
+) -> io::Result<()> {
+    write!(w, "{x}:")?;
+    for (factor, n) in factorization {
+        if print_exponents {
+            if n > 1 {
+                write!(w, " {factor}^{n}")?;
             } else {
-                for _ in 0..*exp {
-                    write!(f, " {p}")?;
-                }
+                write!(w, " {factor}")?;
             }
-        }
-
-        Ok(())
-    }
-}
-
-fn _factor<A: Arithmetic + miller_rabin::Basis>(num: u64, f: Factors) -> Factors {
-    use miller_rabin::Result::*;
-
-    // Shadow the name, so the recursion automatically goes from “Big� arithmetic to small.
-    let _factor = |n, f| {
-        if n < (1 << 32) {
-            _factor::<Montgomery<u32>>(n, f)
         } else {
-            _factor::<A>(n, f)
-        }
-    };
-
-    if num == 1 {
-        return f;
-    }
-
-    let n = A::new(num);
-    let divisor = match miller_rabin::test::<A>(n) {
-        Prime => {
-            #[cfg(feature = "coz")]
-            coz::progress!("factor found");
-            let mut r = f;
-            r.push(num);
-            return r;
+            w.write_all(format!(" {factor}").repeat(n).as_bytes())?;
         }
-
-        Composite(d) => d,
-        Pseudoprime => rho::find_divisor::<A>(n),
-    };
-
-    let f = _factor(divisor, f);
-    _factor(num / divisor, f)
-}
-
-pub fn factor(mut n: u64) -> Factors {
-    #[cfg(feature = "coz")]
-    coz::begin!("factorization");
-    let mut factors = Factors::one();
-
-    if n < 2 {
-        return factors;
-    }
-
-    let n_zeros = n.trailing_zeros();
-    if n_zeros > 0 {
-        factors.add(2, n_zeros as Exponent);
-        n >>= n_zeros;
-    }
-
-    if n == 1 {
-        #[cfg(feature = "coz")]
-        coz::end!("factorization");
-        return factors;
     }
-
-    table::factor(&mut n, &mut factors);
-
-    #[allow(clippy::let_and_return)]
-    let r = if n < (1 << 32) {
-        _factor::<Montgomery<u32>>(n, factors)
-    } else {
-        _factor::<Montgomery<u64>>(n, factors)
-    };
-
-    #[cfg(feature = "coz")]
-    coz::end!("factorization");
-
-    r
+    writeln!(w)?;
+    w.flush()
 }
 
-#[cfg(test)]
-mod tests {
-    use super::{factor, Decomposition, Exponent, Factors};
-    use quickcheck::quickcheck;
-    use smallvec::smallvec;
-    use std::cell::RefCell;
-
-    #[test]
-    fn factor_2044854919485649() {
-        let f = Factors(RefCell::new(Decomposition(smallvec![
-            (503, 1),
-            (2423, 1),
-            (40961, 2)
-        ])));
-        assert_eq!(factor(f.product()), f);
-    }
-
-    #[test]
-    fn factor_recombines_small() {
-        assert!((1..10_000)
-            .map(|i| 2 * i + 1)
-            .all(|i| factor(i).product() == i));
-    }
-
-    #[test]
-    fn factor_recombines_overflowing() {
-        assert!((0..250)
-            .map(|i| 2 * i + 2u64.pow(32) + 1)
-            .all(|i| factor(i).product() == i));
-    }
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
 
-    #[test]
-    fn factor_recombines_strong_pseudoprime() {
-        // This is a strong pseudoprime (wrt. miller_rabin::BASIS)
-        //  and triggered a bug in rho::factor's code path handling
-        //  miller_rabbin::Result::Composite
-        let pseudoprime = 17179869183;
-        for _ in 0..20 {
-            // Repeat the test 20 times, as it only fails some fraction
-            // of the time.
-            assert!(factor(pseudoprime).product() == pseudoprime);
-        }
-    }
+    // 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);
 
-    quickcheck! {
-        fn factor_recombines(i: u64) -> bool {
-            i == 0 || factor(i).product() == i
-        }
+    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());
 
-        fn recombines_factors(f: Factors) -> () {
-            assert_eq!(factor(f.product()), f);
+    if let Some(values) = matches.get_many::<String>(options::NUMBER) {
+        for number in values {
+            print_factors_str(number, &mut w, print_exponents)?;
         }
-
-        fn exponentiate_factors(f: Factors, e: Exponent) -> () {
-            if e == 0 { return; }
-            if let Some(fe) = f.product().checked_pow(e.into()) {
-                assert_eq!(factor(fe), f ^ e);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-use rand::{
-    distributions::{Distribution, Standard},
-    Rng,
-};
-#[cfg(test)]
-impl Distribution<Factors> for Standard {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Factors {
-        let mut f = Factors::one();
-        let mut g = 1u64;
-        let mut n = u64::MAX;
-
-        // spell-checker:ignore (names) Adam Kalai * Kalai's
-        // Adam Kalai's algorithm for generating uniformly-distributed
-        // integers and their factorization.
-        //
-        // See Generating Random Factored Numbers, Easily, J. Cryptology (2003)
-        'attempt: loop {
-            while n > 1 {
-                n = rng.gen_range(1..n);
-                if miller_rabin::is_prime(n) {
-                    if let Some(h) = g.checked_mul(n) {
-                        f.push(n);
-                        g = h;
-                    } else {
-                        // We are overflowing u64, retry
-                        continue 'attempt;
+    } else {
+        let stdin = stdin();
+        let lines = stdin.lock().lines();
+        for line in lines {
+            match line {
+                Ok(line) => {
+                    for number in line.split_whitespace() {
+                        print_factors_str(number, &mut w, print_exponents)?;
                     }
                 }
+                Err(e) => {
+                    set_exit_code(1);
+                    show_error!("error reading input: {e}");
+                    return Ok(());
+                }
             }
-
-            return f;
         }
     }
-}
 
-#[cfg(test)]
-impl quickcheck::Arbitrary for Factors {
-    fn arbitrary(g: &mut quickcheck::Gen) -> Self {
-        factor(u64::arbitrary(g))
+    if let Err(e) = w.flush() {
+        show_error!("{e}");
     }
-}
-
-#[cfg(test)]
-impl std::ops::BitXor<Exponent> for Factors {
-    type Output = Self;
 
-    fn bitxor(self, rhs: Exponent) -> Self {
-        debug_assert_ne!(rhs, 0);
-        let mut r = Self::one();
-        #[allow(clippy::explicit_iter_loop)]
-        for (p, e) in self.0.borrow().0.iter() {
-            r.add(*p, rhs * e);
-        }
+    Ok(())
+}
 
-        debug_assert_eq!(r.product(), self.product().pow(rhs.into()));
-        r
-    }
+pub fn uu_app() -> Command {
+    Command::new(uucore::util_name())
+        .version(uucore::crate_version!())
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .disable_help_flag(true)
+        .args_override_self(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/miller_rabin.rs b/src/uu/factor/src/miller_rabin.rs
deleted file mode 100644
index a06b20cd3b0..00000000000
--- a/src/uu/factor/src/miller_rabin.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-// 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.
-
-// spell-checker:ignore (URL) appspot
-
-use crate::numeric::*;
-
-pub(crate) trait Basis {
-    const BASIS: &'static [u64];
-}
-
-impl Basis for Montgomery<u64> {
-    // Small set of bases for the Miller-Rabin prime test, valid for all 64b integers;
-    //  discovered by Jim Sinclair on 2011-04-20, see miller-rabin.appspot.com
-    #[allow(clippy::unreadable_literal)]
-    const BASIS: &'static [u64] = &[2, 325, 9375, 28178, 450775, 9780504, 1795265022];
-}
-
-impl Basis for Montgomery<u32> {
-    // spell-checker:ignore (names) Steve Worley
-    // Small set of bases for the Miller-Rabin prime test, valid for all 32b integers;
-    //  discovered by Steve Worley on 2013-05-27, see miller-rabin.appspot.com
-    #[allow(clippy::unreadable_literal)]
-    const BASIS: &'static [u64] = &[
-        4230279247111683200,
-        14694767155120705706,
-        16641139526367750375,
-    ];
-}
-
-#[derive(Eq, PartialEq)]
-#[must_use = "Ignoring the output of a primality test."]
-pub(crate) enum Result {
-    Prime,
-    Pseudoprime,
-    Composite(u64),
-}
-
-impl Result {
-    pub(crate) fn is_prime(&self) -> bool {
-        *self == Self::Prime
-    }
-}
-
-// Deterministic Miller-Rabin primality-checking algorithm, adapted to extract
-// (some) dividers; it will fail to factor strong pseudoprimes.
-#[allow(clippy::many_single_char_names)]
-pub(crate) fn test<A: Arithmetic + Basis>(m: A) -> Result {
-    use self::Result::*;
-
-    let n = m.modulus();
-    debug_assert!(n > 1);
-    debug_assert!(n % 2 != 0);
-
-    // n-1 = r 2�
-    let i = (n - 1).trailing_zeros();
-    let r = (n - 1) >> i;
-
-    let one = m.one();
-    let minus_one = m.minus_one();
-
-    'witness: for _a in A::BASIS {
-        let _a = _a % n;
-        if _a == 0 {
-            continue;
-        }
-
-        let a = m.to_mod(_a);
-
-        // x = a^r mod n
-        let mut x = m.pow(a, r);
-
-        if x == one || x == minus_one {
-            continue;
-        }
-
-        for _ in 1..i {
-            let y = m.mul(x, x);
-            if y == one {
-                return Composite(gcd(m.to_u64(x) - 1, m.modulus()));
-            } else if y == minus_one {
-                // This basis element is not a witness of `n` being composite.
-                // Keep looking.
-                continue 'witness;
-            }
-            x = y;
-        }
-
-        return Pseudoprime;
-    }
-
-    Prime
-}
-
-// Used by build.rs' tests and debug assertions
-#[allow(dead_code)]
-pub(crate) fn is_prime(n: u64) -> bool {
-    if n < 2 {
-        false
-    } else if n % 2 == 0 {
-        n == 2
-    } else {
-        test::<Montgomery<u64>>(Montgomery::new(n)).is_prime()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::numeric::{traits::DoubleInt, Arithmetic, Montgomery};
-    use quickcheck::quickcheck;
-    use std::iter;
-    const LARGEST_U64_PRIME: u64 = 0xFFFFFFFFFFFFFFC5;
-
-    fn primes() -> impl Iterator<Item = u64> {
-        iter::once(2).chain(odd_primes())
-    }
-
-    fn odd_primes() -> impl Iterator<Item = u64> {
-        use crate::table::{NEXT_PRIME, PRIME_INVERSIONS_U64};
-        PRIME_INVERSIONS_U64
-            .iter()
-            .map(|(p, _, _)| *p)
-            .chain(iter::once(NEXT_PRIME))
-    }
-
-    #[test]
-    fn largest_prime() {
-        assert!(is_prime(LARGEST_U64_PRIME));
-    }
-
-    #[test]
-    fn largest_composites() {
-        for i in LARGEST_U64_PRIME + 1..=u64::MAX {
-            assert!(!is_prime(i), "2�� - {} reported prime", u64::MAX - i + 1);
-        }
-    }
-
-    #[test]
-    fn two() {
-        assert!(is_prime(2));
-    }
-
-    fn first_primes<A: DoubleInt>()
-    where
-        Montgomery<A>: Basis,
-    {
-        for p in odd_primes() {
-            assert!(
-                test(Montgomery::<A>::new(p)).is_prime(),
-                "{p} reported composite"
-            );
-        }
-    }
-
-    #[test]
-    fn first_primes_u32() {
-        first_primes::<u32>();
-    }
-
-    #[test]
-    fn first_primes_u64() {
-        first_primes::<u64>();
-    }
-
-    #[test]
-    fn one() {
-        assert!(!is_prime(1));
-    }
-    #[test]
-    fn zero() {
-        assert!(!is_prime(0));
-    }
-
-    #[test]
-    fn first_composites() {
-        for (p, q) in primes().zip(odd_primes()) {
-            for i in p + 1..q {
-                assert!(!is_prime(i), "{i} reported prime");
-            }
-        }
-    }
-
-    #[test]
-    fn issue_1556() {
-        // 10 425 511 = 2441 × 4271
-        assert!(!is_prime(10_425_511));
-    }
-
-    fn small_semiprimes<A: DoubleInt>()
-    where
-        Montgomery<A>: Basis,
-    {
-        for p in odd_primes() {
-            for q in odd_primes().take_while(|q| *q <= p) {
-                let n = p * q;
-                let m = Montgomery::<A>::new(n);
-                assert!(!test(m).is_prime(), "{n} = {p} × {q} reported prime");
-            }
-        }
-    }
-
-    #[test]
-    fn small_semiprimes_u32() {
-        small_semiprimes::<u32>();
-    }
-
-    #[test]
-    fn small_semiprimes_u64() {
-        small_semiprimes::<u64>();
-    }
-
-    quickcheck! {
-        fn composites(i: u64, j: u64) -> bool {
-            // TODO: #1559 factor n > 2^64 - 1
-            match i.checked_mul(j) {
-                Some(n) => i < 2 || j < 2 || !is_prime(n),
-                _ => true,
-            }
-        }
-    }
-}
diff --git a/src/uu/factor/src/numeric/gcd.rs b/src/uu/factor/src/numeric/gcd.rs
deleted file mode 100644
index 43c6ce9b71b..00000000000
--- a/src/uu/factor/src/numeric/gcd.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-// 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.
-
-// spell-checker:ignore (vars) kgcdab gcdac gcdbc
-
-use std::cmp::min;
-use std::mem::swap;
-
-pub fn gcd(mut u: u64, mut v: u64) -> u64 {
-    // Stein's binary GCD algorithm
-    // Base cases: gcd(n, 0) = gcd(0, n) = n
-    if u == 0 {
-        return v;
-    } else if v == 0 {
-        return u;
-    }
-
-    // gcd(2� u, 2ʲ v) = 2� gcd(u, v) with u, v odd and k = min(i, j)
-    // 2� is the greatest power of two that divides both u and v
-    let k = {
-        let i = u.trailing_zeros();
-        let j = v.trailing_zeros();
-        u >>= i;
-        v >>= j;
-        min(i, j)
-    };
-
-    loop {
-        // Loop invariant: u and v are odd
-        debug_assert!(u % 2 == 1, "u = {u} is even");
-        debug_assert!(v % 2 == 1, "v = {v} is even");
-
-        // gcd(u, v) = gcd(|u - v|, min(u, v))
-        if u > v {
-            swap(&mut u, &mut v);
-        }
-        v -= u;
-
-        if v == 0 {
-            // Reached the base case; gcd is 2� u
-            return u << k;
-        }
-
-        // gcd(u, 2ʲ v) = gcd(u, v) as u is odd
-        v >>= v.trailing_zeros();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use quickcheck::{quickcheck, TestResult};
-
-    quickcheck! {
-        fn euclidean(a: u64, b: u64) -> bool {
-            // Test against the Euclidean algorithm
-            let g = {
-                let (mut a, mut b) = (a, b);
-                while b > 0 {
-                    a %= b;
-                    swap(&mut a, &mut b);
-                }
-                a
-            };
-            gcd(a, b) == g
-        }
-
-        fn one(a: u64) -> bool {
-            gcd(1, a) == 1
-        }
-
-        fn zero(a: u64) -> bool {
-            gcd(0, a) == a
-        }
-
-        fn divisor(a: u64, b: u64) -> TestResult {
-            // Test that gcd(a, b) divides a and b, unless a == b == 0
-            if a == 0 && b == 0 { return TestResult::discard(); } // restrict test domain to !(a == b == 0)
-
-            let g = gcd(a, b);
-            TestResult::from_bool( g != 0 && a % g == 0 && b % g == 0 )
-        }
-
-        fn commutative(a: u64, b: u64) -> bool {
-            gcd(a, b) == gcd(b, a)
-        }
-
-        fn associative(a: u64, b: u64, c: u64) -> bool {
-            gcd(a, gcd(b, c)) == gcd(gcd(a, b), c)
-        }
-
-        fn scalar_multiplication(a: u64, b: u64, k: u64) -> bool {
-            // TODO: #1559 factor n > 2^64 - 1
-            match (k.checked_mul(a), k.checked_mul(b), k.checked_mul(gcd(a, b))) {
-                (Some(ka), Some(kb), Some(kgcdab)) => gcd(ka, kb) == kgcdab,
-                _ => true
-            }
-        }
-
-        fn multiplicative(a: u64, b: u64, c: u64) -> bool {
-            // TODO: #1559 factor n > 2^64 - 1
-            match (a.checked_mul(b), gcd(a, c).checked_mul(gcd(b, c))) {
-                (Some(ab), Some(gcdac_gcdbc)) => {
-                    // gcd(ab, c) = gcd(a, c) gcd(b, c) when a and b coprime
-                    gcd(a, b) != 1 || gcd(ab, c) == gcdac_gcdbc
-                },
-                _ => true,
-            }
-        }
-
-        fn linearity(a: u64, b: u64, k: u64) -> bool {
-            // TODO: #1559 factor n > 2^64 - 1
-            match k.checked_mul(b) {
-                Some(kb) => {
-                    match a.checked_add(kb) {
-                        Some(a_plus_kb) => gcd(a_plus_kb, b) == gcd(a, b),
-                        _ => true,
-                    }
-                }
-                _ => true,
-            }
-        }
-    }
-}
diff --git a/src/uu/factor/src/numeric/mod.rs b/src/uu/factor/src/numeric/mod.rs
deleted file mode 100644
index d4c0b5dc7f7..00000000000
--- a/src/uu/factor/src/numeric/mod.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// 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.
-
-mod gcd;
-pub use gcd::gcd;
-
-pub(crate) mod traits;
-
-mod modular_inverse;
-pub(crate) use modular_inverse::modular_inverse;
-
-mod montgomery;
-pub(crate) use montgomery::{Arithmetic, Montgomery};
diff --git a/src/uu/factor/src/numeric/modular_inverse.rs b/src/uu/factor/src/numeric/modular_inverse.rs
deleted file mode 100644
index bacf57d9ce6..00000000000
--- a/src/uu/factor/src/numeric/modular_inverse.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-// 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.
-
-use super::traits::Int;
-
-// extended Euclid algorithm
-// precondition: a is odd
-pub(crate) fn modular_inverse<T: Int>(a: T) -> T {
-    let zero = T::zero();
-    let one = T::one();
-    debug_assert!(a % (one + one) == one, "{a:?} is not odd");
-
-    let mut t = zero;
-    let mut new_t = one;
-    let mut r = zero;
-    let mut new_r = a;
-
-    while new_r != zero {
-        let quot = if r == zero {
-            // special case when we're just starting out
-            // This works because we know that
-            // a does not divide 2^64, so floor(2^64 / a) == floor((2^64-1) / a);
-            T::max_value()
-        } else {
-            r
-        } / new_r;
-
-        let new_tp = t.wrapping_sub(&quot.wrapping_mul(&new_t));
-        t = new_t;
-        new_t = new_tp;
-
-        let new_rp = r.wrapping_sub(&quot.wrapping_mul(&new_r));
-        r = new_r;
-        new_r = new_rp;
-    }
-
-    debug_assert_eq!(r, one);
-    t
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{super::traits::Int, *};
-    use quickcheck::quickcheck;
-
-    fn small_values<T: Int>() {
-        // All odd integers from 1 to 20 000
-        let one = T::from(1).unwrap();
-        let two = T::from(2).unwrap();
-        let mut test_values = (0..10_000)
-            .map(|i| T::from(i).unwrap())
-            .map(|i| two * i + one);
-
-        assert!(test_values.all(|x| x.wrapping_mul(&modular_inverse(x)) == one));
-    }
-
-    #[test]
-    fn small_values_u32() {
-        small_values::<u32>();
-    }
-
-    #[test]
-    fn small_values_u64() {
-        small_values::<u64>();
-    }
-
-    quickcheck! {
-        fn random_values_u32(n: u32) -> bool {
-            match 2_u32.checked_mul(n) {
-                Some(n) => modular_inverse(n + 1).wrapping_mul(n + 1) == 1,
-                _ => true,
-            }
-        }
-
-        fn random_values_u64(n: u64) -> bool {
-            match 2_u64.checked_mul(n) {
-                Some(n) => modular_inverse(n + 1).wrapping_mul(n + 1) == 1,
-                _ => true,
-            }
-        }
-    }
-}
diff --git a/src/uu/factor/src/numeric/montgomery.rs b/src/uu/factor/src/numeric/montgomery.rs
deleted file mode 100644
index 10c6dd2d906..00000000000
--- a/src/uu/factor/src/numeric/montgomery.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-// 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.
-
-use super::*;
-
-use traits::{DoubleInt, Int, One, OverflowingAdd, Zero};
-
-pub(crate) trait Arithmetic: Copy + Sized {
-    // The type of integers mod m, in some opaque representation
-    type ModInt: Copy + Sized + Eq;
-
-    fn new(m: u64) -> Self;
-    fn modulus(&self) -> u64;
-    fn to_mod(&self, n: u64) -> Self::ModInt;
-    fn to_u64(&self, n: Self::ModInt) -> u64;
-    fn add(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt;
-    fn mul(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt;
-
-    fn pow(&self, mut a: Self::ModInt, mut b: u64) -> Self::ModInt {
-        let (_a, _b) = (a, b);
-        let mut result = self.one();
-        while b > 0 {
-            if b & 1 != 0 {
-                result = self.mul(result, a);
-            }
-            a = self.mul(a, a);
-            b >>= 1;
-        }
-
-        // Check that r (reduced back to the usual representation) equals
-        //  a^b % n, unless the latter computation overflows
-        // Temporarily commented-out, as there u64::checked_pow is not available
-        //  on the minimum supported Rust version, nor is an appropriate method
-        //  for compiling the check conditionally.
-        //debug_assert!(self
-        //    .to_u64(_a)
-        //    .checked_pow(_b as u32)
-        //    .map(|r| r % self.modulus() == self.to_u64(result))
-        //    .unwrap_or(true));
-
-        result
-    }
-
-    fn one(&self) -> Self::ModInt {
-        self.to_mod(1)
-    }
-    fn minus_one(&self) -> Self::ModInt {
-        self.to_mod(self.modulus() - 1)
-    }
-    fn zero(&self) -> Self::ModInt {
-        self.to_mod(0)
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct Montgomery<T: DoubleInt> {
-    a: T,
-    n: T,
-}
-
-impl<T: DoubleInt> Montgomery<T> {
-    /// computes x/R mod n efficiently
-    fn reduce(&self, x: T::DoubleWidth) -> T {
-        let t_bits = T::zero().count_zeros() as usize;
-
-        debug_assert!(x < (self.n.as_double_width()) << t_bits);
-        // TODO: optimize
-        let Self { a, n } = self;
-        let m = T::from_double_width(x).wrapping_mul(a);
-        let nm = (n.as_double_width()) * (m.as_double_width());
-        let (xnm, overflow) = x.overflowing_add(&nm); // x + n*m
-        debug_assert_eq!(
-            xnm % (T::DoubleWidth::one() << T::zero().count_zeros() as usize),
-            T::DoubleWidth::zero()
-        );
-
-        // (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 {
-                n.wrapping_neg()
-            } else {
-                T::zero()
-            };
-
-        if y >= *n {
-            y - *n
-        } else {
-            y
-        }
-    }
-}
-
-impl<T: DoubleInt> Arithmetic for Montgomery<T> {
-    // Montgomery transform, R=2��
-    // Provides fast arithmetic mod n (n odd, u64)
-    type ModInt = T;
-
-    fn new(n: u64) -> Self {
-        debug_assert!(T::zero().count_zeros() >= 64 || n < (1 << T::zero().count_zeros() as usize));
-        let n = T::from_u64(n);
-        let a = modular_inverse(n).wrapping_neg();
-        debug_assert_eq!(n.wrapping_mul(&a), T::one().wrapping_neg());
-        Self { a, n }
-    }
-
-    fn modulus(&self) -> u64 {
-        self.n.as_u64()
-    }
-
-    fn to_mod(&self, x: u64) -> Self::ModInt {
-        // TODO: optimise!
-        debug_assert!(x < self.n.as_u64());
-        let r = T::from_double_width(
-            ((T::DoubleWidth::from_u64(x)) << T::zero().count_zeros() as usize)
-                % self.n.as_double_width(),
-        );
-        debug_assert_eq!(x, self.to_u64(r));
-        r
-    }
-
-    fn to_u64(&self, n: Self::ModInt) -> u64 {
-        self.reduce(n.as_double_width()).as_u64()
-    }
-
-    fn add(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt {
-        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 + self.n.wrapping_neg()
-        } else {
-            r
-        };
-
-        // Normalize to [0; n[
-        let r = if r < self.n { r } else { r - self.n };
-
-        // Check that r (reduced back to the usual representation) equals
-        // a+b % n
-        #[cfg(debug_assertions)]
-        {
-            let a_r = self.to_u64(a) as u128;
-            let b_r = self.to_u64(b) as u128;
-            let r_r = self.to_u64(r);
-            let r_2 = ((a_r + b_r) % self.n.as_u128()) as u64;
-            debug_assert_eq!(
-                r_r, r_2,
-                "[{}] = {} ≠ {} = {} + {} = [{}] + [{}] mod {}; a = {}",
-                r, r_r, r_2, a_r, b_r, a, b, self.n, self.a
-            );
-        }
-        r
-    }
-
-    fn mul(&self, a: Self::ModInt, b: Self::ModInt) -> Self::ModInt {
-        let r = self.reduce(a.as_double_width() * b.as_double_width());
-
-        // Check that r (reduced back to the usual representation) equals
-        // a*b % n
-        #[cfg(debug_assertions)]
-        {
-            let a_r = self.to_u64(a) as u128;
-            let b_r = self.to_u64(b) as u128;
-            let r_r = self.to_u64(r);
-            let r_2: u64 = ((a_r * b_r) % self.n.as_u128()) as u64;
-            debug_assert_eq!(
-                r_r, r_2,
-                "[{}] = {} ≠ {} = {} * {} = [{}] * [{}] mod {}; a = {}",
-                r, r_r, r_2, a_r, b_r, a, b, self.n, self.a
-            );
-        }
-        r
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn test_add<A: DoubleInt>() {
-        for n in 0..100 {
-            let n = 2 * n + 1;
-            let m = Montgomery::<A>::new(n);
-            for x in 0..n {
-                let m_x = m.to_mod(x);
-                for y in 0..=x {
-                    let m_y = m.to_mod(y);
-                    println!("{n:?}, {x:?}, {y:?}");
-                    assert_eq!((x + y) % n, m.to_u64(m.add(m_x, m_y)));
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn add_u32() {
-        test_add::<u32>();
-    }
-
-    #[test]
-    fn add_u64() {
-        test_add::<u64>();
-    }
-
-    fn test_multiplication<A: DoubleInt>() {
-        for n in 0..100 {
-            let n = 2 * n + 1;
-            let m = Montgomery::<A>::new(n);
-            for x in 0..n {
-                let m_x = m.to_mod(x);
-                for y in 0..=x {
-                    let m_y = m.to_mod(y);
-                    assert_eq!((x * y) % n, m.to_u64(m.mul(m_x, m_y)));
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn multiplication_u32() {
-        test_multiplication::<u32>();
-    }
-
-    #[test]
-    fn multiplication_u64() {
-        test_multiplication::<u64>();
-    }
-
-    fn test_roundtrip<A: DoubleInt>() {
-        for n in 0..100 {
-            let n = 2 * n + 1;
-            let m = Montgomery::<A>::new(n);
-            for x in 0..n {
-                let x_ = m.to_mod(x);
-                assert_eq!(x, m.to_u64(x_));
-            }
-        }
-    }
-
-    #[test]
-    fn roundtrip_u32() {
-        test_roundtrip::<u32>();
-    }
-
-    #[test]
-    fn roundtrip_u64() {
-        test_roundtrip::<u64>();
-    }
-}
diff --git a/src/uu/factor/src/numeric/traits.rs b/src/uu/factor/src/numeric/traits.rs
deleted file mode 100644
index c3528a4ad29..00000000000
--- a/src/uu/factor/src/numeric/traits.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-// 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.
-
-pub(crate) use num_traits::{
-    identities::{One, Zero},
-    ops::overflowing::OverflowingAdd,
-};
-use num_traits::{
-    int::PrimInt,
-    ops::wrapping::{WrappingMul, WrappingNeg, WrappingSub},
-};
-use std::fmt::{Debug, Display};
-
-pub(crate) trait Int:
-    Display + Debug + PrimInt + OverflowingAdd + WrappingNeg + WrappingSub + WrappingMul
-{
-    fn as_u64(&self) -> u64;
-    fn from_u64(n: u64) -> Self;
-
-    #[cfg(debug_assertions)]
-    fn as_u128(&self) -> u128;
-}
-
-pub(crate) trait DoubleInt: Int {
-    /// An integer type with twice the width of `Self`.
-    /// In particular, multiplications (of `Int` values) can be performed in
-    ///  `Self::DoubleWidth` without possibility of overflow.
-    type DoubleWidth: Int;
-
-    fn as_double_width(self) -> Self::DoubleWidth;
-    fn from_double_width(n: Self::DoubleWidth) -> Self;
-}
-
-macro_rules! int {
-    ( $x:ty ) => {
-        impl Int for $x {
-            fn as_u64(&self) -> u64 {
-                *self as u64
-            }
-            fn from_u64(n: u64) -> Self {
-                n as _
-            }
-            #[cfg(debug_assertions)]
-            fn as_u128(&self) -> u128 {
-                *self as u128
-            }
-        }
-    };
-}
-macro_rules! double_int {
-    ( $x:ty, $y:ty ) => {
-        int!($x);
-        impl DoubleInt for $x {
-            type DoubleWidth = $y;
-
-            fn as_double_width(self) -> $y {
-                self as _
-            }
-            fn from_double_width(n: $y) -> Self {
-                n as _
-            }
-        }
-    };
-}
-double_int!(u32, u64);
-double_int!(u64, u128);
-int!(u128);
-
-/// Helper macro for instantiating tests over u32 and u64
-#[cfg(test)]
-#[macro_export]
-macro_rules! parametrized_check {
-    ( $f:ident ) => {
-        paste::item! {
-            #[test]
-            fn [< $f _ u32 >]() {
-                $f::<u32>()
-            }
-            #[test]
-            fn [< $f _ u64 >]() {
-                $f::<u64>()
-            }
-        }
-    };
-}
diff --git a/src/uu/factor/src/rho.rs b/src/uu/factor/src/rho.rs
deleted file mode 100644
index 2af0f685564..00000000000
--- a/src/uu/factor/src/rho.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// 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.
-
-use rand::distributions::{Distribution, Uniform};
-use rand::rngs::SmallRng;
-use rand::{thread_rng, SeedableRng};
-use std::cmp::{max, min};
-
-use crate::numeric::*;
-
-pub(crate) fn find_divisor<A: Arithmetic>(n: A) -> u64 {
-    #![allow(clippy::many_single_char_names)]
-    let mut rand = {
-        let range = Uniform::new(1, n.modulus());
-        let mut rng = SmallRng::from_rng(&mut thread_rng()).unwrap();
-        move || n.to_mod(range.sample(&mut rng))
-    };
-
-    let quadratic = |a, b| move |x| n.add(n.mul(a, n.mul(x, x)), b);
-
-    loop {
-        let f = quadratic(rand(), rand());
-        let mut x = rand();
-        let mut y = x;
-
-        loop {
-            x = f(x);
-            y = f(f(y));
-            let d = {
-                let _x = n.to_u64(x);
-                let _y = n.to_u64(y);
-                gcd(n.modulus(), max(_x, _y) - min(_x, _y))
-            };
-            if d == n.modulus() {
-                // Failure, retry with a different quadratic
-                break;
-            } else if d > 1 {
-                return d;
-            }
-        }
-    }
-}
diff --git a/src/uu/factor/src/table.rs b/src/uu/factor/src/table.rs
deleted file mode 100644
index e9b525a3af5..00000000000
--- a/src/uu/factor/src/table.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-// 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.
-
-// spell-checker: ignore (ToDO) INVS
-
-use crate::Factors;
-
-include!(concat!(env!("OUT_DIR"), "/prime_table.rs"));
-
-pub fn factor(num: &mut u64, factors: &mut Factors) {
-    for &(prime, inv, ceil) in PRIME_INVERSIONS_U64 {
-        if *num == 1 {
-            break;
-        }
-
-        // inv = prime^-1 mod 2^64
-        // ceil = floor((2^64-1) / prime)
-        // if (num * inv) mod 2^64 <= ceil, then prime divides num
-        // See https://math.stackexchange.com/questions/1251327/
-        // for a nice explanation.
-        let mut k = 0;
-        loop {
-            let x = num.wrapping_mul(inv);
-
-            // While prime divides num
-            if x <= ceil {
-                *num = x;
-                k += 1;
-                #[cfg(feature = "coz")]
-                coz::progress!("factor found");
-            } else {
-                if k > 0 {
-                    factors.add(prime, k);
-                }
-                break;
-            }
-        }
-    }
-}
-
-pub const CHUNK_SIZE: usize = 8;
-pub fn factor_chunk(n_s: &mut [u64; CHUNK_SIZE], f_s: &mut [Factors; CHUNK_SIZE]) {
-    for &(prime, inv, ceil) in PRIME_INVERSIONS_U64 {
-        if n_s[0] == 1 && n_s[1] == 1 && n_s[2] == 1 && n_s[3] == 1 {
-            break;
-        }
-
-        for (num, factors) in n_s.iter_mut().zip(f_s.iter_mut()) {
-            if *num == 1 {
-                continue;
-            }
-            let mut k = 0;
-            loop {
-                let x = num.wrapping_mul(inv);
-
-                // While prime divides num
-                if x <= ceil {
-                    *num = x;
-                    k += 1;
-                } else {
-                    if k > 0 {
-                        factors.add(prime, k);
-                    }
-                    break;
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::Factors;
-    use quickcheck::quickcheck;
-    use rand::{rngs::SmallRng, Rng, SeedableRng};
-
-    quickcheck! {
-        fn chunk_vs_iter(seed: u64) -> () {
-            let mut rng = SmallRng::seed_from_u64(seed);
-            let mut n_c: [u64; CHUNK_SIZE] = rng.gen();
-            let mut f_c: [Factors; CHUNK_SIZE] = rng.gen();
-
-            let mut n_i = n_c;
-            let mut f_i = f_c.clone();
-            for (n, f) in n_i.iter_mut().zip(f_i.iter_mut()) {
-                factor(n, f);
-            }
-
-            factor_chunk(&mut n_c, &mut f_c);
-
-            assert_eq!(n_i, n_c);
-            assert_eq!(f_i, f_c);
-        }
-    }
-}
diff --git a/src/uu/false/Cargo.toml b/src/uu/false/Cargo.toml
index 80f3553c0ef..4fcbb9f4ca3 100644
--- a/src/uu/false/Cargo.toml
+++ b/src/uu/false/Cargo.toml
@@ -1,15 +1,19 @@
 [package]
 name = "uu_false"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
-description = "false ~ (uutils) do nothing and fail"
 
-homepage = "https://github.com/uutils/coreutils"
+description = "false ~ (uutils) do nothing and fail"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/false"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/false.rs"
diff --git a/src/uu/false/src/false.rs b/src/uu/false/src/false.rs
index 3ae25e5696d..adf3593ea0d 100644
--- a/src/uu/false/src/false.rs
+++ b/src/uu/false/src/false.rs
@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 use clap::{Arg, ArgAction, Command};
 use std::{ffi::OsString, io::Write};
-use uucore::error::{set_exit_code, UResult};
+use uucore::error::{UResult, set_exit_code};
 use uucore::help_about;
 
 const ABOUT: &str = help_about!("false.md");
@@ -28,7 +28,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         let error = match e.kind() {
             clap::error::ErrorKind::DisplayHelp => command.print_help(),
             clap::error::ErrorKind::DisplayVersion => {
-                writeln!(std::io::stdout(), "{}", command.render_version())
+                write!(std::io::stdout(), "{}", command.render_version())
             }
             _ => Ok(()),
         };
@@ -36,7 +36,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         // Try to display this error.
         if let Err(print_fail) = error {
             // Completely ignore any error here, no more failover and we will fail in any case.
-            let _ = writeln!(std::io::stderr(), "{}: {}", uucore::util_name(), print_fail);
+            let _ = writeln!(std::io::stderr(), "{}: {print_fail}", uucore::util_name());
         }
     }
 
@@ -45,7 +45,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(clap::crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         // We provide our own help and version options, to ensure maximum compatibility with GNU.
         .disable_help_flag(true)
diff --git a/src/uu/fmt/Cargo.toml b/src/uu/fmt/Cargo.toml
index 5b181937bc3..65e03b80dfd 100644
--- a/src/uu/fmt/Cargo.toml
+++ b/src/uu/fmt/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_fmt"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "fmt ~ (uutils) reformat each paragraph of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/fmt"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/fmt.rs"
diff --git a/src/uu/fmt/fmt.md b/src/uu/fmt/fmt.md
index 5cf4fa6e632..6ed7d3048a5 100644
--- a/src/uu/fmt/fmt.md
+++ b/src/uu/fmt/fmt.md
@@ -1,7 +1,7 @@
 # fmt
 
 ```
-fmt [OPTION]... [FILE]...
+fmt [-WIDTH] [OPTION]... [FILE]...
 ```
 
 Reformat paragraphs from input files (or stdin) to stdout.
diff --git a/src/uu/fmt/src/fmt.rs b/src/uu/fmt/src/fmt.rs
index c5eac707303..8366af6cdba 100644
--- a/src/uu/fmt/src/fmt.rs
+++ b/src/uu/fmt/src/fmt.rs
@@ -5,52 +5,54 @@
 
 // spell-checker:ignore (ToDO) PSKIP linebreak ostream parasplit tabwidth xanti xprefix
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::cmp;
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use std::fs::File;
-use std::io::{stdin, stdout, Write};
-use std::io::{BufReader, BufWriter, Read, Stdout};
+use std::io::{BufReader, BufWriter, Read, Stdout, Write, stdin, stdout};
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, help_about, help_usage, show_warning};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::{format_usage, help_about, help_usage};
 
-use self::linebreak::break_lines;
-use self::parasplit::ParagraphStream;
+use linebreak::break_lines;
+use parasplit::ParagraphStream;
 
 mod linebreak;
 mod parasplit;
 
-static ABOUT: &str = help_about!("fmt.md");
+const ABOUT: &str = help_about!("fmt.md");
 const USAGE: &str = help_usage!("fmt.md");
-static MAX_WIDTH: usize = 2500;
-
-static OPT_CROWN_MARGIN: &str = "crown-margin";
-static OPT_TAGGED_PARAGRAPH: &str = "tagged-paragraph";
-static OPT_PRESERVE_HEADERS: &str = "preserve-headers";
-static OPT_SPLIT_ONLY: &str = "split-only";
-static OPT_UNIFORM_SPACING: &str = "uniform-spacing";
-static OPT_PREFIX: &str = "prefix";
-static OPT_SKIP_PREFIX: &str = "skip-prefix";
-static OPT_EXACT_PREFIX: &str = "exact-prefix";
-static OPT_EXACT_SKIP_PREFIX: &str = "exact-skip-prefix";
-static OPT_WIDTH: &str = "width";
-static OPT_GOAL: &str = "goal";
-static OPT_QUICK: &str = "quick";
-static OPT_TAB_WIDTH: &str = "tab-width";
-
-static ARG_FILES: &str = "files";
+const MAX_WIDTH: usize = 2500;
+const DEFAULT_GOAL: usize = 70;
+const DEFAULT_WIDTH: usize = 75;
+// by default, goal is 93% of width
+const DEFAULT_GOAL_TO_WIDTH_RATIO: usize = 93;
+
+mod options {
+    pub const CROWN_MARGIN: &str = "crown-margin";
+    pub const TAGGED_PARAGRAPH: &str = "tagged-paragraph";
+    pub const PRESERVE_HEADERS: &str = "preserve-headers";
+    pub const SPLIT_ONLY: &str = "split-only";
+    pub const UNIFORM_SPACING: &str = "uniform-spacing";
+    pub const PREFIX: &str = "prefix";
+    pub const SKIP_PREFIX: &str = "skip-prefix";
+    pub const EXACT_PREFIX: &str = "exact-prefix";
+    pub const EXACT_SKIP_PREFIX: &str = "exact-skip-prefix";
+    pub const WIDTH: &str = "width";
+    pub const GOAL: &str = "goal";
+    pub const QUICK: &str = "quick";
+    pub const TAB_WIDTH: &str = "tab-width";
+    pub const FILES_OR_WIDTH: &str = "files";
+}
 
 pub type FileOrStdReader = BufReader<Box<dyn Read + 'static>>;
+
 pub struct FmtOptions {
     crown: bool,
     tagged: bool,
     mail: bool,
     split_only: bool,
-    use_prefix: bool,
-    prefix: String,
+    prefix: Option<String>,
     xprefix: bool,
-    use_anti_prefix: bool,
-    anti_prefix: String,
+    anti_prefix: Option<String>,
     xanti_prefix: bool,
     uniform: bool,
     quick: bool,
@@ -59,147 +61,117 @@ pub struct FmtOptions {
     tabwidth: usize,
 }
 
-impl Default for FmtOptions {
-    fn default() -> Self {
-        Self {
-            crown: false,
-            tagged: false,
-            mail: false,
-            uniform: false,
-            quick: false,
-            split_only: false,
-            use_prefix: false,
-            prefix: String::new(),
-            xprefix: false,
-            use_anti_prefix: false,
-            anti_prefix: String::new(),
-            xanti_prefix: false,
-            width: 75,
-            goal: 70,
-            tabwidth: 8,
+impl FmtOptions {
+    fn from_matches(matches: &ArgMatches) -> UResult<Self> {
+        let mut tagged = matches.get_flag(options::TAGGED_PARAGRAPH);
+        let mut crown = matches.get_flag(options::CROWN_MARGIN);
+
+        let mail = matches.get_flag(options::PRESERVE_HEADERS);
+        let uniform = matches.get_flag(options::UNIFORM_SPACING);
+        let quick = matches.get_flag(options::QUICK);
+        let split_only = matches.get_flag(options::SPLIT_ONLY);
+
+        if crown {
+            tagged = false;
+        }
+        if split_only {
+            crown = false;
+            tagged = false;
         }
-    }
-}
 
-/// 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)]
-#[allow(clippy::field_reassign_with_default)]
-fn parse_arguments(args: impl uucore::Args) -> UResult<(Vec<String>, FmtOptions)> {
-    // by default, goal is 93% of width
-    const DEFAULT_GOAL_TO_WIDTH_RATIO: usize = 93;
-
-    let matches = uu_app().try_get_matches_from(args)?;
-
-    let mut files: Vec<String> = matches
-        .get_many::<String>(ARG_FILES)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
-    let mut fmt_opts = FmtOptions::default();
-
-    fmt_opts.tagged = matches.get_flag(OPT_TAGGED_PARAGRAPH);
-    if matches.get_flag(OPT_CROWN_MARGIN) {
-        fmt_opts.crown = true;
-        fmt_opts.tagged = false;
-    }
-    fmt_opts.mail = matches.get_flag(OPT_PRESERVE_HEADERS);
-    fmt_opts.uniform = matches.get_flag(OPT_UNIFORM_SPACING);
-    fmt_opts.quick = matches.get_flag(OPT_QUICK);
-    if matches.get_flag(OPT_SPLIT_ONLY) {
-        fmt_opts.split_only = true;
-        fmt_opts.crown = false;
-        fmt_opts.tagged = false;
-    }
-    fmt_opts.xprefix = matches.contains_id(OPT_EXACT_PREFIX);
-    fmt_opts.xanti_prefix = matches.contains_id(OPT_SKIP_PREFIX);
-
-    if let Some(s) = matches.get_one::<String>(OPT_PREFIX).map(String::from) {
-        fmt_opts.prefix = s;
-        fmt_opts.use_prefix = true;
-    };
-
-    if let Some(s) = matches.get_one::<String>(OPT_SKIP_PREFIX).map(String::from) {
-        fmt_opts.anti_prefix = s;
-        fmt_opts.use_anti_prefix = true;
-    };
-
-    if let Some(s) = matches.get_one::<String>(OPT_WIDTH) {
-        fmt_opts.width = match s.parse::<usize>() {
-            Ok(t) => t,
-            Err(e) => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("Invalid WIDTH specification: {}: {}", s.quote(), e),
-                ));
+        let xprefix = matches.contains_id(options::EXACT_PREFIX);
+        let xanti_prefix = matches.contains_id(options::SKIP_PREFIX);
+
+        let prefix = matches.get_one::<String>(options::PREFIX).map(String::from);
+        let anti_prefix = matches
+            .get_one::<String>(options::SKIP_PREFIX)
+            .map(String::from);
+
+        let width_opt = extract_width(matches)?;
+        let goal_opt_str = matches.get_one::<String>(options::GOAL);
+        let goal_opt = if let Some(goal_str) = goal_opt_str {
+            match goal_str.parse::<usize>() {
+                Ok(goal) => Some(goal),
+                Err(_) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("invalid goal: {}", goal_str.quote()),
+                    ));
+                }
+            }
+        } else {
+            None
+        };
+
+        let (width, goal) = match (width_opt, goal_opt) {
+            (Some(w), Some(g)) => {
+                if g > w {
+                    return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
+                }
+                (w, g)
+            }
+            (Some(0), None) => {
+                // Only allow a goal of zero if the width is set to be zero
+                (0, 0)
+            }
+            (Some(w), None) => {
+                let g = (w * DEFAULT_GOAL_TO_WIDTH_RATIO / 100).max(1);
+                (w, g)
             }
+            (None, Some(g)) => {
+                if g > DEFAULT_WIDTH {
+                    return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
+                }
+                let w = (g * 100 / DEFAULT_GOAL_TO_WIDTH_RATIO).max(g + 3);
+                (w, g)
+            }
+            (None, None) => (DEFAULT_WIDTH, DEFAULT_GOAL),
         };
-        if fmt_opts.width > MAX_WIDTH {
+        debug_assert!(
+            width >= goal,
+            "GOAL {goal} should not be greater than WIDTH {width} when given {width_opt:?} and {goal_opt:?}."
+        );
+
+        if width > MAX_WIDTH {
             return Err(USimpleError::new(
                 1,
-                format!(
-                    "invalid width: '{}': Numerical result out of range",
-                    fmt_opts.width,
-                ),
+                format!("invalid width: '{width}': Numerical result out of range"),
             ));
         }
-        fmt_opts.goal = cmp::min(
-            fmt_opts.width * DEFAULT_GOAL_TO_WIDTH_RATIO / 100,
-            fmt_opts.width - 3,
-        );
-    };
-
-    if let Some(s) = matches.get_one::<String>(OPT_GOAL) {
-        fmt_opts.goal = match s.parse::<usize>() {
-            Ok(t) => t,
-            Err(e) => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("Invalid GOAL specification: {}: {}", s.quote(), e),
-                ));
-            }
-        };
-        if !matches.contains_id(OPT_WIDTH) {
-            fmt_opts.width = cmp::max(
-                fmt_opts.goal * 100 / DEFAULT_GOAL_TO_WIDTH_RATIO,
-                fmt_opts.goal + 3,
-            );
-        } else if fmt_opts.goal > fmt_opts.width {
-            return Err(USimpleError::new(1, "GOAL cannot be greater than WIDTH."));
-        }
-    };
-
-    if let Some(s) = matches.get_one::<String>(OPT_TAB_WIDTH) {
-        fmt_opts.tabwidth = match s.parse::<usize>() {
-            Ok(t) => t,
-            Err(e) => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("Invalid TABWIDTH specification: {}: {}", s.quote(), e),
-                ));
-            }
-        };
-    };
 
-    if fmt_opts.tabwidth < 1 {
-        fmt_opts.tabwidth = 1;
-    }
+        let mut tabwidth = 8;
+        if let Some(s) = matches.get_one::<String>(options::TAB_WIDTH) {
+            tabwidth = match s.parse::<usize>() {
+                Ok(t) => t,
+                Err(e) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("Invalid TABWIDTH specification: {}: {e}", s.quote()),
+                    ));
+                }
+            };
+        };
 
-    // immutable now
-    let fmt_opts = fmt_opts;
+        if tabwidth < 1 {
+            tabwidth = 1;
+        }
 
-    if files.is_empty() {
-        files.push("-".to_owned());
+        Ok(Self {
+            crown,
+            tagged,
+            mail,
+            split_only,
+            prefix,
+            xprefix,
+            anti_prefix,
+            xanti_prefix,
+            uniform,
+            quick,
+            width,
+            goal,
+            tabwidth,
+        })
     }
-
-    Ok((files, fmt_opts))
 }
 
 /// Process the content of a file and format it according to the provided options.
@@ -218,16 +190,21 @@ fn process_file(
     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 mut fp = BufReader::new(match file_name {
+        "-" => Box::new(stdin()) as Box<dyn Read + 'static>,
+        _ => {
+            let f = File::open(file_name)
+                .map_err_context(|| format!("cannot open {} for reading", file_name.quote()))?;
+            if f.metadata()
+                .map_err_context(|| format!("cannot get metadata for {}", file_name.quote()))?
+                .is_dir()
+            {
+                return Err(USimpleError::new(1, "read error".to_string()));
             }
-        },
-    };
+
+            Box::new(f) as Box<dyn Read + 'static>
+        }
+    });
 
     let p_stream = ParagraphStream::new(fmt_opts, &mut fp);
     for para_result in p_stream {
@@ -253,9 +230,99 @@ fn process_file(
     Ok(())
 }
 
+/// Extract the file names from the positional arguments, ignoring any negative width in the first
+/// position.
+///
+/// # Returns
+/// A `UResult<()>` with the file names, or an error if one of the file names could not be parsed
+/// (e.g., it is given as a negative number not in the first argument and not after a --
+fn extract_files(matches: &ArgMatches) -> UResult<Vec<String>> {
+    let in_first_pos = matches
+        .index_of(options::FILES_OR_WIDTH)
+        .is_some_and(|x| x == 1);
+    let is_neg = |s: &str| s.parse::<isize>().is_ok_and(|w| w < 0);
+
+    let files: UResult<Vec<String>> = matches
+        .get_many::<String>(options::FILES_OR_WIDTH)
+        .into_iter()
+        .flatten()
+        .enumerate()
+        .filter_map(|(i, x)| {
+            if is_neg(x) {
+                if in_first_pos && i == 0 {
+                    None
+                } else {
+                    let first_num = x.chars().nth(1).expect("a negative number should be at least two characters long");
+                    Some(Err(
+                        UUsageError::new(1, format!("invalid option -- {first_num}; -WIDTH is recognized only when it is the first\noption; use -w N instead"))
+                    ))
+                }
+            } else {
+                Some(Ok(x.clone()))
+            }
+        })
+        .collect();
+
+    if files.as_ref().is_ok_and(|f| f.is_empty()) {
+        Ok(vec!["-".into()])
+    } else {
+        files
+    }
+}
+
+fn extract_width(matches: &ArgMatches) -> UResult<Option<usize>> {
+    let width_opt = matches.get_one::<String>(options::WIDTH);
+    if let Some(width_str) = width_opt {
+        return if let Ok(width) = width_str.parse::<usize>() {
+            Ok(Some(width))
+        } else {
+            Err(USimpleError::new(
+                1,
+                format!("invalid width: {}", width_str.quote()),
+            ))
+        };
+    }
+
+    if let Some(1) = matches.index_of(options::FILES_OR_WIDTH) {
+        let width_arg = matches.get_one::<String>(options::FILES_OR_WIDTH).unwrap();
+        if let Some(num) = width_arg.strip_prefix('-') {
+            Ok(num.parse::<usize>().ok())
+        } else {
+            // will be treated as a file name
+            Ok(None)
+        }
+    } else {
+        Ok(None)
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let (files, fmt_opts) = parse_arguments(args)?;
+    let args: Vec<_> = args.collect();
+
+    // Warn the user if it looks like we're trying to pass a number in the first
+    // argument with non-numeric characters
+    if let Some(first_arg) = args.get(1) {
+        let first_arg = first_arg.to_string_lossy();
+        let malformed_number = first_arg.starts_with('-')
+            && first_arg.chars().nth(1).is_some_and(|c| c.is_ascii_digit())
+            && first_arg.chars().skip(2).any(|c| !c.is_ascii_digit());
+        if malformed_number {
+            return Err(USimpleError::new(
+                1,
+                format!(
+                    "invalid width: {}",
+                    first_arg.strip_prefix('-').unwrap().quote()
+                ),
+            ));
+        }
+    }
+
+    let matches = uu_app().try_get_matches_from(&args)?;
+
+    let files = extract_files(&matches)?;
+
+    let fmt_opts = FmtOptions::from_matches(&matches)?;
 
     let mut ostream = BufWriter::new(stdout());
 
@@ -268,14 +335,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
-            Arg::new(OPT_CROWN_MARGIN)
+            Arg::new(options::CROWN_MARGIN)
                 .short('c')
-                .long(OPT_CROWN_MARGIN)
+                .long(options::CROWN_MARGIN)
                 .help(
                     "First and second line of paragraph \
                     may have different indentations, in which \
@@ -285,7 +353,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_TAGGED_PARAGRAPH)
+            Arg::new(options::TAGGED_PARAGRAPH)
                 .short('t')
                 .long("tagged-paragraph")
                 .help(
@@ -295,7 +363,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_PRESERVE_HEADERS)
+            Arg::new(options::PRESERVE_HEADERS)
                 .short('m')
                 .long("preserve-headers")
                 .help(
@@ -305,14 +373,14 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_SPLIT_ONLY)
+            Arg::new(options::SPLIT_ONLY)
                 .short('s')
                 .long("split-only")
                 .help("Split lines only, do not reflow.")
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_UNIFORM_SPACING)
+            Arg::new(options::UNIFORM_SPACING)
                 .short('u')
                 .long("uniform-spacing")
                 .help(
@@ -325,7 +393,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_PREFIX)
+            Arg::new(options::PREFIX)
                 .short('p')
                 .long("prefix")
                 .help(
@@ -337,7 +405,7 @@ pub fn uu_app() -> Command {
                 .value_name("PREFIX"),
         )
         .arg(
-            Arg::new(OPT_SKIP_PREFIX)
+            Arg::new(options::SKIP_PREFIX)
                 .short('P')
                 .long("skip-prefix")
                 .help(
@@ -348,7 +416,7 @@ pub fn uu_app() -> Command {
                 .value_name("PSKIP"),
         )
         .arg(
-            Arg::new(OPT_EXACT_PREFIX)
+            Arg::new(options::EXACT_PREFIX)
                 .short('x')
                 .long("exact-prefix")
                 .help(
@@ -358,7 +426,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_EXACT_SKIP_PREFIX)
+            Arg::new(options::EXACT_SKIP_PREFIX)
                 .short('X')
                 .long("exact-skip-prefix")
                 .help(
@@ -368,21 +436,23 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_WIDTH)
+            Arg::new(options::WIDTH)
                 .short('w')
                 .long("width")
-                .help("Fill output lines up to a maximum of WIDTH columns, default 75.")
+                .help("Fill output lines up to a maximum of WIDTH columns, default 75. This can be specified as a negative number in the first argument.")
+                // We must accept invalid values if they are overridden later. This is not supported by clap, so accept all strings instead.
                 .value_name("WIDTH"),
         )
         .arg(
-            Arg::new(OPT_GOAL)
+            Arg::new(options::GOAL)
                 .short('g')
                 .long("goal")
-                .help("Goal width, default of 93% of WIDTH. Must be less than WIDTH.")
+                .help("Goal width, default of 93% of WIDTH. Must be less than or equal to WIDTH.")
+                // We must accept invalid values if they are overridden later. This is not supported by clap, so accept all strings instead.
                 .value_name("GOAL"),
         )
         .arg(
-            Arg::new(OPT_QUICK)
+            Arg::new(options::QUICK)
                 .short('q')
                 .long("quick")
                 .help(
@@ -392,7 +462,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_TAB_WIDTH)
+            Arg::new(options::TAB_WIDTH)
                 .short('T')
                 .long("tab-width")
                 .help(
@@ -403,8 +473,64 @@ pub fn uu_app() -> Command {
                 .value_name("TABWIDTH"),
         )
         .arg(
-            Arg::new(ARG_FILES)
+            Arg::new(options::FILES_OR_WIDTH)
                 .action(ArgAction::Append)
-                .value_hint(clap::ValueHint::FilePath),
+                .value_name("FILES")
+                .value_hint(clap::ValueHint::FilePath)
+                .allow_negative_numbers(true),
         )
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::uu_app;
+    use crate::{extract_files, extract_width};
+
+    #[test]
+    fn parse_negative_width() {
+        let matches = uu_app()
+            .try_get_matches_from(vec!["fmt", "-3", "some-file"])
+            .unwrap();
+
+        assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+        assert_eq!(extract_width(&matches).ok(), Some(Some(3)));
+    }
+
+    #[test]
+    fn parse_width_as_arg() {
+        let matches = uu_app()
+            .try_get_matches_from(vec!["fmt", "-w3", "some-file"])
+            .unwrap();
+
+        assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+        assert_eq!(extract_width(&matches).ok(), Some(Some(3)));
+    }
+
+    #[test]
+    fn parse_no_args() {
+        let matches = uu_app().try_get_matches_from(vec!["fmt"]).unwrap();
+
+        assert_eq!(extract_files(&matches).unwrap(), vec!["-"]);
+        assert_eq!(extract_width(&matches).ok(), Some(None));
+    }
+
+    #[test]
+    fn parse_just_file_name() {
+        let matches = uu_app()
+            .try_get_matches_from(vec!["fmt", "some-file"])
+            .unwrap();
+
+        assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+        assert_eq!(extract_width(&matches).ok(), Some(None));
+    }
+
+    #[test]
+    fn parse_with_both_widths_positional_first() {
+        let matches = uu_app()
+            .try_get_matches_from(vec!["fmt", "-10", "-w3", "some-file"])
+            .unwrap();
+
+        assert_eq!(extract_files(&matches).unwrap(), vec!["some-file"]);
+        assert_eq!(extract_width(&matches).ok(), Some(Some(3)));
+    }
+}
diff --git a/src/uu/fmt/src/linebreak.rs b/src/uu/fmt/src/linebreak.rs
index fbd990fff1e..6c34b08088a 100644
--- a/src/uu/fmt/src/linebreak.rs
+++ b/src/uu/fmt/src/linebreak.rs
@@ -5,15 +5,11 @@
 
 // spell-checker:ignore (ToDO) INFTY MULT accum breakwords linebreak linebreaking linebreaks linelen maxlength minlength nchars ostream overlen parasplit plass posn powf punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen
 
-use std::cmp;
-use std::i64;
 use std::io::{BufWriter, Stdout, Write};
-use std::mem;
+use std::{cmp, mem};
 
-use uucore::crash;
-
-use crate::parasplit::{ParaWords, Paragraph, WordInfo};
 use crate::FmtOptions;
+use crate::parasplit::{ParaWords, Paragraph, WordInfo};
 
 struct BreakArgs<'a> {
     opts: &'a FmtOptions,
@@ -24,7 +20,7 @@ struct BreakArgs<'a> {
     ostream: &'a mut BufWriter<Stdout>,
 }
 
-impl<'a> BreakArgs<'a> {
+impl BreakArgs<'_> {
     fn compute_width(&self, winfo: &WordInfo, posn: usize, fresh: bool) -> usize {
         if fresh {
             0
@@ -46,7 +42,7 @@ pub fn break_lines(
     ostream: &mut BufWriter<Stdout>,
 ) -> std::io::Result<()> {
     // indent
-    let p_indent = &para.indent_str[..];
+    let p_indent = &para.indent_str;
     let p_indent_len = para.indent_len;
 
     // words
@@ -55,14 +51,12 @@ pub fn break_lines(
 
     // the first word will *always* appear on the first line
     // make sure of this here
-    let (w, w_len) = match p_words_words.next() {
-        Some(winfo) => (winfo.word, winfo.word_nchars),
-        None => {
-            return ostream.write_all(b"\n");
-        }
+    let Some(winfo) = p_words_words.next() else {
+        return ostream.write_all(b"\n");
     };
+
     // print the init, if it exists, and get its length
-    let p_init_len = w_len
+    let p_init_len = winfo.word_nchars
         + if opts.crown || opts.tagged {
             // handle "init" portion
             ostream.write_all(para.init_str.as_bytes())?;
@@ -75,8 +69,9 @@ pub fn break_lines(
             // except that mail headers get no indent at all
             0
         };
+
     // write first word after writing init
-    ostream.write_all(w.as_bytes())?;
+    ostream.write_all(winfo.word.as_bytes())?;
 
     // does this paragraph require uniform spacing?
     let uniform = para.mail_header || opts.uniform;
@@ -103,15 +98,16 @@ fn break_simple<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
     mut iter: T,
     args: &mut BreakArgs<'a>,
 ) -> std::io::Result<()> {
-    iter.try_fold((args.init_len, false), |l, winfo| {
-        accum_words_simple(args, l, winfo)
+    iter.try_fold((args.init_len, false), |(l, prev_punct), winfo| {
+        accum_words_simple(args, l, prev_punct, winfo)
     })?;
     args.ostream.write_all(b"\n")
 }
 
 fn accum_words_simple<'a>(
     args: &mut BreakArgs<'a>,
-    (l, prev_punct): (usize, bool),
+    l: usize,
+    prev_punct: bool,
     winfo: &'a WordInfo<'a>,
 ) -> std::io::Result<(usize, bool)> {
     // compute the length of this word, considering how tabs will expand at this position on the line
@@ -168,9 +164,7 @@ fn break_knuth_plass<'a, T: Clone + Iterator<Item = &'a WordInfo<'a>>>(
 
                 // We find identical breakpoints here by comparing addresses of the references.
                 // This is OK because the backing vector is not mutating once we are linebreaking.
-                let winfo_ptr = winfo as *const _;
-                let next_break_ptr = next_break as *const _;
-                if winfo_ptr == next_break_ptr {
+                if std::ptr::eq(winfo, next_break) {
                     // OK, we found the matching word
                     if break_before {
                         write_newline(args.indent_str, args.ostream)?;
@@ -233,25 +227,22 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
         linebreak: None,
         break_before: false,
         demerits: 0,
-        prev_rat: 0.0f32,
+        prev_rat: 0.0,
         length: args.init_len,
         fresh: false,
     }];
     // this vec holds the current active linebreaks; next_ holds the breaks that will be active for
     // the next word
-    let active_breaks = &mut vec![0];
-    let next_active_breaks = &mut vec![];
+    let mut active_breaks = vec![0];
+    let mut next_active_breaks = vec![];
 
-    let stretch = (args.opts.width - args.opts.goal) as isize;
-    let minlength = args.opts.goal - stretch as usize;
+    let stretch = args.opts.width - args.opts.goal;
+    let minlength = args.opts.goal.max(stretch + 1) - stretch;
     let mut new_linebreaks = vec![];
     let mut is_sentence_start = false;
     let mut least_demerits = 0;
     loop {
-        let w = match iter.next() {
-            None => break,
-            Some(w) => w,
-        };
+        let Some(w) = iter.next() else { break };
 
         // if this is the last word, we don't add additional demerits for this break
         let (is_last_word, is_sentence_end) = match iter.peek() {
@@ -307,7 +298,7 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
                         compute_demerits(
                             args.opts.goal as isize - tlen as isize,
                             stretch,
-                            w.word_nchars as isize,
+                            w.word_nchars,
                             active.prev_rat,
                         )
                     };
@@ -358,38 +349,36 @@ fn find_kp_breakpoints<'a, T: Iterator<Item = &'a WordInfo<'a>>>(
             least_demerits = cmp::max(ld_next, 0);
         }
         // swap in new list of active breaks
-        mem::swap(active_breaks, next_active_breaks);
+        mem::swap(&mut active_breaks, &mut next_active_breaks);
         // If this was the last word in a sentence, the next one must be the first in the next.
         is_sentence_start = is_sentence_end;
     }
 
     // return the best path
-    build_best_path(&linebreaks, active_breaks)
+    build_best_path(&linebreaks, &active_breaks)
 }
 
 fn build_best_path<'a>(paths: &[LineBreak<'a>], active: &[usize]) -> Vec<(&'a WordInfo<'a>, bool)> {
-    let mut breakwords = vec![];
     // of the active paths, we select the one with the fewest demerits
-    let mut best_idx = match active.iter().min_by_key(|&&a| paths[a].demerits) {
-        None => crash!(
-            1,
-            "Failed to find a k-p linebreak solution. This should never happen."
-        ),
-        Some(&s) => s,
-    };
-
-    // now, chase the pointers back through the break list, recording
-    // the words at which we should break
-    loop {
-        let next_best = &paths[best_idx];
-        match next_best.linebreak {
-            None => return breakwords,
-            Some(prev) => {
-                breakwords.push((prev, next_best.break_before));
-                best_idx = next_best.prev;
+    active
+        .iter()
+        .min_by_key(|&&a| paths[a].demerits)
+        .map(|&(mut best_idx)| {
+            let mut breakwords = vec![];
+            // now, chase the pointers back through the break list, recording
+            // the words at which we should break
+            loop {
+                let next_best = &paths[best_idx];
+                match next_best.linebreak {
+                    None => return breakwords,
+                    Some(prev) => {
+                        breakwords.push((prev, next_best.break_before));
+                        best_idx = next_best.prev;
+                    }
+                }
             }
-        }
-    }
+        })
+        .unwrap_or_default()
 }
 
 // "infinite" badness is more like (1+BAD_INFTY)^2 because of how demerits are computed
@@ -402,7 +391,7 @@ const DR_MULT: f32 = 600.0;
 // DL_MULT is penalty multiplier for short words at end of line
 const DL_MULT: f32 = 300.0;
 
-fn compute_demerits(delta_len: isize, stretch: isize, wlen: isize, prev_rat: f32) -> (i64, f32) {
+fn compute_demerits(delta_len: isize, stretch: usize, wlen: usize, prev_rat: f32) -> (i64, f32) {
     // how much stretch are we using?
     let ratio = if delta_len == 0 {
         0.0f32
@@ -428,7 +417,7 @@ fn compute_demerits(delta_len: isize, stretch: isize, wlen: isize, prev_rat: f32
     };
 
     // we penalize lines that have very different ratios from previous lines
-    let bad_delta_r = (DR_MULT * (((ratio - prev_rat) / 2.0).powi(3)).abs()) as i64;
+    let bad_delta_r = (DR_MULT * ((ratio - prev_rat) / 2.0).powi(3).abs()) as i64;
 
     let demerits = i64::pow(1 + bad_linelen + bad_wordlen + bad_delta_r, 2);
 
@@ -449,8 +438,8 @@ fn restart_active_breaks<'a>(
     } else {
         // choose the lesser evil: breaking too early, or breaking too late
         let wlen = w.word_nchars + args.compute_width(w, active.length, active.fresh);
-        let underlen = (min - active.length) as isize;
-        let overlen = ((wlen + slen + active.length) - args.opts.width) as isize;
+        let underlen = min as isize - active.length as isize;
+        let overlen = (wlen + slen + active.length) as isize - args.opts.width as isize;
         if overlen > underlen {
             // break early, put this word on the next line
             (true, args.indent_len + w.word_nchars)
@@ -474,11 +463,7 @@ fn restart_active_breaks<'a>(
 // Number of spaces to add before a word, based on mode, newline, sentence start.
 fn compute_slen(uniform: bool, newline: bool, start: bool, punct: bool) -> usize {
     if uniform || newline {
-        if start || (newline && punct) {
-            2
-        } else {
-            1
-        }
+        if start || (newline && punct) { 2 } else { 1 }
     } else {
         0
     }
diff --git a/src/uu/fmt/src/parasplit.rs b/src/uu/fmt/src/parasplit.rs
index 68c8f78fa89..f9da4ad58fd 100644
--- a/src/uu/fmt/src/parasplit.rs
+++ b/src/uu/fmt/src/parasplit.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) INFTY MULT PSKIP accum aftertab beforetab breakwords fmt's formatline linebreak linebreaking linebreaks linelen maxlength minlength nchars noformat noformatline ostream overlen parasplit pfxind plass pmatch poffset posn powf prefixindent punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen wordsplits xanti xprefix
+// spell-checker:ignore (ToDO) INFTY MULT PSKIP accum aftertab beforetab breakwords fmt's formatline linebreak linebreaking linebreaks linelen maxlength minlength nchars noformat noformatline ostream overlen parasplit plass pmatch poffset posn powf prefixindent punct signum slen sstart tabwidth tlen underlen winfo wlen wordlen wordsplits xanti xprefix
 
 use std::io::{BufRead, Lines};
 use std::iter::Peekable;
@@ -52,48 +52,48 @@ impl Line {
     }
 }
 
-// each line's prefix has to be considered to know whether to merge it with
-// the next line or not
+/// Each line's prefix has to be considered to know whether to merge it with
+/// the next line or not
 #[derive(Debug)]
 pub struct FileLine {
     line: String,
-    indent_end: usize, // the end of the indent, always the start of the text
-    pfxind_end: usize, // the end of the PREFIX's indent, that is, the spaces before the prefix
-    indent_len: usize, // display length of indent taking into account tabs
-    prefix_len: usize, // PREFIX indent length taking into account tabs
+    /// The end of the indent, always the start of the text
+    indent_end: usize,
+    /// The end of the PREFIX's indent, that is, the spaces before the prefix
+    prefix_indent_end: usize,
+    /// Display length of indent taking into account tabs
+    indent_len: usize,
+    /// PREFIX indent length taking into account tabs
+    prefix_len: usize,
 }
 
-// iterator that produces a stream of Lines from a file
+/// Iterator that produces a stream of Lines from a file
 pub struct FileLines<'a> {
     opts: &'a FmtOptions,
     lines: Lines<&'a mut FileOrStdReader>,
 }
 
-impl<'a> FileLines<'a> {
+impl FileLines<'_> {
     fn new<'b>(opts: &'b FmtOptions, lines: Lines<&'b mut FileOrStdReader>) -> FileLines<'b> {
         FileLines { opts, lines }
     }
 
-    // returns true if this line should be formatted
+    /// returns true if this line should be formatted
     fn match_prefix(&self, line: &str) -> (bool, usize) {
-        if !self.opts.use_prefix {
+        let Some(prefix) = &self.opts.prefix else {
             return (true, 0);
-        }
+        };
 
-        FileLines::match_prefix_generic(&self.opts.prefix[..], line, self.opts.xprefix)
+        FileLines::match_prefix_generic(prefix, line, self.opts.xprefix)
     }
 
-    // returns true if this line should be formatted
+    /// returns true if this line should be formatted
     fn match_anti_prefix(&self, line: &str) -> bool {
-        if !self.opts.use_anti_prefix {
+        let Some(anti_prefix) = &self.opts.anti_prefix else {
             return true;
-        }
+        };
 
-        match FileLines::match_prefix_generic(
-            &self.opts.anti_prefix[..],
-            line,
-            self.opts.xanti_prefix,
-        ) {
+        match FileLines::match_prefix_generic(anti_prefix, line, self.opts.xanti_prefix) {
             (true, _) => false,
             (_, _) => true,
         }
@@ -144,17 +144,11 @@ impl<'a> FileLines<'a> {
     }
 }
 
-impl<'a> Iterator for FileLines<'a> {
+impl Iterator for FileLines<'_> {
     type Item = Line;
 
     fn next(&mut self) -> Option<Line> {
-        let n = match self.lines.next() {
-            Some(t) => match t {
-                Ok(tt) => tt,
-                Err(_) => return None,
-            },
-            None => return None,
-        };
+        let n = self.lines.next()?.ok()?;
 
         // if this line is entirely whitespace,
         // emit a blank line
@@ -178,7 +172,7 @@ impl<'a> Iterator for FileLines<'a> {
         // not truly blank we will not allow mail headers on the
         // following line)
         if pmatch
-            && n[poffset + self.opts.prefix.len()..]
+            && n[poffset + self.opts.prefix.as_ref().map_or(0, |s| s.len())..]
                 .chars()
                 .all(char::is_whitespace)
         {
@@ -192,44 +186,53 @@ impl<'a> Iterator for FileLines<'a> {
         }
 
         // figure out the indent, prefix, and prefixindent ending points
-        let prefix_end = poffset + self.opts.prefix.len();
+        let prefix_end = poffset + self.opts.prefix.as_ref().map_or(0, |s| s.len());
         let (indent_end, prefix_len, indent_len) = self.compute_indent(&n[..], prefix_end);
 
         Some(Line::FormatLine(FileLine {
             line: n,
             indent_end,
-            pfxind_end: poffset,
+            prefix_indent_end: poffset,
             indent_len,
             prefix_len,
         }))
     }
 }
 
-// a paragraph : a collection of FileLines that are to be formatted
-// plus info about the paragraph's indentation
-// (but we only retain the String from the FileLine; the other info
-// is only there to help us in deciding how to merge lines into Paragraphs
+/// A paragraph : a collection of FileLines that are to be formatted
+/// plus info about the paragraph's indentation
+///
+/// We only retain the String from the FileLine; the other info
+/// is only there to help us in deciding how to merge lines into Paragraphs
 #[derive(Debug)]
 pub struct Paragraph {
-    lines: Vec<String>,     // the lines of the file
-    pub init_str: String,   // string representing the init, that is, the first line's indent
-    pub init_len: usize,    // printable length of the init string considering TABWIDTH
-    init_end: usize,        // byte location of end of init in first line String
-    pub indent_str: String, // string representing indent
-    pub indent_len: usize,  // length of above
-    indent_end: usize, // byte location of end of indent (in crown and tagged mode, only applies to 2nd line and onward)
-    pub mail_header: bool, // we need to know if this is a mail header because we do word splitting differently in that case
+    /// the lines of the file
+    lines: Vec<String>,
+    /// string representing the init, that is, the first line's indent
+    pub init_str: String,
+    /// printable length of the init string considering TABWIDTH
+    pub init_len: usize,
+    /// byte location of end of init in first line String
+    init_end: usize,
+    /// string representing indent
+    pub indent_str: String,
+    /// length of above
+    pub indent_len: usize,
+    /// byte location of end of indent (in crown and tagged mode, only applies to 2nd line and onward)
+    indent_end: usize,
+    /// we need to know if this is a mail header because we do word splitting differently in that case
+    pub mail_header: bool,
 }
 
-// an iterator producing a stream of paragraphs from a stream of lines
-// given a set of options.
+/// An iterator producing a stream of paragraphs from a stream of lines
+/// given a set of options.
 pub struct ParagraphStream<'a> {
     lines: Peekable<FileLines<'a>>,
     next_mail: bool,
     opts: &'a FmtOptions,
 }
 
-impl<'a> ParagraphStream<'a> {
+impl ParagraphStream<'_> {
     pub fn new<'b>(opts: &'b FmtOptions, reader: &'b mut FileOrStdReader) -> ParagraphStream<'b> {
         let lines = FileLines::new(opts, reader.lines()).peekable();
         // at the beginning of the file, we might find mail headers
@@ -240,7 +243,7 @@ impl<'a> ParagraphStream<'a> {
         }
     }
 
-    // detect RFC822 mail header
+    /// Detect RFC822 mail header
     fn is_mail_header(line: &FileLine) -> bool {
         // a mail header begins with either "From " (envelope sender line)
         // or with a sequence of printable ASCII chars (33 to 126, inclusive,
@@ -252,9 +255,8 @@ impl<'a> ParagraphStream<'a> {
             if l_slice.starts_with("From ") {
                 true
             } else {
-                let colon_posn = match l_slice.find(':') {
-                    Some(n) => n,
-                    None => return false,
+                let Some(colon_posn) = l_slice.find(':') else {
+                    return false;
                 };
 
                 // header field must be nonzero length
@@ -270,18 +272,15 @@ impl<'a> ParagraphStream<'a> {
     }
 }
 
-impl<'a> Iterator for ParagraphStream<'a> {
+impl Iterator for ParagraphStream<'_> {
     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() {
-            None => return None,
-            Some(l) => match *l {
-                Line::FormatLine(_) => false,
-                Line::NoFormatLine(_, _) => true,
-            },
+        let noformat = match self.lines.peek()? {
+            Line::FormatLine(_) => false,
+            Line::NoFormatLine(_, _) => true,
         };
 
         // found a NoFormatLine, immediately dump it out
@@ -299,101 +298,95 @@ impl<'a> Iterator for ParagraphStream<'a> {
         let mut indent_end = 0;
         let mut indent_len = 0;
         let mut prefix_len = 0;
-        let mut pfxind_end = 0;
+        let mut prefix_indent_end = 0;
         let mut p_lines = Vec::new();
 
         let mut in_mail = false;
         let mut second_done = false; // for when we use crown or tagged mode
         loop {
-            {
-                // peek ahead
-                // need to explicitly force fl out of scope before we can call self.lines.next()
-                let fl = match self.lines.peek() {
-                    None => break,
-                    Some(l) => match *l {
-                        Line::FormatLine(ref x) => x,
-                        Line::NoFormatLine(..) => break,
-                    },
-                };
+            // peek ahead
+            // need to explicitly force fl out of scope before we can call self.lines.next()
+            let Some(Line::FormatLine(fl)) = self.lines.peek() else {
+                break;
+            };
 
-                if p_lines.is_empty() {
-                    // first time through the loop, get things set up
-                    // detect mail header
-                    if self.opts.mail && self.next_mail && ParagraphStream::is_mail_header(fl) {
-                        in_mail = true;
-                        // there can't be any indent or pfxind because otherwise is_mail_header
-                        // would fail since there cannot be any whitespace before the colon in a
-                        // valid header field
-                        indent_str.push_str("  ");
-                        indent_len = 2;
+            if p_lines.is_empty() {
+                // first time through the loop, get things set up
+                // detect mail header
+                if self.opts.mail && self.next_mail && ParagraphStream::is_mail_header(fl) {
+                    in_mail = true;
+                    // there can't be any indent or prefixindent because otherwise is_mail_header
+                    // would fail since there cannot be any whitespace before the colon in a
+                    // valid header field
+                    indent_str.push_str("  ");
+                    indent_len = 2;
+                } else {
+                    if self.opts.crown || self.opts.tagged {
+                        init_str.push_str(&fl.line[..fl.indent_end]);
+                        init_len = fl.indent_len;
+                        init_end = fl.indent_end;
                     } else {
-                        if self.opts.crown || self.opts.tagged {
-                            init_str.push_str(&fl.line[..fl.indent_end]);
-                            init_len = fl.indent_len;
-                            init_end = fl.indent_end;
-                        } else {
-                            second_done = true;
-                        }
-
-                        // these will be overwritten in the 2nd line of crown or tagged mode, but
-                        // we are not guaranteed to get to the 2nd line, e.g., if the next line
-                        // is a NoFormatLine or None. Thus, we set sane defaults the 1st time around
-                        indent_str.push_str(&fl.line[..fl.indent_end]);
-                        indent_len = fl.indent_len;
-                        indent_end = fl.indent_end;
-
-                        // save these to check for matching lines
-                        prefix_len = fl.prefix_len;
-                        pfxind_end = fl.pfxind_end;
-
-                        // in tagged mode, add 4 spaces of additional indenting by default
-                        // (gnu fmt's behavior is different: it seems to find the closest column to
-                        // indent_end that is divisible by 3. But honestly that behavior seems
-                        // pretty arbitrary.
-                        // Perhaps a better default would be 1 TABWIDTH? But ugh that's so big.
-                        if self.opts.tagged {
-                            indent_str.push_str("    ");
-                            indent_len += 4;
-                        }
-                    }
-                } else if in_mail {
-                    // lines following mail headers must begin with spaces
-                    if fl.indent_end == 0 || (self.opts.use_prefix && fl.pfxind_end == 0) {
-                        break; // this line does not begin with spaces
-                    }
-                } else if !second_done {
-                    // now we have enough info to handle crown margin and tagged mode
-
-                    // in both crown and tagged modes we require that prefix_len is the same
-                    if prefix_len != fl.prefix_len || pfxind_end != fl.pfxind_end {
-                        break;
-                    }
-
-                    // in tagged mode, indent has to be *different* on following lines
-                    if self.opts.tagged
-                        && indent_len - 4 == fl.indent_len
-                        && indent_end == fl.indent_end
-                    {
-                        break;
+                        second_done = true;
                     }
 
-                    // this is part of the same paragraph, get the indent info from this line
-                    indent_str.clear();
+                    // these will be overwritten in the 2nd line of crown or tagged mode, but
+                    // we are not guaranteed to get to the 2nd line, e.g., if the next line
+                    // is a NoFormatLine or None. Thus, we set sane defaults the 1st time around
                     indent_str.push_str(&fl.line[..fl.indent_end]);
                     indent_len = fl.indent_len;
                     indent_end = fl.indent_end;
 
-                    second_done = true;
-                } else {
-                    // detect mismatch
-                    if indent_end != fl.indent_end
-                        || pfxind_end != fl.pfxind_end
-                        || indent_len != fl.indent_len
-                        || prefix_len != fl.prefix_len
-                    {
-                        break;
+                    // save these to check for matching lines
+                    prefix_len = fl.prefix_len;
+                    prefix_indent_end = fl.prefix_indent_end;
+
+                    // in tagged mode, add 4 spaces of additional indenting by default
+                    // (gnu fmt's behavior is different: it seems to find the closest column to
+                    // indent_end that is divisible by 3. But honestly that behavior seems
+                    // pretty arbitrary.
+                    // Perhaps a better default would be 1 TABWIDTH? But ugh that's so big.
+                    if self.opts.tagged {
+                        indent_str.push_str("    ");
+                        indent_len += 4;
                     }
                 }
+            } else if in_mail {
+                // lines following mail headers must begin with spaces
+                if fl.indent_end == 0 || (self.opts.prefix.is_some() && fl.prefix_indent_end == 0) {
+                    break; // this line does not begin with spaces
+                }
+            } else if !second_done {
+                // now we have enough info to handle crown margin and tagged mode
+
+                // in both crown and tagged modes we require that prefix_len is the same
+                if prefix_len != fl.prefix_len || prefix_indent_end != fl.prefix_indent_end {
+                    break;
+                }
+
+                // in tagged mode, indent has to be *different* on following lines
+                if self.opts.tagged
+                    && indent_len - 4 == fl.indent_len
+                    && indent_end == fl.indent_end
+                {
+                    break;
+                }
+
+                // this is part of the same paragraph, get the indent info from this line
+                indent_str.clear();
+                indent_str.push_str(&fl.line[..fl.indent_end]);
+                indent_len = fl.indent_len;
+                indent_end = fl.indent_end;
+
+                second_done = true;
+            } else {
+                // detect mismatch
+                if indent_end != fl.indent_end
+                    || prefix_indent_end != fl.prefix_indent_end
+                    || indent_len != fl.indent_len
+                    || prefix_len != fl.prefix_len
+                {
+                    break;
+                }
             }
 
             p_lines.push(self.lines.next().unwrap().get_formatline().line);
@@ -429,7 +422,7 @@ pub struct ParaWords<'a> {
 }
 
 impl<'a> ParaWords<'a> {
-    pub fn new<'b>(opts: &'b FmtOptions, para: &'b Paragraph) -> ParaWords<'b> {
+    pub fn new(opts: &'a FmtOptions, para: &'a Paragraph) -> Self {
         let mut pw = ParaWords {
             opts,
             para,
@@ -497,7 +490,7 @@ struct WordSplit<'a> {
     prev_punct: bool,
 }
 
-impl<'a> WordSplit<'a> {
+impl WordSplit<'_> {
     fn analyze_tabs(&self, string: &str) -> (Option<usize>, usize, Option<usize>) {
         // given a string, determine (length before tab) and (printed length after first tab)
         // if there are no tabs, beforetab = -1 and aftertab is the printed length
@@ -523,7 +516,7 @@ impl<'a> WordSplit<'a> {
     }
 }
 
-impl<'a> WordSplit<'a> {
+impl WordSplit<'_> {
     fn new<'b>(opts: &'b FmtOptions, string: &'b str) -> WordSplit<'b> {
         // wordsplits *must* start at a non-whitespace character
         let trim_string = string.trim_start();
@@ -566,12 +559,11 @@ impl<'a> Iterator for WordSplit<'a> {
 
         // find the start of the next word, and record if we find a tab character
         let (before_tab, after_tab, word_start) =
-            match self.analyze_tabs(&self.string[old_position..]) {
-                (b, a, Some(s)) => (b, a, s + old_position),
-                (_, _, None) => {
-                    self.position = self.length;
-                    return None;
-                }
+            if let (b, a, Some(s)) = self.analyze_tabs(&self.string[old_position..]) {
+                (b, a, s + old_position)
+            } else {
+                self.position = self.length;
+                return None;
             };
 
         // find the beginning of the next whitespace
diff --git a/src/uu/fold/Cargo.toml b/src/uu/fold/Cargo.toml
index ff2f2f6d564..ab6adaba16c 100644
--- a/src/uu/fold/Cargo.toml
+++ b/src/uu/fold/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_fold"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "fold ~ (uutils) wrap each line of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/fold"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/fold.rs"
diff --git a/src/uu/fold/src/fold.rs b/src/uu/fold/src/fold.rs
index 95b6d9a8236..0aba9c57ee4 100644
--- a/src/uu/fold/src/fold.rs
+++ b/src/uu/fold/src/fold.rs
@@ -5,9 +5,9 @@
 
 // spell-checker:ignore (ToDOs) ncount routput
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, Read};
+use std::io::{BufRead, BufReader, Read, stdin};
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
@@ -35,7 +35,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let bytes = matches.get_flag(options::BYTES);
     let spaces = matches.get_flag(options::SPACES);
     let poss_width = match matches.get_one::<String>(options::WIDTH) {
-        Some(v) => Some(v.to_owned()),
+        Some(v) => Some(v.clone()),
         None => obs_width,
     };
 
@@ -43,14 +43,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         Some(inp_width) => inp_width.parse::<usize>().map_err(|e| {
             USimpleError::new(
                 1,
-                format!("illegal width value ({}): {}", inp_width.quote(), e),
+                format!("illegal width value ({}): {e}", inp_width.quote()),
             )
         })?,
         None => 80,
     };
 
     let files = match matches.get_many::<String>(options::FILE) {
-        Some(v) => v.map(|v| v.to_owned()).collect(),
+        Some(v) => v.cloned().collect(),
         None => vec!["-".to_owned()],
     };
 
@@ -59,7 +59,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
@@ -99,7 +99,7 @@ pub fn uu_app() -> Command {
 fn handle_obsolete(args: &[String]) -> (Vec<String>, Option<String>) {
     for (i, arg) in args.iter().enumerate() {
         let slice = &arg;
-        if slice.starts_with('-') && slice.chars().nth(1).map_or(false, |c| c.is_ascii_digit()) {
+        if slice.starts_with('-') && slice.chars().nth(1).is_some_and(|c| c.is_ascii_digit()) {
             let mut v = args.to_vec();
             v.remove(i);
             return (v, Some(slice[1..].to_owned()));
diff --git a/src/uu/groups/Cargo.toml b/src/uu/groups/Cargo.toml
index d503d3e83f6..d3cd62d4900 100644
--- a/src/uu/groups/Cargo.toml
+++ b/src/uu/groups/Cargo.toml
@@ -1,21 +1,25 @@
 [package]
 name = "uu_groups"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "groups ~ (uutils) display group memberships for USERNAME"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/groups"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/groups.rs"
 
 [dependencies]
 clap = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true, features = ["entries", "process"] }
 
 [[bin]]
diff --git a/src/uu/groups/src/groups.rs b/src/uu/groups/src/groups.rs
index 0f0dfce804a..6f7fbf5fed2 100644
--- a/src/uu/groups/src/groups.rs
+++ b/src/uu/groups/src/groups.rs
@@ -2,26 +2,18 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-//
-// ============================================================================
-// Test suite summary for GNU coreutils 8.32.162-4eda
-// ============================================================================
-// PASS: tests/misc/groups-dash.sh
-// PASS: tests/misc/groups-process-all.sh
-// PASS: tests/misc/groups-version.sh
 
 // spell-checker:ignore (ToDO) passwd
 
-use std::error::Error;
-use std::fmt::Display;
+use thiserror::Error;
 use uucore::{
     display::Quotable,
-    entries::{get_groups_gnu, gid2grp, Locate, Passwd},
+    entries::{Locate, Passwd, get_groups_gnu, gid2grp},
     error::{UError, UResult},
     format_usage, help_about, help_usage, show,
 };
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 
 mod options {
     pub const USERS: &str = "USERNAME";
@@ -29,26 +21,20 @@ mod options {
 const ABOUT: &str = help_about!("groups.md");
 const USAGE: &str = help_usage!("groups.md");
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum GroupsError {
+    #[error("failed to fetch groups")]
     GetGroupsFailed,
+
+    #[error("cannot find name for group ID {0}")]
     GroupNotFound(u32),
+
+    #[error("{user}: no such user", user = .0.quote())]
     UserNotFound(String),
 }
 
-impl Error for GroupsError {}
 impl UError for GroupsError {}
 
-impl Display for GroupsError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Self::GetGroupsFailed => write!(f, "failed to fetch groups"),
-            Self::GroupNotFound(gid) => write!(f, "cannot find name for group ID {gid}"),
-            Self::UserNotFound(user) => write!(f, "{}: no such user", user.quote()),
-        }
-    }
-}
-
 fn infallible_gid2grp(gid: &u32) -> String {
     match gid2grp(*gid) {
         Ok(grp) => grp,
@@ -70,9 +56,8 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .unwrap_or_default();
 
     if users.is_empty() {
-        let gids = match get_groups_gnu(None) {
-            Ok(v) => v,
-            Err(_) => return Err(GroupsError::GetGroupsFailed.into()),
+        let Ok(gids) = get_groups_gnu(None) else {
+            return Err(GroupsError::GetGroupsFailed.into());
         };
         let groups: Vec<String> = gids.iter().map(infallible_gid2grp).collect();
         println!("{}", groups.join(" "));
@@ -83,7 +68,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         match Passwd::locate(user.as_str()) {
             Ok(p) => {
                 let groups: Vec<String> = p.belongs_to().iter().map(infallible_gid2grp).collect();
-                println!("{} : {}", user, groups.join(" "));
+                println!("{user} : {}", groups.join(" "));
             }
             Err(_) => {
                 // The `show!()` macro sets the global exit code for the program.
@@ -96,7 +81,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/hashsum/Cargo.toml b/src/uu/hashsum/Cargo.toml
index 1b075fb4871..ff1c7de1c10 100644
--- a/src/uu/hashsum/Cargo.toml
+++ b/src/uu/hashsum/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_hashsum"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "hashsum ~ (uutils) display or check input digests"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/hashsum"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/hashsum.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["sum"] }
+uucore = { workspace = true, features = ["checksum", "sum"] }
 memchr = { workspace = true }
 regex = { workspace = true }
 hex = { workspace = true }
diff --git a/src/uu/hashsum/hashsum.md b/src/uu/hashsum/hashsum.md
index a632eedf3d9..35ec840a39c 100644
--- a/src/uu/hashsum/hashsum.md
+++ b/src/uu/hashsum/hashsum.md
@@ -1,7 +1,7 @@
 # hashsum
 
 ```
-hashsum [OPTIONS] [FILE]...
+hashsum --<digest> [OPTIONS]... [FILE]...
 ```
 
 Compute and check message digests.
diff --git a/src/uu/hashsum/src/hashsum.rs b/src/uu/hashsum/src/hashsum.rs
index f8f00f01119..cd8ca912df5 100644
--- a/src/uu/hashsum/src/hashsum.rs
+++ b/src/uu/hashsum/src/hashsum.rs
@@ -5,27 +5,28 @@
 
 // spell-checker:ignore (ToDO) algo, algoname, regexes, nread, nonames
 
-use clap::builder::ValueParser;
-use clap::crate_version;
 use clap::ArgAction;
+use clap::builder::ValueParser;
+use clap::value_parser;
 use clap::{Arg, ArgMatches, Command};
-use hex::encode;
-use regex::Captures;
-use regex::Regex;
-use std::cmp::Ordering;
-use std::error::Error;
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
-use std::io::{self, stdin, BufRead, BufReader, Read};
+use std::io::{BufReader, Read, stdin};
 use std::iter;
 use std::num::ParseIntError;
 use std::path::Path;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::sum::{
-    Blake2b, Blake3, Digest, DigestWriter, Md5, Sha1, Sha224, Sha256, Sha384, Sha3_224, Sha3_256,
-    Sha3_384, Sha3_512, Sha512, Shake128, Shake256,
-};
-use uucore::{crash, display::Quotable, show_warning};
+use uucore::checksum::ChecksumError;
+use uucore::checksum::ChecksumOptions;
+use uucore::checksum::ChecksumVerbose;
+use uucore::checksum::HashAlgorithm;
+use uucore::checksum::calculate_blake2b_length;
+use uucore::checksum::create_sha3;
+use uucore::checksum::detect_algo;
+use uucore::checksum::digest_reader;
+use uucore::checksum::escape_filename;
+use uucore::checksum::perform_checksum_validation;
+use uucore::error::{FromIo, UResult};
+use uucore::sum::{Digest, Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
 use uucore::{format_usage, help_about, help_usage};
 
 const NAME: &str = "hashsum";
@@ -36,176 +37,16 @@ struct Options {
     algoname: &'static str,
     digest: Box<dyn Digest + 'static>,
     binary: bool,
-    check: bool,
+    //check: bool,
     tag: bool,
     nonames: bool,
-    status: bool,
-    quiet: bool,
-    strict: bool,
-    warn: bool,
+    //status: bool,
+    //quiet: bool,
+    //strict: bool,
+    //warn: bool,
     output_bits: usize,
     zero: bool,
-}
-
-/// 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 (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" => create_blake2b(matches),
-        "b3sum" => ("BLAKE3", Box::new(Blake3::new()) as Box<dyn Digest>, 256),
-        "sha3sum" => create_sha3(matches),
-        "sha3-224sum" => (
-            "SHA3-224",
-            Box::new(Sha3_224::new()) as Box<dyn Digest>,
-            224,
-        ),
-        "sha3-256sum" => (
-            "SHA3-256",
-            Box::new(Sha3_256::new()) as Box<dyn Digest>,
-            256,
-        ),
-        "sha3-384sum" => (
-            "SHA3-384",
-            Box::new(Sha3_384::new()) as Box<dyn Digest>,
-            384,
-        ),
-        "sha3-512sum" => (
-            "SHA3-512",
-            Box::new(Sha3_512::new()) as Box<dyn Digest>,
-            512,
-        ),
-        "shake128sum" => create_shake128(matches),
-        "shake256sum" => create_shake256(matches),
-        _ => create_algorithm_from_flags(matches),
-    };
-    (name, alg, output_bits)
+    //ignore_missing: bool,
 }
 
 /// Creates a hasher instance based on the command-line flags.
@@ -216,80 +57,103 @@ fn detect_algo(
 ///
 /// # 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.
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err 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| {
+fn create_algorithm_from_flags(matches: &ArgMatches) -> UResult<HashAlgorithm> {
+    let mut alg: Option<HashAlgorithm> = None;
+
+    let mut set_or_err = |new_alg: HashAlgorithm| -> UResult<()> {
         if alg.is_some() {
-            crash!(1, "You cannot combine multiple hash algorithms!");
-        };
-        name = n;
-        alg = Some(val);
-        output_bits = bits;
+            return Err(ChecksumError::CombineMultipleAlgorithms.into());
+        }
+        alg = Some(new_alg);
+        Ok(())
     };
 
     if matches.get_flag("md5") {
-        set_or_crash("MD5", Box::new(Md5::new()), 128);
+        set_or_err(detect_algo("md5sum", None)?)?;
     }
     if matches.get_flag("sha1") {
-        set_or_crash("SHA1", Box::new(Sha1::new()), 160);
+        set_or_err(detect_algo("sha1sum", None)?)?;
     }
     if matches.get_flag("sha224") {
-        set_or_crash("SHA224", Box::new(Sha224::new()), 224);
+        set_or_err(detect_algo("sha224sum", None)?)?;
     }
     if matches.get_flag("sha256") {
-        set_or_crash("SHA256", Box::new(Sha256::new()), 256);
+        set_or_err(detect_algo("sha256sum", None)?)?;
     }
     if matches.get_flag("sha384") {
-        set_or_crash("SHA384", Box::new(Sha384::new()), 384);
+        set_or_err(detect_algo("sha384sum", None)?)?;
     }
     if matches.get_flag("sha512") {
-        set_or_crash("SHA512", Box::new(Sha512::new()), 512);
+        set_or_err(detect_algo("sha512sum", None)?)?;
     }
     if matches.get_flag("b2sum") {
-        set_or_crash("BLAKE2", Box::new(Blake2b::new()), 512);
+        set_or_err(detect_algo("b2sum", None)?)?;
     }
     if matches.get_flag("b3sum") {
-        set_or_crash("BLAKE3", Box::new(Blake3::new()), 256);
+        set_or_err(detect_algo("b3sum", None)?)?;
     }
     if matches.get_flag("sha3") {
-        let (n, val, bits) = create_sha3(matches);
-        set_or_crash(n, val, bits);
+        let bits = matches.get_one::<usize>("bits").copied();
+        set_or_err(create_sha3(bits)?)?;
     }
     if matches.get_flag("sha3-224") {
-        set_or_crash("SHA3-224", Box::new(Sha3_224::new()), 224);
+        set_or_err(HashAlgorithm {
+            name: "SHA3-224",
+            create_fn: Box::new(|| Box::new(Sha3_224::new())),
+            bits: 224,
+        })?;
     }
     if matches.get_flag("sha3-256") {
-        set_or_crash("SHA3-256", Box::new(Sha3_256::new()), 256);
+        set_or_err(HashAlgorithm {
+            name: "SHA3-256",
+            create_fn: Box::new(|| Box::new(Sha3_256::new())),
+            bits: 256,
+        })?;
     }
     if matches.get_flag("sha3-384") {
-        set_or_crash("SHA3-384", Box::new(Sha3_384::new()), 384);
+        set_or_err(HashAlgorithm {
+            name: "SHA3-384",
+            create_fn: Box::new(|| Box::new(Sha3_384::new())),
+            bits: 384,
+        })?;
     }
     if matches.get_flag("sha3-512") {
-        set_or_crash("SHA3-512", Box::new(Sha3_512::new()), 512);
+        set_or_err(HashAlgorithm {
+            name: "SHA3-512",
+            create_fn: Box::new(|| Box::new(Sha3_512::new())),
+            bits: 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"),
-        }
+            Some(bits) => set_or_err(HashAlgorithm {
+                name: "SHAKE128",
+                create_fn: Box::new(|| Box::new(Shake128::new())),
+                bits: *bits,
+            })?,
+            None => return Err(ChecksumError::BitsRequiredForShake128.into()),
+        };
     }
     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"),
-        }
+            Some(bits) => set_or_err(HashAlgorithm {
+                name: "SHAKE256",
+                create_fn: Box::new(|| Box::new(Shake256::new())),
+                bits: *bits,
+            })?,
+            None => return Err(ChecksumError::BitsRequiredForShake256.into()),
+        };
+    }
+
+    if alg.is_none() {
+        return Err(ChecksumError::NeedAlgorithmToHash.into());
     }
 
-    let alg = alg.unwrap_or_else(|| crash!(1, "You must specify hash algorithm!"));
-    (name, alg, output_bits)
+    Ok(alg.unwrap())
 }
 
 // TODO: return custom error type
@@ -311,7 +175,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     // Default binary in Windows, text mode otherwise
     let binary_flag_default = cfg!(windows);
 
-    let command = uu_app(&binary_name);
+    let (command, is_hashsum_bin) = uu_app(&binary_name);
 
     // FIXME: this should use try_get_matches_from() and crash!(), but at the moment that just
     //        causes "error: " to be printed twice (once from crash!() and once from clap).  With
@@ -319,7 +183,22 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
     //        least somewhat better from a user's perspective.
     let matches = command.try_get_matches_from(args)?;
 
-    let (name, algo, bits) = detect_algo(&binary_name, &matches);
+    let input_length: Option<&usize> = if binary_name == "b2sum" {
+        matches.get_one::<usize>(options::LENGTH)
+    } else {
+        None
+    };
+
+    let length = match input_length {
+        Some(length) => calculate_blake2b_length(*length)?,
+        None => None,
+    };
+
+    let algo = if is_hashsum_bin {
+        create_algorithm_from_flags(&matches)?
+    } else {
+        detect_algo(&binary_name, length)?
+    };
 
     let binary = if matches.get_flag("binary") {
         true
@@ -329,74 +208,144 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
         binary_flag_default
     };
     let check = matches.get_flag("check");
-    let tag = matches.get_flag("tag");
-    let nonames = *matches
-        .try_get_one("no-names")
-        .unwrap_or(None)
-        .unwrap_or(&false);
     let status = matches.get_flag("status");
     let quiet = matches.get_flag("quiet") || status;
     let strict = matches.get_flag("strict");
     let warn = matches.get_flag("warn") && !status;
+    let ignore_missing = matches.get_flag("ignore-missing");
+
+    if ignore_missing && !check {
+        // --ignore-missing needs -c
+        return Err(ChecksumError::IgnoreNotCheck.into());
+    }
+
+    if check {
+        // on Windows, allow --binary/--text to be used with --check
+        // and keep the behavior of defaulting to binary
+        #[cfg(not(windows))]
+        let binary = {
+            let text_flag = matches.get_flag("text");
+            let binary_flag = matches.get_flag("binary");
+
+            if binary_flag || text_flag {
+                return Err(ChecksumError::BinaryTextConflict.into());
+            }
+
+            false
+        };
+
+        // Execute the checksum validation based on the presence of files or the use of stdin
+        // Determine the source of input: a list of files or stdin.
+        let input = matches.get_many::<OsString>(options::FILE).map_or_else(
+            || iter::once(OsStr::new("-")).collect::<Vec<_>>(),
+            |files| files.map(OsStr::new).collect::<Vec<_>>(),
+        );
+
+        let verbose = ChecksumVerbose::new(status, quiet, warn);
+
+        let opts = ChecksumOptions {
+            binary,
+            ignore_missing,
+            strict,
+            verbose,
+        };
+
+        // Execute the checksum validation
+        return perform_checksum_validation(
+            input.iter().copied(),
+            Some(algo.name),
+            Some(algo.bits),
+            opts,
+        );
+    } else if quiet {
+        return Err(ChecksumError::QuietNotCheck.into());
+    } else if strict {
+        return Err(ChecksumError::StrictNotCheck.into());
+    }
+
+    let nonames = *matches
+        .try_get_one("no-names")
+        .unwrap_or(None)
+        .unwrap_or(&false);
     let zero = matches.get_flag("zero");
 
     let opts = Options {
-        algoname: name,
-        digest: algo,
-        output_bits: bits,
+        algoname: algo.name,
+        digest: (algo.create_fn)(),
+        output_bits: algo.bits,
         binary,
-        check,
-        tag,
+        tag: matches.get_flag("tag"),
         nonames,
-        status,
-        quiet,
-        strict,
-        warn,
+        //status,
+        //quiet,
+        //warn,
         zero,
+        //ignore_missing,
     };
 
-    match matches.get_many::<OsString>("FILE") {
+    // Show the hashsum of the input
+    match matches.get_many::<OsString>(options::FILE) {
         Some(files) => hashsum(opts, files.map(|f| f.as_os_str())),
         None => hashsum(opts, iter::once(OsStr::new("-"))),
     }
 }
 
+mod options {
+    //pub const ALGORITHM: &str = "algorithm";
+    pub const FILE: &str = "file";
+    //pub const UNTAGGED: &str = "untagged";
+    pub const TAG: &str = "tag";
+    pub const LENGTH: &str = "length";
+    //pub const RAW: &str = "raw";
+    //pub const BASE64: &str = "base64";
+    pub const CHECK: &str = "check";
+    pub const STRICT: &str = "strict";
+    pub const TEXT: &str = "text";
+    pub const BINARY: &str = "binary";
+    pub const STATUS: &str = "status";
+    pub const WARN: &str = "warn";
+    pub const QUIET: &str = "quiet";
+}
+
 pub fn uu_app_common() -> Command {
     #[cfg(windows)]
-    const BINARY_HELP: &str = "read in binary mode (default)";
+    const BINARY_HELP: &str = "read or check in binary mode (default)";
     #[cfg(not(windows))]
     const BINARY_HELP: &str = "read in binary mode";
     #[cfg(windows)]
-    const TEXT_HELP: &str = "read in text mode";
+    const TEXT_HELP: &str = "read or check in text mode";
     #[cfg(not(windows))]
     const TEXT_HELP: &str = "read in text mode (default)";
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
-            Arg::new("binary")
+            Arg::new(options::BINARY)
                 .short('b')
                 .long("binary")
                 .help(BINARY_HELP)
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("check")
+            Arg::new(options::CHECK)
                 .short('c')
                 .long("check")
                 .help("read hashsums from the FILEs and check them")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .conflicts_with("tag"),
         )
         .arg(
-            Arg::new("tag")
+            Arg::new(options::TAG)
                 .long("tag")
                 .help("create a BSD-style checksum")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .conflicts_with("text"),
         )
         .arg(
-            Arg::new("text")
+            Arg::new(options::TEXT)
                 .short('t')
                 .long("text")
                 .help(TEXT_HELP)
@@ -404,31 +353,40 @@ pub fn uu_app_common() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("quiet")
+            Arg::new(options::QUIET)
                 .short('q')
-                .long("quiet")
+                .long(options::QUIET)
                 .help("don't print OK for each successfully verified file")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with_all([options::STATUS, options::WARN]),
         )
         .arg(
-            Arg::new("status")
+            Arg::new(options::STATUS)
                 .short('s')
                 .long("status")
                 .help("don't output anything, status code shows success")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with_all([options::QUIET, options::WARN]),
         )
         .arg(
-            Arg::new("strict")
+            Arg::new(options::STRICT)
                 .long("strict")
                 .help("exit non-zero for improperly formatted checksum lines")
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("warn")
+            Arg::new("ignore-missing")
+                .long("ignore-missing")
+                .help("don't fail or report status for missing files")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::WARN)
                 .short('w')
                 .long("warn")
                 .help("warn about improperly formatted checksum lines")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with_all([options::QUIET, options::STATUS]),
         )
         .arg(
             Arg::new("zero")
@@ -438,10 +396,10 @@ pub fn uu_app_common() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("FILE")
+            Arg::new(options::FILE)
                 .index(1)
                 .action(ArgAction::Append)
-                .value_name("FILE")
+                .value_name(options::FILE)
                 .value_hint(clap::ValueHint::FilePath)
                 .value_parser(ValueParser::os_string()),
         )
@@ -453,12 +411,16 @@ pub fn uu_app_length() -> Command {
 
 fn uu_app_opt_length(command: Command) -> Command {
     command.arg(
-        Arg::new("length")
+        Arg::new(options::LENGTH)
+            .long(options::LENGTH)
+            .value_parser(value_parser!(usize))
             .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),
+            .help(
+                "digest length in bits; must not exceed the max for the blake2 algorithm \
+                    and must be a multiple of 8",
+            )
+            .overrides_with(options::LENGTH)
+            .action(ArgAction::Set),
     )
 }
 
@@ -530,43 +492,25 @@ pub fn uu_app_custom() -> Command {
 
 // hashsum is handled differently in build.rs, therefore this is not the same
 // as in other utilities.
-fn uu_app(binary_name: &str) -> Command {
+fn uu_app(binary_name: &str) -> (Command, bool) {
     match binary_name {
         // These all support the same options.
         "md5sum" | "sha1sum" | "sha224sum" | "sha256sum" | "sha384sum" | "sha512sum" => {
-            uu_app_common()
+            (uu_app_common(), false)
         }
         // b2sum supports the md5sum options plus -l/--length.
-        "b2sum" => uu_app_length(),
+        "b2sum" => (uu_app_length(), false),
         // 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(),
+        "sha3-224sum" | "sha3-256sum" | "sha3-384sum" | "sha3-512sum" => (uu_app_common(), false),
         // These have never been part of GNU Coreutils, and require an additional --bits
         // option to specify their output size.
-        "sha3sum" | "shake128sum" | "shake256sum" => uu_app_bits(),
+        "sha3sum" | "shake128sum" | "shake256sum" => (uu_app_bits(), false),
         // b3sum has never been part of GNU Coreutils, and has a --no-names option in
         // addition to the b2sum options.
-        "b3sum" => uu_app_b3sum(),
+        "b3sum" => (uu_app_b3sum(), false),
         // We're probably just being called as `hashsum`, so give them everything.
-        _ => uu_app_custom(),
-    }
-}
-
-#[derive(Debug)]
-enum HashsumError {
-    InvalidRegex,
-    InvalidFormat,
-}
-
-impl Error for HashsumError {}
-impl UError for HashsumError {}
-
-impl std::fmt::Display for HashsumError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Self::InvalidRegex => write!(f, "invalid regular expression"),
-            Self::InvalidFormat => Ok(()),
-        }
+        _ => (uu_app_custom(), true),
     }
 }
 
@@ -575,9 +519,6 @@ fn hashsum<'a, I>(mut options: Options, files: I) -> UResult<()>
 where
     I: Iterator<Item = &'a OsStr>,
 {
-    let mut bad_format = 0;
-    let mut failed_cksum = 0;
-    let mut failed_open_file = 0;
     let binary_marker = if options.binary { "*" } else { " " };
     for filename in files {
         let filename = Path::new(filename);
@@ -592,220 +533,40 @@ where
                 File::open(filename).map_err_context(|| "failed to open file".to_string())?;
             Box::new(file_buf) as Box<dyn Read>
         });
-        if options.check {
-            // Set up Regexes for line validation and parsing
-            //
-            // First, we compute the number of bytes we expect to be in
-            // the digest string. If the algorithm has a variable number
-            // of output bits, then we use the `+` modifier in the
-            // regular expression, otherwise we use the `{n}` modifier,
-            // where `n` is the number of bytes.
-            let bytes = options.digest.output_bits() / 4;
-            let bytes_marker = if bytes > 0 {
-                format!("{{{bytes}}}")
-            } else {
-                "+".to_string()
-            };
-            // 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 = 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 {
-                    Ok(l) => l,
-                    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) => {
-                        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().to_string(),
-                            caps.name("digest").unwrap().as_str().to_ascii_lowercase(),
-                            true,
-                        ),
-                        None => {
-                            bad_format += 1;
-                            if options.strict {
-                                return Err(HashsumError::InvalidFormat.into());
-                            }
-                            if options.warn {
-                                show_warning!(
-                                    "{}: {}: improperly formatted {} checksum line",
-                                    filename.maybe_quote(),
-                                    i + 1,
-                                    options.algoname
-                                );
-                            }
-                            continue;
-                        }
-                    },
-                };
-                let f = match File::open(ck_filename.clone()) {
-                    Err(_) => {
-                        failed_open_file += 1;
-                        println!(
-                            "{}: {}: No such file or directory",
-                            uucore::util_name(),
-                            ck_filename
-                        );
-                        println!("{ck_filename}: FAILED open or read");
-                        continue;
-                    }
-                    Ok(file) => file,
-                };
-                let mut ckf = BufReader::new(Box::new(f) as Box<dyn Read>);
-                let real_sum = digest_reader(
-                    &mut options.digest,
-                    &mut ckf,
-                    binary_check,
-                    options.output_bits,
-                )
-                .map_err_context(|| "failed to read input".to_string())?
-                .to_ascii_lowercase();
-                // FIXME: Filenames with newlines should be treated specially.
-                // GNU appears to replace newlines by \n and backslashes by
-                // \\ and prepend a backslash (to the hash or filename) if it did
-                // this escaping.
-                // Different sorts of output (checking vs outputting hashes) may
-                // handle this differently. Compare carefully to GNU.
-                // If you can, try to preserve invalid unicode using OsStr(ing)Ext
-                // and display it using uucore::display::print_verbatim(). This is
-                // easier (and more important) on Unix than on Windows.
-                if sum == real_sum {
-                    if !options.quiet {
-                        println!("{ck_filename}: OK");
-                    }
+        let (sum, _) = digest_reader(
+            &mut options.digest,
+            &mut file,
+            options.binary,
+            options.output_bits,
+        )
+        .map_err_context(|| "failed to read input".to_string())?;
+        let (escaped_filename, prefix) = escape_filename(filename);
+        if options.tag {
+            if options.algoname == "blake2b" {
+                if options.digest.output_bits() == 512 {
+                    println!("BLAKE2b ({escaped_filename}) = {sum}");
                 } else {
-                    if !options.status {
-                        println!("{ck_filename}: FAILED");
-                    }
-                    failed_cksum += 1;
+                    // special case for BLAKE2b with non-default output length
+                    println!(
+                        "BLAKE2b-{} ({escaped_filename}) = {sum}",
+                        options.digest.output_bits()
+                    );
                 }
-            }
-        } else {
-            let sum = digest_reader(
-                &mut options.digest,
-                &mut file,
-                options.binary,
-                options.output_bits,
-            )
-            .map_err_context(|| "failed to read input".to_string())?;
-            if options.tag {
-                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());
-            }
-        }
-    }
-    if !options.status {
-        match bad_format.cmp(&1) {
-            Ordering::Equal => show_warning!("{} line is improperly formatted", bad_format),
-            Ordering::Greater => show_warning!("{} lines are improperly formatted", bad_format),
-            Ordering::Less => {}
-        };
-        if failed_cksum > 0 {
-            show_warning!("{} computed checksum did NOT match", failed_cksum);
-        }
-        match failed_open_file.cmp(&1) {
-            Ordering::Equal => show_warning!("{} listed file could not be read", failed_open_file),
-            Ordering::Greater => {
-                show_warning!("{} listed files could not be read", failed_open_file);
+                println!(
+                    "{prefix}{} ({escaped_filename}) = {sum}",
+                    options.algoname.to_ascii_uppercase()
+                );
             }
-            Ordering::Less => {}
+        } else if options.nonames {
+            println!("{sum}");
+        } else if options.zero {
+            // with zero, we don't escape the filename
+            print!("{sum} {binary_marker}{}\0", filename.display());
+        } else {
+            println!("{prefix}{sum} {binary_marker}{escaped_filename}");
         }
     }
-
     Ok(())
 }
-
-fn digest_reader<T: Read>(
-    digest: &mut Box<dyn Digest>,
-    reader: &mut BufReader<T>,
-    binary: bool,
-    output_bits: usize,
-) -> io::Result<String> {
-    digest.reset();
-
-    // Read bytes from `reader` and write those bytes to `digest`.
-    //
-    // If `binary` is `false` and the operating system is Windows, then
-    // `DigestWriter` replaces "\r\n" with "\n" before it writes the
-    // bytes into `digest`. Otherwise, it just inserts the bytes as-is.
-    //
-    // In order to support replacing "\r\n", we must call `finalize()`
-    // in order to support the possibility that the last character read
-    // from the reader was "\r". (This character gets buffered by
-    // `DigestWriter` and only written if the following character is
-    // "\n". But when "\r" is the last character read, we need to force
-    // it to be written.)
-    let mut digest_writer = DigestWriter::new(digest, binary);
-    std::io::copy(reader, &mut digest_writer)?;
-    digest_writer.finalize();
-
-    if digest.output_bits() > 0 {
-        Ok(digest.result_str())
-    } else {
-        // Assume it's SHAKE.  result_str() doesn't work with shake (as of 8/30/2016)
-        let mut bytes = Vec::new();
-        bytes.resize((output_bits + 7) / 8, 0);
-        digest.hash_finalize(&mut bytes);
-        Ok(encode(bytes))
-    }
-}
diff --git a/src/uu/head/Cargo.toml b/src/uu/head/Cargo.toml
index bdbe45dc185..a812bac3160 100644
--- a/src/uu/head/Cargo.toml
+++ b/src/uu/head/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_head"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "head ~ (uutils) display the first lines of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/head"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/head.rs"
@@ -17,7 +20,13 @@ path = "src/head.rs"
 [dependencies]
 clap = { workspace = true }
 memchr = { workspace = true }
-uucore = { workspace = true, features = ["ringbuffer", "lines"] }
+thiserror = { workspace = true }
+uucore = { workspace = true, features = [
+  "parser",
+  "ringbuffer",
+  "lines",
+  "fs",
+] }
 
 [[bin]]
 name = "head"
diff --git a/src/uu/head/src/head.rs b/src/uu/head/src/head.rs
index c60bbfe994a..573926a7bb2 100644
--- a/src/uu/head/src/head.rs
+++ b/src/uu/head/src/head.rs
@@ -3,22 +3,23 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (vars) zlines BUFWRITER seekable
+// spell-checker:ignore (vars) seekable
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use std::ffi::OsString;
-use std::io::{self, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write};
+use std::fs::File;
+use std::io::{self, BufWriter, Read, Seek, SeekFrom, Write};
+use std::num::TryFromIntError;
+#[cfg(unix)]
+use std::os::fd::{AsRawFd, FromRawFd};
+use thiserror::Error;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UError, UResult};
 use uucore::line_ending::LineEnding;
-use uucore::lines::lines;
 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 = help_about!("head.md");
 const USAGE: &str = help_usage!("head.md");
 
@@ -31,14 +32,46 @@ mod options {
     pub const FILES_NAME: &str = "FILE";
     pub const PRESUME_INPUT_PIPE: &str = "-PRESUME-INPUT-PIPE";
 }
+
 mod parse;
 mod take;
-use take::take_all_but;
+use take::copy_all_but_n_bytes;
+use take::copy_all_but_n_lines;
 use take::take_lines;
 
+#[derive(Error, Debug)]
+enum HeadError {
+    /// Wrapper around `io::Error`
+    #[error("error reading {name}: {err}")]
+    Io { name: String, err: io::Error },
+
+    #[error("parse error: {0}")]
+    ParseError(String),
+
+    #[error("bad argument encoding")]
+    BadEncoding,
+
+    #[error("{0}: number of -bytes or -lines is too large")]
+    NumTooLarge(#[from] TryFromIntError),
+
+    #[error("clap error: {0}")]
+    Clap(#[from] clap::Error),
+
+    #[error("{0}")]
+    MatchOption(String),
+}
+
+impl UError for HeadError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+type HeadResult<T> = Result<T, HeadError>;
+
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -151,30 +184,21 @@ impl Mode {
 
 fn arg_iterate<'a>(
     mut args: impl uucore::Args + 'a,
-) -> UResult<Box<dyn Iterator<Item = OsString> + 'a>> {
+) -> HeadResult<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)) => match e {
-                    parse::ParseError::Syntax => Err(USimpleError::new(
-                        1,
-                        format!("bad argument format: {}", s.quote()),
-                    )),
-                    parse::ParseError::Overflow => Err(USimpleError::new(
-                        1,
-                        format!(
-                            "invalid argument: {} Value too large for defined datatype",
-                            s.quote()
-                        ),
-                    )),
-                },
+                Some(Err(parse::ParseError)) => Err(HeadError::ParseError(format!(
+                    "bad argument format: {}",
+                    s.quote()
+                ))),
                 None => Ok(Box::new(vec![first, second].into_iter().chain(args))),
             }
         } else {
-            Err(USimpleError::new(1, "bad argument encoding".to_owned()))
+            Err(HeadError::BadEncoding)
         }
     } else {
         Ok(Box::new(vec![first].into_iter()))
@@ -193,7 +217,7 @@ struct HeadOptions {
 
 impl HeadOptions {
     ///Construct options from matches
-    pub fn get_from(matches: &clap::ArgMatches) -> Result<Self, String> {
+    pub fn get_from(matches: &ArgMatches) -> Result<Self, String> {
         let mut options = Self::default();
 
         options.quiet = matches.get_flag(options::QUIET_NAME);
@@ -204,118 +228,109 @@ impl HeadOptions {
         options.mode = Mode::from(matches)?;
 
         options.files = match matches.get_many::<String>(options::FILES_NAME) {
-            Some(v) => v.map(|s| s.to_owned()).collect(),
+            Some(v) => v.cloned().collect(),
             None => vec!["-".to_owned()],
         };
-        //println!("{:#?}", options);
+
         Ok(options)
     }
 }
 
-fn read_n_bytes<R>(input: R, n: u64) -> std::io::Result<()>
-where
-    R: Read,
-{
+#[inline]
+fn wrap_in_stdout_error(err: io::Error) -> io::Error {
+    io::Error::new(
+        err.kind(),
+        format!("error writing 'standard output': {err}"),
+    )
+}
+
+fn read_n_bytes(input: impl Read, n: u64) -> io::Result<u64> {
     // Read the first `n` bytes from the `input` reader.
     let mut reader = input.take(n);
 
     // Write those bytes to `stdout`.
-    let stdout = std::io::stdout();
+    let stdout = io::stdout();
     let mut stdout = stdout.lock();
 
-    io::copy(&mut reader, &mut stdout)?;
+    let bytes_written = io::copy(&mut reader, &mut stdout).map_err(wrap_in_stdout_error)?;
 
-    Ok(())
+    // Make sure we finish writing everything to the target before
+    // exiting. Otherwise, when Rust is implicitly flushing, any
+    // error will be silently ignored.
+    stdout.flush().map_err(wrap_in_stdout_error)?;
+
+    Ok(bytes_written)
 }
 
-fn read_n_lines(input: &mut impl std::io::BufRead, n: u64, separator: u8) -> std::io::Result<()> {
+fn read_n_lines(input: &mut impl io::BufRead, n: u64, separator: u8) -> io::Result<u64> {
     // Read the first `n` lines from the `input` reader.
     let mut reader = take_lines(input, n, separator);
 
     // Write those bytes to `stdout`.
-    let stdout = std::io::stdout();
+    let stdout = io::stdout();
     let stdout = stdout.lock();
-    let mut writer = BufWriter::with_capacity(BUFWRITER_CAPACITY, stdout);
+    let mut writer = BufWriter::with_capacity(BUF_SIZE, stdout);
 
-    io::copy(&mut reader, &mut writer)?;
+    let bytes_written = io::copy(&mut reader, &mut writer).map_err(wrap_in_stdout_error)?;
 
-    Ok(())
-}
+    // Make sure we finish writing everything to the target before
+    // exiting. Otherwise, when Rust is implicitly flushing, any
+    // error will be silently ignored.
+    writer.flush().map_err(wrap_in_stdout_error)?;
 
-fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: usize) -> std::io::Result<()> {
-    if n == 0 {
-        //prints everything
-        return read_n_bytes(input, std::u64::MAX);
-    }
-
-    let stdout = std::io::stdout();
-    let mut stdout = stdout.lock();
+    Ok(bytes_written)
+}
 
-    let mut ring_buffer = vec![0u8; n];
+fn catch_too_large_numbers_in_backwards_bytes_or_lines(n: u64) -> Option<usize> {
+    usize::try_from(n).ok()
+}
 
-    // first we fill the ring buffer
-    if let Err(e) = input.read_exact(&mut ring_buffer) {
-        if e.kind() == ErrorKind::UnexpectedEof {
-            return Ok(());
-        } else {
-            return Err(e);
-        }
-    }
-    let mut buffer = [0u8; BUF_SIZE];
-    loop {
-        let read = loop {
-            match input.read(&mut buffer) {
-                Ok(n) => break n,
-                Err(e) => match e.kind() {
-                    ErrorKind::Interrupted => {}
-                    _ => return Err(e),
-                },
-            }
-        };
-        if read == 0 {
-            return Ok(());
-        } else if read >= n {
-            stdout.write_all(&ring_buffer)?;
-            stdout.write_all(&buffer[..read - n])?;
-            for i in 0..n {
-                ring_buffer[i] = buffer[read - n + i];
-            }
-        } else {
-            stdout.write_all(&ring_buffer[..read])?;
-            for i in 0..n - read {
-                ring_buffer[i] = ring_buffer[read + i];
-            }
-            ring_buffer[n - read..].copy_from_slice(&buffer[..read]);
-        }
+fn read_but_last_n_bytes(mut input: impl Read, n: u64) -> io::Result<u64> {
+    let mut bytes_written: u64 = 0;
+    if let Some(n) = catch_too_large_numbers_in_backwards_bytes_or_lines(n) {
+        let stdout = io::stdout();
+        let mut stdout = stdout.lock();
+
+        bytes_written = copy_all_but_n_bytes(&mut input, &mut stdout, n)
+            .map_err(wrap_in_stdout_error)?
+            .try_into()
+            .unwrap();
+
+        // Make sure we finish writing everything to the target before
+        // exiting. Otherwise, when Rust is implicitly flushing, any
+        // error will be silently ignored.
+        stdout.flush().map_err(wrap_in_stdout_error)?;
     }
+    Ok(bytes_written)
 }
 
-fn read_but_last_n_lines(
-    input: impl std::io::BufRead,
-    n: usize,
-    separator: u8,
-) -> std::io::Result<()> {
-    let stdout = std::io::stdout();
+fn read_but_last_n_lines(mut input: impl Read, n: u64, separator: u8) -> io::Result<u64> {
+    let stdout = io::stdout();
     let mut stdout = stdout.lock();
-    for bytes in take_all_but(lines(input, separator), n) {
-        stdout.write_all(&bytes?)?;
+    if n == 0 {
+        return io::copy(&mut input, &mut stdout).map_err(wrap_in_stdout_error);
     }
-    Ok(())
+    let mut bytes_written: u64 = 0;
+    if let Some(n) = catch_too_large_numbers_in_backwards_bytes_or_lines(n) {
+        bytes_written = copy_all_but_n_lines(input, &mut stdout, n, separator)
+            .map_err(wrap_in_stdout_error)?
+            .try_into()
+            .unwrap();
+        // Make sure we finish writing everything to the target before
+        // exiting. Otherwise, when Rust is implicitly flushing, any
+        // error will be silently ignored.
+        stdout.flush().map_err(wrap_in_stdout_error)?;
+    }
+    Ok(bytes_written)
 }
 
 /// Return the index in `input` just after the `n`th line from the end.
 ///
 /// If `n` exceeds the number of lines in this file, then return 0.
-///
-/// The cursor must be at the start of the seekable input before
-/// calling this function. This function rewinds the cursor to the
+/// This function rewinds the cursor to the
 /// beginning of the input just before returning unless there is an
 /// I/O error.
 ///
-/// If `zeroed` is `false`, interpret the newline character `b'\n'` as
-/// a line ending. If `zeroed` is `true`, interpret the null character
-/// `b'\0'` as a line ending instead.
-///
 /// # Errors
 ///
 /// This function returns an error if there is a problem seeking
@@ -342,24 +357,25 @@ fn read_but_last_n_lines(
 /// assert_eq!(find_nth_line_from_end(&mut input, 4, false).unwrap(), 0);
 /// assert_eq!(find_nth_line_from_end(&mut input, 1000, false).unwrap(), 0);
 /// ```
-fn find_nth_line_from_end<R>(input: &mut R, n: u64, separator: u8) -> std::io::Result<u64>
+fn find_nth_line_from_end<R>(input: &mut R, n: u64, separator: u8) -> io::Result<u64>
 where
     R: Read + Seek,
 {
-    let size = input.seek(SeekFrom::End(0))?;
+    let file_size = input.seek(SeekFrom::End(0))?;
 
     let mut buffer = [0u8; BUF_SIZE];
-    let buf_size: usize = (BUF_SIZE as u64).min(size).try_into().unwrap();
-    let buffer = &mut buffer[..buf_size];
 
     let mut i = 0u64;
     let mut lines = 0u64;
 
     loop {
         // the casts here are ok, `buffer.len()` should never be above a few k
-        input.seek(SeekFrom::Current(
-            -((buffer.len() as i64).min((size - i) as i64)),
-        ))?;
+        let bytes_remaining_to_search = file_size - i;
+        let bytes_to_read_this_loop = bytes_remaining_to_search.min(BUF_SIZE.try_into().unwrap());
+        let read_start_offset = bytes_remaining_to_search - bytes_to_read_this_loop;
+        let buffer = &mut buffer[..bytes_to_read_this_loop.try_into().unwrap()];
+
+        input.seek(SeekFrom::Start(read_start_offset))?;
         input.read_exact(buffer)?;
         for byte in buffer.iter().rev() {
             if byte == &separator {
@@ -368,49 +384,66 @@ where
             // if it were just `n`,
             if lines == n + 1 {
                 input.rewind()?;
-                return Ok(size - i);
+                return Ok(file_size - i);
             }
             i += 1;
         }
-        if size - i == 0 {
+        if file_size - i == 0 {
             input.rewind()?;
             return Ok(0);
         }
     }
 }
 
-fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
+fn is_seekable(input: &mut File) -> bool {
+    let current_pos = input.stream_position();
+    current_pos.is_ok()
+        && input.seek(SeekFrom::End(0)).is_ok()
+        && input.seek(SeekFrom::Start(current_pos.unwrap())).is_ok()
+}
+
+fn head_backwards_file(input: &mut File, options: &HeadOptions) -> io::Result<u64> {
+    let st = input.metadata()?;
+    let seekable = is_seekable(input);
+    let blksize_limit = uucore::fs::sane_blksize::sane_blksize_from_metadata(&st);
+    if !seekable || st.len() <= blksize_limit {
+        head_backwards_without_seek_file(input, options)
+    } else {
+        head_backwards_on_seekable_file(input, options)
+    }
+}
+
+fn head_backwards_without_seek_file(input: &mut File, options: &HeadOptions) -> io::Result<u64> {
+    match options.mode {
+        Mode::AllButLastBytes(n) => read_but_last_n_bytes(input, n),
+        Mode::AllButLastLines(n) => read_but_last_n_lines(input, n, options.line_ending.into()),
+        _ => unreachable!(),
+    }
+}
+
+fn head_backwards_on_seekable_file(input: &mut File, options: &HeadOptions) -> io::Result<u64> {
     match options.mode {
         Mode::AllButLastBytes(n) => {
             let size = input.metadata()?.len();
             if n >= size {
-                return Ok(());
+                Ok(0)
             } else {
-                read_n_bytes(
-                    &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
-                    size - n,
-                )?;
+                read_n_bytes(input, size - n)
             }
         }
         Mode::AllButLastLines(n) => {
             let found = find_nth_line_from_end(input, n, options.line_ending.into())?;
-            read_n_bytes(
-                &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
-                found,
-            )?;
+            read_n_bytes(input, found)
         }
         _ => unreachable!(),
     }
-    Ok(())
 }
 
-fn head_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
+fn head_file(input: &mut File, options: &HeadOptions) -> io::Result<u64> {
     match options.mode {
-        Mode::FirstBytes(n) => {
-            read_n_bytes(&mut std::io::BufReader::with_capacity(BUF_SIZE, input), n)
-        }
+        Mode::FirstBytes(n) => read_n_bytes(input, n),
         Mode::FirstLines(n) => read_n_lines(
-            &mut std::io::BufReader::with_capacity(BUF_SIZE, input),
+            &mut io::BufReader::with_capacity(BUF_SIZE, input),
             n,
             options.line_ending.into(),
         ),
@@ -430,39 +463,45 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
                     }
                     println!("==> standard input <==");
                 }
-                let stdin = std::io::stdin();
-                let mut stdin = stdin.lock();
-
-                // Outputting "all-but-last" requires us to use a ring buffer with size n, so n
-                // must be converted from u64 to usize to fit in memory. If such conversion fails,
-                // it means the platform doesn't have enough memory to hold the buffer, so we fail.
-                if let Mode::AllButLastLines(n) | Mode::AllButLastBytes(n) = options.mode {
-                    if let Err(e) = usize::try_from(n) {
-                        show!(USimpleError::new(
-                            1,
-                            format!("{e}: number of bytes is too large")
-                        ));
-                        continue;
-                    };
-                };
-
-                match options.mode {
-                    Mode::FirstBytes(n) => read_n_bytes(&mut stdin, n),
-                    // unwrap is guaranteed to succeed because we checked the value of n above
-                    Mode::AllButLastBytes(n) => {
-                        read_but_last_n_bytes(&mut stdin, n.try_into().unwrap())
+                let stdin = io::stdin();
+
+                #[cfg(unix)]
+                {
+                    let stdin_raw_fd = stdin.as_raw_fd();
+                    let mut stdin_file = unsafe { File::from_raw_fd(stdin_raw_fd) };
+                    let current_pos = stdin_file.stream_position();
+                    if let Ok(current_pos) = current_pos {
+                        // We have a seekable file. Ensure we set the input stream to the
+                        // last byte read so that any tools that parse the remainder of
+                        // the stdin stream read from the correct place.
+
+                        let bytes_read = head_file(&mut stdin_file, options)?;
+                        stdin_file.seek(SeekFrom::Start(current_pos + bytes_read))?;
+                    } else {
+                        let _bytes_read = head_file(&mut stdin_file, options)?;
                     }
-                    Mode::FirstLines(n) => read_n_lines(&mut stdin, n, options.line_ending.into()),
-                    // unwrap is guaranteed to succeed because we checked the value of n above
-                    Mode::AllButLastLines(n) => read_but_last_n_lines(
-                        &mut stdin,
-                        n.try_into().unwrap(),
-                        options.line_ending.into(),
-                    ),
                 }
+
+                #[cfg(not(unix))]
+                {
+                    let mut stdin = stdin.lock();
+
+                    match options.mode {
+                        Mode::FirstBytes(n) => read_n_bytes(&mut stdin, n),
+                        Mode::AllButLastBytes(n) => read_but_last_n_bytes(&mut stdin, n),
+                        Mode::FirstLines(n) => {
+                            read_n_lines(&mut stdin, n, options.line_ending.into())
+                        }
+                        Mode::AllButLastLines(n) => {
+                            read_but_last_n_lines(&mut stdin, n, options.line_ending.into())
+                        }
+                    }?;
+                }
+
+                Ok(())
             }
             (name, false) => {
-                let mut file = match std::fs::File::open(name) {
+                let mut file = match File::open(name) {
                     Ok(f) => f,
                     Err(err) => {
                         show!(err.map_err_context(|| format!(
@@ -478,19 +517,21 @@ fn uu_head(options: &HeadOptions) -> UResult<()> {
                     }
                     println!("==> {name} <==");
                 }
-                head_file(&mut file, options)
+                head_file(&mut file, options)?;
+                Ok(())
             }
         };
-        if res.is_err() {
+        if let Err(e) = res {
             let name = if file.as_str() == "-" {
                 "standard input"
             } else {
                 file
             };
-            show!(USimpleError::new(
-                1,
-                format!("error reading {name}: Input/output error")
-            ));
+            return Err(HeadError::Io {
+                name: name.to_string(),
+                err: e,
+            }
+            .into());
         }
         first = false;
     }
@@ -507,7 +548,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let args = match HeadOptions::get_from(&matches) {
         Ok(o) => o,
         Err(s) => {
-            return Err(USimpleError::new(1, s));
+            return Err(HeadError::MatchOption(s).into());
         }
     };
     uu_head(&args)
@@ -515,10 +556,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 #[cfg(test)]
 mod tests {
+    use io::Cursor;
     use std::ffi::OsString;
-    use std::io::Cursor;
 
     use super::*;
+
     fn options(args: &str) -> Result<HeadOptions, String> {
         let combined = "head ".to_owned() + args;
         let args = combined.split_whitespace().map(OsString::from);
@@ -526,6 +568,7 @@ mod tests {
             .get_matches_from(arg_iterate(args).map_err(|_| String::from("Arg iterate failed"))?);
         HeadOptions::get_from(&matches)
     }
+
     #[test]
     fn test_args_modes() {
         let args = options("-n -10M -vz").unwrap();
@@ -533,16 +576,19 @@ mod tests {
         assert!(args.verbose);
         assert_eq!(args.mode, Mode::AllButLastLines(10 * 1024 * 1024));
     }
+
     #[test]
     fn test_gnu_compatibility() {
         let args = options("-n 1 -c 1 -n 5 -c kiB -vqvqv").unwrap(); // spell-checker:disable-line
-        assert!(args.mode == Mode::FirstBytes(1024));
+        assert_eq!(args.mode, Mode::FirstBytes(1024));
         assert!(args.verbose);
         assert_eq!(options("-5").unwrap().mode, Mode::FirstLines(5));
         assert_eq!(options("-2b").unwrap().mode, Mode::FirstBytes(1024));
         assert_eq!(options("-5 -c 1").unwrap().mode, Mode::FirstBytes(1));
     }
+
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn all_args_test() {
         assert!(options("--silent").unwrap().quiet);
         assert!(options("--quiet").unwrap().quiet);
@@ -559,11 +605,13 @@ mod tests {
         assert_eq!(options("--bytes 15").unwrap().mode, Mode::FirstBytes(15));
         assert_eq!(options("-c 15").unwrap().mode, Mode::FirstBytes(15));
     }
+
     #[test]
     fn test_options_errors() {
         assert!(options("-n IsThisTheRealLife?").is_err());
         assert!(options("-c IsThisJustFantasy").is_err());
     }
+
     #[test]
     fn test_options_correct_defaults() {
         let opts = HeadOptions::default();
@@ -574,6 +622,7 @@ mod tests {
         assert_eq!(opts.mode, Mode::FirstLines(10));
         assert!(opts.files.is_empty());
     }
+
     fn arg_outputs(src: &str) -> Result<String, ()> {
         let split = src.split_whitespace().map(OsString::from);
         match arg_iterate(split) {
@@ -586,6 +635,7 @@ mod tests {
             Err(_) => Err(()),
         }
     }
+
     #[test]
     fn test_arg_iterate() {
         // test that normal args remain unchanged
@@ -606,10 +656,11 @@ mod tests {
         //test that bad obsoletes are an error
         assert!(arg_outputs("head -123FooBar").is_err());
         //test overflow
-        assert!(arg_outputs("head -100000000000000000000000000000000000000000").is_err());
+        assert!(arg_outputs("head -100000000000000000000000000000000000000000").is_ok());
         //test that empty args remain unchanged
         assert_eq!(arg_outputs("head"), Ok("head".to_owned()));
     }
+
     #[test]
     #[cfg(target_os = "linux")]
     fn test_arg_iterate_bad_encoding() {
@@ -618,21 +669,69 @@ mod tests {
         // this arises from a conversion from OsString to &str
         assert!(arg_iterate(vec![OsString::from("head"), invalid].into_iter()).is_err());
     }
+
     #[test]
     fn read_early_exit() {
-        let mut empty = std::io::BufReader::new(std::io::Cursor::new(Vec::new()));
+        let mut empty = io::BufReader::new(Cursor::new(Vec::new()));
         assert!(read_n_bytes(&mut empty, 0).is_ok());
         assert!(read_n_lines(&mut empty, 0, b'\n').is_ok());
     }
 
     #[test]
     fn test_find_nth_line_from_end() {
-        let mut input = Cursor::new("x\ny\nz\n");
-        assert_eq!(find_nth_line_from_end(&mut input, 0, b'\n').unwrap(), 6);
-        assert_eq!(find_nth_line_from_end(&mut input, 1, b'\n').unwrap(), 4);
-        assert_eq!(find_nth_line_from_end(&mut input, 2, b'\n').unwrap(), 2);
-        assert_eq!(find_nth_line_from_end(&mut input, 3, b'\n').unwrap(), 0);
-        assert_eq!(find_nth_line_from_end(&mut input, 4, b'\n').unwrap(), 0);
-        assert_eq!(find_nth_line_from_end(&mut input, 1000, b'\n').unwrap(), 0);
+        // Make sure our input buffer is several multiples of BUF_SIZE in size
+        // such that we can be reasonably confident we've exercised all logic paths.
+        // Make the contents of the buffer look like...
+        // aaaa\n
+        // aaaa\n
+        // aaaa\n
+        // aaaa\n
+        // aaaa\n
+        // ...
+        // This will make it easier to validate the results since each line will have
+        // 5 bytes in it.
+
+        let minimum_buffer_size = BUF_SIZE * 4;
+        let mut input_buffer = vec![];
+        let mut loop_iteration: u64 = 0;
+        while input_buffer.len() < minimum_buffer_size {
+            for _n in 0..4 {
+                input_buffer.push(b'a');
+            }
+            loop_iteration += 1;
+            input_buffer.push(b'\n');
+        }
+
+        let lines_in_input_file = loop_iteration;
+        let input_length = lines_in_input_file * 5;
+        assert_eq!(input_length, input_buffer.len().try_into().unwrap());
+        let mut input = Cursor::new(input_buffer);
+        // We now have loop_iteration lines in the buffer Now walk backwards through the buffer
+        // to confirm everything parses correctly.
+        // Use a large step size to prevent the test from taking too long, but don't use a power
+        // of 2 in case we miss some corner case.
+        let step_size = 511;
+        for n in (0..lines_in_input_file).filter(|v| v % step_size == 0) {
+            // The 5*n comes from 5-bytes per row.
+            assert_eq!(
+                find_nth_line_from_end(&mut input, n, b'\n').unwrap(),
+                input_length - 5 * n
+            );
+        }
+
+        // Now confirm that if we query with a value >= lines_in_input_file we get an offset
+        // of 0
+        assert_eq!(
+            find_nth_line_from_end(&mut input, lines_in_input_file, b'\n').unwrap(),
+            0
+        );
+        assert_eq!(
+            find_nth_line_from_end(&mut input, lines_in_input_file + 1, b'\n').unwrap(),
+            0
+        );
+        assert_eq!(
+            find_nth_line_from_end(&mut input, lines_in_input_file + 1000, b'\n').unwrap(),
+            0
+        );
     }
 }
diff --git a/src/uu/head/src/parse.rs b/src/uu/head/src/parse.rs
index 90e1f2ce008..a4ce6e71069 100644
--- a/src/uu/head/src/parse.rs
+++ b/src/uu/head/src/parse.rs
@@ -4,91 +4,37 @@
 // file that was distributed with this source code.
 
 use std::ffi::OsString;
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parser::parse_size::{ParseSizeError, parse_size_u64_max};
 
 #[derive(PartialEq, Eq, Debug)]
-pub enum ParseError {
-    Syntax,
-    Overflow,
-}
+pub struct 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>> {
+pub fn parse_obsolete(src: &str) -> Option<Result<Vec<OsString>, ParseError>> {
     let mut chars = src.char_indices();
-    if let Some((_, '-')) = chars.next() {
-        let mut num_end = 0usize;
+    if let Some((mut num_start, '-')) = chars.next() {
+        num_start += 1;
+        let mut num_end = src.len();
         let mut has_num = false;
+        let mut plus_possible = 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;
+                plus_possible = false;
+            } else if c == '+' && plus_possible {
+                plus_possible = false;
+                num_start += 1;
+                continue;
             } else {
+                num_end = n;
                 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)),
-            }
+            process_num_block(&src[num_start..num_end], last_char, &mut chars)
         } else {
             None
         }
@@ -96,6 +42,71 @@ pub fn parse_obsolete(src: &str) -> Option<Result<impl Iterator<Item = OsString>
         None
     }
 }
+
+/// Processes the numeric block of the input string to generate the appropriate options.
+fn process_num_block(
+    src: &str,
+    last_char: char,
+    chars: &mut std::str::CharIndices,
+) -> Option<Result<Vec<OsString>, ParseError>> {
+    let num = match src.parse::<usize>() {
+        Ok(n) => n,
+        Err(e) if *e.kind() == std::num::IntErrorKind::PosOverflow => usize::MAX,
+        _ => return Some(Err(ParseError)),
+    };
+    let mut quiet = false;
+    let mut verbose = false;
+    let mut zero_terminated = false;
+    let mut multiplier = None;
+    let mut c = last_char;
+    loop {
+        // note 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)),
+        }
+        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 = num.saturating_mul(n);
+        options.push(OsString::from(format!("{num}")));
+    } else {
+        options.push(OsString::from("-n"));
+        options.push(OsString::from(format!("{num}")));
+    }
+    Some(Ok(options))
+}
+
 /// Parses an -c or -n argument,
 /// the bool specifies whether to read from the end
 pub fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
@@ -119,27 +130,34 @@ pub fn parse_num(src: &str) -> Result<(u64, bool), ParseSizeError> {
     if trimmed_string.is_empty() {
         Ok((0, all_but_last))
     } else {
-        parse_size(trimmed_string).map(|n| (n, all_but_last))
+        parse_size_u64_max(trimmed_string).map(|n| (n, all_but_last))
     }
 }
 
 #[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())),
+                Ok(v) => Some(Ok(v
+                    .into_iter()
+                    .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]
+    #[allow(clippy::cognitive_complexity)]
     fn test_parse_numbers_obsolete() {
         assert_eq!(obsolete("-5"), obsolete_result(&["-n", "5"]));
         assert_eq!(obsolete("-100"), obsolete_result(&["-n", "100"]));
@@ -158,32 +176,42 @@ mod tests {
             obsolete_result(&["-z", "-c", "110100480"])
         );
     }
+
     #[test]
     fn test_parse_errors_obsolete() {
-        assert_eq!(obsolete("-5n"), Some(Err(ParseError::Syntax)));
-        assert_eq!(obsolete("-5c5"), Some(Err(ParseError::Syntax)));
+        assert_eq!(obsolete("-5n"), Some(Err(ParseError)));
+        assert_eq!(obsolete("-5c5"), Some(Err(ParseError)));
     }
+
     #[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))
+            obsolete_result(&["-c", "18446744073709551615"])
         );
         assert_eq!(
             obsolete("-10000000000000000000000"),
-            Some(Err(ParseError::Overflow))
+            obsolete_result(&["-n", "18446744073709551615"])
         );
     }
+
     #[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!(
+            obsolete("-42949672960"),
+            obsolete_result(&["-n", "4294967295"])
+        );
+        assert_eq!(
+            obsolete("-42949672k"),
+            obsolete_result(&["-c", "4294967295"])
+        );
     }
 }
diff --git a/src/uu/head/src/take.rs b/src/uu/head/src/take.rs
index da48afd6a86..1a303bbd401 100644
--- a/src/uu/head/src/take.rs
+++ b/src/uu/head/src/take.rs
@@ -3,67 +3,308 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 //! Take all but the last elements of an iterator.
-use std::io::Read;
-
 use memchr::memchr_iter;
+use std::collections::VecDeque;
+use std::io::{ErrorKind, Read, Write};
 
-use uucore::ringbuffer::RingBuffer;
+const BUF_SIZE: usize = 65536;
 
-/// Create an iterator over all but the last `n` elements of `iter`.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// let data = [1, 2, 3, 4, 5];
-/// let n = 2;
-/// let mut iter = take_all_but(data.iter(), n);
-/// assert_eq!(Some(4), iter.next());
-/// assert_eq!(Some(5), iter.next());
-/// assert_eq!(None, iter.next());
-/// ```
-pub fn take_all_but<I: Iterator>(iter: I, n: usize) -> TakeAllBut<I> {
-    TakeAllBut::new(iter, n)
+struct TakeAllBuffer {
+    buffer: Vec<u8>,
+    start_index: usize,
 }
 
-/// An iterator that only iterates over the last elements of another iterator.
-pub struct TakeAllBut<I: Iterator> {
-    iter: I,
-    buf: RingBuffer<<I as Iterator>::Item>,
+impl TakeAllBuffer {
+    fn new() -> Self {
+        TakeAllBuffer {
+            buffer: vec![],
+            start_index: 0,
+        }
+    }
+
+    fn fill_buffer(&mut self, reader: &mut impl Read) -> std::io::Result<usize> {
+        self.buffer.resize(BUF_SIZE, 0);
+        self.start_index = 0;
+        loop {
+            match reader.read(&mut self.buffer[..]) {
+                Ok(n) => {
+                    self.buffer.truncate(n);
+                    return Ok(n);
+                }
+                Err(e) if e.kind() == ErrorKind::Interrupted => continue,
+                Err(e) => return Err(e),
+            }
+        }
+    }
+
+    fn write_bytes_exact(&mut self, writer: &mut impl Write, bytes: usize) -> std::io::Result<()> {
+        let buffer_to_write = &self.remaining_buffer()[..bytes];
+        writer.write_all(buffer_to_write)?;
+        self.start_index += bytes;
+        assert!(self.start_index <= self.buffer.len());
+        Ok(())
+    }
+
+    fn write_all(&mut self, writer: &mut impl Write) -> std::io::Result<usize> {
+        let remaining_bytes = self.remaining_bytes();
+        self.write_bytes_exact(writer, remaining_bytes)?;
+        Ok(remaining_bytes)
+    }
+
+    fn write_bytes_limit(
+        &mut self,
+        writer: &mut impl Write,
+        max_bytes: usize,
+    ) -> std::io::Result<usize> {
+        let bytes_to_write = self.remaining_bytes().min(max_bytes);
+        self.write_bytes_exact(writer, bytes_to_write)?;
+        Ok(bytes_to_write)
+    }
+
+    fn remaining_buffer(&self) -> &[u8] {
+        &self.buffer[self.start_index..]
+    }
+
+    fn remaining_bytes(&self) -> usize {
+        self.remaining_buffer().len()
+    }
+
+    fn is_empty(&self) -> bool {
+        assert!(self.start_index <= self.buffer.len());
+        self.start_index == self.buffer.len()
+    }
 }
 
-impl<I: Iterator> TakeAllBut<I> {
-    pub fn new(mut iter: I, n: usize) -> Self {
-        // Create a new ring buffer and fill it up.
-        //
-        // If there are fewer than `n` elements in `iter`, then we
-        // exhaust the iterator so that whenever `TakeAllBut::next()` is
-        // called, it will return `None`, as expected.
-        let mut buf = RingBuffer::new(n);
-        for _ in 0..n {
-            let value = match iter.next() {
-                None => {
+/// Function to copy all but `n` bytes from the reader to the writer.
+///
+/// If `n` exceeds the number of bytes in the input file then nothing is copied.
+/// If no errors are encountered then the function returns the number of bytes
+/// copied.
+///
+/// Algorithm for this function is as follows...
+/// 1 - Chunks of the input file are read into a queue of TakeAllBuffer instances.
+///     Chunks are read until at least we have enough data to write out the entire contents of the
+///     first TakeAllBuffer in the queue whilst still retaining at least `n` bytes in the queue.
+///     If we hit EoF at any point, stop reading.
+/// 2 - Assess whether we managed to queue up greater-than `n` bytes. If not, we must be done, in
+///     which case break and return.
+/// 3 - Write either the full first buffer of data, or just enough bytes to get back down to having
+///     the required `n` bytes of data queued.
+/// 4 - Go back to (1).
+pub fn copy_all_but_n_bytes(
+    reader: &mut impl Read,
+    writer: &mut impl Write,
+    n: usize,
+) -> std::io::Result<usize> {
+    let mut buffers: VecDeque<TakeAllBuffer> = VecDeque::new();
+    let mut empty_buffer_pool: Vec<TakeAllBuffer> = vec![];
+    let mut buffered_bytes: usize = 0;
+    let mut total_bytes_copied = 0;
+    loop {
+        loop {
+            // Try to buffer at least enough to write the entire first buffer.
+            let front_buffer = buffers.front();
+            if let Some(front_buffer) = front_buffer {
+                if buffered_bytes >= n + front_buffer.remaining_bytes() {
                     break;
                 }
-                Some(x) => x,
+            }
+            let mut new_buffer = empty_buffer_pool.pop().unwrap_or_else(TakeAllBuffer::new);
+            let filled_bytes = new_buffer.fill_buffer(reader)?;
+            if filled_bytes == 0 {
+                // filled_bytes==0 => Eof
+                break;
+            }
+            buffers.push_back(new_buffer);
+            buffered_bytes += filled_bytes;
+        }
+
+        // If we've got <=n bytes buffered here we have nothing left to do.
+        if buffered_bytes <= n {
+            break;
+        }
+
+        let excess_buffered_bytes = buffered_bytes - n;
+        // Since we have some data buffered, can assume we have >=1 buffer - i.e. safe to unwrap.
+        let front_buffer = buffers.front_mut().unwrap();
+        let bytes_written = front_buffer.write_bytes_limit(writer, excess_buffered_bytes)?;
+        buffered_bytes -= bytes_written;
+        total_bytes_copied += bytes_written;
+        // If the front buffer is empty (which it probably is), push it into the empty-buffer-pool.
+        if front_buffer.is_empty() {
+            empty_buffer_pool.push(buffers.pop_front().unwrap());
+        }
+    }
+    Ok(total_bytes_copied)
+}
+
+struct TakeAllLinesBuffer {
+    inner: TakeAllBuffer,
+    terminated_lines: usize,
+    partial_line: bool,
+}
+
+struct BytesAndLines {
+    bytes: usize,
+    terminated_lines: usize,
+}
+
+impl TakeAllLinesBuffer {
+    fn new() -> Self {
+        TakeAllLinesBuffer {
+            inner: TakeAllBuffer::new(),
+            terminated_lines: 0,
+            partial_line: false,
+        }
+    }
+
+    fn fill_buffer(
+        &mut self,
+        reader: &mut impl Read,
+        separator: u8,
+    ) -> std::io::Result<BytesAndLines> {
+        let bytes_read = self.inner.fill_buffer(reader)?;
+        // Count the number of lines...
+        self.terminated_lines = memchr_iter(separator, self.inner.remaining_buffer()).count();
+        if let Some(last_char) = self.inner.remaining_buffer().last() {
+            if *last_char != separator {
+                self.partial_line = true;
+            }
+        }
+        Ok(BytesAndLines {
+            bytes: bytes_read,
+            terminated_lines: self.terminated_lines,
+        })
+    }
+
+    fn write_lines(
+        &mut self,
+        writer: &mut impl Write,
+        max_lines: usize,
+        separator: u8,
+    ) -> std::io::Result<BytesAndLines> {
+        assert!(max_lines > 0, "Must request at least 1 line.");
+        let ret;
+        if max_lines > self.terminated_lines {
+            ret = BytesAndLines {
+                bytes: self.inner.write_all(writer)?,
+                terminated_lines: self.terminated_lines,
+            };
+            self.terminated_lines = 0;
+        } else {
+            let index = memchr_iter(separator, self.inner.remaining_buffer()).nth(max_lines - 1);
+            assert!(
+                index.is_some(),
+                "Somehow we're being asked to write more lines than we have, that's a bug in copy_all_but_lines."
+            );
+            let index = index.unwrap();
+            // index is the offset of the separator character, zero indexed. Need to add 1 to get the number
+            // of bytes to write.
+            let bytes_to_write = index + 1;
+            self.inner.write_bytes_exact(writer, bytes_to_write)?;
+            ret = BytesAndLines {
+                bytes: bytes_to_write,
+                terminated_lines: max_lines,
             };
-            buf.push_back(value);
+            self.terminated_lines -= max_lines;
         }
-        Self { iter, buf }
+        Ok(ret)
+    }
+
+    fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    fn terminated_lines(&self) -> usize {
+        self.terminated_lines
+    }
+
+    fn partial_line(&self) -> bool {
+        self.partial_line
     }
 }
 
-impl<I: Iterator> Iterator for TakeAllBut<I>
-where
-    I: Iterator,
-{
-    type Item = <I as Iterator>::Item;
+/// Function to copy all but `n` lines from the reader to the writer.
+///
+/// Lines are inferred from the `separator` value passed in by the client.
+/// If `n` exceeds the number of lines in the input file then nothing is copied.
+/// The last line in the file is not required to end with a `separator` character.
+/// If no errors are encountered then they function returns the number of bytes
+/// copied.
+///
+/// Algorithm for this function is as follows...
+/// 1 - Chunks of the input file are read into a queue of TakeAllLinesBuffer instances.
+///     Chunks are read until at least we have enough lines that we can write out the entire
+///     contents of the first TakeAllLinesBuffer in the queue whilst still retaining at least
+///     `n` lines in the queue.
+///     If we hit EoF at any point, stop reading.
+/// 2 - Asses whether we managed to queue up greater-than `n` lines. If not, we must be done, in
+///     which case break and return.
+/// 3 - Write either the full first buffer of data, or just enough lines to get back down to
+///     having the required `n` lines of data queued.
+/// 4 - Go back to (1).
+///
+/// Note that lines will regularly straddle multiple TakeAllLinesBuffer instances. The partial_line
+/// flag on TakeAllLinesBuffer tracks this, and we use that to ensure that we write out enough
+/// lines in the case that the input file doesn't end with a `separator` character.
+pub fn copy_all_but_n_lines<R: Read, W: Write>(
+    mut reader: R,
+    writer: &mut W,
+    n: usize,
+    separator: u8,
+) -> std::io::Result<usize> {
+    // This function requires `n` > 0. Assert it!
+    assert!(n > 0);
+    let mut buffers: VecDeque<TakeAllLinesBuffer> = VecDeque::new();
+    let mut buffered_terminated_lines: usize = 0;
+    let mut empty_buffers = vec![];
+    let mut total_bytes_copied = 0;
+    loop {
+        // Try to buffer enough such that we can write out the entire first buffer.
+        loop {
+            // First check if we have enough lines buffered that we can write out the entire
+            // front buffer. If so, break.
+            let front_buffer = buffers.front();
+            if let Some(front_buffer) = front_buffer {
+                if buffered_terminated_lines > n + front_buffer.terminated_lines() {
+                    break;
+                }
+            }
+            // Else we need to try to buffer more data...
+            let mut new_buffer = empty_buffers.pop().unwrap_or_else(TakeAllLinesBuffer::new);
+            let fill_result = new_buffer.fill_buffer(&mut reader, separator)?;
+            if fill_result.bytes == 0 {
+                // fill_result.bytes == 0 => EoF.
+                break;
+            }
+            buffered_terminated_lines += fill_result.terminated_lines;
+            buffers.push_back(new_buffer);
+        }
 
-    fn next(&mut self) -> Option<<I as Iterator>::Item> {
-        match self.iter.next() {
-            Some(value) => self.buf.push_back(value),
-            None => None,
+        // If we've not buffered more lines than we need to hold back we must be done.
+        if buffered_terminated_lines < n
+            || (buffered_terminated_lines == n && !buffers.back().unwrap().partial_line())
+        {
+            break;
+        }
+
+        let excess_buffered_terminated_lines = buffered_terminated_lines - n;
+        // Since we have some data buffered can assume we have at least 1 buffer, so safe to unwrap.
+        let lines_to_write = if buffers.back().unwrap().partial_line() {
+            excess_buffered_terminated_lines + 1
+        } else {
+            excess_buffered_terminated_lines
+        };
+        let front_buffer = buffers.front_mut().unwrap();
+        let write_result = front_buffer.write_lines(writer, lines_to_write, separator)?;
+        buffered_terminated_lines -= write_result.terminated_lines;
+        total_bytes_copied += write_result.bytes;
+        // If the front buffer is empty (which it probably is), push it into the empty-buffer-pool.
+        if front_buffer.is_empty() {
+            empty_buffers.push(buffers.pop_front().unwrap());
         }
     }
+    Ok(total_bytes_copied)
 }
 
 /// Like `std::io::Take`, but for lines instead of bytes.
@@ -118,38 +359,285 @@ pub fn take_lines<R>(reader: R, limit: u64, separator: u8) -> TakeLines<R> {
 #[cfg(test)]
 mod tests {
 
-    use std::io::BufRead;
-    use std::io::BufReader;
+    use std::io::{BufRead, BufReader};
 
-    use crate::take::take_all_but;
-    use crate::take::take_lines;
+    use crate::take::{
+        TakeAllBuffer, TakeAllLinesBuffer, copy_all_but_n_bytes, copy_all_but_n_lines, take_lines,
+    };
 
     #[test]
-    fn test_fewer_elements() {
-        let mut iter = take_all_but([0, 1, 2].iter(), 2);
-        assert_eq!(Some(&0), iter.next());
-        assert_eq!(None, iter.next());
+    fn test_take_all_buffer_exact_bytes() {
+        let input_buffer = "abc";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut take_all_buffer = TakeAllBuffer::new();
+        let bytes_read = take_all_buffer.fill_buffer(&mut input_reader).unwrap();
+        assert_eq!(bytes_read, input_buffer.len());
+        assert_eq!(take_all_buffer.remaining_bytes(), input_buffer.len());
+        assert_eq!(take_all_buffer.remaining_buffer(), input_buffer.as_bytes());
+        assert!(!take_all_buffer.is_empty());
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        for (index, c) in input_buffer.bytes().enumerate() {
+            take_all_buffer
+                .write_bytes_exact(&mut output_reader, 1)
+                .unwrap();
+            let buf_ref = output_reader.get_ref();
+            assert_eq!(buf_ref.len(), index + 1);
+            assert_eq!(buf_ref[index], c);
+            assert_eq!(
+                take_all_buffer.remaining_bytes(),
+                input_buffer.len() - (index + 1)
+            );
+            assert_eq!(
+                take_all_buffer.remaining_buffer(),
+                &input_buffer.as_bytes()[index + 1..]
+            );
+        }
+
+        assert!(take_all_buffer.is_empty());
+        assert_eq!(take_all_buffer.remaining_bytes(), 0);
+        assert_eq!(take_all_buffer.remaining_buffer(), "".as_bytes());
     }
 
     #[test]
-    fn test_same_number_of_elements() {
-        let mut iter = take_all_but([0, 1].iter(), 2);
-        assert_eq!(None, iter.next());
+    fn test_take_all_buffer_all_bytes() {
+        let input_buffer = "abc";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut take_all_buffer = TakeAllBuffer::new();
+        let bytes_read = take_all_buffer.fill_buffer(&mut input_reader).unwrap();
+        assert_eq!(bytes_read, input_buffer.len());
+        assert_eq!(take_all_buffer.remaining_bytes(), input_buffer.len());
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_written = take_all_buffer.write_all(&mut output_reader).unwrap();
+        assert_eq!(bytes_written, input_buffer.len());
+        assert_eq!(output_reader.get_ref().as_slice(), input_buffer.as_bytes());
+
+        assert!(take_all_buffer.is_empty());
+        assert_eq!(take_all_buffer.remaining_bytes(), 0);
+        assert_eq!(take_all_buffer.remaining_buffer(), "".as_bytes());
+
+        // Now do a write_all on an empty TakeAllBuffer. Confirm correct behavior.
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_written = take_all_buffer.write_all(&mut output_reader).unwrap();
+        assert_eq!(bytes_written, 0);
+        assert_eq!(output_reader.get_ref().as_slice().len(), 0);
     }
 
     #[test]
-    fn test_more_elements() {
-        let mut iter = take_all_but([0].iter(), 2);
-        assert_eq!(None, iter.next());
+    fn test_take_all_buffer_limit_bytes() {
+        let input_buffer = "abc";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut take_all_buffer = TakeAllBuffer::new();
+        let bytes_read = take_all_buffer.fill_buffer(&mut input_reader).unwrap();
+        assert_eq!(bytes_read, input_buffer.len());
+        assert_eq!(take_all_buffer.remaining_bytes(), input_buffer.len());
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        // Write all but 1 bytes.
+        let bytes_to_write = input_buffer.len() - 1;
+        let bytes_written = take_all_buffer
+            .write_bytes_limit(&mut output_reader, bytes_to_write)
+            .unwrap();
+        assert_eq!(bytes_written, bytes_to_write);
+        assert_eq!(
+            output_reader.get_ref().as_slice(),
+            &input_buffer.as_bytes()[..bytes_to_write]
+        );
+        assert!(!take_all_buffer.is_empty());
+        assert_eq!(take_all_buffer.remaining_bytes(), 1);
+        assert_eq!(
+            take_all_buffer.remaining_buffer(),
+            &input_buffer.as_bytes()[bytes_to_write..]
+        );
+
+        // Write 1 more byte - i.e. last byte in buffer.
+        let bytes_to_write = 1;
+        let bytes_written = take_all_buffer
+            .write_bytes_limit(&mut output_reader, bytes_to_write)
+            .unwrap();
+        assert_eq!(bytes_written, bytes_to_write);
+        assert_eq!(output_reader.get_ref().as_slice(), input_buffer.as_bytes());
+        assert!(take_all_buffer.is_empty());
+        assert_eq!(take_all_buffer.remaining_bytes(), 0);
+        assert_eq!(take_all_buffer.remaining_buffer(), "".as_bytes());
+
+        // Write 1 more byte - i.e. confirm behavior on already empty buffer.
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_to_write = 1;
+        let bytes_written = take_all_buffer
+            .write_bytes_limit(&mut output_reader, bytes_to_write)
+            .unwrap();
+        assert_eq!(bytes_written, 0);
+        assert_eq!(output_reader.get_ref().as_slice().len(), 0);
+        assert!(take_all_buffer.is_empty());
+        assert_eq!(take_all_buffer.remaining_bytes(), 0);
+        assert_eq!(take_all_buffer.remaining_buffer(), "".as_bytes());
     }
 
     #[test]
-    fn test_zero_elements() {
-        let mut iter = take_all_but([0, 1, 2].iter(), 0);
-        assert_eq!(Some(&0), iter.next());
-        assert_eq!(Some(&1), iter.next());
-        assert_eq!(Some(&2), iter.next());
-        assert_eq!(None, iter.next());
+    #[allow(clippy::cognitive_complexity)]
+    fn test_take_all_lines_buffer() {
+        // 3 lines with new-lines and one partial line.
+        let input_buffer = "a\nb\nc\ndef";
+        let separator = b'\n';
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut take_all_lines_buffer = TakeAllLinesBuffer::new();
+        let fill_result = take_all_lines_buffer
+            .fill_buffer(&mut input_reader, separator)
+            .unwrap();
+        assert_eq!(fill_result.bytes, input_buffer.len());
+        assert_eq!(fill_result.terminated_lines, 3);
+        assert_eq!(take_all_lines_buffer.terminated_lines(), 3);
+        assert!(!take_all_lines_buffer.is_empty());
+        assert!(take_all_lines_buffer.partial_line());
+
+        // Write 1st line.
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let lines_to_write = 1;
+        let write_result = take_all_lines_buffer
+            .write_lines(&mut output_reader, lines_to_write, separator)
+            .unwrap();
+        assert_eq!(write_result.bytes, 2);
+        assert_eq!(write_result.terminated_lines, lines_to_write);
+        assert_eq!(output_reader.get_ref().as_slice(), "a\n".as_bytes());
+        assert!(!take_all_lines_buffer.is_empty());
+        assert_eq!(take_all_lines_buffer.terminated_lines(), 2);
+
+        // Write 2nd line.
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let lines_to_write = 1;
+        let write_result = take_all_lines_buffer
+            .write_lines(&mut output_reader, lines_to_write, separator)
+            .unwrap();
+        assert_eq!(write_result.bytes, 2);
+        assert_eq!(write_result.terminated_lines, lines_to_write);
+        assert_eq!(output_reader.get_ref().as_slice(), "b\n".as_bytes());
+        assert!(!take_all_lines_buffer.is_empty());
+        assert_eq!(take_all_lines_buffer.terminated_lines(), 1);
+
+        // Now try to write 3 lines even though we have only 1 line remaining. Should write everything left in the buffer.
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let lines_to_write = 3;
+        let write_result = take_all_lines_buffer
+            .write_lines(&mut output_reader, lines_to_write, separator)
+            .unwrap();
+        assert_eq!(write_result.bytes, 5);
+        assert_eq!(write_result.terminated_lines, 1);
+        assert_eq!(output_reader.get_ref().as_slice(), "c\ndef".as_bytes());
+        assert!(take_all_lines_buffer.is_empty());
+        assert_eq!(take_all_lines_buffer.terminated_lines(), 0);
+
+        // Test empty buffer.
+        let input_buffer = "";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut take_all_lines_buffer = TakeAllLinesBuffer::new();
+        let fill_result = take_all_lines_buffer
+            .fill_buffer(&mut input_reader, separator)
+            .unwrap();
+        assert_eq!(fill_result.bytes, 0);
+        assert_eq!(fill_result.terminated_lines, 0);
+        assert_eq!(take_all_lines_buffer.terminated_lines(), 0);
+        assert!(take_all_lines_buffer.is_empty());
+        assert!(!take_all_lines_buffer.partial_line());
+
+        // Test buffer that ends with newline.
+        let input_buffer = "\n";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut take_all_lines_buffer = TakeAllLinesBuffer::new();
+        let fill_result = take_all_lines_buffer
+            .fill_buffer(&mut input_reader, separator)
+            .unwrap();
+        assert_eq!(fill_result.bytes, 1);
+        assert_eq!(fill_result.terminated_lines, 1);
+        assert_eq!(take_all_lines_buffer.terminated_lines(), 1);
+        assert!(!take_all_lines_buffer.is_empty());
+        assert!(!take_all_lines_buffer.partial_line());
+    }
+
+    #[test]
+    fn test_copy_all_but_n_bytes() {
+        // Test the copy_all_but_bytes fn. Test several scenarios...
+        // 1 - Hold back more bytes than the input will provide. Should have nothing written to output.
+        let input_buffer = "a\nb\nc\ndef";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied = copy_all_but_n_bytes(
+            &mut input_reader,
+            &mut output_reader,
+            input_buffer.len() + 1,
+        )
+        .unwrap();
+        assert_eq!(bytes_copied, 0);
+
+        // 2 - Hold back exactly the number of bytes the input will provide. Should have nothing written to output.
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_bytes(&mut input_reader, &mut output_reader, input_buffer.len())
+                .unwrap();
+        assert_eq!(bytes_copied, 0);
+
+        // 3 - Hold back 1 fewer byte than input will provide. Should have one byte written to output.
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied = copy_all_but_n_bytes(
+            &mut input_reader,
+            &mut output_reader,
+            input_buffer.len() - 1,
+        )
+        .unwrap();
+        assert_eq!(bytes_copied, 1);
+        assert_eq!(output_reader.get_ref()[..], input_buffer.as_bytes()[0..1]);
+    }
+
+    #[test]
+    fn test_copy_all_but_n_lines() {
+        // Test the copy_all_but_lines fn. Test several scenarios...
+        // 1 - Hold back more lines than the input will provide. Should have nothing written to output.
+        let input_buffer = "a\nb\nc\ndef";
+        let separator = b'\n';
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_lines(&mut input_reader, &mut output_reader, 5, separator).unwrap();
+        assert_eq!(bytes_copied, 0);
+
+        // 2 - Hold back exactly the number of lines the input will provide. Should have nothing written to output.
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_lines(&mut input_reader, &mut output_reader, 4, separator).unwrap();
+        assert_eq!(bytes_copied, 0);
+
+        // 3 - Hold back 1 fewer lines than input will provide. Should have one line written to output.
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_lines(&mut input_reader, &mut output_reader, 3, separator).unwrap();
+        assert_eq!(bytes_copied, 2);
+        assert_eq!(output_reader.get_ref()[..], input_buffer.as_bytes()[0..2]);
+
+        // Now test again with an input that has a new-line ending...
+        // 4 - Hold back more lines than the input will provide. Should have nothing written to output.
+        let input_buffer = "a\nb\nc\ndef\n";
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_lines(&mut input_reader, &mut output_reader, 5, separator).unwrap();
+        assert_eq!(bytes_copied, 0);
+
+        // 5 - Hold back exactly the number of lines the input will provide. Should have nothing written to output.
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_lines(&mut input_reader, &mut output_reader, 4, separator).unwrap();
+        assert_eq!(bytes_copied, 0);
+
+        // 6 - Hold back 1 fewer lines than input will provide. Should have one line written to output.
+        let mut input_reader = std::io::Cursor::new(input_buffer);
+        let mut output_reader = std::io::Cursor::new(vec![0x10; 0]);
+        let bytes_copied =
+            copy_all_but_n_lines(&mut input_reader, &mut output_reader, 3, separator).unwrap();
+        assert_eq!(bytes_copied, 2);
+        assert_eq!(output_reader.get_ref()[..], input_buffer.as_bytes()[0..2]);
     }
 
     #[test]
diff --git a/src/uu/hostid/Cargo.toml b/src/uu/hostid/Cargo.toml
index f34fee820a5..3599f0847bf 100644
--- a/src/uu/hostid/Cargo.toml
+++ b/src/uu/hostid/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_hostid"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "hostid ~ (uutils) display the numeric identifier of the current host"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/hostid"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/hostid.rs"
diff --git a/src/uu/hostid/src/hostid.rs b/src/uu/hostid/src/hostid.rs
index a5c18d07563..a01151dde17 100644
--- a/src/uu/hostid/src/hostid.rs
+++ b/src/uu/hostid/src/hostid.rs
@@ -5,28 +5,23 @@
 
 // spell-checker:ignore (ToDO) gethostid
 
-use clap::{crate_version, Command};
-use libc::c_long;
+use clap::Command;
+use libc::{c_long, gethostid};
 use uucore::{error::UResult, format_usage, help_about, help_usage};
 
 const USAGE: &str = help_usage!("hostid.md");
 const ABOUT: &str = help_about!("hostid.md");
 
-// currently rust libc interface doesn't include gethostid
-extern "C" {
-    pub fn gethostid() -> c_long;
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    uu_app().get_matches_from(args);
+    uu_app().try_get_matches_from(args)?;
     hostid();
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/hostname/Cargo.toml b/src/uu/hostname/Cargo.toml
index 8e36e672a80..40b62ef51a0 100644
--- a/src/uu/hostname/Cargo.toml
+++ b/src/uu/hostname/Cargo.toml
@@ -1,24 +1,30 @@
 [package]
 name = "uu_hostname"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "hostname ~ (uutils) display or set the host name of the current host"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/hostname"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/hostname.rs"
 
 [dependencies]
 clap = { workspace = true }
-hostname = { version = "0.3", features = ["set"] }
+hostname = { workspace = true, features = ["set"] }
 uucore = { workspace = true, features = ["wide"] }
 
+[target.'cfg(any(target_os = "freebsd", target_os = "openbsd"))'.dependencies]
+dns-lookup = { workspace = true }
+
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-sys = { workspace = true, features = [
   "Win32_Networking_WinSock",
diff --git a/src/uu/hostname/src/hostname.rs b/src/uu/hostname/src/hostname.rs
index 6a318cb8c26..29b2bb6ba1e 100644
--- a/src/uu/hostname/src/hostname.rs
+++ b/src/uu/hostname/src/hostname.rs
@@ -3,14 +3,18 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) MAKEWORD addrs hashset
+// spell-checker:ignore hashset Addrs addrs
 
+#[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))]
 use std::net::ToSocketAddrs;
 use std::str;
 use std::{collections::hash_set::HashSet, ffi::OsString};
 
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
+
+#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
+use dns_lookup::lookup_host;
 
 use uucore::{
     error::{FromIo, UResult},
@@ -30,7 +34,7 @@ static OPT_HOST: &str = "host";
 mod wsa {
     use std::io;
 
-    use windows_sys::Win32::Networking::WinSock::{WSACleanup, WSAStartup, WSADATA};
+    use windows_sys::Win32::Networking::WinSock::{WSACleanup, WSADATA, WSAStartup};
 
     pub(super) struct WsaHandle(());
 
@@ -71,7 +75,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -121,13 +125,25 @@ fn display_hostname(matches: &ArgMatches) -> UResult<()> {
         .into_owned();
 
     if matches.get_flag(OPT_IP_ADDRESS) {
-        // XXX: to_socket_addrs needs hostname:port so append a dummy port and remove it later.
-        // This was originally supposed to use std::net::lookup_host, but that seems to be
-        // deprecated.  Perhaps we should use the dns-lookup crate?
-        let hostname = hostname + ":1";
-        let addresses = hostname
-            .to_socket_addrs()
-            .map_err_context(|| "failed to resolve socket addresses".to_owned())?;
+        let addresses;
+
+        #[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))]
+        {
+            let hostname = hostname + ":1";
+            let addrs = hostname
+                .to_socket_addrs()
+                .map_err_context(|| "failed to resolve socket addresses".to_owned())?;
+            addresses = addrs;
+        }
+
+        // DNS reverse lookup via "hostname:1" does not work on FreeBSD and OpenBSD
+        // use dns-lookup crate instead
+        #[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
+        {
+            let addrs: Vec<std::net::IpAddr> = lookup_host(hostname.as_str()).unwrap();
+            addresses = addrs;
+        }
+
         let mut hashset = HashSet::new();
         let mut output = String::new();
         for addr in addresses {
diff --git a/src/uu/id/Cargo.toml b/src/uu/id/Cargo.toml
index 77cda20be89..449b9cf925e 100644
--- a/src/uu/id/Cargo.toml
+++ b/src/uu/id/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_id"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "id ~ (uutils) display user and group information for USER"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/id"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/id.rs"
diff --git a/src/uu/id/src/id.rs b/src/uu/id/src/id.rs
index 49ad549257d..314d12d6804 100644
--- a/src/uu/id/src/id.rs
+++ b/src/uu/id/src/id.rs
@@ -33,12 +33,12 @@
 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::ffi::CStr;
 use uucore::display::Quotable;
 use uucore::entries::{self, Group, Locate, Passwd};
 use uucore::error::UResult;
-use uucore::error::{set_exit_code, USimpleError};
+use uucore::error::{USimpleError, set_exit_code};
 pub use uucore::libc;
 use uucore::libc::{getlogin, uid_t};
 use uucore::line_ending::LineEnding;
@@ -47,7 +47,15 @@ use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 macro_rules! cstr2cow {
     ($v:expr) => {
-        unsafe { CStr::from_ptr($v).to_string_lossy() }
+        unsafe {
+            let ptr = $v;
+            // Must be not null to call cstr2cow
+            if ptr.is_null() {
+                None
+            } else {
+                Some({ CStr::from_ptr(ptr) }.to_string_lossy())
+            }
+        }
     };
 }
 
@@ -109,6 +117,7 @@ struct State {
 }
 
 #[uucore::main]
+#[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
@@ -129,7 +138,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         selinux_supported: {
             #[cfg(feature = "selinux")]
             {
-                selinux::kernel_support() != selinux::KernelSupport::Unsupported
+                uucore::selinux::is_selinux_enabled()
             }
             #[cfg(not(feature = "selinux"))]
             {
@@ -148,7 +157,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     if (state.nflag || state.rflag) && default_format && !state.cflag {
         return Err(USimpleError::new(
             1,
-            "cannot print only names or real IDs in default format",
+            "printing only names or real IDs requires -u, -g, or -G",
         ));
     }
     if state.zflag && default_format && !state.cflag {
@@ -165,33 +174,27 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     }
 
-    let delimiter = {
-        if state.zflag {
-            "\0".to_string()
-        } else {
-            " ".to_string()
-        }
-    };
+    let delimiter = if state.zflag { "\0" } else { " " };
     let line_ending = LineEnding::from_zero_flag(state.zflag);
 
     if state.cflag {
-        if state.selinux_supported {
+        return if state.selinux_supported {
             // print SElinux context and exit
             #[cfg(all(any(target_os = "linux", target_os = "android"), feature = "selinux"))]
             if let Ok(context) = selinux::SecurityContext::current(false) {
                 let bytes = context.as_bytes();
-                print!("{}{}", String::from_utf8_lossy(bytes), line_ending);
+                print!("{}{line_ending}", String::from_utf8_lossy(bytes));
             } else {
                 // print error because `cflag` was explicitly requested
                 return Err(USimpleError::new(1, "can't get process context"));
             }
-            return Ok(());
+            Ok(())
         } else {
-            return Err(USimpleError::new(
+            Err(USimpleError::new(
                 1,
                 "--context (-Z) works only on an SELinux-enabled kernel",
-            ));
-        }
+            ))
+        };
     }
 
     for i in 0..=users.len() {
@@ -229,10 +232,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             return Ok(());
         }
 
-        let (uid, gid) = possible_pw.as_ref().map(|p| (p.uid, p.gid)).unwrap_or((
-            if state.rflag { getuid() } else { geteuid() },
-            if state.rflag { getgid() } else { getegid() },
-        ));
+        let (uid, gid) = possible_pw.as_ref().map(|p| (p.uid, p.gid)).unwrap_or({
+            let use_effective = !state.rflag && (state.uflag || state.gflag || state.gsflag);
+            if use_effective {
+                (geteuid(), getegid())
+            } else {
+                (getuid(), getgid())
+            }
+        });
         state.ids = Some(Ids {
             uid,
             gid,
@@ -245,7 +252,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 "{}",
                 if state.nflag {
                     entries::gid2grp(gid).unwrap_or_else(|_| {
-                        show_error!("cannot find name for group ID {}", gid);
+                        show_error!("cannot find name for group ID {gid}");
                         set_exit_code(1);
                         gid.to_string()
                     })
@@ -260,7 +267,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 "{}",
                 if state.nflag {
                     entries::uid2usr(uid).unwrap_or_else(|_| {
-                        show_error!("cannot find name for user ID {}", uid);
+                        show_error!("cannot find name for user ID {uid}");
                         set_exit_code(1);
                         uid.to_string()
                     })
@@ -285,7 +292,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                     .map(|&id| {
                         if state.nflag {
                             entries::gid2grp(id).unwrap_or_else(|_| {
-                                show_error!("cannot find name for group ID {}", id);
+                                show_error!("cannot find name for group ID {id}");
                                 set_exit_code(1);
                                 id.to_string()
                             })
@@ -294,7 +301,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                         }
                     })
                     .collect::<Vec<_>>()
-                    .join(&delimiter),
+                    .join(delimiter),
                 // NOTE: this is necessary to pass GNU's "tests/id/zero.sh":
                 if state.zflag && state.user_specified && users.len() > 1 {
                     "\0"
@@ -319,10 +326,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::OPT_AUDIT)
                 .short('A')
@@ -395,6 +403,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::OPT_PASSWORD)
                 .short('P')
                 .help("Display the id as a password file entry.")
+                .conflicts_with(options::OPT_HUMAN_READABLE)
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -445,11 +454,11 @@ fn pretty(possible_pw: Option<Passwd>) {
                 .join(" ")
         );
     } else {
-        let login = cstr2cow!(getlogin() as *const _);
+        let login = cstr2cow!(getlogin().cast_const());
         let rid = getuid();
         if let Ok(p) = Passwd::locate(rid) {
-            if login == p.name {
-                println!("login\t{login}");
+            if let Some(user_name) = login {
+                println!("login\t{user_name}");
             }
             println!("uid\t{}", p.name);
         } else {
@@ -506,7 +515,7 @@ fn pline(possible_uid: Option<uid_t>) {
     );
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))]
 fn pline(possible_uid: Option<uid_t>) {
     let uid = possible_uid.unwrap_or_else(getuid);
     let pw = Passwd::locate(uid).unwrap();
@@ -523,10 +532,10 @@ fn pline(possible_uid: Option<uid_t>) {
     );
 }
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "openbsd"))]
 fn auditid() {}
 
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "openbsd")))]
 fn auditid() {
     use std::mem::MaybeUninit;
 
@@ -554,40 +563,37 @@ fn id_print(state: &State, groups: &[u32]) {
     let egid = state.ids.as_ref().unwrap().egid;
 
     print!(
-        "uid={}({})",
-        uid,
+        "uid={uid}({})",
         entries::uid2usr(uid).unwrap_or_else(|_| {
-            show_error!("cannot find name for user ID {}", uid);
+            show_error!("cannot find name for user ID {uid}");
             set_exit_code(1);
             uid.to_string()
         })
     );
     print!(
-        " gid={}({})",
-        gid,
+        " gid={gid}({})",
         entries::gid2grp(gid).unwrap_or_else(|_| {
-            show_error!("cannot find name for group ID {}", gid);
+            show_error!("cannot find name for group ID {gid}");
             set_exit_code(1);
             gid.to_string()
         })
     );
     if !state.user_specified && (euid != uid) {
         print!(
-            " euid={}({})",
-            euid,
+            " euid={euid}({})",
             entries::uid2usr(euid).unwrap_or_else(|_| {
-                show_error!("cannot find name for user ID {}", euid);
+                show_error!("cannot find name for user ID {euid}");
                 set_exit_code(1);
                 euid.to_string()
             })
         );
     }
     if !state.user_specified && (egid != gid) {
+        // BUG?  printing egid={euid} ?
         print!(
-            " egid={}({})",
-            euid,
+            " egid={egid}({})",
             entries::gid2grp(egid).unwrap_or_else(|_| {
-                show_error!("cannot find name for group ID {}", egid);
+                show_error!("cannot find name for group ID {egid}");
                 set_exit_code(1);
                 egid.to_string()
             })
@@ -598,10 +604,9 @@ fn id_print(state: &State, groups: &[u32]) {
         groups
             .iter()
             .map(|&gr| format!(
-                "{}({})",
-                gr,
+                "{gr}({})",
                 entries::gid2grp(gr).unwrap_or_else(|_| {
-                    show_error!("cannot find name for group ID {}", gr);
+                    show_error!("cannot find name for group ID {gr}");
                     set_exit_code(1);
                     gr.to_string()
                 })
@@ -623,7 +628,7 @@ fn id_print(state: &State, groups: &[u32]) {
     }
 }
 
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
+#[cfg(not(any(target_os = "linux", target_os = "android", target_os = "openbsd")))]
 mod audit {
     use super::libc::{c_int, c_uint, dev_t, pid_t, uid_t};
 
@@ -648,6 +653,7 @@ mod audit {
     pub type au_tid_addr_t = au_tid_addr;
 
     #[repr(C)]
+    #[expect(clippy::struct_field_names)]
     pub struct c_auditinfo_addr {
         pub ai_auid: au_id_t,         // Audit user ID
         pub ai_mask: au_mask_t,       // Audit masks.
@@ -657,7 +663,7 @@ mod audit {
     }
     pub type c_auditinfo_addr_t = c_auditinfo_addr;
 
-    extern "C" {
+    unsafe extern "C" {
         pub fn getaudit(auditinfo_addr: *mut c_auditinfo_addr_t) -> c_int;
     }
 }
diff --git a/src/uu/install/Cargo.toml b/src/uu/install/Cargo.toml
index e66cbeb72c7..a715902cba0 100644
--- a/src/uu/install/Cargo.toml
+++ b/src/uu/install/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_install"
-version = "0.0.21"
-authors = ["Ben Eills <ben@beneills.com>", "uutils developers"]
-license = "MIT"
 description = "install ~ (uutils) copy files from SOURCE to DESTINATION (with specified attributes)"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/install"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/install.rs"
@@ -19,14 +22,20 @@ clap = { workspace = true }
 filetime = { workspace = true }
 file_diff = { workspace = true }
 libc = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true, features = [
   "backup-control",
+  "buf-copy",
   "fs",
   "mode",
   "perms",
   "entries",
+  "process",
 ] }
 
+[features]
+selinux = ["uucore/selinux"]
+
 [[bin]]
 name = "install"
 path = "src/main.rs"
diff --git a/src/uu/install/src/install.rs b/src/uu/install/src/install.rs
index 02cf8345ddf..c4590240bea 100644
--- a/src/uu/install/src/install.rs
+++ b/src/uu/install/src/install.rs
@@ -7,28 +7,32 @@
 
 mod mode;
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use file_diff::diff;
-use filetime::{set_file_times, FileTime};
+use filetime::{FileTime, set_file_times};
+use std::fmt::Debug;
+use std::fs::File;
+use std::fs::{self, metadata};
+use std::path::{MAIN_SEPARATOR, Path, PathBuf};
+use std::process;
+use thiserror::Error;
 use uucore::backup_control::{self, BackupMode};
+use uucore::buf_copy::copy_stream;
 use uucore::display::Quotable;
 use uucore::entries::{grp2gid, usr2uid};
-use uucore::error::{FromIo, UError, UIoError, UResult, UUsageError};
+use uucore::error::{FromIo, UError, 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, help_about, help_usage, show, show_error, show_if_err, uio_error};
+use uucore::perms::{Verbosity, VerbosityLevel, wrap_chown};
+use uucore::process::{getegid, geteuid};
+#[cfg(feature = "selinux")]
+use uucore::selinux::{contexts_differ, set_selinux_security_context};
+use uucore::{format_usage, help_about, help_usage, show, show_error, show_if_err};
 
-use libc::{getegid, geteuid};
-use std::error::Error;
-use std::fmt::{Debug, Display};
-use std::fs;
-use std::fs::File;
-use std::os::unix::fs::MetadataExt;
+#[cfg(unix)]
+use std::os::unix::fs::{FileTypeExt, MetadataExt};
 #[cfg(unix)]
 use std::os::unix::prelude::OsStrExt;
-use std::path::{Path, PathBuf, MAIN_SEPARATOR};
-use std::process;
 
 const DEFAULT_MODE: u32 = 0o755;
 const DEFAULT_STRIP_PROGRAM: &str = "strip";
@@ -48,32 +52,72 @@ pub struct Behavior {
     strip_program: String,
     create_leading: bool,
     target_dir: Option<String>,
+    no_target_dir: bool,
+    preserve_context: bool,
+    context: Option<String>,
 }
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 enum InstallError {
-    Unimplemented(String),
-    DirNeedsArg(),
-    CreateDirFailed(PathBuf, std::io::Error),
+    #[error("{} with -d requires at least one argument.", uucore::util_name())]
+    DirNeedsArg,
+
+    #[error("failed to create {0}")]
+    CreateDirFailed(PathBuf, #[source] std::io::Error),
+
+    #[error("failed to chmod {}", .0.quote())]
     ChmodFailed(PathBuf),
+
+    #[error("failed to chown {}: {}", .0.quote(), .1)]
     ChownFailed(PathBuf, String),
+
+    #[error("invalid target {}: No such file or directory", .0.quote())]
     InvalidTarget(PathBuf),
+
+    #[error("target {} is not a directory", .0.quote())]
     TargetDirIsntDir(PathBuf),
-    BackupFailed(PathBuf, PathBuf, std::io::Error),
-    InstallFailed(PathBuf, PathBuf, std::io::Error),
+
+    #[error("cannot backup {0} to {1}")]
+    BackupFailed(PathBuf, PathBuf, #[source] std::io::Error),
+
+    #[error("cannot install {0} to {1}")]
+    InstallFailed(PathBuf, PathBuf, #[source] std::io::Error),
+
+    #[error("strip program failed: {0}")]
     StripProgramFailed(String),
-    MetadataFailed(std::io::Error),
+
+    #[error("metadata error")]
+    MetadataFailed(#[source] std::io::Error),
+
+    #[error("invalid user: {}", .0.quote())]
     InvalidUser(String),
+
+    #[error("invalid group: {}", .0.quote())]
     InvalidGroup(String),
+
+    #[error("omitting directory {}", .0.quote())]
     OmittingDirectory(PathBuf),
+
+    #[error("failed to access {}: Not a directory", .0.quote())]
+    NotADirectory(PathBuf),
+
+    #[error("cannot overwrite directory {} with non-directory {}", .0.quote(), .1.quote())]
+    OverrideDirectoryFailed(PathBuf, PathBuf),
+
+    #[error("'{0}' and '{1}' are the same file")]
+    SameFile(PathBuf, PathBuf),
+
+    #[error("extra operand {}\n{}", .0.quote(), .1.quote())]
+    ExtraOperand(String, String),
+
+    #[cfg(feature = "selinux")]
+    #[error("{}", .0)]
+    SelinuxContextFailed(String),
 }
 
 impl UError for InstallError {
     fn code(&self) -> i32 {
-        match self {
-            Self::Unimplemented(_) => 2,
-            _ => 1,
-        }
+        1
     }
 
     fn usage(&self) -> bool {
@@ -81,49 +125,6 @@ impl UError for InstallError {
     }
 }
 
-impl Error for InstallError {}
-
-impl Display for InstallError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Unimplemented(opt) => write!(f, "Unimplemented feature: {opt}"),
-            Self::DirNeedsArg() => {
-                write!(
-                    f,
-                    "{} with -d requires at least one argument.",
-                    uucore::util_name()
-                )
-            }
-            Self::CreateDirFailed(dir, e) => {
-                Display::fmt(&uio_error!(e, "failed to create {}", dir.quote()), f)
-            }
-            Self::ChmodFailed(file) => write!(f, "failed to chmod {}", file.quote()),
-            Self::ChownFailed(file, msg) => write!(f, "failed to chown {}: {}", file.quote(), msg),
-            Self::InvalidTarget(target) => write!(
-                f,
-                "invalid target {}: No such file or directory",
-                target.quote()
-            ),
-            Self::TargetDirIsntDir(target) => {
-                write!(f, "target {} is not a directory", target.quote())
-            }
-            Self::BackupFailed(from, to, e) => Display::fmt(
-                &uio_error!(e, "cannot backup {} to {}", from.quote(), to.quote()),
-                f,
-            ),
-            Self::InstallFailed(from, to, e) => Display::fmt(
-                &uio_error!(e, "cannot install {} to {}", from.quote(), to.quote()),
-                f,
-            ),
-            Self::StripProgramFailed(msg) => write!(f, "strip program failed: {msg}"),
-            Self::MetadataFailed(e) => Display::fmt(&uio_error!(e, ""), f),
-            Self::InvalidUser(user) => write!(f, "invalid user: {}", user.quote()),
-            Self::InvalidGroup(group) => write!(f, "invalid group: {}", group.quote()),
-            Self::OmittingDirectory(dir) => write!(f, "omitting directory {}", dir.quote()),
-        }
-    }
-}
-
 #[derive(Clone, Eq, PartialEq)]
 pub enum MainFunction {
     /// Create directories
@@ -135,10 +136,7 @@ pub enum MainFunction {
 impl Behavior {
     /// Determine the mode for chmod after copy.
     pub fn mode(&self) -> u32 {
-        match self.specified_mode {
-            Some(x) => x,
-            None => DEFAULT_MODE,
-        }
+        self.specified_mode.unwrap_or(DEFAULT_MODE)
     }
 }
 
@@ -176,8 +174,6 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(|v| v.map(ToString::to_string).collect())
         .unwrap_or_default();
 
-    check_unimplemented(&matches)?;
-
     let behavior = behavior(&matches)?;
 
     match behavior.main_function {
@@ -188,7 +184,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -221,7 +217,6 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            // TODO implement flag
             Arg::new(OPT_CREATE_LEADING)
                 .short('D')
                 .help(
@@ -278,7 +273,6 @@ pub fn uu_app() -> Command {
         )
         .arg(backup_control::arguments::suffix())
         .arg(
-            // TODO implement flag
             Arg::new(OPT_TARGET_DIRECTORY)
                 .short('t')
                 .long(OPT_TARGET_DIRECTORY)
@@ -287,11 +281,10 @@ pub fn uu_app() -> Command {
                 .value_hint(clap::ValueHint::DirPath),
         )
         .arg(
-            // TODO implement flag
             Arg::new(OPT_NO_TARGET_DIRECTORY)
                 .short('T')
                 .long(OPT_NO_TARGET_DIRECTORY)
-                .help("(unimplemented) treat DEST as a normal file")
+                .help("treat DEST as a normal file")
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -302,21 +295,20 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            // TODO implement flag
             Arg::new(OPT_PRESERVE_CONTEXT)
                 .short('P')
                 .long(OPT_PRESERVE_CONTEXT)
-                .help("(unimplemented) preserve security context")
+                .help("preserve security context")
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            // TODO implement flag
             Arg::new(OPT_CONTEXT)
                 .short('Z')
                 .long(OPT_CONTEXT)
-                .help("(unimplemented) set security context of files and directories")
+                .help("set security context of files and directories")
                 .value_name("CONTEXT")
-                .action(ArgAction::SetTrue),
+                .value_parser(clap::value_parser!(String))
+                .num_args(0..=1),
         )
         .arg(
             Arg::new(ARG_FILES)
@@ -326,27 +318,6 @@ pub fn uu_app() -> Command {
         )
 }
 
-/// Check for unimplemented command line arguments.
-///
-/// Either return the degenerate Ok value, or an Err with string.
-///
-/// # Errors
-///
-/// Error datum is a string of the unimplemented argument.
-///
-///
-fn check_unimplemented(matches: &ArgMatches) -> UResult<()> {
-    if matches.get_flag(OPT_NO_TARGET_DIRECTORY) {
-        Err(InstallError::Unimplemented(String::from("--no-target-directory, -T")).into())
-    } else if matches.get_flag(OPT_PRESERVE_CONTEXT) {
-        Err(InstallError::Unimplemented(String::from("--preserve-context, -P")).into())
-    } else if matches.get_flag(OPT_CONTEXT) {
-        Err(InstallError::Unimplemented(String::from("--context, -Z")).into())
-    } else {
-        Ok(())
-    }
-}
-
 /// Determine behavior, given command line arguments.
 ///
 /// If successful, returns a filled-out Behavior struct.
@@ -367,7 +338,7 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
     let specified_mode: Option<u32> = if matches.contains_id(OPT_MODE) {
         let x = matches.get_one::<String>(OPT_MODE).ok_or(1)?;
         Some(mode::parse(x, considering_dir, get_umask()).map_err(|err| {
-            show_error!("Invalid mode string: {}", err);
+            show_error!("Invalid mode string: {err}");
             1
         })?)
     } else {
@@ -375,9 +346,12 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
     };
 
     let backup_mode = backup_control::determine_backup_mode(matches)?;
-    let target_dir = matches
-        .get_one::<String>(OPT_TARGET_DIRECTORY)
-        .map(|d| d.to_owned());
+    let target_dir = matches.get_one::<String>(OPT_TARGET_DIRECTORY).cloned();
+    let no_target_dir = matches.get_flag(OPT_NO_TARGET_DIRECTORY);
+    if target_dir.is_some() && no_target_dir {
+        show_error!("Options --target-directory and --no-target-directory are mutually exclusive");
+        return Err(1.into());
+    }
 
     let preserve_timestamps = matches.get_flag(OPT_PRESERVE_TIMESTAMPS);
     let compare = matches.get_flag(OPT_COMPARE);
@@ -421,6 +395,8 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
         }
     };
 
+    let context = matches.get_one::<String>(OPT_CONTEXT).cloned();
+
     Ok(Behavior {
         main_function,
         specified_mode,
@@ -440,6 +416,9 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
         ),
         create_leading: matches.get_flag(OPT_CREATE_LEADING),
         target_dir,
+        no_target_dir,
+        preserve_context: matches.get_flag(OPT_PRESERVE_CONTEXT),
+        context,
     })
 }
 
@@ -452,7 +431,7 @@ fn behavior(matches: &ArgMatches) -> UResult<Behavior> {
 ///
 fn directory(paths: &[String], b: &Behavior) -> UResult<()> {
     if paths.is_empty() {
-        Err(InstallError::DirNeedsArg().into())
+        Err(InstallError::DirNeedsArg.into())
     } else {
         for path in paths.iter().map(Path::new) {
             // if the path already exist, don't try to create it again
@@ -490,6 +469,10 @@ fn directory(paths: &[String], b: &Behavior) -> UResult<()> {
             }
 
             show_if_err!(chown_optional_user_group(path, b));
+
+            // Set SELinux context for directory if needed
+            #[cfg(feature = "selinux")]
+            show_if_err!(set_selinux_context(path, b));
         }
         // If the exit code was set, or show! has been called at least once
         // (which sets the exit code as well), function execution will end after
@@ -526,11 +509,15 @@ fn is_potential_directory_path(path: &Path) -> bool {
 ///
 /// Returns a Result type with the Err variant containing the error message.
 ///
+#[allow(clippy::cognitive_complexity)]
 fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
     // first check that paths contains at least one element
     if paths.is_empty() {
         return Err(UUsageError::new(1, "missing file operand"));
     }
+    if b.no_target_dir && paths.len() > 2 {
+        return Err(InstallError::ExtraOperand(paths[2].clone(), format_usage(USAGE)).into());
+    }
 
     // get the target from either "-t foo" param or from the last given paths argument
     let target: PathBuf = if let Some(path) = &b.target_dir {
@@ -566,6 +553,13 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
         };
 
         if let Some(to_create) = to_create {
+            // if the path ends in /, remove it
+            let to_create = if to_create.to_string_lossy().ends_with('/') {
+                Path::new(to_create.to_str().unwrap().trim_end_matches('/'))
+            } else {
+                to_create
+            };
+
             if !to_create.exists() {
                 if b.verbose {
                     let mut result = PathBuf::new();
@@ -584,15 +578,32 @@ fn standard(mut paths: Vec<String>, b: &Behavior) -> UResult<()> {
                 }
             }
         }
+        if b.target_dir.is_some() {
+            let p = to_create.unwrap();
+
+            if !p.exists() || !p.is_dir() {
+                return Err(InstallError::NotADirectory(p.to_path_buf()).into());
+            }
+        }
     }
 
-    if sources.len() > 1 || is_potential_directory_path(&target) {
+    if sources.len() > 1 {
         copy_files_into_dir(sources, &target, b)
     } else {
         let source = sources.first().unwrap();
 
         if source.is_dir() {
-            return Err(InstallError::OmittingDirectory(source.to_path_buf()).into());
+            return Err(InstallError::OmittingDirectory(source.clone()).into());
+        }
+
+        if b.no_target_dir && target.exists() {
+            return Err(
+                InstallError::OverrideDirectoryFailed(target.clone(), source.clone()).into(),
+            );
+        }
+
+        if is_potential_directory_path(&target) {
+            return copy_files_into_dir(sources, &target, b);
         }
 
         if target.is_file() || is_new_file_path(&target) {
@@ -627,13 +638,13 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
         }
 
         if sourcepath.is_dir() {
-            let err = InstallError::OmittingDirectory(sourcepath.to_path_buf());
+            let err = InstallError::OmittingDirectory(sourcepath.clone());
             show!(err);
             continue;
         }
 
         let mut targetpath = target_dir.to_path_buf();
-        let filename = sourcepath.components().last().unwrap();
+        let filename = sourcepath.components().next_back().unwrap();
         targetpath.push(filename);
 
         show_if_err!(copy(sourcepath, &targetpath, b));
@@ -647,6 +658,7 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
 /// Handle incomplete user/group parings for chown.
 ///
 /// Returns a Result type with the Err variant containing the error message.
+/// If the user is root, revert the uid & gid
 ///
 /// # Parameters
 ///
@@ -658,23 +670,31 @@ fn copy_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
 /// return an empty error value.
 ///
 fn chown_optional_user_group(path: &Path, b: &Behavior) -> UResult<()> {
-    if b.owner_id.is_some() || b.group_id.is_some() {
-        let meta = match fs::metadata(path) {
-            Ok(meta) => meta,
-            Err(e) => return Err(InstallError::MetadataFailed(e).into()),
-        };
+    // GNU coreutils doesn't print chown operations during install with verbose flag.
+    let verbosity = Verbosity {
+        groups_only: b.owner_id.is_none(),
+        level: VerbosityLevel::Normal,
+    };
 
-        // GNU coreutils doesn't print chown operations during install with verbose flag.
-        let verbosity = Verbosity {
-            groups_only: b.owner_id.is_none(),
-            level: VerbosityLevel::Normal,
-        };
+    // Determine the owner and group IDs to be used for chown.
+    let (owner_id, group_id) = if b.owner_id.is_some() || b.group_id.is_some() {
+        (b.owner_id, b.group_id)
+    } else if geteuid() == 0 {
+        // Special case for root user.
+        (Some(0), Some(0))
+    } else {
+        // No chown operation needed.
+        return Ok(());
+    };
 
-        match wrap_chown(path, &meta, b.owner_id, b.group_id, false, verbosity) {
-            Ok(msg) if b.verbose && !msg.is_empty() => println!("chown: {msg}"),
-            Ok(_) => {}
-            Err(e) => return Err(InstallError::ChownFailed(path.to_path_buf(), e).into()),
-        }
+    let meta = match metadata(path) {
+        Ok(meta) => meta,
+        Err(e) => return Err(InstallError::MetadataFailed(e).into()),
+    };
+    match wrap_chown(path, &meta, owner_id, group_id, false, verbosity) {
+        Ok(msg) if b.verbose && !msg.is_empty() => println!("chown: {msg}"),
+        Ok(_) => {}
+        Err(e) => return Err(InstallError::ChownFailed(path.to_path_buf(), e).into()),
     }
 
     Ok(())
@@ -698,15 +718,9 @@ fn perform_backup(to: &Path, b: &Behavior) -> UResult<Option<PathBuf>> {
         }
         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());
-            }
+            fs::rename(to, backup_path).map_err(|err| {
+                InstallError::BackupFailed(to.to_path_buf(), backup_path.clone(), err)
+            })?;
         }
         Ok(backup_path)
     } else {
@@ -714,7 +728,24 @@ fn perform_backup(to: &Path, b: &Behavior) -> UResult<Option<PathBuf>> {
     }
 }
 
-/// Copy a file from one path to another.
+/// Copy a non-special file using std::fs::copy.
+///
+/// # 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_normal_file(from: &Path, to: &Path) -> UResult<()> {
+    if let Err(err) = fs::copy(from, to) {
+        return Err(InstallError::InstallFailed(from.to_path_buf(), to.to_path_buf(), err).into());
+    }
+    Ok(())
+}
+
+/// Copy a file from one path to another. Handles the certain cases of special
+/// files (e.g character specials).
 ///
 /// # Parameters
 ///
@@ -726,18 +757,50 @@ fn perform_backup(to: &Path, b: &Behavior) -> UResult<Option<PathBuf>> {
 /// 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) {
+    if let Ok(to_abs) = to.canonicalize() {
+        if from.canonicalize()? == to_abs {
+            return Err(InstallError::SameFile(from.to_path_buf(), to.to_path_buf()).into());
+        }
+    }
+
+    if to.is_dir() && !from.is_dir() {
+        return Err(InstallError::OverrideDirectoryFailed(
+            to.to_path_buf().clone(),
+            from.to_path_buf().clone(),
+        )
+        .into());
+    }
+    // fs::copy fails if destination is a invalid symlink.
+    // so lets just remove all existing files at destination before copy.
+    if let Err(e) = fs::remove_file(to) {
+        if e.kind() != std::io::ErrorKind::NotFound {
+            show_error!(
+                "Failed to remove existing file {}. Error: {e:?}",
+                to.display(),
+            );
+        }
+    }
+
+    let ft = match metadata(from) {
+        Ok(ft) => ft.file_type(),
+        Err(err) => {
             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());
+    };
+
+    // Stream-based copying to get around the limitations of std::fs::copy
+    #[cfg(unix)]
+    if ft.is_char_device() || ft.is_block_device() || ft.is_fifo() {
+        let mut handle = File::open(from)?;
+        let mut dest = File::create(to)?;
+        copy_stream(&mut handle, &mut dest)?;
+        return Ok(());
     }
+
+    copy_normal_file(from, to)?;
+
     Ok(())
 }
 
@@ -753,14 +816,24 @@ fn copy_file(from: &Path, to: &Path) -> UResult<()> {
 /// 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() {
+    // Check if the filename starts with a hyphen and adjust the path
+    let to_str = to.as_os_str().to_str().unwrap_or_default();
+    let to = if to_str.starts_with('-') {
+        let mut new_path = PathBuf::from(".");
+        new_path.push(to);
+        new_path
+    } else {
+        to.to_path_buf()
+    };
+    match process::Command::new(&b.strip_program).arg(&to).status() {
+        Ok(status) => {
+            if !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(),
-                )
+                return Err(InstallError::StripProgramFailed(format!(
+                    "strip process terminated abnormally - exit code: {}",
+                    status.code().unwrap()
+                ))
                 .into());
             }
         }
@@ -808,7 +881,7 @@ fn set_ownership_and_permissions(to: &Path, b: &Behavior) -> UResult<()> {
 /// 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) {
+    let meta = match metadata(from) {
         Ok(meta) => meta,
         Err(e) => return Err(InstallError::MetadataFailed(e).into()),
     };
@@ -816,13 +889,11 @@ fn preserve_timestamps(from: &Path, to: &Path) -> UResult<()> {
     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(())
-        }
+    if let Err(e) = set_file_times(to, accessed_time, modified_time) {
+        show_error!("{e}");
+        // ignore error
     }
+    Ok(())
 }
 
 /// Copy one file to a new location, changing metadata.
@@ -858,6 +929,14 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
         preserve_timestamps(from, to)?;
     }
 
+    #[cfg(feature = "selinux")]
+    if b.preserve_context {
+        uucore::selinux::preserve_security_context(from, to)
+            .map_err(|e| InstallError::SelinuxContextFailed(e.to_string()))?;
+    } else if b.context.is_some() {
+        set_selinux_context(to, b)?;
+    }
+
     if b.verbose {
         print!("{} -> {}", from.quote(), to.quote());
         match backup_path {
@@ -887,60 +966,90 @@ fn copy(from: &Path, to: &Path, b: &Behavior) -> UResult<()> {
 /// Crashes the program if a nonexistent owner or group is specified in _b_.
 ///
 fn need_copy(from: &Path, to: &Path, b: &Behavior) -> UResult<bool> {
-    let from_meta = match fs::metadata(from) {
-        Ok(meta) => meta,
-        Err(_) => return Ok(true),
+    // Attempt to retrieve metadata for the source file.
+    // If this fails, assume the file needs to be copied.
+    let Ok(from_meta) = metadata(from) else {
+        return Ok(true);
     };
-    let to_meta = match fs::metadata(to) {
-        Ok(meta) => meta,
-        Err(_) => return Ok(true),
+
+    // Attempt to retrieve metadata for the destination file.
+    // If this fails, assume the file needs to be copied.
+    let Ok(to_meta) = metadata(to) else {
+        return Ok(true);
     };
 
-    // setuid || setgid || sticky
+    // Define special file mode bits (setuid, setgid, sticky).
     let extra_mode: u32 = 0o7000;
+    // Define all file mode bits (including permissions).
     // setuid || setgid || sticky || permissions
     let all_modes: u32 = 0o7777;
 
+    // Check if any special mode bits are set in the specified mode,
+    // source file mode, or destination file mode.
     if b.specified_mode.unwrap_or(0) & extra_mode != 0
         || from_meta.mode() & extra_mode != 0
         || to_meta.mode() & extra_mode != 0
     {
         return Ok(true);
     }
+
+    // Check if the mode of the destination file differs from the specified mode.
     if b.mode() != to_meta.mode() & all_modes {
         return Ok(true);
     }
 
+    // Check if either the source or destination is not a file.
     if !from_meta.is_file() || !to_meta.is_file() {
         return Ok(true);
     }
 
+    // Check if the file sizes differ.
     if from_meta.len() != to_meta.len() {
         return Ok(true);
     }
 
+    #[cfg(feature = "selinux")]
+    if b.preserve_context && contexts_differ(from, to) {
+        return Ok(true);
+    }
+
     // TODO: if -P (#1809) and from/to contexts mismatch, return true.
 
+    // Check if the owner ID is specified and differs from the destination file's owner.
     if let Some(owner_id) = b.owner_id {
         if owner_id != to_meta.uid() {
             return Ok(true);
         }
-    } else if let Some(group_id) = b.group_id {
+    }
+
+    // Check if the group ID is specified and differs from the destination file's group.
+    if let Some(group_id) = b.group_id {
         if group_id != to_meta.gid() {
             return Ok(true);
         }
     } else {
         #[cfg(not(target_os = "windows"))]
-        unsafe {
-            if to_meta.uid() != geteuid() || to_meta.gid() != getegid() {
-                return Ok(true);
-            }
+        // Check if the destination file's owner or group
+        // differs from the effective user/group ID of the process.
+        if to_meta.uid() != geteuid() || to_meta.gid() != getegid() {
+            return Ok(true);
         }
     }
 
+    // Check if the contents of the source and destination files differ.
     if !diff(from.to_str().unwrap(), to.to_str().unwrap()) {
         return Ok(true);
     }
 
     Ok(false)
 }
+
+#[cfg(feature = "selinux")]
+fn set_selinux_context(path: &Path, behavior: &Behavior) -> UResult<()> {
+    if !behavior.preserve_context && behavior.context.is_some() {
+        // Use the provided context set by -Z/--context
+        set_selinux_security_context(path, behavior.context.as_ref())
+            .map_err(|e| InstallError::SelinuxContextFailed(e.to_string()))?;
+    }
+    Ok(())
+}
diff --git a/src/uu/install/src/mode.rs b/src/uu/install/src/mode.rs
index f9018e16f8e..5fcb9f332ee 100644
--- a/src/uu/install/src/mode.rs
+++ b/src/uu/install/src/mode.rs
@@ -9,10 +9,7 @@ use uucore::mode;
 
 /// Takes a user-supplied string and tries to parse to u16 mode bitmask.
 pub fn parse(mode_string: &str, considering_dir: bool, umask: u32) -> Result<u32, String> {
-    let numbers: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-
-    // Passing 000 as the existing permissions seems to mirror GNU behavior.
-    if mode_string.contains(numbers) {
+    if mode_string.chars().any(|c| c.is_ascii_digit()) {
         mode::parse_numeric(0, mode_string, considering_dir)
     } else {
         mode::parse_symbolic(0, mode_string, umask, considering_dir)
@@ -28,7 +25,7 @@ pub fn chmod(path: &Path, mode: u32) -> Result<(), ()> {
     use std::os::unix::fs::PermissionsExt;
     use uucore::{display::Quotable, show_error};
     fs::set_permissions(path, fs::Permissions::from_mode(mode)).map_err(|err| {
-        show_error!("{}: chmod failed with error {}", path.maybe_quote(), err);
+        show_error!("{}: chmod failed with error {err}", path.maybe_quote());
     })
 }
 
diff --git a/src/uu/join/BENCHMARKING.md b/src/uu/join/BENCHMARKING.md
index 80814ed1cb7..988259aa734 100644
--- a/src/uu/join/BENCHMARKING.md
+++ b/src/uu/join/BENCHMARKING.md
@@ -55,7 +55,7 @@ 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
+- `-i` uses our custom code for case-insensitive text comparisons
 - `--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.
diff --git a/src/uu/join/Cargo.toml b/src/uu/join/Cargo.toml
index 971f8e4552b..1c7349c2c14 100644
--- a/src/uu/join/Cargo.toml
+++ b/src/uu/join/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_join"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "join ~ (uutils) merge lines from inputs with matching join fields"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/join"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/join.rs"
@@ -18,6 +21,7 @@ path = "src/join.rs"
 clap = { workspace = true }
 uucore = { workspace = true }
 memchr = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "join"
diff --git a/src/uu/join/join.md b/src/uu/join/join.md
index ec91950b8bc..04275342a6e 100644
--- a/src/uu/join/join.md
+++ b/src/uu/join/join.md
@@ -1,7 +1,7 @@
 # join
 
 ```
-join [OPTIONS] <FILE1> <FILE2>
+join [OPTION]... FILE1 FILE2
 ```
 
 For each pair of input lines with identical join fields, write a line to
diff --git a/src/uu/join/src/join.rs b/src/uu/join/src/join.rs
index 71720f2cca9..0c6816cb649 100644
--- a/src/uu/join/src/join.rs
+++ b/src/uu/join/src/join.rs
@@ -3,69 +3,155 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) autoformat FILENUM whitespaces pairable unpairable nocheck
+// spell-checker:ignore (ToDO) autoformat FILENUM whitespaces pairable unpairable nocheck memmem
 
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, Command};
-use memchr::{memchr3_iter, memchr_iter};
+use clap::{Arg, ArgAction, Command};
+use memchr::{Memchr3, memchr_iter, memmem::Finder};
 use std::cmp::Ordering;
-use std::convert::From;
-use std::error::Error;
 use std::ffi::OsString;
-use std::fmt::Display;
 use std::fs::File;
-use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Split, Stdin, Write};
+use std::io::{BufRead, BufReader, BufWriter, Split, Stdin, Write, stdin, stdout};
 use std::num::IntErrorKind;
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
+use thiserror::Error;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UError, UResult, USimpleError, set_exit_code};
 use uucore::line_ending::LineEnding;
-use uucore::{crash, crash_if_err, format_usage, help_about, help_usage};
+use uucore::{format_usage, help_about, help_usage};
 
 const ABOUT: &str = help_about!("join.md");
 const USAGE: &str = help_usage!("join.md");
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum JoinError {
-    IOError(std::io::Error),
+    #[error("io error: {0}")]
+    IOError(#[from] std::io::Error),
+
+    #[error("{0}")]
     UnorderedInput(String),
 }
 
+// If you still need the UError implementation for compatibility:
 impl UError for JoinError {
     fn code(&self) -> i32 {
         1
     }
 }
 
-impl Error for JoinError {}
+#[derive(Copy, Clone, PartialEq)]
+enum FileNum {
+    File1,
+    File2,
+}
+
+#[derive(Clone)]
+enum SepSetting {
+    /// Any single-byte separator.
+    Byte(u8),
+    /// A single character more than one byte long.
+    Char(Vec<u8>),
+    /// No separators, join on the entire line.
+    Line,
+    /// Whitespace separators.
+    Whitespaces,
+}
+
+trait Separator: Clone {
+    /// Using this separator, return the start and end index of all fields in the haystack.
+    fn field_ranges(&self, haystack: &[u8], len_guess: usize) -> Vec<(usize, usize)>;
+    /// The separator as it appears when in the output.
+    fn output_separator(&self) -> &[u8];
+}
+
+/// Simple separators one byte in length.
+#[derive(Copy, Clone)]
+struct OneByteSep {
+    byte: [u8; 1],
+}
+
+impl Separator for OneByteSep {
+    fn field_ranges(&self, haystack: &[u8], len_guess: usize) -> Vec<(usize, usize)> {
+        let mut field_ranges = Vec::with_capacity(len_guess);
+        let mut last_end = 0;
 
-impl Display for JoinError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::IOError(e) => write!(f, "io error: {e}"),
-            Self::UnorderedInput(e) => f.write_str(e),
+        for i in memchr_iter(self.byte[0], haystack) {
+            field_ranges.push((last_end, i));
+            last_end = i + 1;
         }
+        field_ranges.push((last_end, haystack.len()));
+        field_ranges
     }
+
+    fn output_separator(&self) -> &[u8] {
+        &self.byte
+    }
+}
+
+/// Multi-byte (but still single character) separators.
+#[derive(Clone)]
+struct MultiByteSep<'a> {
+    finder: Finder<'a>,
 }
 
-impl From<std::io::Error> for JoinError {
-    fn from(error: std::io::Error) -> Self {
-        Self::IOError(error)
+impl Separator for MultiByteSep<'_> {
+    fn field_ranges(&self, haystack: &[u8], len_guess: usize) -> Vec<(usize, usize)> {
+        let mut field_ranges = Vec::with_capacity(len_guess);
+        let mut last_end = 0;
+
+        for i in self.finder.find_iter(haystack) {
+            field_ranges.push((last_end, i));
+            last_end = i + self.finder.needle().len();
+        }
+        field_ranges.push((last_end, haystack.len()));
+        field_ranges
+    }
+
+    fn output_separator(&self) -> &[u8] {
+        self.finder.needle()
     }
 }
 
-#[derive(Copy, Clone, PartialEq)]
-enum FileNum {
-    File1,
-    File2,
+/// Whole-line separator.
+#[derive(Copy, Clone)]
+struct LineSep {}
+
+impl Separator for LineSep {
+    fn field_ranges(&self, haystack: &[u8], _len_guess: usize) -> Vec<(usize, usize)> {
+        vec![(0, haystack.len())]
+    }
+
+    fn output_separator(&self) -> &[u8] {
+        &[]
+    }
 }
 
-#[derive(Copy, Clone, PartialEq)]
-enum Sep {
-    Char(u8),
-    Line,
-    Whitespaces,
+/// Default whitespace separator.
+#[derive(Copy, Clone)]
+struct WhitespaceSep {}
+
+impl Separator for WhitespaceSep {
+    fn field_ranges(&self, haystack: &[u8], len_guess: usize) -> Vec<(usize, usize)> {
+        let mut field_ranges = Vec::with_capacity(len_guess);
+        let mut last_end = 0;
+
+        // GNU join used Bourne shell field splitters by default
+        // FIXME: but now uses locale-dependent whitespace
+        for i in Memchr3::new(b' ', b'\t', b'\n', haystack) {
+            // leading whitespace should be dropped, contiguous whitespace merged
+            if i > last_end {
+                field_ranges.push((last_end, i));
+            }
+            last_end = i + 1;
+        }
+        field_ranges.push((last_end, haystack.len()));
+        field_ranges
+    }
+
+    fn output_separator(&self) -> &[u8] {
+        b" "
+    }
 }
 
 #[derive(Copy, Clone, PartialEq)]
@@ -83,7 +169,7 @@ struct Settings {
     print_joined: bool,
     ignore_case: bool,
     line_ending: LineEnding,
-    separator: Sep,
+    separator: SepSetting,
     autoformat: bool,
     format: Vec<Spec>,
     empty: Vec<u8>,
@@ -101,7 +187,7 @@ impl Default for Settings {
             print_joined: true,
             ignore_case: false,
             line_ending: LineEnding::Newline,
-            separator: Sep::Whitespaces,
+            separator: SepSetting::Whitespaces,
             autoformat: false,
             format: vec![],
             empty: vec![],
@@ -112,20 +198,15 @@ impl Default for Settings {
 }
 
 /// Output representation.
-struct Repr<'a> {
+struct Repr<'a, Sep: Separator> {
     line_ending: LineEnding,
-    separator: u8,
-    format: &'a [Spec],
+    separator: Sep,
+    format: Vec<Spec>,
     empty: &'a [u8],
 }
 
-impl<'a> Repr<'a> {
-    fn new(
-        line_ending: LineEnding,
-        separator: u8,
-        format: &'a [Spec],
-        empty: &'a [u8],
-    ) -> Repr<'a> {
+impl<'a, Sep: Separator> Repr<'a, Sep> {
+    fn new(line_ending: LineEnding, separator: Sep, format: Vec<Spec>, empty: &'a [u8]) -> Self {
         Repr {
             line_ending,
             separator,
@@ -161,7 +242,7 @@ impl<'a> Repr<'a> {
     ) -> Result<(), std::io::Error> {
         for i in 0..line.field_ranges.len() {
             if i != index {
-                writer.write_all(&[self.separator])?;
+                writer.write_all(self.separator.output_separator())?;
                 writer.write_all(line.get_field(i).unwrap())?;
             }
         }
@@ -175,7 +256,7 @@ impl<'a> Repr<'a> {
     {
         for i in 0..self.format.len() {
             if i > 0 {
-                writer.write_all(&[self.separator])?;
+                writer.write_all(self.separator.output_separator())?;
             }
 
             let field = match f(&self.format[i]) {
@@ -193,14 +274,48 @@ impl<'a> Repr<'a> {
     }
 }
 
+/// Byte slice wrapper whose Ord implementation is case-insensitive on ASCII.
+#[derive(Eq)]
+struct CaseInsensitiveSlice<'a> {
+    v: &'a [u8],
+}
+
+impl Ord for CaseInsensitiveSlice<'_> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        if let Some((s, o)) =
+            std::iter::zip(self.v.iter(), other.v.iter()).find(|(s, o)| !s.eq_ignore_ascii_case(o))
+        {
+            // first characters that differ, return the case-insensitive comparison
+            let s = s.to_ascii_lowercase();
+            let o = o.to_ascii_lowercase();
+            s.cmp(&o)
+        } else {
+            // one of the strings is a substring or equal of the other
+            self.v.len().cmp(&other.v.len())
+        }
+    }
+}
+
+impl PartialOrd for CaseInsensitiveSlice<'_> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq for CaseInsensitiveSlice<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.v.eq_ignore_ascii_case(other.v)
+    }
+}
+
 /// Input processing parameters.
-struct Input {
+struct Input<Sep: Separator> {
     separator: Sep,
     ignore_case: bool,
     check_order: CheckOrder,
 }
 
-impl Input {
+impl<Sep: Separator> Input<Sep> {
     fn new(separator: Sep, ignore_case: bool, check_order: CheckOrder) -> Self {
         Self {
             separator,
@@ -212,9 +327,9 @@ impl Input {
     fn compare(&self, field1: Option<&[u8]>, field2: Option<&[u8]>) -> Ordering {
         if let (Some(field1), Some(field2)) = (field1, field2) {
             if self.ignore_case {
-                field1
-                    .to_ascii_lowercase()
-                    .cmp(&field2.to_ascii_lowercase())
+                let field1 = CaseInsensitiveSlice { v: field1 };
+                let field2 = CaseInsensitiveSlice { v: field2 };
+                field1.cmp(&field2)
             } else {
                 field1.cmp(field2)
             }
@@ -277,24 +392,8 @@ struct Line {
 }
 
 impl Line {
-    fn new(string: Vec<u8>, separator: Sep, len_guess: usize) -> Self {
-        let mut field_ranges = Vec::with_capacity(len_guess);
-        let mut last_end = 0;
-        if separator == Sep::Whitespaces {
-            // GNU join uses Bourne shell field splitters by default
-            for i in memchr3_iter(b' ', b'\t', b'\n', &string) {
-                if i > last_end {
-                    field_ranges.push((last_end, i));
-                }
-                last_end = i + 1;
-            }
-        } else if let Sep::Char(sep) = separator {
-            for i in memchr_iter(sep, &string) {
-                field_ranges.push((last_end, i));
-                last_end = i + 1;
-            }
-        }
-        field_ranges.push((last_end, string.len()));
+    fn new<Sep: Separator>(string: Vec<u8>, separator: &Sep, len_guess: usize) -> Self {
+        let field_ranges = separator.field_ranges(&string, len_guess);
 
         Self {
             field_ranges,
@@ -334,37 +433,35 @@ impl<'a> State<'a> {
         key: usize,
         line_ending: LineEnding,
         print_unpaired: bool,
-    ) -> State<'a> {
-        let f = if name == "-" {
+    ) -> UResult<Self> {
+        let file_buf = if name == "-" {
             Box::new(stdin.lock()) as Box<dyn BufRead>
         } else {
-            match File::open(name) {
-                Ok(file) => Box::new(BufReader::new(file)) as Box<dyn BufRead>,
-                Err(err) => crash!(1, "{}: {}", name.maybe_quote(), err),
-            }
+            let file = File::open(name).map_err_context(|| format!("{}", name.maybe_quote()))?;
+            Box::new(BufReader::new(file)) as Box<dyn BufRead>
         };
 
-        State {
+        Ok(State {
             key,
             file_name: name,
             file_num,
             print_unpaired,
-            lines: f.split(line_ending as u8),
+            lines: file_buf.split(line_ending as u8),
             max_len: 1,
             seq: Vec::new(),
             line_num: 0,
             has_failed: false,
             has_unpaired: false,
-        }
+        })
     }
 
     /// Skip the current unpaired line.
-    fn skip_line(
+    fn skip_line<Sep: Separator>(
         &mut self,
         writer: &mut impl Write,
-        input: &Input,
-        repr: &Repr,
-    ) -> Result<(), JoinError> {
+        input: &Input<Sep>,
+        repr: &Repr<'a, Sep>,
+    ) -> UResult<()> {
         if self.print_unpaired {
             self.print_first_line(writer, repr)?;
         }
@@ -375,7 +472,7 @@ impl<'a> State<'a> {
 
     /// Keep reading line sequence until the key does not change, return
     /// the first line whose key differs.
-    fn extend(&mut self, input: &Input) -> Result<Option<Line>, JoinError> {
+    fn extend<Sep: Separator>(&mut self, input: &Input<Sep>) -> UResult<Option<Line>> {
         while let Some(line) = self.next_line(input)? {
             let diff = input.compare(self.get_current_key(), line.get_field(self.key));
 
@@ -390,11 +487,11 @@ impl<'a> State<'a> {
     }
 
     /// Print lines in the buffers as headers.
-    fn print_headers(
+    fn print_headers<Sep: Separator>(
         &self,
         writer: &mut impl Write,
         other: &State,
-        repr: &Repr,
+        repr: &Repr<'a, Sep>,
     ) -> Result<(), std::io::Error> {
         if self.has_line() {
             if other.has_line() {
@@ -410,11 +507,11 @@ impl<'a> State<'a> {
     }
 
     /// Combine two line sequences.
-    fn combine(
+    fn combine<Sep: Separator>(
         &self,
         writer: &mut impl Write,
         other: &State,
-        repr: &Repr,
+        repr: &Repr<'a, Sep>,
     ) -> Result<(), std::io::Error> {
         let key = self.get_current_key();
 
@@ -457,13 +554,16 @@ impl<'a> State<'a> {
         }
     }
 
-    fn reset_read_line(&mut self, input: &Input) -> Result<(), std::io::Error> {
-        let line = self.read_line(input.separator)?;
+    fn reset_read_line<Sep: Separator>(
+        &mut self,
+        input: &Input<Sep>,
+    ) -> Result<(), std::io::Error> {
+        let line = self.read_line(&input.separator)?;
         self.reset(line);
         Ok(())
     }
 
-    fn reset_next_line(&mut self, input: &Input) -> Result<(), JoinError> {
+    fn reset_next_line<Sep: Separator>(&mut self, input: &Input<Sep>) -> Result<(), JoinError> {
         let line = self.next_line(input)?;
         self.reset(line);
         Ok(())
@@ -473,23 +573,27 @@ impl<'a> State<'a> {
         !self.seq.is_empty()
     }
 
-    fn initialize(&mut self, read_sep: Sep, autoformat: bool) -> usize {
-        if let Some(line) = crash_if_err!(1, self.read_line(read_sep)) {
+    fn initialize<Sep: Separator>(
+        &mut self,
+        read_sep: &Sep,
+        autoformat: bool,
+    ) -> std::io::Result<usize> {
+        if let Some(line) = self.read_line(read_sep)? {
             self.seq.push(line);
 
             if autoformat {
-                return self.seq[0].field_ranges.len();
+                return Ok(self.seq[0].field_ranges.len());
             }
         }
-        0
+        Ok(0)
     }
 
-    fn finalize(
+    fn finalize<Sep: Separator>(
         &mut self,
         writer: &mut impl Write,
-        input: &Input,
-        repr: &Repr,
-    ) -> Result<(), JoinError> {
+        input: &Input<Sep>,
+        repr: &Repr<'a, Sep>,
+    ) -> UResult<()> {
         if self.has_line() {
             if self.print_unpaired {
                 self.print_first_line(writer, repr)?;
@@ -509,7 +613,7 @@ impl<'a> State<'a> {
     }
 
     /// Get the next line without the order check.
-    fn read_line(&mut self, sep: Sep) -> Result<Option<Line>, std::io::Error> {
+    fn read_line<Sep: Separator>(&mut self, sep: &Sep) -> Result<Option<Line>, std::io::Error> {
         match self.lines.next() {
             Some(value) => {
                 self.line_num += 1;
@@ -524,8 +628,8 @@ impl<'a> State<'a> {
     }
 
     /// Get the next line with the order check.
-    fn next_line(&mut self, input: &Input) -> Result<Option<Line>, JoinError> {
-        if let Some(line) = self.read_line(input.separator)? {
+    fn next_line<Sep: Separator>(&mut self, input: &Input<Sep>) -> Result<Option<Line>, JoinError> {
+        if let Some(line) = self.read_line(&input.separator)? {
             if input.check_order == CheckOrder::Disabled {
                 return Ok(Some(line));
             }
@@ -546,7 +650,7 @@ impl<'a> State<'a> {
                 if input.check_order == CheckOrder::Enabled {
                     return Err(JoinError::UnorderedInput(err_msg));
                 }
-                eprintln!("{}: {}", uucore::execution_phrase(), err_msg);
+                eprintln!("{}: {err_msg}", uucore::execution_phrase());
                 self.has_failed = true;
             }
 
@@ -561,11 +665,11 @@ impl<'a> State<'a> {
         self.seq[0].get_field(self.key)
     }
 
-    fn print_line(
+    fn print_line<Sep: Separator>(
         &self,
         writer: &mut impl Write,
         line: &Line,
-        repr: &Repr,
+        repr: &Repr<'a, Sep>,
     ) -> Result<(), std::io::Error> {
         if repr.uses_format() {
             repr.print_format(writer, |spec| match *spec {
@@ -586,25 +690,62 @@ impl<'a> State<'a> {
         repr.print_line_ending(writer)
     }
 
-    fn print_first_line(&self, writer: &mut impl Write, repr: &Repr) -> Result<(), std::io::Error> {
+    fn print_first_line<Sep: Separator>(
+        &self,
+        writer: &mut impl Write,
+        repr: &Repr<'a, Sep>,
+    ) -> Result<(), std::io::Error> {
         self.print_line(writer, &self.seq[0], repr)
     }
 }
 
-#[uucore::main]
-#[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
+fn parse_separator(value_os: &OsString) -> UResult<SepSetting> {
+    // Five possible separator values:
+    // No argument supplied, separate on whitespace; handled implicitly as the default elsewhere
+    // An empty string arg, whole line separation
+    // On unix-likes only, a single arbitrary byte
+    // The two-character "\0" string, interpreted as a single 0 byte
+    // A single scalar valid in the locale encoding (currently only UTF-8)
 
-    let keys = parse_field_number_option(matches.get_one::<String>("j").map(|s| s.as_str()))?;
-    let key1 = parse_field_number_option(matches.get_one::<String>("1").map(|s| s.as_str()))?;
-    let key2 = parse_field_number_option(matches.get_one::<String>("2").map(|s| s.as_str()))?;
+    if value_os.is_empty() {
+        return Ok(SepSetting::Line);
+    }
 
-    let mut settings = Settings::default();
+    #[cfg(unix)]
+    {
+        let value = value_os.as_bytes();
+        if value.len() == 1 {
+            return Ok(SepSetting::Byte(value[0]));
+        }
+    }
+
+    let Some(value) = value_os.to_str() else {
+        #[cfg(unix)]
+        return Err(USimpleError::new(1, "non-UTF-8 multi-byte tab"));
+        #[cfg(not(unix))]
+        return Err(USimpleError::new(
+            1,
+            "unprintable field separators are only supported on unix-like platforms",
+        ));
+    };
+
+    let mut chars = value.chars();
+    let c = chars.next().expect("valid string with at least one byte");
+    match chars.next() {
+        None => Ok(SepSetting::Char(value.into())),
+        Some('0') if c == '\\' => Ok(SepSetting::Byte(0)),
+        _ => Err(USimpleError::new(1, format!("multi-character tab {value}"))),
+    }
+}
+
+fn parse_print_settings(matches: &clap::ArgMatches) -> UResult<(bool, bool, bool)> {
+    let mut print_joined = true;
+    let mut print_unpaired1 = false;
+    let mut print_unpaired2 = false;
 
     let v_values = matches.get_many::<String>("v");
     if v_values.is_some() {
-        settings.print_joined = false;
+        print_joined = false;
     }
 
     let unpaired = v_values
@@ -612,47 +753,49 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .chain(matches.get_many("a").unwrap_or_default());
     for file_num in unpaired {
         match parse_file_number(file_num)? {
-            FileNum::File1 => settings.print_unpaired1 = true,
-            FileNum::File2 => settings.print_unpaired2 = true,
+            FileNum::File1 => print_unpaired1 = true,
+            FileNum::File2 => print_unpaired2 = true,
         }
     }
 
+    Ok((print_joined, print_unpaired1, print_unpaired2))
+}
+
+fn get_and_parse_field_number(matches: &clap::ArgMatches, key: &str) -> UResult<Option<usize>> {
+    let value = matches.get_one::<String>(key).map(|s| s.as_str());
+    parse_field_number_option(value)
+}
+
+/// Parses the command-line arguments and constructs a `Settings` struct.
+///
+/// This function takes the matches from the command-line arguments, processes them,
+/// and returns a `Settings` struct that encapsulates the configuration for the program.
+#[allow(clippy::field_reassign_with_default)]
+fn parse_settings(matches: &clap::ArgMatches) -> UResult<Settings> {
+    let keys = get_and_parse_field_number(matches, "j")?;
+    let key1 = get_and_parse_field_number(matches, "1")?;
+    let key2 = get_and_parse_field_number(matches, "2")?;
+
+    let (print_joined, print_unpaired1, print_unpaired2) = parse_print_settings(matches)?;
+
+    let mut settings = Settings::default();
+
+    settings.print_joined = print_joined;
+    settings.print_unpaired1 = print_unpaired1;
+    settings.print_unpaired2 = print_unpaired2;
+
     settings.ignore_case = matches.get_flag("i");
     settings.key1 = get_field_number(keys, key1)?;
     settings.key2 = get_field_number(keys, key2)?;
-
     if let Some(value_os) = matches.get_one::<OsString>("t") {
-        #[cfg(unix)]
-        let value = value_os.as_bytes();
-        #[cfg(not(unix))]
-        let value = match value_os.to_str() {
-            Some(value) => value.as_bytes(),
-            None => {
-                return Err(USimpleError::new(
-                    1,
-                    "unprintable field separators are only supported on unix-like platforms",
-                ))
-            }
-        };
-        settings.separator = match value.len() {
-            0 => Sep::Line,
-            1 => Sep::Char(value[0]),
-            2 if value[0] == b'\\' && value[1] == b'0' => Sep::Char(0),
-            _ => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("multi-character tab {}", value_os.to_string_lossy()),
-                ))
-            }
-        };
+        settings.separator = parse_separator(value_os)?;
     }
-
     if let Some(format) = matches.get_one::<String>("o") {
         if format == "auto" {
             settings.autoformat = true;
         } else {
             let mut specs = vec![];
-            for part in format.split(|c| c == ' ' || c == ',' || c == '\t') {
+            for part in format.split([' ', ',', '\t']) {
                 specs.push(Spec::parse(part)?);
             }
             settings.format = specs;
@@ -677,6 +820,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     settings.line_ending = LineEnding::from_zero_flag(matches.get_flag("z"));
 
+    Ok(settings)
+}
+
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
+
+    let settings = parse_settings(&matches)?;
+
     let file1 = matches.get_one::<String>("file1").unwrap();
     let file2 = matches.get_one::<String>("file2").unwrap();
 
@@ -684,15 +836,25 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         return Err(USimpleError::new(1, "both files cannot be standard input"));
     }
 
-    match exec(file1, file2, settings) {
-        Ok(_) => Ok(()),
-        Err(e) => Err(USimpleError::new(1, format!("{e}"))),
+    let sep = settings.separator.clone();
+    match sep {
+        SepSetting::Byte(byte) => exec(file1, file2, settings, OneByteSep { byte: [byte] }),
+        SepSetting::Char(c) => exec(
+            file1,
+            file2,
+            settings,
+            MultiByteSep {
+                finder: Finder::new(&c),
+            },
+        ),
+        SepSetting::Whitespaces => exec(file1, file2, settings, WhitespaceSep {}),
+        SepSetting::Line => exec(file1, file2, settings, LineSep {}),
     }
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -808,7 +970,7 @@ FILENUM is 1 or 2, corresponding to FILE1 or FILE2",
         )
 }
 
-fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
+fn exec<Sep: Separator>(file1: &str, file2: &str, settings: Settings, sep: Sep) -> UResult<()> {
     let stdin = stdin();
 
     let mut state1 = State::new(
@@ -818,7 +980,7 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
         settings.key1,
         settings.line_ending,
         settings.print_unpaired1,
-    );
+    )?;
 
     let mut state2 = State::new(
         FileNum::File2,
@@ -827,42 +989,31 @@ fn exec(file1: &str, file2: &str, settings: Settings) -> Result<(), JoinError> {
         settings.key2,
         settings.line_ending,
         settings.print_unpaired2,
-    );
+    )?;
 
-    let input = Input::new(
-        settings.separator,
-        settings.ignore_case,
-        settings.check_order,
-    );
+    let input = Input::new(sep.clone(), settings.ignore_case, settings.check_order);
 
     let format = if settings.autoformat {
         let mut format = vec![Spec::Key];
-        let mut initialize = |state: &mut State| {
-            let max_fields = state.initialize(settings.separator, settings.autoformat);
+        let mut initialize = |state: &mut State| -> UResult<()> {
+            let max_fields = state.initialize(&sep, settings.autoformat)?;
             for i in 0..max_fields {
                 if i != state.key {
                     format.push(Spec::Field(state.file_num, i));
                 }
             }
+            Ok(())
         };
-        initialize(&mut state1);
-        initialize(&mut state2);
+        initialize(&mut state1)?;
+        initialize(&mut state2)?;
         format
     } else {
-        state1.initialize(settings.separator, settings.autoformat);
-        state2.initialize(settings.separator, settings.autoformat);
+        state1.initialize(&sep, settings.autoformat)?;
+        state2.initialize(&sep, settings.autoformat)?;
         settings.format
     };
 
-    let repr = Repr::new(
-        settings.line_ending,
-        match settings.separator {
-            Sep::Char(sep) => sep,
-            _ => b' ',
-        },
-        &format,
-        &settings.empty,
-    );
+    let repr = Repr::new(settings.line_ending, sep, format, &settings.empty);
 
     let stdout = stdout();
     let mut writer = BufWriter::new(stdout.lock());
diff --git a/src/uu/kill/Cargo.toml b/src/uu/kill/Cargo.toml
index a675f00eda3..65385e28915 100644
--- a/src/uu/kill/Cargo.toml
+++ b/src/uu/kill/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_kill"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "kill ~ (uutils) send a signal to a process"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/kill"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/kill.rs"
diff --git a/src/uu/kill/src/kill.rs b/src/uu/kill/src/kill.rs
index b0e18a79820..8d8aa0b614d 100644
--- a/src/uu/kill/src/kill.rs
+++ b/src/uu/kill/src/kill.rs
@@ -5,18 +5,23 @@
 
 // spell-checker:ignore (ToDO) signalname pids killpg
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use nix::sys::signal::{self, Signal};
 use nix::unistd::Pid;
 use std::io::Error;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
-use uucore::signals::{signal_by_name_or_value, ALL_SIGNALS};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::signals::{ALL_SIGNALS, signal_by_name_or_value, signal_name_by_value};
 use uucore::{format_usage, help_about, help_usage, show};
 
 static ABOUT: &str = help_about!("kill.md");
 const USAGE: &str = help_usage!("kill.md");
 
+// When the -l option is selected, the program displays the type of signal related to a certain
+// value or string. In case of a value, the program should control the lower 8 bits, but there is
+// a particular case in which if the value is in range [128, 159], it is translated to a signal
+const OFFSET: usize = 128;
+
 pub mod options {
     pub static PIDS_OR_SIGNALS: &str = "pids_or_signals";
     pub static LIST: &str = "list";
@@ -60,24 +65,45 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             } else {
                 15_usize //SIGTERM
             };
-            let sig: Signal = (sig as i32)
-                .try_into()
-                .map_err(|e| std::io::Error::from_raw_os_error(e as i32))?;
+
+            let sig_name = signal_name_by_value(sig);
+            // Signal does not support converting from EXIT
+            // Instead, nix::signal::kill expects Option::None to properly handle EXIT
+            let sig: Option<Signal> = if sig_name.is_some_and(|name| name == "EXIT") {
+                None
+            } else {
+                let sig = (sig as i32)
+                    .try_into()
+                    .map_err(|e| Error::from_raw_os_error(e as i32))?;
+                Some(sig)
+            };
+
             let pids = parse_pids(&pids_or_signals)?;
-            kill(sig, &pids);
-            Ok(())
+            if pids.is_empty() {
+                Err(USimpleError::new(
+                    1,
+                    "no process ID specified\n\
+                     Try --help for more information.",
+                ))
+            } else {
+                kill(sig, &pids);
+                Ok(())
+            }
         }
         Mode::Table => {
             table();
             Ok(())
         }
-        Mode::List => list(pids_or_signals.get(0)),
+        Mode::List => {
+            list(&pids_or_signals);
+            Ok(())
+        }
     }
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -101,9 +127,11 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::SIGNAL)
                 .short('s')
+                .short_alias('n') // For bash compatibility, like in GNU coreutils
                 .long(options::SIGNAL)
                 .value_name("signal")
-                .help("Sends given signal instead of SIGTERM"),
+                .help("Sends given signal instead of SIGTERM")
+                .conflicts_with_all([options::LIST, options::TABLE]),
         )
         .arg(
             Arg::new(options::PIDS_OR_SIGNALS)
@@ -118,6 +146,10 @@ fn handle_obsolete(args: &mut Vec<String>) -> Option<usize> {
         // Old signal can only be in the first argument position
         let slice = args[1].as_str();
         if let Some(signal) = slice.strip_prefix('-') {
+            // With '-', a signal name must start with an uppercase char
+            if signal.chars().next().is_some_and(|c| c.is_lowercase()) {
+                return None;
+            }
             // Check if it is a valid signal
             let opt_signal = signal_by_name_or_value(signal);
             if opt_signal.is_some() {
@@ -131,49 +163,54 @@ fn handle_obsolete(args: &mut Vec<String>) -> Option<usize> {
 }
 
 fn table() {
-    let name_width = ALL_SIGNALS.iter().map(|n| n.len()).max().unwrap();
-
     for (idx, signal) in ALL_SIGNALS.iter().enumerate() {
-        print!("{0: >#2} {1: <#2$}", idx, signal, name_width + 2);
-        if (idx + 1) % 7 == 0 {
-            println!();
-        }
+        println!("{idx: >#2} {signal}");
     }
-    println!();
 }
 
 fn print_signal(signal_name_or_value: &str) -> UResult<()> {
+    // Closure used to track the last 8 bits of the signal value
+    // when the -l option is passed only the lower 8 bits are important
+    // or the value is in range [128, 159]
+    // Example: kill -l 143 => TERM because 143 = 15 + 128
+    // Example: kill -l 2304 => EXIT
+    let lower_8_bits = |x: usize| x & 0xff;
+    let option_num_parse = signal_name_or_value.parse::<usize>().ok();
+
     for (value, &signal) in ALL_SIGNALS.iter().enumerate() {
-        if signal == signal_name_or_value || (format!("SIG{signal}")) == signal_name_or_value {
+        if signal.eq_ignore_ascii_case(signal_name_or_value)
+            || format!("SIG{signal}").eq_ignore_ascii_case(signal_name_or_value)
+        {
             println!("{value}");
             return Ok(());
-        } else if signal_name_or_value == value.to_string() {
+        } else if signal_name_or_value == value.to_string()
+            || option_num_parse.is_some_and(|signal_value| lower_8_bits(signal_value) == value)
+            || option_num_parse.is_some_and(|signal_value| signal_value == value + OFFSET)
+        {
             println!("{signal}");
             return Ok(());
         }
     }
     Err(USimpleError::new(
         1,
-        format!("unknown signal name {}", signal_name_or_value.quote()),
+        format!("{}: invalid signal", signal_name_or_value.quote()),
     ))
 }
 
 fn print_signals() {
-    for (idx, signal) in ALL_SIGNALS.iter().enumerate() {
-        if idx > 0 {
-            print!(" ");
-        }
-        print!("{signal}");
+    for signal in ALL_SIGNALS {
+        println!("{signal}");
     }
-    println!();
 }
 
-fn list(arg: Option<&String>) -> UResult<()> {
-    match arg {
-        Some(x) => print_signal(x),
-        None => {
-            print_signals();
-            Ok(())
+fn list(signals: &Vec<String>) {
+    if signals.is_empty() {
+        print_signals();
+    } else {
+        for signal in signals {
+            if let Err(e) = print_signal(signal) {
+                uucore::show!(e);
+            }
         }
     }
 }
@@ -184,7 +221,7 @@ fn parse_signal_value(signal_name: &str) -> UResult<usize> {
         Some(x) => Ok(x),
         None => Err(USimpleError::new(
             1,
-            format!("unknown signal name {}", signal_name.quote()),
+            format!("{}: invalid signal", signal_name.quote()),
         )),
     }
 }
@@ -193,17 +230,19 @@ fn parse_pids(pids: &[String]) -> UResult<Vec<i32>> {
     pids.iter()
         .map(|x| {
             x.parse::<i32>().map_err(|e| {
-                USimpleError::new(1, format!("failed to parse argument {}: {}", x.quote(), e))
+                USimpleError::new(1, format!("failed to parse argument {}: {e}", x.quote()))
             })
         })
         .collect()
 }
 
-fn kill(sig: Signal, pids: &[i32]) {
+fn kill(sig: Option<Signal>, pids: &[i32]) {
     for &pid in pids {
         if let Err(e) = signal::kill(Pid::from_raw(pid), sig) {
-            show!(Error::from_raw_os_error(e as i32)
-                .map_err_context(|| format!("sending signal to {pid} failed")));
+            show!(
+                Error::from_raw_os_error(e as i32)
+                    .map_err_context(|| format!("sending signal to {pid} failed"))
+            );
         }
     }
 }
diff --git a/src/uu/link/Cargo.toml b/src/uu/link/Cargo.toml
index 2406476cabc..41366f5d5a8 100644
--- a/src/uu/link/Cargo.toml
+++ b/src/uu/link/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_link"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "link ~ (uutils) create a hard (file system) link to FILE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/link"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/link.rs"
diff --git a/src/uu/link/src/link.rs b/src/uu/link/src/link.rs
index 806e89828bb..31f1239d86c 100644
--- a/src/uu/link/src/link.rs
+++ b/src/uu/link/src/link.rs
@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, Command};
+use clap::{Arg, Command};
 use std::ffi::OsString;
 use std::fs::hard_link;
 use std::path::Path;
@@ -35,7 +35,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/ln/Cargo.toml b/src/uu/ln/Cargo.toml
index 6488963cce3..47a492a43b1 100644
--- a/src/uu/ln/Cargo.toml
+++ b/src/uu/ln/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_ln"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "ln ~ (uutils) create a (file system) link to TARGET"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ln"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/ln.rs"
@@ -17,6 +20,7 @@ path = "src/ln.rs"
 [dependencies]
 clap = { workspace = true }
 uucore = { workspace = true, features = ["backup-control", "fs"] }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "ln"
diff --git a/src/uu/ln/ln.md b/src/uu/ln/ln.md
index b2320d6c427..6bd6ee01619 100644
--- a/src/uu/ln/ln.md
+++ b/src/uu/ln/ln.md
@@ -7,7 +7,7 @@ ln [OPTION]... TARGET... DIRECTORY
 ln [OPTION]... -t DIRECTORY TARGET...
 ```
 
-Change file owner and group
+Make links between files.
 
 ## After Help
 
diff --git a/src/uu/ln/src/ln.rs b/src/uu/ln/src/ln.rs
index 8b76aa73c0b..3b8ff0d7069 100644
--- a/src/uu/ln/src/ln.rs
+++ b/src/uu/ln/src/ln.rs
@@ -5,17 +5,17 @@
 
 // spell-checker:ignore (ToDO) srcpath targetpath EEXIST
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult};
 use uucore::fs::{make_path_relative_to, paths_refer_to_same_file};
 use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show_error};
 
 use std::borrow::Cow;
-use std::error::Error;
+use std::collections::HashSet;
 use std::ffi::OsString;
-use std::fmt::Display;
 use std::fs;
+use thiserror::Error;
 
 #[cfg(any(unix, target_os = "redox"))]
 use std::os::unix::fs::symlink;
@@ -23,7 +23,7 @@ use std::os::unix::fs::symlink;
 use std::os::windows::fs::{symlink_dir, symlink_file};
 use std::path::{Path, PathBuf};
 use uucore::backup_control::{self, BackupMode};
-use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
+use uucore::fs::{MissingHandling, ResolveMode, canonicalize};
 
 pub struct Settings {
     overwrite: OverwriteMode,
@@ -45,38 +45,25 @@ pub enum OverwriteMode {
     Force,
 }
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 enum LnError {
+    #[error("target {} is not a directory", _0.quote())]
     TargetIsDirectory(PathBuf),
+
+    #[error("")]
     SomeLinksFailed,
+
+    #[error("{} and {} are the same file", _0.quote(), _1.quote())]
     SameFile(PathBuf, PathBuf),
+
+    #[error("missing destination file operand after {}", _0.quote())]
     MissingDestination(PathBuf),
-    ExtraOperand(OsString),
-}
 
-impl Display for LnError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::TargetIsDirectory(s) => write!(f, "target {} is not a directory", s.quote()),
-            Self::SameFile(s, d) => {
-                write!(f, "{} and {} are the same file", s.quote(), d.quote())
-            }
-            Self::SomeLinksFailed => Ok(()),
-            Self::MissingDestination(s) => {
-                write!(f, "missing destination file operand after {}", s.quote())
-            }
-            Self::ExtraOperand(s) => write!(
-                f,
-                "extra operand {}\nTry '{} --help' for more information.",
-                s.quote(),
-                uucore::execution_phrase()
-            ),
-        }
-    }
+    #[error("extra operand {}\nTry '{} --help' for more information.",
+    format!("{_0:?}").trim_matches('"'), _1)]
+    ExtraOperand(OsString, String),
 }
 
-impl Error for LnError {}
-
 impl UError for LnError {
     fn code(&self) -> i32 {
         1
@@ -106,8 +93,7 @@ static ARG_FILES: &str = "files";
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let after_help = format!(
-        "{}\n\n{}",
-        AFTER_HELP,
+        "{AFTER_HELP}\n\n{}",
         backup_control::BACKUP_CONTROL_LONG_HELP
     );
 
@@ -157,7 +143,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -283,7 +269,11 @@ fn exec(files: &[PathBuf], settings: &Settings) -> UResult<()> {
         return Err(LnError::MissingDestination(files[0].clone()).into());
     }
     if files.len() > 2 {
-        return Err(LnError::ExtraOperand(files[2].clone().into()).into());
+        return Err(LnError::ExtraOperand(
+            files[2].clone().into(),
+            uucore::execution_phrase().to_string(),
+        )
+        .into());
     }
     assert!(!files.is_empty());
 
@@ -295,53 +285,65 @@ fn link_files_in_dir(files: &[PathBuf], target_dir: &Path, settings: &Settings)
     if !target_dir.is_dir() {
         return Err(LnError::TargetIsDirectory(target_dir.to_owned()).into());
     }
+    // remember the linked destinations for further usage
+    let mut linked_destinations: HashSet<PathBuf> = HashSet::with_capacity(files.len());
 
     let mut all_successful = true;
     for srcpath in files {
-        let targetpath =
-            if settings.no_dereference && matches!(settings.overwrite, OverwriteMode::Force) {
-                // In that case, we don't want to do link resolution
-                // We need to clean the target
-                if target_dir.is_symlink() {
-                    if target_dir.is_file() {
-                        if let Err(e) = fs::remove_file(target_dir) {
-                            show_error!("Could not update {}: {}", target_dir.quote(), e);
-                        };
-                    }
-                    if target_dir.is_dir() {
-                        // Not sure why but on Windows, the symlink can be
-                        // considered as a dir
-                        // See test_ln::test_symlink_no_deref_dir
-                        if let Err(e) = fs::remove_dir(target_dir) {
-                            show_error!("Could not update {}: {}", target_dir.quote(), e);
-                        };
+        let targetpath = if settings.no_dereference
+            && matches!(settings.overwrite, OverwriteMode::Force)
+            && target_dir.is_symlink()
+        {
+            // In that case, we don't want to do link resolution
+            // We need to clean the target
+            if target_dir.is_file() {
+                if let Err(e) = fs::remove_file(target_dir) {
+                    show_error!("Could not update {}: {e}", target_dir.quote());
+                };
+            }
+            if target_dir.is_dir() {
+                // Not sure why but on Windows, the symlink can be
+                // considered as a dir
+                // See test_ln::test_symlink_no_deref_dir
+                if let Err(e) = fs::remove_dir(target_dir) {
+                    show_error!("Could not update {}: {e}", target_dir.quote());
+                };
+            }
+            target_dir.to_path_buf()
+        } else {
+            match srcpath.as_os_str().to_str() {
+                Some(name) => {
+                    match Path::new(name).file_name() {
+                        Some(basename) => target_dir.join(basename),
+                        // This can be None only for "." or "..". Trying
+                        // to create a link with such name will fail with
+                        // EEXIST, which agrees with the behavior of GNU
+                        // coreutils.
+                        None => target_dir.join(name),
                     }
                 }
-                target_dir.to_path_buf()
-            } else {
-                match srcpath.as_os_str().to_str() {
-                    Some(name) => {
-                        match Path::new(name).file_name() {
-                            Some(basename) => target_dir.join(basename),
-                            // This can be None only for "." or "..". Trying
-                            // to create a link with such name will fail with
-                            // EEXIST, which agrees with the behavior of GNU
-                            // coreutils.
-                            None => target_dir.join(name),
-                        }
-                    }
-                    None => {
-                        show_error!("cannot stat {}: No such file or directory", srcpath.quote());
-                        all_successful = false;
-                        continue;
-                    }
+                None => {
+                    show_error!("cannot stat {}: No such file or directory", srcpath.quote());
+                    all_successful = false;
+                    continue;
                 }
-            };
+            }
+        };
 
-        if let Err(e) = link(srcpath, &targetpath, settings) {
-            show_error!("{}", e);
+        if linked_destinations.contains(&targetpath) {
+            // If the target file was already created in this ln call, do not overwrite
+            show_error!(
+                "will not overwrite just-created '{}' with '{}'",
+                targetpath.display(),
+                srcpath.display()
+            );
+            all_successful = false;
+        } else if let Err(e) = link(srcpath, &targetpath, settings) {
+            show_error!("{e}");
             all_successful = false;
         }
+
+        linked_destinations.insert(targetpath.clone());
     }
     if all_successful {
         Ok(())
@@ -374,12 +376,12 @@ fn link(src: &Path, dst: &Path, settings: &Settings) -> UResult<()> {
 
     if dst.is_symlink() || dst.exists() {
         backup_path = match settings.backup {
-            BackupMode::NoBackup => None,
-            BackupMode::SimpleBackup => Some(simple_backup_path(dst, &settings.suffix)),
-            BackupMode::NumberedBackup => Some(numbered_backup_path(dst)),
-            BackupMode::ExistingBackup => Some(existing_backup_path(dst, &settings.suffix)),
+            BackupMode::None => None,
+            BackupMode::Simple => Some(simple_backup_path(dst, &settings.suffix)),
+            BackupMode::Numbered => Some(numbered_backup_path(dst)),
+            BackupMode::Existing => Some(existing_backup_path(dst, &settings.suffix)),
         };
-        if settings.backup == BackupMode::ExistingBackup && !settings.symbolic {
+        if settings.backup == BackupMode::Existing && !settings.symbolic {
             // when ln --backup f f, it should detect that it is the same file
             if paths_refer_to_same_file(src, dst, true) {
                 return Err(LnError::SameFile(src.to_owned(), dst.to_owned()).into());
diff --git a/src/uu/logname/Cargo.toml b/src/uu/logname/Cargo.toml
index 29116455b40..e723595b3b4 100644
--- a/src/uu/logname/Cargo.toml
+++ b/src/uu/logname/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_logname"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "logname ~ (uutils) display the login name of the current user"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/logname"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/logname.rs"
diff --git a/src/uu/logname/src/logname.rs b/src/uu/logname/src/logname.rs
index 52505d98d49..5437bbae344 100644
--- a/src/uu/logname/src/logname.rs
+++ b/src/uu/logname/src/logname.rs
@@ -3,15 +3,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-/* last synced with: logname (GNU coreutils) 8.22 */
-
 // spell-checker:ignore (ToDO) getlogin userlogin
 
-use clap::{crate_version, Command};
+use clap::Command;
 use std::ffi::CStr;
 use uucore::{error::UResult, format_usage, help_about, help_usage, show_error};
 
-extern "C" {
+unsafe extern "C" {
     // POSIX requires using getlogin (or equivalent code)
     pub fn getlogin() -> *const libc::c_char;
 }
@@ -32,8 +30,6 @@ const USAGE: &str = help_usage!("logname.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let _ = uu_app().try_get_matches_from(args)?;
 
     match get_userlogin() {
@@ -46,7 +42,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .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 3103e43b0f1..3611d7a9608 100644
--- a/src/uu/ls/BENCHMARKING.md
+++ b/src/uu/ls/BENCHMARKING.md
@@ -1,6 +1,13 @@
 # Benchmarking ls
 
 ls majorly involves fetching a lot of details (depending upon what details are requested, eg. time/date, inode details, etc) for each path using system calls. Ideally, any system call should be done only once for each of the paths - not adhering to this principle leads to a lot of system call overhead multiplying and bubbling up, especially for recursive ls, therefore it is important to always benchmark multiple scenarios.
+
+ls _also_ prints a lot of information, so optimizing formatting operations is also critical:
+ - Try to avoid using `format` unless required.
+ - Try to avoid repeated string copies unless necessary.
+ - If a temporary buffer is required, try to allocate a reasonable capacity to start with to avoid repeated reallocations.
+ - Some values might be expensive to compute (e.g. current line width), but are only required in some cases. Consider delaying computations, e.g. by wrapping the evaluation in a LazyCell.
+
 This is an overview over what was benchmarked, and if you make changes to `ls`, you are encouraged to check
 how performance was affected for the workloads listed below. Feel free to add other workloads to the
 list that we should improve / make sure not to regress.
diff --git a/src/uu/ls/Cargo.toml b/src/uu/ls/Cargo.toml
index b1114644d40..ff00175e747 100644
--- a/src/uu/ls/Cargo.toml
+++ b/src/uu/ls/Cargo.toml
@@ -1,32 +1,45 @@
 [package]
 name = "uu_ls"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "ls ~ (uutils) display directory contents"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ls"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/ls.rs"
 
 [dependencies]
-clap = { workspace = true, features = ["env"] }
+ansi-width = { workspace = true }
 chrono = { workspace = true }
-unicode-width = { workspace = true }
-number_prefix = { workspace = true }
-term_grid = { workspace = true }
-terminal_size = { workspace = true }
+clap = { workspace = true, features = ["env"] }
 glob = { workspace = true }
+hostname = { workspace = true }
 lscolors = { workspace = true }
-uucore = { workspace = true, features = ["entries", "fs"] }
-once_cell = { workspace = true }
-is-terminal = { workspace = true }
+number_prefix = { workspace = true }
 selinux = { workspace = true, optional = true }
+terminal_size = { workspace = true }
+thiserror = { workspace = true }
+uucore = { workspace = true, features = [
+  "colors",
+  "custom-tz-fmt",
+  "entries",
+  "format",
+  "fs",
+  "fsxattr",
+  "parser",
+  "quoting-style",
+  "version-cmp",
+] }
+uutils_term_grid = { workspace = true }
 
 [[bin]]
 name = "ls"
diff --git a/src/uu/ls/src/colors.rs b/src/uu/ls/src/colors.rs
new file mode 100644
index 00000000000..ab19672ea98
--- /dev/null
+++ b/src/uu/ls/src/colors.rs
@@ -0,0 +1,202 @@
+// 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.
+use super::PathData;
+use super::get_metadata_with_deref_opt;
+use lscolors::{Indicator, LsColors, Style};
+use std::ffi::OsString;
+use std::fs::{DirEntry, Metadata};
+use std::io::{BufWriter, Stdout};
+
+/// We need this struct to be able to store the previous style.
+/// This because we need to check the previous value in case we don't need
+/// the reset
+pub(crate) struct StyleManager<'a> {
+    /// last style that is applied, if `None` that means reset is applied.
+    pub(crate) current_style: Option<Style>,
+    /// `true` if the initial reset is applied
+    pub(crate) initial_reset_is_done: bool,
+    pub(crate) colors: &'a LsColors,
+}
+
+impl<'a> StyleManager<'a> {
+    pub(crate) fn new(colors: &'a LsColors) -> Self {
+        Self {
+            initial_reset_is_done: false,
+            current_style: None,
+            colors,
+        }
+    }
+
+    pub(crate) fn apply_style(
+        &mut self,
+        new_style: Option<&Style>,
+        name: OsString,
+        wrap: bool,
+    ) -> OsString {
+        let mut style_code = String::new();
+        let mut force_suffix_reset: bool = false;
+
+        // if reset is done we need to apply normal style before applying new style
+        if self.is_reset() {
+            if let Some(norm_sty) = self.get_normal_style().copied() {
+                style_code.push_str(&self.get_style_code(&norm_sty));
+            }
+        }
+
+        if let Some(new_style) = new_style {
+            // we only need to apply a new style if it's not the same as the current
+            // style for example if normal is the current style and a file with
+            // normal style is to be printed we could skip printing new color
+            // codes
+            if !self.is_current_style(new_style) {
+                style_code.push_str(self.reset(!self.initial_reset_is_done));
+                style_code.push_str(&self.get_style_code(new_style));
+            }
+        }
+        // if new style is None and current style is Normal we should reset it
+        else if matches!(self.get_normal_style().copied(), Some(norm_style) if self.is_current_style(&norm_style))
+        {
+            style_code.push_str(self.reset(false));
+            // even though this is an unnecessary reset for gnu compatibility we allow it here
+            force_suffix_reset = true;
+        }
+
+        // we need this clear to eol code in some terminals, for instance if the
+        // text is in the last row of the terminal meaning the terminal need to
+        // scroll up in order to print new text in this situation if the clear
+        // to eol code is not present the background of the text would stretch
+        // till the end of line
+        let clear_to_eol = if wrap { "\x1b[K" } else { "" };
+
+        let mut ret: OsString = style_code.into();
+        ret.push(name);
+        ret.push(self.reset(force_suffix_reset));
+        ret.push(clear_to_eol);
+        ret
+    }
+
+    /// Resets the current style and returns the default ANSI reset code to
+    /// reset all text formatting attributes. If `force` is true, the reset is
+    /// done even if the reset has been applied before.
+    pub(crate) fn reset(&mut self, force: bool) -> &'static str {
+        // todo:
+        // We need to use style from `Indicator::Reset` but as of now ls colors
+        // uses a fallback mechanism and because of that if `Indicator::Reset`
+        // is not specified it would fallback to `Indicator::Normal` which seems
+        // to be non compatible with gnu
+        if self.current_style.is_some() || force {
+            self.initial_reset_is_done = true;
+            self.current_style = None;
+            return "\x1b[0m";
+        }
+        ""
+    }
+
+    pub(crate) fn get_style_code(&mut self, new_style: &Style) -> String {
+        self.current_style = Some(*new_style);
+        let mut nu_a_style = new_style.to_nu_ansi_term_style();
+        nu_a_style.prefix_with_reset = false;
+        let mut ret = nu_a_style.paint("").to_string();
+        // remove the suffix reset
+        ret.truncate(ret.len() - 4);
+        ret
+    }
+
+    pub(crate) fn is_current_style(&self, new_style: &Style) -> bool {
+        matches!(&self.current_style, Some(style) if style == new_style)
+    }
+
+    pub(crate) fn is_reset(&self) -> bool {
+        self.current_style.is_none()
+    }
+
+    pub(crate) fn get_normal_style(&self) -> Option<&Style> {
+        self.colors.style_for_indicator(Indicator::Normal)
+    }
+    pub(crate) fn apply_normal(&mut self) -> String {
+        if let Some(sty) = self.get_normal_style().copied() {
+            return self.get_style_code(&sty);
+        }
+        String::new()
+    }
+
+    pub(crate) fn apply_style_based_on_metadata(
+        &mut self,
+        path: &PathData,
+        md_option: Option<&Metadata>,
+        name: OsString,
+        wrap: bool,
+    ) -> OsString {
+        let style = self
+            .colors
+            .style_for_path_with_metadata(&path.p_buf, md_option);
+        self.apply_style(style, name, wrap)
+    }
+
+    pub(crate) fn apply_style_based_on_dir_entry(
+        &mut self,
+        dir_entry: &DirEntry,
+        name: OsString,
+        wrap: bool,
+    ) -> OsString {
+        let style = self.colors.style_for(dir_entry);
+        self.apply_style(style, name, wrap)
+    }
+}
+
+/// Colors the provided name based on the style determined for the given path
+/// This function is quite long because it tries to leverage DirEntry to avoid
+/// unnecessary calls to stat()
+/// and manages the symlink errors
+pub(crate) fn color_name(
+    name: OsString,
+    path: &PathData,
+    style_manager: &mut StyleManager,
+    out: &mut BufWriter<Stdout>,
+    target_symlink: Option<&PathData>,
+    wrap: bool,
+) -> OsString {
+    // Check if the file has capabilities
+    #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+    {
+        // Skip checking capabilities if LS_COLORS=ca=:
+        let capabilities = style_manager
+            .colors
+            .style_for_indicator(Indicator::Capabilities);
+
+        let has_capabilities = if capabilities.is_none() {
+            false
+        } else {
+            uucore::fsxattr::has_acl(path.p_buf.as_path())
+        };
+
+        // If the file has capabilities, use a specific style for `ca` (capabilities)
+        if has_capabilities {
+            return style_manager.apply_style(capabilities, name, wrap);
+        }
+    }
+
+    if !path.must_dereference {
+        // If we need to dereference (follow) a symlink, we will need to get the metadata
+        if let Some(de) = &path.de {
+            // There is a DirEntry, we don't need to get the metadata for the color
+            return style_manager.apply_style_based_on_dir_entry(de, name, wrap);
+        }
+    }
+
+    if let Some(target) = target_symlink {
+        // use the optional target_symlink
+        // Use fn get_metadata_with_deref_opt instead of get_metadata() here because ls
+        // should not exit with an err, if we are unable to obtain the target_metadata
+        let md_res = get_metadata_with_deref_opt(&target.p_buf, path.must_dereference);
+        let md = md_res.or_else(|_| path.p_buf.symlink_metadata());
+        style_manager.apply_style_based_on_metadata(path, md.ok().as_ref(), name, wrap)
+    } else {
+        let md_option = path.get_metadata(out);
+        let symlink_metadata = path.p_buf.symlink_metadata().ok();
+        let md = md_option.or(symlink_metadata.as_ref());
+        style_manager.apply_style_based_on_metadata(path, md, name, wrap)
+    }
+}
diff --git a/src/uu/ls/src/dired.rs b/src/uu/ls/src/dired.rs
new file mode 100644
index 00000000000..69122ccd08b
--- /dev/null
+++ b/src/uu/ls/src/dired.rs
@@ -0,0 +1,350 @@
+// 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.
+// spell-checker:ignore dired subdired
+
+/// `dired` Module Documentation
+///
+/// This module handles the --dired output format, representing file and
+/// directory listings.
+///
+/// Key Mechanisms:
+/// 1. **Position Tracking**:
+///    - The module tracks byte positions for each file or directory entry.
+///    - `BytePosition`: Represents a byte range with start and end positions.
+///    - `DiredOutput`: Contains positions for DIRED and SUBDIRED outputs and
+///      maintains a padding value.
+///
+/// 2. **Padding**:
+///    - Padding is used when dealing with directory names or the "total" line.
+///    - The module adjusts byte positions by adding padding for these cases.
+///    - This ensures correct offset for subsequent files or directories.
+///
+/// 3. **Position Calculation**:
+///    - Functions like `calculate_dired`, `calculate_subdired`, and
+///      `calculate_and_update_positions` compute byte positions based on output
+///      length, previous positions, and padding.
+///
+/// 4. **Output**:
+///    - The module provides functions to print the DIRED output
+///      (`print_dired_output`) based on calculated positions and configuration.
+///    - Helpers like `print_positions` print positions with specific prefixes.
+///
+/// Overall, the module ensures each entry in the DIRED output has the correct
+/// byte position, considering additional lines or padding affecting positions.
+///
+use crate::Config;
+use std::fmt;
+use std::io::{BufWriter, Stdout, Write};
+use uucore::error::UResult;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct BytePosition {
+    pub start: usize,
+    pub end: usize,
+}
+
+/// Represents the output structure for DIRED, containing positions for both DIRED and SUBDIRED.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct DiredOutput {
+    pub dired_positions: Vec<BytePosition>,
+    pub subdired_positions: Vec<BytePosition>,
+    pub padding: usize,
+}
+
+impl fmt::Display for BytePosition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} {}", self.start, self.end)
+    }
+}
+
+// When --dired is used, all lines starts with 2 spaces
+static DIRED_TRAILING_OFFSET: usize = 2;
+
+fn get_offset_from_previous_line(dired_positions: &[BytePosition]) -> usize {
+    if let Some(last_position) = dired_positions.last() {
+        last_position.end + 1
+    } else {
+        0
+    }
+}
+
+/// Calculates the byte positions for DIRED
+pub fn calculate_dired(
+    dired_positions: &[BytePosition],
+    output_display_len: usize,
+    dfn_len: usize,
+) -> (usize, usize) {
+    let offset_from_previous_line = get_offset_from_previous_line(dired_positions);
+
+    let start = output_display_len + offset_from_previous_line;
+    let end = start + dfn_len;
+    (start, end)
+}
+
+pub fn indent(out: &mut BufWriter<Stdout>) -> UResult<()> {
+    write!(out, "  ")?;
+    Ok(())
+}
+
+pub fn calculate_subdired(dired: &mut DiredOutput, path_len: usize) {
+    let offset_from_previous_line = get_offset_from_previous_line(&dired.dired_positions);
+
+    let additional_offset = if dired.subdired_positions.is_empty() {
+        0
+    } else {
+        // if we have several directories: \n\n
+        2
+    };
+
+    let start = offset_from_previous_line + DIRED_TRAILING_OFFSET + additional_offset;
+    let end = start + path_len;
+    dired.subdired_positions.push(BytePosition { start, end });
+}
+
+/// Prints the dired output based on the given configuration and dired structure.
+pub fn print_dired_output(
+    config: &Config,
+    dired: &DiredOutput,
+    out: &mut BufWriter<Stdout>,
+) -> UResult<()> {
+    out.flush()?;
+    if !dired.dired_positions.is_empty() {
+        print_positions("//DIRED//", &dired.dired_positions);
+    }
+    if config.recursive {
+        print_positions("//SUBDIRED//", &dired.subdired_positions);
+    }
+    println!("//DIRED-OPTIONS// --quoting-style={}", config.quoting_style);
+    Ok(())
+}
+
+/// Helper function to print positions with a given prefix.
+fn print_positions(prefix: &str, positions: &Vec<BytePosition>) {
+    print!("{prefix}");
+    for c in positions {
+        print!(" {c}");
+    }
+    println!();
+}
+
+pub fn add_total(dired: &mut DiredOutput, total_len: usize) {
+    if dired.padding == 0 {
+        let offset_from_previous_line = get_offset_from_previous_line(&dired.dired_positions);
+        // when dealing with "  total: xx", it isn't part of the //DIRED//
+        // so, we just keep the size line to add it to the position of the next file
+        dired.padding = total_len + offset_from_previous_line + DIRED_TRAILING_OFFSET;
+    } else {
+        // += because if we are in -R, we have "  dir:\n  total X". So, we need to take the
+        // previous padding too.
+        // and we already have the previous position in mind
+        dired.padding += total_len + DIRED_TRAILING_OFFSET;
+    }
+}
+
+// when using -R, we have the dirname. we need to add it to the padding
+pub fn add_dir_name(dired: &mut DiredOutput, dir_len: usize) {
+    // 1 for the ":" in "  dirname:"
+    dired.padding += dir_len + DIRED_TRAILING_OFFSET + 1;
+}
+
+/// Calculates byte positions and updates the dired structure.
+pub fn calculate_and_update_positions(
+    dired: &mut DiredOutput,
+    output_display_len: usize,
+    dfn_len: usize,
+) {
+    let offset = dired
+        .dired_positions
+        .last()
+        .map_or(DIRED_TRAILING_OFFSET, |last_position| {
+            last_position.start + DIRED_TRAILING_OFFSET
+        });
+    let start = output_display_len + offset + DIRED_TRAILING_OFFSET;
+    let end = start + dfn_len;
+    update_positions(dired, start, end);
+}
+
+/// Updates the dired positions based on the given start and end positions.
+/// update when it is the first element in the list (to manage "total X")
+/// insert when it isn't the about total
+pub fn update_positions(dired: &mut DiredOutput, start: usize, end: usize) {
+    // padding can be 0 but as it doesn't matter
+    dired.dired_positions.push(BytePosition {
+        start: start + dired.padding,
+        end: end + dired.padding,
+    });
+    // Remove the previous padding
+    dired.padding = 0;
+}
+
+/// Checks if the "--dired" or "-D" argument is present in the command line arguments.
+/// we don't use clap here because we need to know if the argument is present
+/// as it can be overridden by --hyperlink
+pub fn is_dired_arg_present() -> bool {
+    std::env::args_os().any(|x| x == "--dired" || x == "-D")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calculate_dired() {
+        let output_display = "sample_output".to_string();
+        let dfn = "sample_file".to_string();
+        let dired_positions = vec![BytePosition { start: 5, end: 10 }];
+        let (start, end) = calculate_dired(&dired_positions, output_display.len(), dfn.len());
+
+        assert_eq!(start, 24);
+        assert_eq!(end, 35);
+    }
+
+    #[test]
+    fn test_get_offset_from_previous_line() {
+        let positions = vec![
+            BytePosition { start: 0, end: 3 },
+            BytePosition { start: 4, end: 7 },
+            BytePosition { start: 8, end: 11 },
+        ];
+        assert_eq!(get_offset_from_previous_line(&positions), 12);
+    }
+    #[test]
+    fn test_calculate_subdired() {
+        let mut dired = DiredOutput {
+            dired_positions: vec![
+                BytePosition { start: 0, end: 3 },
+                BytePosition { start: 4, end: 7 },
+                BytePosition { start: 8, end: 11 },
+            ],
+            subdired_positions: vec![],
+            padding: 0,
+        };
+        let path_len = 5;
+        calculate_subdired(&mut dired, path_len);
+        assert_eq!(
+            dired.subdired_positions,
+            vec![BytePosition { start: 14, end: 19 }],
+        );
+    }
+
+    #[test]
+    fn test_add_dir_name() {
+        let mut dired = DiredOutput {
+            dired_positions: vec![
+                BytePosition { start: 0, end: 3 },
+                BytePosition { start: 4, end: 7 },
+                BytePosition { start: 8, end: 11 },
+            ],
+            subdired_positions: vec![],
+            padding: 0,
+        };
+        let dir_len = 5;
+        add_dir_name(&mut dired, dir_len);
+        assert_eq!(
+            dired,
+            DiredOutput {
+                dired_positions: vec![
+                    BytePosition { start: 0, end: 3 },
+                    BytePosition { start: 4, end: 7 },
+                    BytePosition { start: 8, end: 11 },
+                ],
+                subdired_positions: vec![],
+                // 8 = 1 for the \n + 5 for dir_len + 2 for "  " + 1 for :
+                padding: 8
+            }
+        );
+    }
+
+    #[test]
+    fn test_add_total() {
+        let mut dired = DiredOutput {
+            dired_positions: vec![
+                BytePosition { start: 0, end: 3 },
+                BytePosition { start: 4, end: 7 },
+                BytePosition { start: 8, end: 11 },
+            ],
+            subdired_positions: vec![],
+            padding: 0,
+        };
+        // if we have "total: 2"
+        let total_len = 8;
+        add_total(&mut dired, total_len);
+        // 22 = 8 (len) + 2 (padding) + 11 (previous position) + 1 (\n)
+        assert_eq!(dired.padding, 22);
+    }
+
+    #[test]
+    fn test_add_dir_name_and_total() {
+        // test when we have
+        //   dirname:
+        //   total 0
+        //   -rw-r--r-- 1 sylvestre sylvestre 0 Sep 30 09:41 ab
+
+        let mut dired = DiredOutput {
+            dired_positions: vec![
+                BytePosition { start: 0, end: 3 },
+                BytePosition { start: 4, end: 7 },
+                BytePosition { start: 8, end: 11 },
+            ],
+            subdired_positions: vec![],
+            padding: 0,
+        };
+        let dir_len = 5;
+        add_dir_name(&mut dired, dir_len);
+        // 8 = 2 ("  ") + 1 (\n) + 5 + 1 (: of dirname)
+        assert_eq!(dired.padding, 8);
+
+        let total_len = 8;
+        add_total(&mut dired, total_len);
+        assert_eq!(dired.padding, 18);
+    }
+
+    #[test]
+    fn test_dired_update_positions() {
+        let mut dired = DiredOutput {
+            dired_positions: vec![BytePosition { start: 5, end: 10 }],
+            subdired_positions: vec![],
+            padding: 10,
+        };
+
+        // Test with adjust = true
+        update_positions(&mut dired, 15, 20);
+        let last_position = dired.dired_positions.last().unwrap();
+        assert_eq!(last_position.start, 25); // 15 + 10 (end of the previous position)
+        assert_eq!(last_position.end, 30); // 20 + 10 (end of the previous position)
+
+        // Test with adjust = false
+        update_positions(&mut dired, 30, 35);
+        let last_position = dired.dired_positions.last().unwrap();
+        assert_eq!(last_position.start, 30);
+        assert_eq!(last_position.end, 35);
+    }
+
+    #[test]
+    fn test_calculate_and_update_positions() {
+        let mut dired = DiredOutput {
+            dired_positions: vec![
+                BytePosition { start: 0, end: 3 },
+                BytePosition { start: 4, end: 7 },
+                BytePosition { start: 8, end: 11 },
+            ],
+            subdired_positions: vec![],
+            padding: 5,
+        };
+        let output_display_len = 15;
+        let dfn_len = 5;
+        calculate_and_update_positions(&mut dired, output_display_len, dfn_len);
+        assert_eq!(
+            dired.dired_positions,
+            vec![
+                BytePosition { start: 0, end: 3 },
+                BytePosition { start: 4, end: 7 },
+                BytePosition { start: 8, end: 11 },
+                BytePosition { start: 32, end: 37 },
+            ]
+        );
+        assert_eq!(dired.padding, 0);
+    }
+}
diff --git a/src/uu/ls/src/ls.rs b/src/uu/ls/src/ls.rs
index 1f5165e8303..0297a569cef 100644
--- a/src/uu/ls/src/ls.rs
+++ b/src/uu/ls/src/ls.rs
@@ -3,29 +3,18 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) cpio svgz webm somegroup nlink rmvb xspf tabsize dired
-
-use clap::{
-    builder::{NonEmptyStringValueParser, ValueParser},
-    crate_version, Arg, ArgAction, Command,
-};
-use glob::{MatchOptions, Pattern};
-use is_terminal::IsTerminal;
-use lscolors::LsColors;
-use number_prefix::NumberPrefix;
-use once_cell::unsync::OnceCell;
-use std::collections::HashSet;
-use std::num::IntErrorKind;
+// spell-checker:ignore (ToDO) somegroup nlink tabsize dired subdired dtype colorterm stringly nohash
 
+use std::iter;
 #[cfg(windows)]
 use std::os::windows::fs::MetadataExt;
+use std::{cell::LazyCell, cell::OnceCell, num::IntErrorKind};
 use std::{
     cmp::Reverse,
-    error::Error,
     ffi::{OsStr, OsString},
-    fmt::{Display, Write as FmtWrite},
+    fmt::Write as FmtWrite,
     fs::{self, DirEntry, FileType, Metadata, ReadDir},
-    io::{stdout, BufWriter, ErrorKind, Stdout, Write},
+    io::{BufWriter, ErrorKind, Stdout, Write, stdout},
     path::{Path, PathBuf},
     time::{SystemTime, UNIX_EPOCH},
 };
@@ -35,8 +24,25 @@ use std::{
     os::unix::fs::{FileTypeExt, MetadataExt},
     time::Duration,
 };
-use term_grid::{Cell, Direction, Filling, Grid, GridOptions};
-use unicode_width::UnicodeWidthStr;
+use std::{collections::HashSet, io::IsTerminal};
+
+use ansi_width::ansi_width;
+use chrono::format::{Item, StrftimeItems};
+use chrono::{DateTime, Local, TimeDelta};
+use clap::{
+    Arg, ArgAction, Command,
+    builder::{NonEmptyStringValueParser, PossibleValue, ValueParser},
+};
+use glob::{MatchOptions, Pattern};
+use lscolors::LsColors;
+use term_grid::{DEFAULT_SEPARATOR_SIZE, Direction, Filling, Grid, GridOptions, SPACES_IN_TAB};
+use thiserror::Error;
+use uucore::error::USimpleError;
+use uucore::format::human::{SizeFormat, human_readable};
+#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+use uucore::fsxattr::has_acl;
+#[cfg(unix)]
+use uucore::libc::{S_IXGRP, S_IXOTH, S_IXUSR};
 #[cfg(any(
     target_os = "linux",
     target_os = "macos",
@@ -50,19 +56,27 @@ use unicode_width::UnicodeWidthStr;
     target_os = "solaris"
 ))]
 use uucore::libc::{dev_t, major, minor};
-#[cfg(unix)]
-use uucore::libc::{S_IXGRP, S_IXOTH, S_IXUSR};
 use uucore::line_ending::LineEnding;
-use uucore::quoting_style::{escape_name, QuotingStyle};
+use uucore::quoting_style::{self, QuotingStyle, escape_name};
 use uucore::{
+    custom_tz_fmt,
     display::Quotable,
-    error::{set_exit_code, UError, UResult},
+    error::{UError, UResult, set_exit_code},
     format_usage,
     fs::display_permissions,
-    parse_size::parse_size,
+    os_str_as_bytes_lossy,
+    parser::parse_size::parse_size_u64,
+    parser::shortcut_value_parser::ShortcutValueParser,
     version_cmp::version_cmp,
 };
-use uucore::{help_about, help_section, help_usage, parse_glob, show, show_error, show_warning};
+use uucore::{
+    help_about, help_section, help_usage, parser::parse_glob, show, show_error, show_warning,
+};
+
+mod dired;
+use dired::{DiredOutput, is_dired_arg_present};
+mod colors;
+use colors::{StyleManager, color_name};
 
 #[cfg(not(feature = "selinux"))]
 static CONTEXT_HELP_TEXT: &str = "print any security context of each file (not enabled)";
@@ -79,7 +93,7 @@ pub mod options {
         pub static LONG: &str = "long";
         pub static COLUMNS: &str = "C";
         pub static ACROSS: &str = "x";
-        pub static TAB_SIZE: &str = "tabsize"; // silently ignored (see #3624)
+        pub static TAB_SIZE: &str = "tabsize";
         pub static COMMAS: &str = "m";
         pub static LONG_NO_OWNER: &str = "g";
         pub static LONG_NO_GROUP: &str = "o";
@@ -156,20 +170,49 @@ pub mod options {
     pub static GROUP_DIRECTORIES_FIRST: &str = "group-directories-first";
     pub static ZERO: &str = "zero";
     pub static DIRED: &str = "dired";
+    pub static HYPERLINK: &str = "hyperlink";
 }
 
 const DEFAULT_TERM_WIDTH: u16 = 80;
 const POSIXLY_CORRECT_BLOCK_SIZE: u64 = 512;
-#[cfg(unix)]
 const DEFAULT_BLOCK_SIZE: u64 = 1024;
+const DEFAULT_FILE_SIZE_BLOCK_SIZE: u64 = 1;
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 enum LsError {
+    #[error("invalid line width: '{0}'")]
     InvalidLineWidth(String),
-    IOError(std::io::Error),
-    IOErrorContext(std::io::Error, PathBuf, bool),
+
+    #[error("general io error: {0}")]
+    IOError(#[from] std::io::Error),
+
+    #[error("{}", match .1.kind() {
+        ErrorKind::NotFound => format!("cannot access '{}': No such file or directory", .0.to_string_lossy()),
+        ErrorKind::PermissionDenied => match .1.raw_os_error().unwrap_or(1) {
+            1 => format!("cannot access '{}': Operation not permitted", .0.to_string_lossy()),
+            _ => if .0.is_dir() {
+                format!("cannot open directory '{}': Permission denied", .0.to_string_lossy())
+            } else {
+                format!("cannot open file '{}': Permission denied", .0.to_string_lossy())
+            },
+        },
+        _ => match .1.raw_os_error().unwrap_or(1) {
+            9 => format!("cannot open directory '{}': Bad file descriptor", .0.to_string_lossy()),
+            _ => format!("unknown io error: '{:?}', '{:?}'", .0.to_string_lossy(), .1),
+        },
+    })]
+    IOErrorContext(PathBuf, std::io::Error, bool),
+
+    #[error("invalid --block-size argument '{0}'")]
     BlockSizeParseError(String),
+
+    #[error("--dired and --zero are incompatible")]
+    DiredAndZeroAreIncompatible,
+
+    #[error("{}: not listing already-listed directory", .0.to_string_lossy())]
     AlreadyListedError(PathBuf),
+
+    #[error("invalid --time-style argument {}\nPossible values are: {:?}\n\nFor more information try --help", .0.quote(), .1)]
     TimeStyleParseError(String, Vec<String>),
 }
 
@@ -180,100 +223,10 @@ impl UError for LsError {
             Self::IOError(_) => 1,
             Self::IOErrorContext(_, _, false) => 1,
             Self::IOErrorContext(_, _, true) => 2,
-            Self::BlockSizeParseError(_) => 1,
+            Self::BlockSizeParseError(_) => 2,
+            Self::DiredAndZeroAreIncompatible => 2,
             Self::AlreadyListedError(_) => 2,
-            Self::TimeStyleParseError(_, _) => 1,
-        }
-    }
-}
-
-impl Error for LsError {}
-
-impl Display for LsError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::BlockSizeParseError(s) => {
-                write!(f, "invalid --block-size argument {}", s.quote())
-            }
-            Self::TimeStyleParseError(s, possible_time_styles) => {
-                write!(
-                    f,
-                    "invalid --time-style argument {}\nPossible values are: {:?}\n\nFor more information try --help",
-                    s.quote(),
-                    possible_time_styles
-                )
-            }
-            Self::InvalidLineWidth(s) => write!(f, "invalid line width: {}", s.quote()),
-            Self::IOError(e) => write!(f, "general io error: {e}"),
-            Self::IOErrorContext(e, p, _) => {
-                let error_kind = e.kind();
-                let errno = e.raw_os_error().unwrap_or(1i32);
-
-                match error_kind {
-                    // No such file or directory
-                    ErrorKind::NotFound => {
-                        write!(
-                            f,
-                            "cannot access '{}': No such file or directory",
-                            p.to_string_lossy(),
-                        )
-                    }
-                    // Permission denied and Operation not permitted
-                    ErrorKind::PermissionDenied =>
-                    {
-                        #[allow(clippy::wildcard_in_or_patterns)]
-                        match errno {
-                            1i32 => {
-                                write!(
-                                    f,
-                                    "cannot access '{}': Operation not permitted",
-                                    p.to_string_lossy(),
-                                )
-                            }
-                            13i32 | _ => {
-                                if p.is_dir() {
-                                    write!(
-                                        f,
-                                        "cannot open directory '{}': Permission denied",
-                                        p.to_string_lossy(),
-                                    )
-                                } else {
-                                    write!(
-                                        f,
-                                        "cannot open file '{}': Permission denied",
-                                        p.to_string_lossy(),
-                                    )
-                                }
-                            }
-                        }
-                    }
-                    _ => match errno {
-                        9i32 => {
-                            // only should ever occur on a read_dir on a bad fd
-                            write!(
-                                f,
-                                "cannot open directory '{}': Bad file descriptor",
-                                p.to_string_lossy(),
-                            )
-                        }
-                        _ => {
-                            write!(
-                                f,
-                                "unknown io error: '{:?}', '{:?}'",
-                                p.to_string_lossy(),
-                                e
-                            )
-                        }
-                    },
-                }
-            }
-            Self::AlreadyListedError(path) => {
-                write!(
-                    f,
-                    "{}: not listing already-listed directory",
-                    path.to_string_lossy()
-                )
-            }
+            Self::TimeStyleParseError(_, _) => 2,
         }
     }
 }
@@ -298,13 +251,6 @@ enum Sort {
     Width,
 }
 
-#[derive(PartialEq)]
-enum SizeFormat {
-    Bytes,
-    Binary,  // Powers of 1024, --human-readable, -h
-    Decimal, // Powers of 1000, --si
-}
-
 #[derive(PartialEq, Eq)]
 enum Files {
     All,
@@ -328,6 +274,67 @@ enum TimeStyle {
     Format(String),
 }
 
+/// A struct/impl used to format a file DateTime, precomputing the format for performance reasons.
+struct TimeStyler {
+    // default format, always specified.
+    default: Vec<Item<'static>>,
+    // format for a recent time, only specified it is is different from the default
+    recent: Option<Vec<Item<'static>>>,
+    // If `recent` is set, cache the threshold time when we switch from recent to default format.
+    recent_time_threshold: Option<DateTime<Local>>,
+}
+
+impl TimeStyler {
+    /// Create a TimeStyler based on a TimeStyle specification.
+    fn new(style: &TimeStyle) -> TimeStyler {
+        let default: Vec<Item<'static>> = match style {
+            TimeStyle::FullIso => StrftimeItems::new("%Y-%m-%d %H:%M:%S.%f %z").parse(),
+            TimeStyle::LongIso => StrftimeItems::new("%Y-%m-%d %H:%M").parse(),
+            TimeStyle::Iso => StrftimeItems::new("%Y-%m-%d ").parse(),
+            // In this version of chrono translating can be done
+            // The function is chrono::datetime::DateTime::format_localized
+            // However it's currently still hard to get the current pure-rust-locale
+            // So it's not yet implemented
+            TimeStyle::Locale => StrftimeItems::new("%b %e  %Y").parse(),
+            TimeStyle::Format(fmt) => {
+                StrftimeItems::new_lenient(custom_tz_fmt::custom_time_format(fmt).as_str())
+                    .parse_to_owned()
+            }
+        }
+        .unwrap();
+        let recent = match style {
+            TimeStyle::Iso => Some(StrftimeItems::new("%m-%d %H:%M")),
+            // See comment above about locale
+            TimeStyle::Locale => Some(StrftimeItems::new("%b %e %H:%M")),
+            _ => None,
+        }
+        .map(|x| x.collect());
+        let recent_time_threshold = if recent.is_some() {
+            // According to GNU a Gregorian year has 365.2425 * 24 * 60 * 60 == 31556952 seconds on the average.
+            Some(Local::now() - TimeDelta::try_seconds(31_556_952 / 2).unwrap())
+        } else {
+            None
+        };
+
+        TimeStyler {
+            default,
+            recent,
+            recent_time_threshold,
+        }
+    }
+
+    /// Format a DateTime, using `recent` format if available, and the DateTime
+    /// is recent enough.
+    fn format(&self, time: DateTime<Local>) -> String {
+        if self.recent.is_none() || time <= self.recent_time_threshold.unwrap() {
+            time.format_with_items(self.default.iter())
+        } else {
+            time.format_with_items(self.recent.as_ref().unwrap().iter())
+        }
+        .to_string()
+    }
+}
+
 fn parse_time_style(options: &clap::ArgMatches) -> Result<TimeStyle, LsError> {
     let possible_time_styles = vec![
         "full-iso".to_string(),
@@ -340,8 +347,8 @@ fn parse_time_style(options: &clap::ArgMatches) -> Result<TimeStyle, LsError> {
         //If both FULL_TIME and TIME_STYLE are present
         //The one added last is dominant
         if options.get_flag(options::FULL_TIME)
-            && options.indices_of(options::FULL_TIME).unwrap().last()
-                > options.indices_of(options::TIME_STYLE).unwrap().last()
+            && options.indices_of(options::FULL_TIME).unwrap().next_back()
+                > options.indices_of(options::TIME_STYLE).unwrap().next_back()
         {
             Ok(TimeStyle::FullIso)
         } else {
@@ -398,7 +405,9 @@ pub struct Config {
     color: Option<LsColors>,
     long: LongFormat,
     alloc_size: bool,
-    block_size: Option<u64>,
+    file_size_block_size: u64,
+    #[allow(dead_code)]
+    block_size: u64, // is never read on Windows
     width: u16,
     // Dir and vdir needs access to this field
     pub quoting_style: QuotingStyle,
@@ -408,6 +417,9 @@ pub struct Config {
     selinux_supported: bool,
     group_directories_first: bool,
     line_ending: LineEnding,
+    dired: bool,
+    hyperlink: bool,
+    tab_size: usize,
 }
 
 // Fields that can be removed or added to the long format
@@ -462,7 +474,7 @@ fn extract_format(options: &clap::ArgMatches) -> (Format, Option<&'static str>)
         (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() {
+    } else if stdout().is_terminal() {
         (Format::Columns, None)
     } else {
         (Format::OneLine, None)
@@ -527,6 +539,7 @@ fn extract_time(options: &clap::ArgMatches) -> Time {
         match field.as_str() {
             "ctime" | "status" => Time::Change,
             "access" | "atime" | "use" => Time::Access,
+            "mtime" | "modification" => Time::Modification,
             "birth" | "creation" => Time::Birth,
             // below should never happen as clap already restricts the values.
             _ => unreachable!("Invalid field for --time"),
@@ -540,23 +553,118 @@ fn extract_time(options: &clap::ArgMatches) -> Time {
     }
 }
 
+// Some env variables can be passed
+// For now, we are only verifying if empty or not and known for TERM
+fn is_color_compatible_term() -> bool {
+    let is_term_set = std::env::var("TERM").is_ok();
+    let is_colorterm_set = std::env::var("COLORTERM").is_ok();
+
+    let term = std::env::var("TERM").unwrap_or_default();
+    let colorterm = std::env::var("COLORTERM").unwrap_or_default();
+
+    // Search function in the TERM struct to manage the wildcards
+    let term_matches = |term: &str| -> bool {
+        uucore::colors::TERMS.iter().any(|&pattern| {
+            term == pattern
+                || (pattern.ends_with('*') && term.starts_with(&pattern[..pattern.len() - 1]))
+        })
+    };
+
+    if is_term_set && term.is_empty() && is_colorterm_set && colorterm.is_empty() {
+        return false;
+    }
+
+    if !term.is_empty() && !term_matches(&term) {
+        return false;
+    }
+    true
+}
+
 /// 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 {
+    if !is_color_compatible_term() {
+        return false;
+    }
+
     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(),
+            "auto" | "tty" | "if-tty" => stdout().is_terminal(),
             /* "never" | "no" | "none" | */ _ => false,
         },
     }
 }
 
+/// Extracts the hyperlink option to use based on the options provided.
+///
+/// # Returns
+///
+/// A boolean representing whether to hyperlink files.
+fn extract_hyperlink(options: &clap::ArgMatches) -> bool {
+    let hyperlink = options
+        .get_one::<String>(options::HYPERLINK)
+        .unwrap()
+        .as_str();
+
+    match hyperlink {
+        "always" | "yes" | "force" => true,
+        "auto" | "tty" | "if-tty" => stdout().is_terminal(),
+        "never" | "no" | "none" => false,
+        _ => unreachable!("should be handled by clap"),
+    }
+}
+
+/// Match the argument given to --quoting-style or the QUOTING_STYLE env variable.
+///
+/// # Arguments
+///
+/// * `style`: the actual argument string
+/// * `show_control` - A boolean value representing whether or not to show control characters.
+///
+/// # Returns
+///
+/// * An option with None if the style string is invalid, or a `QuotingStyle` wrapped in `Some`.
+fn match_quoting_style_name(style: &str, show_control: bool) -> Option<QuotingStyle> {
+    match style {
+        "literal" => Some(QuotingStyle::Literal { show_control }),
+        "shell" => Some(QuotingStyle::Shell {
+            escape: false,
+            always_quote: false,
+            show_control,
+        }),
+        "shell-always" => Some(QuotingStyle::Shell {
+            escape: false,
+            always_quote: true,
+            show_control,
+        }),
+        "shell-escape" => Some(QuotingStyle::Shell {
+            escape: true,
+            always_quote: false,
+            show_control,
+        }),
+        "shell-escape-always" => Some(QuotingStyle::Shell {
+            escape: true,
+            always_quote: true,
+            show_control,
+        }),
+        "c" => Some(QuotingStyle::C {
+            quotes: quoting_style::Quotes::Double,
+        }),
+        "escape" => Some(QuotingStyle::C {
+            quotes: quoting_style::Quotes::None,
+        }),
+        _ => None,
+    }
+}
+
 /// Extracts the quoting style to use based on the options provided.
+/// If no options are given, it looks if a default quoting style is provided
+/// through the QUOTING_STYLE environment variable.
 ///
 /// # Arguments
 ///
@@ -567,40 +675,12 @@ fn extract_color(options: &clap::ArgMatches) -> bool {
 ///
 /// 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());
+    let opt_quoting_style = options.get_one::<String>(options::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"),
+        match match_quoting_style_name(style, show_control) {
+            Some(qs) => qs,
+            None => unreachable!("Should have been caught by Clap"),
         }
     } else if options.get_flag(options::quoting::LITERAL) {
         QuotingStyle::Literal { show_control }
@@ -612,12 +692,30 @@ fn extract_quoting_style(options: &clap::ArgMatches, show_control: bool) -> Quot
         QuotingStyle::C {
             quotes: quoting_style::Quotes::Double,
         }
+    } else if options.get_flag(options::DIRED) {
+        QuotingStyle::Literal { show_control }
     } else {
-        // TODO: use environment variable if available
-        QuotingStyle::Shell {
-            escape: true,
-            always_quote: false,
-            show_control,
+        // If set, the QUOTING_STYLE environment variable specifies a default style.
+        if let Ok(style) = std::env::var("QUOTING_STYLE") {
+            match match_quoting_style_name(style.as_str(), show_control) {
+                Some(qs) => return qs,
+                None => eprintln!(
+                    "{}: Ignoring invalid value of environment variable QUOTING_STYLE: '{style}'",
+                    std::env::args().next().unwrap_or_else(|| "ls".to_string()),
+                ),
+            }
+        }
+
+        // By default, `ls` uses Shell escape quoting style when writing to a terminal file
+        // descriptor and Literal otherwise.
+        if stdout().is_terminal() {
+            QuotingStyle::Shell {
+                escape: true,
+                always_quote: false,
+                show_control,
+            }
+        } else {
+            QuotingStyle::Literal { show_control }
         }
     }
 }
@@ -641,7 +739,7 @@ fn extract_indicator_style(options: &clap::ArgMatches) -> IndicatorStyle {
             "never" | "no" | "none" => IndicatorStyle::None,
             "always" | "yes" | "force" => IndicatorStyle::Classify,
             "auto" | "tty" | "if-tty" => {
-                if std::io::stdout().is_terminal() {
+                if stdout().is_terminal() {
                     IndicatorStyle::Classify
                 } else {
                     IndicatorStyle::None
@@ -658,19 +756,51 @@ fn extract_indicator_style(options: &clap::ArgMatches) -> IndicatorStyle {
     }
 }
 
-fn parse_width(s: &str) -> Result<u16, LsError> {
-    let radix = match s.starts_with('0') && s.len() > 1 {
-        true => 8,
-        false => 10,
+/// Parses the width value from either the command line arguments or the environment variables.
+fn parse_width(width_match: Option<&String>) -> Result<u16, LsError> {
+    let parse_width_from_args = |s: &str| -> Result<u16, LsError> {
+        let radix = if s.starts_with('0') && s.len() > 1 {
+            8
+        } else {
+            10
+        };
+        match u16::from_str_radix(s, radix) {
+            Ok(x) => Ok(x),
+            Err(e) => match e.kind() {
+                IntErrorKind::PosOverflow => Ok(u16::MAX),
+                _ => Err(LsError::InvalidLineWidth(s.into())),
+            },
+        }
+    };
+
+    let parse_width_from_env =
+        |columns: OsString| match columns.to_str().and_then(|s| s.parse().ok()) {
+            Some(columns) => columns,
+            None => {
+                show_error!(
+                    "ignoring invalid width in environment variable COLUMNS: {}",
+                    columns.quote()
+                );
+                DEFAULT_TERM_WIDTH
+            }
+        };
+
+    let calculate_term_size = || match terminal_size::terminal_size() {
+        Some((width, _)) => width.0,
+        None => DEFAULT_TERM_WIDTH,
     };
-    match u16::from_str_radix(s, radix) {
-        Ok(x) => Ok(x),
-        Err(e) => match e.kind() {
-            IntErrorKind::PosOverflow => Ok(u16::MAX),
-            _ => Err(LsError::InvalidLineWidth(s.into())),
+
+    let ret = match width_match {
+        Some(x) => parse_width_from_args(x)?,
+        None => match std::env::var_os("COLUMNS") {
+            Some(columns) => parse_width_from_env(columns),
+            None => calculate_term_size(),
         },
-    }
+    };
+
+    Ok(ret)
 }
+
 impl Config {
     #[allow(clippy::cognitive_complexity)]
     pub fn from(options: &clap::ArgMatches) -> UResult<Self> {
@@ -704,7 +834,7 @@ impl Config {
                 options::FULL_TIME,
             ]
             .iter()
-            .flat_map(|opt| {
+            .filter_map(|opt| {
                 if options.value_source(opt) == Some(clap::parser::ValueSource::CommandLine) {
                     options.indices_of(opt)
                 } else {
@@ -726,19 +856,18 @@ impl Config {
         }
 
         let sort = extract_sort(options);
-
         let time = extract_time(options);
-
         let mut needs_color = extract_color(options);
+        let hyperlink = extract_hyperlink(options);
 
-        let cmd_line_bs = options.get_one::<String>(options::size::BLOCK_SIZE);
-        let opt_si = cmd_line_bs.is_some()
+        let opt_block_size = options.get_one::<String>(options::size::BLOCK_SIZE);
+        let opt_si = opt_block_size.is_some()
             && options
                 .get_one::<String>(options::size::BLOCK_SIZE)
                 .unwrap()
                 .eq("si")
             || options.get_flag(options::size::SI);
-        let opt_hr = (cmd_line_bs.is_some()
+        let opt_hr = (opt_block_size.is_some()
             && options
                 .get_one::<String>(options::size::BLOCK_SIZE)
                 .unwrap()
@@ -746,10 +875,6 @@ impl Config {
             || options.get_flag(options::size::HUMAN_READABLE);
         let opt_kb = options.get_flag(options::size::KIBIBYTES);
 
-        let bs_env_var = std::env::var_os("BLOCK_SIZE");
-        let ls_bs_env_var = std::env::var_os("LS_BLOCK_SIZE");
-        let pc_env_var = std::env::var_os("POSIXLY_CORRECT");
-
         let size_format = if opt_si {
             SizeFormat::Decimal
         } else if opt_hr {
@@ -758,38 +883,66 @@ impl Config {
             SizeFormat::Bytes
         };
 
-        let raw_bs = if let Some(cmd_line_bs) = cmd_line_bs {
-            OsString::from(cmd_line_bs)
-        } else if !opt_kb {
-            if let Some(ls_bs_env_var) = ls_bs_env_var {
-                ls_bs_env_var
-            } else if let Some(bs_env_var) = bs_env_var {
-                bs_env_var
-            } else {
-                OsString::from("")
-            }
+        let env_var_blocksize = std::env::var_os("BLOCKSIZE");
+        let env_var_block_size = std::env::var_os("BLOCK_SIZE");
+        let env_var_ls_block_size = std::env::var_os("LS_BLOCK_SIZE");
+        let env_var_posixly_correct = std::env::var_os("POSIXLY_CORRECT");
+        let mut is_env_var_blocksize = false;
+
+        let raw_block_size = if let Some(opt_block_size) = opt_block_size {
+            OsString::from(opt_block_size)
+        } else if let Some(env_var_ls_block_size) = env_var_ls_block_size {
+            env_var_ls_block_size
+        } else if let Some(env_var_block_size) = env_var_block_size {
+            env_var_block_size
+        } else if let Some(env_var_blocksize) = env_var_blocksize {
+            is_env_var_blocksize = true;
+            env_var_blocksize
         } else {
             OsString::from("")
         };
 
-        let block_size: Option<u64> = if !opt_si && !opt_hr && !raw_bs.is_empty() {
-            match parse_size(&raw_bs.to_string_lossy()) {
-                Ok(size) => Some(size),
+        let (file_size_block_size, block_size) = if !opt_si && !opt_hr && !raw_block_size.is_empty()
+        {
+            match parse_size_u64(&raw_block_size.to_string_lossy()) {
+                Ok(size) => match (is_env_var_blocksize, opt_kb) {
+                    (true, true) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE),
+                    (true, false) => (DEFAULT_FILE_SIZE_BLOCK_SIZE, size),
+                    (false, true) => {
+                        // --block-size overrides -k
+                        if opt_block_size.is_some() {
+                            (size, size)
+                        } else {
+                            (size, DEFAULT_BLOCK_SIZE)
+                        }
+                    }
+                    (false, false) => (size, size),
+                },
                 Err(_) => {
-                    show!(LsError::BlockSizeParseError(
-                        cmd_line_bs.unwrap().to_owned()
-                    ));
-                    None
+                    // only fail if invalid block size was specified with --block-size,
+                    // ignore invalid block size from env vars
+                    if let Some(invalid_block_size) = opt_block_size {
+                        return Err(Box::new(LsError::BlockSizeParseError(
+                            invalid_block_size.clone(),
+                        )));
+                    }
+                    if is_env_var_blocksize {
+                        (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
+                    } else {
+                        (DEFAULT_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
+                    }
                 }
             }
-        } else if let Some(pc) = pc_env_var {
-            if pc.as_os_str() == OsStr::new("true") || pc == OsStr::new("1") {
-                Some(POSIXLY_CORRECT_BLOCK_SIZE)
+        } else if env_var_posixly_correct.is_some() {
+            if opt_kb {
+                (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
             } else {
-                None
+                (DEFAULT_FILE_SIZE_BLOCK_SIZE, POSIXLY_CORRECT_BLOCK_SIZE)
             }
+        } else if opt_si {
+            (DEFAULT_FILE_SIZE_BLOCK_SIZE, 1000)
         } else {
-            None
+            (DEFAULT_FILE_SIZE_BLOCK_SIZE, DEFAULT_BLOCK_SIZE)
         };
 
         let long = {
@@ -807,26 +960,7 @@ impl Config {
                 numeric_uid_gid,
             }
         };
-
-        let width = match options.get_one::<String>(options::WIDTH) {
-            Some(x) => parse_width(x)?,
-            None => match terminal_size::terminal_size() {
-                Some((width, _)) => width.0,
-                None => match std::env::var_os("COLUMNS") {
-                    Some(columns) => match columns.to_str().and_then(|s| s.parse().ok()) {
-                        Some(columns) => columns,
-                        None => {
-                            show_error!(
-                                "ignoring invalid width in environment variable COLUMNS: {}",
-                                columns.quote()
-                            );
-                            DEFAULT_TERM_WIDTH
-                        }
-                    },
-                    None => DEFAULT_TERM_WIDTH,
-                },
-            },
-        };
+        let width = parse_width(options.get_one::<String>(options::WIDTH))?;
 
         #[allow(clippy::needless_bool)]
         let mut show_control = if options.get_flag(options::HIDE_CONTROL_CHARS) {
@@ -834,12 +968,18 @@ impl Config {
         } else if options.get_flag(options::SHOW_CONTROL_CHARS) {
             true
         } else {
-            !std::io::stdout().is_terminal()
+            !stdout().is_terminal()
         };
 
         let mut quoting_style = extract_quoting_style(options, show_control);
         let indicator_style = extract_indicator_style(options);
-        let time_style = parse_time_style(options)?;
+        // Only parse the value to "--time-style" if it will become relevant.
+        let dired = options.get_flag(options::DIRED);
+        let time_style = if format == Format::Long || dired {
+            parse_time_style(options)?
+        } else {
+            TimeStyle::Iso
+        };
 
         let mut ignore_patterns: Vec<Pattern> = Vec::new();
 
@@ -956,6 +1096,16 @@ impl Config {
             None
         };
 
+        if dired || is_dired_arg_present() {
+            // --dired implies --format=long
+            // if we have --dired --hyperlink, we don't show dired but we still want to see the
+            // long format
+            format = Format::Long;
+        }
+        if dired && options.get_flag(options::ZERO) {
+            return Err(Box::new(LsError::DiredAndZeroAreIncompatible));
+        }
+
         let dereference = if options.get_flag(options::dereference::ALL) {
             Dereference::All
         } else if options.get_flag(options::dereference::ARGS) {
@@ -971,6 +1121,16 @@ impl Config {
             Dereference::DirArgs
         };
 
+        let tab_size = if !needs_color {
+            options
+                .get_one::<String>(options::format::TAB_SIZE)
+                .and_then(|size| size.parse::<usize>().ok())
+                .or_else(|| std::env::var("TABSIZE").ok().and_then(|s| s.parse().ok()))
+        } else {
+            Some(0)
+        }
+        .unwrap_or(SPACES_IN_TAB);
+
         Ok(Self {
             format,
             files,
@@ -987,6 +1147,7 @@ impl Config {
             inode: options.get_flag(options::INODE),
             long,
             alloc_size: options.get_flag(options::size::ALLOCATION_SIZE),
+            file_size_block_size,
             block_size,
             width,
             quoting_style,
@@ -996,7 +1157,7 @@ impl Config {
             selinux_supported: {
                 #[cfg(feature = "selinux")]
                 {
-                    selinux::kernel_support() != selinux::KernelSupport::Unsupported
+                    uucore::selinux::is_selinux_enabled()
                 }
                 #[cfg(not(feature = "selinux"))]
                 {
@@ -1005,6 +1166,9 @@ impl Config {
             },
             group_directories_first: options.get_flag(options::GROUP_DIRECTORIES_FIRST),
             line_ending: LineEnding::from_zero_flag(options.get_flag(options::ZERO)),
+            dired,
+            hyperlink,
+            tab_size,
         })
     }
 }
@@ -1013,7 +1177,22 @@ impl Config {
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let command = uu_app();
 
-    let matches = command.get_matches_from(args);
+    let matches = match command.try_get_matches_from(args) {
+        // clap successfully parsed the arguments:
+        Ok(matches) => matches,
+        // --help, --version, etc.:
+        Err(e) if e.exit_code() == 0 => {
+            return Err(e.into());
+        }
+        // Errors in argument *values* cause exit code 1:
+        Err(e) if e.kind() == clap::error::ErrorKind::InvalidValue => {
+            return Err(USimpleError::new(1, e.to_string()));
+        }
+        // All other argument parsing errors cause exit code 2:
+        Err(e) => {
+            return Err(USimpleError::new(2, e.to_string()));
+        }
+    };
 
     let config = Config::from(&matches)?;
 
@@ -1027,11 +1206,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
         .disable_help_flag(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::HELP)
                 .long(options::HELP)
@@ -1043,7 +1223,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::FORMAT)
                 .long(options::FORMAT)
                 .help("Set the display format.")
-                .value_parser([
+                .value_parser(ShortcutValueParser::new([
                     "long",
                     "verbose",
                     "single-column",
@@ -1052,7 +1232,7 @@ pub fn uu_app() -> Command {
                     "across",
                     "horizontal",
                     "commas",
-                ])
+                ]))
                 .hide_possible_values(true)
                 .require_equals(true)
                 .overrides_with_all([
@@ -1061,6 +1241,7 @@ pub fn uu_app() -> Command {
                     options::format::LONG,
                     options::format::ACROSS,
                     options::format::COLUMNS,
+                    options::DIRED,
                 ]),
         )
         .arg(
@@ -1104,13 +1285,12 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            // silently ignored (see #3624)
             Arg::new(options::format::TAB_SIZE)
                 .short('T')
                 .long(options::format::TAB_SIZE)
                 .env("TABSIZE")
                 .value_name("COLS")
-                .help("Assume tab stops at each COLS instead of 8 (unimplemented)"),
+                .help("Assume tab stops at each COLS instead of 8"),
         )
         .arg(
             Arg::new(options::format::COMMAS)
@@ -1128,7 +1308,6 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::ZERO)
                 .long(options::ZERO)
-                .conflicts_with(options::DIRED)
                 .overrides_with(options::ZERO)
                 .help("List entries separated by ASCII NUL characters.")
                 .action(ArgAction::SetTrue),
@@ -1137,8 +1316,25 @@ pub fn uu_app() -> Command {
             Arg::new(options::DIRED)
                 .long(options::DIRED)
                 .short('D')
-                .hide(true)
-                .action(ArgAction::SetTrue),
+                .help("generate output designed for Emacs' dired (Directory Editor) mode")
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::HYPERLINK),
+        )
+        .arg(
+            Arg::new(options::HYPERLINK)
+                .long(options::HYPERLINK)
+                .help("hyperlink file names WHEN")
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("always").alias("yes").alias("force"),
+                    PossibleValue::new("auto").alias("tty").alias("if-tty"),
+                    PossibleValue::new("never").alias("no").alias("none"),
+                ]))
+                .require_equals(true)
+                .num_args(0..=1)
+                .default_missing_value("always")
+                .default_value("never")
+                .value_name("WHEN")
+                .overrides_with(options::DIRED),
         )
         // The next four arguments do not override with the other format
         // options, see the comment in Config::from for the reason.
@@ -1179,15 +1375,15 @@ pub fn uu_app() -> Command {
             Arg::new(options::QUOTING_STYLE)
                 .long(options::QUOTING_STYLE)
                 .help("Set quoting style.")
-                .value_parser([
-                    "literal",
-                    "shell",
-                    "shell-always",
-                    "shell-escape",
-                    "shell-escape-always",
-                    "c",
-                    "escape",
-                ])
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("literal"),
+                    PossibleValue::new("shell"),
+                    PossibleValue::new("shell-escape"),
+                    PossibleValue::new("shell-always"),
+                    PossibleValue::new("shell-escape-always"),
+                    PossibleValue::new("c").alias("c-maybe"),
+                    PossibleValue::new("escape"),
+                ]))
                 .overrides_with_all([
                     options::QUOTING_STYLE,
                     options::quoting::LITERAL,
@@ -1259,12 +1455,16 @@ pub fn uu_app() -> Command {
                     "Show time in <field>:\n\
                         \taccess time (-u): atime, access, use;\n\
                         \tchange time (-t): ctime, status.\n\
+                        \tmodification time: mtime, modification.\n\
                         \tbirth time: birth, creation;",
                 )
                 .value_name("field")
-                .value_parser([
-                    "atime", "access", "use", "ctime", "status", "birth", "creation",
-                ])
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("atime").alias("access").alias("use"),
+                    PossibleValue::new("ctime").alias("status"),
+                    PossibleValue::new("mtime").alias("modification"),
+                    PossibleValue::new("birth").alias("creation"),
+                ]))
                 .hide_possible_values(true)
                 .require_equals(true)
                 .overrides_with_all([options::TIME, options::time::ACCESS, options::time::CHANGE]),
@@ -1324,7 +1524,7 @@ pub fn uu_app() -> Command {
                 .long(options::SORT)
                 .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", "width"])
+                .value_parser(ShortcutValueParser::new(["name", "none", "time", "size", "version", "extension", "width"]))
                 .require_equals(true)
                 .overrides_with_all([
                     options::SORT,
@@ -1502,7 +1702,7 @@ pub fn uu_app() -> Command {
                 .short('h')
                 .long(options::size::HUMAN_READABLE)
                 .help("Print human readable file sizes (e.g. 1K 234M 56G).")
-                .overrides_with(options::size::SI)
+                .overrides_with_all([options::size::BLOCK_SIZE, options::size::SI])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -1519,6 +1719,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::size::SI)
                 .long(options::size::SI)
                 .help("Print human readable file sizes using powers of 1000 instead of 1024.")
+                .overrides_with_all([options::size::BLOCK_SIZE, options::size::HUMAN_READABLE])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -1526,7 +1727,8 @@ pub fn uu_app() -> Command {
                 .long(options::size::BLOCK_SIZE)
                 .require_equals(true)
                 .value_name("BLOCK_SIZE")
-                .help("scale sizes by BLOCK_SIZE when printing them"),
+                .help("scale sizes by BLOCK_SIZE when printing them")
+                .overrides_with_all([options::size::SI, options::size::HUMAN_READABLE]),
         )
         .arg(
             Arg::new(options::INODE)
@@ -1570,9 +1772,11 @@ pub fn uu_app() -> Command {
             Arg::new(options::COLOR)
                 .long(options::COLOR)
                 .help("Color output based on file type.")
-                .value_parser([
-                    "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
-                ])
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("always").alias("yes").alias("force"),
+                    PossibleValue::new("auto").alias("tty").alias("if-tty"),
+                    PossibleValue::new("never").alias("no").alias("none"),
+                ]))
                 .require_equals(true)
                 .num_args(0..=1),
         )
@@ -1583,7 +1787,7 @@ pub fn uu_app() -> Command {
                     "Append indicator with style WORD to entry names: \
                 none (default),  slash (-p), file-type (--file-type), classify (-F)",
                 )
-                .value_parser(["none", "slash", "file-type", "classify"])
+                .value_parser(ShortcutValueParser::new(["none", "slash", "file-type", "classify"]))
                 .overrides_with_all([
                     options::indicator_style::FILE_TYPE,
                     options::indicator_style::SLASH,
@@ -1614,9 +1818,11 @@ pub fn uu_app() -> Command {
                     --dereference-command-line-symlink-to-dir options are specified.",
                 )
                 .value_name("when")
-                .value_parser([
-                    "always", "yes", "force", "auto", "tty", "if-tty", "never", "no", "none",
-                ])
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("always").alias("yes").alias("force"),
+                    PossibleValue::new("auto").alias("tty").alias("if-tty"),
+                    PossibleValue::new("never").alias("no").alias("none"),
+                ]))
                 .default_missing_value("always")
                 .require_equals(true)
                 .num_args(0..=1)
@@ -1702,6 +1908,8 @@ struct PathData {
     // Result<MetaData> got from symlink_metadata() or metadata() based on config
     md: OnceCell<Option<Metadata>>,
     ft: OnceCell<Option<FileType>>,
+    // can be used to avoid reading the metadata. Can be also called d_type:
+    // https://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
     de: Option<DirEntry>,
     // Name of the file - will be empty for . or ..
     display_name: OsString,
@@ -1797,10 +2005,11 @@ impl PathData {
         }
     }
 
-    fn md(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
+    fn get_metadata(&self, out: &mut BufWriter<Stdout>) -> Option<&Metadata> {
         self.md
             .get_or_init(|| {
                 // check if we can use DirEntry metadata
+                // it will avoid a call to stat()
                 if !self.must_dereference {
                     if let Some(dir_entry) = &self.de {
                         return dir_entry.metadata().ok();
@@ -1808,7 +2017,7 @@ impl PathData {
                 }
 
                 // if not, check if we can use Path metadata
-                match get_metadata(self.p_buf.as_path(), self.must_dereference) {
+                match get_metadata_with_deref_opt(self.p_buf.as_path(), self.must_dereference) {
                     Err(err) => {
                         // FIXME: A bit tricky to propagate the result here
                         out.flush().unwrap();
@@ -1823,8 +2032,8 @@ impl PathData {
                             }
                         }
                         show!(LsError::IOErrorContext(
-                            err,
                             self.p_buf.clone(),
+                            err,
                             self.command_line
                         ));
                         None
@@ -1837,17 +2046,74 @@ impl PathData {
 
     fn file_type(&self, out: &mut BufWriter<Stdout>) -> Option<&FileType> {
         self.ft
-            .get_or_init(|| self.md(out).map(|md| md.file_type()))
+            .get_or_init(|| self.get_metadata(out).map(|md| md.file_type()))
             .as_ref()
     }
 }
 
+/// Show the directory name in the case where several arguments are given to ls
+/// or the recursive flag is passed.
+///
+/// ```no-exec
+/// $ ls -R
+/// .:                  <- This is printed by this function
+/// dir1 file1 file2
+///
+/// dir1:               <- This as well
+/// file11
+/// ```
+fn show_dir_name(
+    path_data: &PathData,
+    out: &mut BufWriter<Stdout>,
+    config: &Config,
+) -> std::io::Result<()> {
+    let escaped_name =
+        quoting_style::escape_dir_name(path_data.p_buf.as_os_str(), &config.quoting_style);
+
+    let name = if config.hyperlink && !config.dired {
+        create_hyperlink(&escaped_name, path_data)
+    } else {
+        escaped_name
+    };
+
+    write_os_str(out, &name)?;
+    write!(out, ":")
+}
+
+// A struct to encapsulate state that is passed around from `list` functions.
+struct ListState<'a> {
+    out: BufWriter<Stdout>,
+    style_manager: Option<StyleManager<'a>>,
+    // TODO: More benchmarking with different use cases is required here.
+    // From experiments, BTreeMap may be faster than HashMap, especially as the
+    // number of users/groups is very limited. It seems like nohash::IntMap
+    // performance was equivalent to BTreeMap.
+    // It's possible a simple vector linear(binary?) search implementation would be even faster.
+    #[cfg(unix)]
+    uid_cache: HashMap<u32, String>,
+    #[cfg(unix)]
+    gid_cache: HashMap<u32, String>,
+
+    time_styler: TimeStyler,
+}
+
+#[allow(clippy::cognitive_complexity)]
 pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
     let mut files = Vec::<PathData>::new();
     let mut dirs = Vec::<PathData>::new();
-    let mut out = BufWriter::new(stdout());
+    let mut dired = DiredOutput::default();
     let initial_locs_len = locs.len();
 
+    let mut state = ListState {
+        out: BufWriter::new(stdout()),
+        style_manager: config.color.as_ref().map(StyleManager::new),
+        #[cfg(unix)]
+        uid_cache: HashMap::new(),
+        #[cfg(unix)]
+        gid_cache: HashMap::new(),
+        time_styler: TimeStyler::new(&config.time_style),
+    };
+
     for loc in locs {
         let path_data = PathData::new(PathBuf::from(loc), None, None, config, true);
 
@@ -1857,11 +2123,11 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
         // Proper GNU handling is don't show if dereferenced symlink DNE
         // but only for the base dir, for a child dir show, and print ?s
         // in long format
-        if path_data.md(&mut out).is_none() {
+        if path_data.get_metadata(&mut state.out).is_none() {
             continue;
         }
 
-        let show_dir_contents = match path_data.file_type(&mut out) {
+        let show_dir_contents = match path_data.file_type(&mut state.out) {
             Some(ft) => !config.directory && ft.is_dir(),
             None => {
                 set_exit_code(1);
@@ -1876,10 +2142,19 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
         }
     }
 
-    sort_entries(&mut files, config, &mut out);
-    sort_entries(&mut dirs, config, &mut out);
+    sort_entries(&mut files, config, &mut state.out);
+    sort_entries(&mut dirs, config, &mut state.out);
+
+    if let Some(style_manager) = state.style_manager.as_mut() {
+        // ls will try to write a reset before anything is written if normal
+        // color is given
+        if style_manager.get_normal_style().is_some() {
+            let to_write = style_manager.reset(true);
+            write!(state.out, "{to_write}")?;
+        }
+    }
 
-    display_items(&files, config, &mut out)?;
+    display_items(&files, config, &mut state, &mut dired)?;
 
     for (pos, path_data) in dirs.iter().enumerate() {
         // Do read_dir call here to match GNU semantics by printing
@@ -1887,10 +2162,10 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
         let read_dir = match fs::read_dir(&path_data.p_buf) {
             Err(err) => {
                 // flush stdout buffer before the error to preserve formatting and order
-                out.flush()?;
+                state.out.flush()?;
                 show!(LsError::IOErrorContext(
-                    err,
                     path_data.p_buf.clone(),
+                    err,
                     path_data.command_line
                 ));
                 continue;
@@ -1901,9 +2176,23 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
         // Print dir heading - name... 'total' comes after error display
         if initial_locs_len > 1 || config.recursive {
             if pos.eq(&0usize) && files.is_empty() {
-                writeln!(out, "{}:", path_data.p_buf.display())?;
+                if config.dired {
+                    dired::indent(&mut state.out)?;
+                }
+                show_dir_name(path_data, &mut state.out, config)?;
+                writeln!(state.out)?;
+                if config.dired {
+                    // First directory displayed
+                    let dir_len = path_data.display_name.len();
+                    // add the //SUBDIRED// coordinates
+                    dired::calculate_subdired(&mut dired, dir_len);
+                    // Add the padding for the dir name
+                    dired::add_dir_name(&mut dired, dir_len);
+                }
             } else {
-                writeln!(out, "\n{}:", path_data.p_buf.display())?;
+                writeln!(state.out)?;
+                show_dir_name(path_data, &mut state.out, config)?;
+                writeln!(state.out)?;
             }
         }
         let mut listed_ancestors = HashSet::new();
@@ -1911,9 +2200,18 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
             &path_data.p_buf,
             path_data.must_dereference,
         )?);
-        enter_directory(path_data, read_dir, config, &mut out, &mut listed_ancestors)?;
+        enter_directory(
+            path_data,
+            read_dir,
+            config,
+            &mut state,
+            &mut listed_ancestors,
+            &mut dired,
+        )?;
+    }
+    if config.dired && !config.hyperlink {
+        dired::print_dired_output(config, &dired, &mut state.out)?;
     }
-
     Ok(())
 }
 
@@ -1921,12 +2219,14 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
     match config.sort {
         Sort::Time => entries.sort_by_key(|k| {
             Reverse(
-                k.md(out)
+                k.get_metadata(out)
                     .and_then(|md| get_system_time(md, config))
                     .unwrap_or(UNIX_EPOCH),
             )
         }),
-        Sort::Size => entries.sort_by_key(|k| Reverse(k.md(out).map(|md| md.len()).unwrap_or(0))),
+        Sort::Size => {
+            entries.sort_by_key(|k| Reverse(k.get_metadata(out).map(|md| md.len()).unwrap_or(0)));
+        }
         // The default sort in GNU ls is case insensitive
         Sort::Name => entries.sort_by(|a, b| a.display_name.cmp(&b.display_name)),
         Sort::Version => entries.sort_by(|a, b| {
@@ -1957,17 +2257,14 @@ fn sort_entries(entries: &mut [PathData], config: &Config, out: &mut BufWriter<S
             let md = {
                 // We will always try to deref symlinks to group directories, so PathData.md
                 // is not always useful.
-                if p.must_dereference {
-                    p.md.get()
-                } else {
-                    None
-                }
+                if p.must_dereference { p.md.get() } else { None }
             };
 
             !match md {
                 None | Some(None) => {
                     // If it metadata cannot be determined, treat as a file.
-                    get_metadata(p.p_buf.as_path(), true).map_or_else(|_| false, |m| m.is_dir())
+                    get_metadata_with_deref_opt(p.p_buf.as_path(), true)
+                        .map_or_else(|_| false, |m| m.is_dir())
                 }
                 Some(Some(m)) => m.is_dir(),
             }
@@ -2006,7 +2303,11 @@ fn should_display(entry: &DirEntry, config: &Config) -> bool {
         case_sensitive: true,
     };
     let file_name = entry.file_name();
-    // If the decoding fails, still show an incorrect rendering
+    // If the decoding fails, still match best we can
+    // FIXME: use OsStrings or Paths once we have a glob crate that supports it:
+    // https://github.com/rust-lang/glob/issues/23
+    // https://github.com/rust-lang/glob/issues/78
+    // https://github.com/BurntSushi/ripgrep/issues/1250
     let file_name = match file_name.to_str() {
         Some(s) => s.to_string(),
         None => file_name.to_string_lossy().into_owned(),
@@ -2022,8 +2323,9 @@ fn enter_directory(
     path_data: &PathData,
     read_dir: ReadDir,
     config: &Config,
-    out: &mut BufWriter<Stdout>,
+    state: &mut ListState,
     listed_ancestors: &mut HashSet<FileInformation>,
+    dired: &mut DiredOutput,
 ) -> UResult<()> {
     // Create vec of entries with initial dot files
     let mut entries: Vec<PathData> = if config.files == Files::All {
@@ -2052,7 +2354,7 @@ fn enter_directory(
         let dir_entry = match raw_entry {
             Ok(path) => path,
             Err(err) => {
-                out.flush()?;
+                state.out.flush()?;
                 show!(LsError::IOError(err));
                 continue;
             }
@@ -2065,29 +2367,34 @@ fn enter_directory(
         };
     }
 
-    sort_entries(&mut entries, config, out);
+    sort_entries(&mut entries, config, &mut state.out);
 
     // Print total after any error display
     if config.format == Format::Long || config.alloc_size {
-        display_total(&entries, config, out)?;
+        let total = return_total(&entries, config, &mut state.out)?;
+        write!(state.out, "{}", total.as_str())?;
+        if config.dired {
+            dired::add_total(dired, total.len());
+        }
     }
 
-    display_items(&entries, config, out)?;
+    display_items(&entries, config, state, dired)?;
 
     if config.recursive {
         for e in entries
             .iter()
             .skip(if config.files == Files::All { 2 } else { 0 })
-            .filter(|p| p.ft.get().is_some())
-            .filter(|p| p.ft.get().unwrap().is_some())
-            .filter(|p| p.ft.get().unwrap().unwrap().is_dir())
+            .filter(|p| {
+                p.ft.get()
+                    .is_some_and(|o_ft| o_ft.is_some_and(|ft| ft.is_dir()))
+            })
         {
             match fs::read_dir(&e.p_buf) {
                 Err(err) => {
-                    out.flush()?;
+                    state.out.flush()?;
                     show!(LsError::IOErrorContext(
-                        err,
                         e.p_buf.clone(),
+                        err,
                         e.command_line
                     ));
                     continue;
@@ -2096,12 +2403,28 @@ fn enter_directory(
                     if listed_ancestors
                         .insert(FileInformation::from_path(&e.p_buf, e.must_dereference)?)
                     {
-                        writeln!(out, "\n{}:", e.p_buf.display())?;
-                        enter_directory(e, rd, config, out, listed_ancestors)?;
+                        // when listing several directories in recursive mode, we show
+                        // "dirname:" at the beginning of the file list
+                        writeln!(state.out)?;
+                        if config.dired {
+                            // We already injected the first dir
+                            // Continue with the others
+                            // 2 = \n + \n
+                            dired.padding = 2;
+                            dired::indent(&mut state.out)?;
+                            let dir_name_size = e.p_buf.to_string_lossy().len();
+                            dired::calculate_subdired(dired, dir_name_size);
+                            // inject dir name
+                            dired::add_dir_name(dired, dir_name_size);
+                        }
+
+                        show_dir_name(e, &mut state.out, config)?;
+                        writeln!(state.out)?;
+                        enter_directory(e, rd, config, state, listed_ancestors, dired)?;
                         listed_ancestors
                             .remove(&FileInformation::from_path(&e.p_buf, e.must_dereference)?);
                     } else {
-                        out.flush()?;
+                        state.out.flush()?;
                         show!(LsError::AlreadyListedError(e.p_buf.clone()));
                     }
                 }
@@ -2112,7 +2435,7 @@ fn enter_directory(
     Ok(())
 }
 
-fn get_metadata(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
+fn get_metadata_with_deref_opt(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
     if dereference {
         p_buf.metadata()
     } else {
@@ -2123,22 +2446,20 @@ fn get_metadata(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
 fn display_dir_entry_size(
     entry: &PathData,
     config: &Config,
-    out: &mut BufWriter<std::io::Stdout>,
+    state: &mut ListState,
 ) -> (usize, usize, usize, usize, usize, usize) {
     // TODO: Cache/memorize the display_* results so we don't have to recalculate them.
-    if let Some(md) = entry.md(out) {
+    if let Some(md) = entry.get_metadata(&mut state.out) {
         let (size_len, major_len, minor_len) = match display_len_or_rdev(md, config) {
-            SizeOrDeviceId::Device(major, minor) => (
-                (major.len() + minor.len() + 2usize),
-                major.len(),
-                minor.len(),
-            ),
+            SizeOrDeviceId::Device(major, minor) => {
+                (major.len() + minor.len() + 2usize, major.len(), minor.len())
+            }
             SizeOrDeviceId::Size(size) => (size.len(), 0usize, 0usize),
         };
         (
             display_symlink_count(md).len(),
-            display_uname(md, config).len(),
-            display_group(md, config).len(),
+            display_uname(md, config, state).len(),
+            display_group(md, config, state).len(),
             size_len,
             major_len,
             minor_len,
@@ -2148,29 +2469,55 @@ fn display_dir_entry_size(
     }
 }
 
-fn pad_left(string: &str, count: usize) -> String {
-    format!("{string:>count$}")
+// A simple, performant, ExtendPad trait to add a string to a Vec<u8>, padding with spaces
+// on the left or right, without making additional copies, or using formatting functions.
+trait ExtendPad {
+    fn extend_pad_left(&mut self, string: &str, count: usize);
+    fn extend_pad_right(&mut self, string: &str, count: usize);
 }
 
-fn pad_right(string: &str, count: usize) -> String {
-    format!("{string:<count$}")
+impl ExtendPad for Vec<u8> {
+    fn extend_pad_left(&mut self, string: &str, count: usize) {
+        if string.len() < count {
+            self.extend(iter::repeat_n(b' ', count - string.len()));
+        }
+        self.extend(string.as_bytes());
+    }
+
+    fn extend_pad_right(&mut self, string: &str, count: usize) {
+        self.extend(string.as_bytes());
+        if string.len() < count {
+            self.extend(iter::repeat_n(b' ', count - string.len()));
+        }
+    }
 }
 
-fn display_total(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> UResult<()> {
+// TODO: Consider converting callers to use ExtendPad instead, as it avoids
+// additional copies.
+fn pad_left(string: &str, count: usize) -> String {
+    format!("{string:>count$}")
+}
+
+fn return_total(
+    items: &[PathData],
+    config: &Config,
+    out: &mut BufWriter<Stdout>,
+) -> UResult<String> {
     let mut total_size = 0;
     for item in items {
         total_size += item
-            .md(out)
+            .get_metadata(out)
             .as_ref()
             .map_or(0, |md| get_block_size(md, config));
     }
-    write!(
-        out,
+    if config.dired {
+        dired::indent(out)?;
+    }
+    Ok(format!(
         "total {}{}",
         display_size(total_size, config),
         config.line_ending
-    )?;
-    Ok(())
+    ))
 }
 
 fn display_additional_leading_info(
@@ -2183,7 +2530,7 @@ fn display_additional_leading_info(
     #[cfg(unix)]
     {
         if config.inode {
-            let i = if let Some(md) = item.md(out) {
+            let i = if let Some(md) = item.get_metadata(out) {
                 get_inode(md)
             } else {
                 "?".to_owned()
@@ -2193,7 +2540,7 @@ fn display_additional_leading_info(
     }
 
     if config.alloc_size {
-        let s = if let Some(md) = item.md(out) {
+        let s = if let Some(md) = item.get_metadata(out) {
             display_size(get_block_size(md, config), config)
         } else {
             "?".to_owned()
@@ -2209,28 +2556,42 @@ fn display_additional_leading_info(
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout>) -> UResult<()> {
+fn display_items(
+    items: &[PathData],
+    config: &Config,
+    state: &mut ListState,
+    dired: &mut DiredOutput,
+) -> UResult<()> {
     // `-Z`, `--context`:
     // Display the SELinux security context or '?' if none is found. When used with the `-l`
     // option, print the security context to the left of the size column.
 
+    let quoted = items.iter().any(|item| {
+        let name = escape_name(&item.display_name, &config.quoting_style);
+        os_str_starts_with(&name, b"'")
+    });
+
     if config.format == Format::Long {
-        let padding_collection = calculate_padding_collection(items, config, out);
+        let padding_collection = calculate_padding_collection(items, config, state);
 
         for item in items {
             #[cfg(unix)]
-            if config.inode || config.alloc_size {
-                let more_info =
-                    display_additional_leading_info(item, &padding_collection, config, out)?;
-                write!(out, "{more_info}")?;
-            }
+            let should_display_leading_info = config.inode || config.alloc_size;
             #[cfg(not(unix))]
-            if config.alloc_size {
-                let more_info =
-                    display_additional_leading_info(item, &padding_collection, config, out)?;
-                write!(out, "{more_info}")?;
+            let should_display_leading_info = config.alloc_size;
+
+            if should_display_leading_info {
+                let more_info = display_additional_leading_info(
+                    item,
+                    &padding_collection,
+                    config,
+                    &mut state.out,
+                )?;
+
+                write!(state.out, "{more_info}")?;
             }
-            display_item_long(item, &padding_collection, config, out)?;
+
+            display_item_long(item, &padding_collection, config, state, dired, quoted)?;
         }
     } else {
         let mut longest_context_len = 1;
@@ -2244,48 +2605,83 @@ fn display_items(items: &[PathData], config: &Config, out: &mut BufWriter<Stdout
             None
         };
 
-        let padding = calculate_padding_collection(items, config, out);
+        let padding = calculate_padding_collection(items, config, state);
 
-        let mut names_vec = Vec::new();
+        // we need to apply normal color to non filename output
+        if let Some(style_manager) = &mut state.style_manager {
+            write!(state.out, "{}", style_manager.apply_normal())?;
+        }
 
+        let mut names_vec = Vec::new();
         for i in items {
-            let more_info = display_additional_leading_info(i, &padding, config, out)?;
-            let cell = display_file_name(i, config, prefix_context, more_info, out);
+            let more_info = display_additional_leading_info(i, &padding, config, &mut state.out)?;
+            // it's okay to set current column to zero which is used to decide
+            // whether text will wrap or not, because when format is grid or
+            // column ls will try to place the item name in a new line if it
+            // wraps.
+            let cell = display_item_name(
+                i,
+                config,
+                prefix_context,
+                more_info,
+                state,
+                LazyCell::new(Box::new(|| 0)),
+            );
+
             names_vec.push(cell);
         }
 
-        let names = names_vec.into_iter();
+        let mut names = names_vec.into_iter();
 
         match config.format {
-            Format::Columns => display_grid(names, config.width, Direction::TopToBottom, out)?,
-            Format::Across => display_grid(names, config.width, Direction::LeftToRight, out)?,
+            Format::Columns => {
+                display_grid(
+                    names,
+                    config.width,
+                    Direction::TopToBottom,
+                    &mut state.out,
+                    quoted,
+                    config.tab_size,
+                )?;
+            }
+            Format::Across => {
+                display_grid(
+                    names,
+                    config.width,
+                    Direction::LeftToRight,
+                    &mut state.out,
+                    quoted,
+                    config.tab_size,
+                )?;
+            }
             Format::Commas => {
                 let mut current_col = 0;
-                let mut names = names;
                 if let Some(name) = names.next() {
-                    write!(out, "{}", name.contents)?;
-                    current_col = name.width as u16 + 2;
+                    write_os_str(&mut state.out, &name)?;
+                    current_col = ansi_width(&name.to_string_lossy()) as u16 + 2;
                 }
                 for name in names {
-                    let name_width = name.width as u16;
+                    let name_width = ansi_width(&name.to_string_lossy()) as u16;
                     // If the width is 0 we print one single line
                     if config.width != 0 && current_col + name_width + 1 > config.width {
                         current_col = name_width + 2;
-                        write!(out, ",\n{}", name.contents)?;
+                        writeln!(state.out, ",")?;
                     } else {
                         current_col += name_width + 2;
-                        write!(out, ", {}", name.contents)?;
+                        write!(state.out, ", ")?;
                     }
+                    write_os_str(&mut state.out, &name)?;
                 }
                 // Current col is never zero again if names have been printed.
                 // So we print a newline.
                 if current_col > 0 {
-                    write!(out, "{}", config.line_ending)?;
+                    write!(state.out, "{}", config.line_ending)?;
                 }
             }
             _ => {
                 for name in names {
-                    write!(out, "{}{}", name.contents, config.line_ending)?;
+                    write_os_str(&mut state.out, &name)?;
+                    write!(state.out, "{}", config.line_ending)?;
                 }
             }
         };
@@ -2308,17 +2704,7 @@ fn get_block_size(md: &Metadata, config: &Config) -> u64 {
         };
         match config.size_format {
             SizeFormat::Binary | SizeFormat::Decimal => raw_blocks,
-            SizeFormat::Bytes => {
-                if cfg!(unix) {
-                    if let Some(user_block_size) = config.block_size {
-                        raw_blocks / user_block_size
-                    } else {
-                        raw_blocks / DEFAULT_BLOCK_SIZE
-                    }
-                } else {
-                    raw_blocks
-                }
-            }
+            SizeFormat::Bytes => raw_blocks / config.block_size,
         }
     }
     #[cfg(not(unix))]
@@ -2329,10 +2715,12 @@ fn get_block_size(md: &Metadata, config: &Config) -> u64 {
 }
 
 fn display_grid(
-    names: impl Iterator<Item = Cell>,
+    names: impl Iterator<Item = OsString>,
     width: u16,
     direction: Direction,
     out: &mut BufWriter<Stdout>,
+    quoted: bool,
+    tab_size: usize,
 ) -> UResult<()> {
     if width == 0 {
         // If the width is 0 we print one single line
@@ -2342,35 +2730,69 @@ fn display_grid(
                 write!(out, "  ")?;
             }
             printed_something = true;
-            write!(out, "{}", name.contents)?;
+            write_os_str(out, &name)?;
         }
         if printed_something {
             writeln!(out)?;
         }
     } else {
-        let mut grid = Grid::new(GridOptions {
-            filling: Filling::Spaces(2),
-            direction,
-        });
+        let names: Vec<_> = if quoted {
+            // In case some names are quoted, GNU adds a space before each
+            // entry that does not start with a quote to make it prettier
+            // on multiline.
+            //
+            // Example:
+            // ```
+            // $ ls
+            // 'a\nb'   bar
+            //  foo     baz
+            // ^       ^
+            // These spaces is added
+            // ```
+            names
+                .map(|n| {
+                    if os_str_starts_with(&n, b"'") || os_str_starts_with(&n, b"\"") {
+                        n
+                    } else {
+                        let mut ret: OsString = " ".into();
+                        ret.push(n);
+                        ret
+                    }
+                })
+                .collect()
+        } else {
+            names.collect()
+        };
 
-        for name in names {
-            grid.add(name);
-        }
+        // FIXME: the Grid crate only supports &str, so can't display raw bytes
+        let names: Vec<_> = names
+            .into_iter()
+            .map(|s| s.to_string_lossy().into_owned())
+            .collect();
+
+        // Since tab_size=0 means no \t, use Spaces separator for optimization.
+        let filling = match tab_size {
+            0 => Filling::Spaces(DEFAULT_SEPARATOR_SIZE),
+            _ => Filling::Tabs {
+                spaces: DEFAULT_SEPARATOR_SIZE,
+                tab_size,
+            },
+        };
 
-        match grid.fit_into_width(width as usize) {
-            Some(output) => {
-                write!(out, "{output}")?;
-            }
-            // Width is too small for the grid, so we fit it in one column
-            None => {
-                write!(out, "{}", grid.fit_into_columns(1))?;
-            }
-        }
+        let grid = Grid::new(
+            names,
+            GridOptions {
+                filling,
+                direction,
+                width: width as usize,
+            },
+        );
+        write!(out, "{grid}")?;
     }
     Ok(())
 }
 
-/// This writes to the BufWriter out a single string of the output of `ls -l`.
+/// This writes to the BufWriter state.out a single string of the output of `ls -l`.
 ///
 /// It writes the following keys, in order:
 /// * `inode` ([`get_inode`], config-optional)
@@ -2381,11 +2803,11 @@ fn display_grid(
 /// * `author` ([`display_uname`], config-optional)
 /// * `size / rdev` ([`display_len_or_rdev`])
 /// * `system_time` ([`get_system_time`])
-/// * `file_name` ([`display_file_name`])
+/// * `item_name` ([`display_item_name`])
 ///
 /// This function needs to display information in columns:
 /// * permissions and system_time are already guaranteed to be pre-formatted in fixed length.
-/// * file_name is the last column and is left-aligned.
+/// * item_name is the last column and is left-aligned.
 /// * Everything else needs to be padded using [`pad_left`].
 ///
 /// That's why we have the parameters:
@@ -2403,96 +2825,120 @@ fn display_item_long(
     item: &PathData,
     padding: &PaddingCollection,
     config: &Config,
-    out: &mut BufWriter<Stdout>,
+    state: &mut ListState,
+    dired: &mut DiredOutput,
+    quoted: bool,
 ) -> UResult<()> {
-    if let Some(md) = item.md(out) {
-        write!(
-            out,
-            "{}{} {}",
-            display_permissions(md, true),
-            if item.security_context.len() > 1 {
-                // GNU `ls` uses a "." character to indicate a file with a security context,
-                // but not other alternate access method.
-                "."
-            } else {
-                ""
-            },
-            pad_left(&display_symlink_count(md), padding.link_count)
-        )?;
+    let mut output_display: Vec<u8> = Vec::with_capacity(128);
+
+    // apply normal color to non filename outputs
+    if let Some(style_manager) = &mut state.style_manager {
+        output_display.extend(style_manager.apply_normal().as_bytes());
+    }
+    if config.dired {
+        output_display.extend(b"  ");
+    }
+    if let Some(md) = item.get_metadata(&mut state.out) {
+        #[cfg(any(not(unix), target_os = "android", target_os = "macos"))]
+        // TODO: See how Mac should work here
+        let is_acl_set = false;
+        #[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
+        let is_acl_set = has_acl(item.display_name.as_os_str());
+        output_display.extend(display_permissions(md, true).as_bytes());
+        if item.security_context.len() > 1 {
+            // GNU `ls` uses a "." character to indicate a file with a security context,
+            // but not other alternate access method.
+            output_display.extend(b".");
+        } else if is_acl_set {
+            output_display.extend(b"+");
+        }
+        output_display.extend(b" ");
+        output_display.extend_pad_left(&display_symlink_count(md), padding.link_count);
 
         if config.long.owner {
-            write!(
-                out,
-                " {}",
-                pad_right(&display_uname(md, config), padding.uname)
-            )?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right(display_uname(md, config, state), padding.uname);
         }
 
         if config.long.group {
-            write!(
-                out,
-                " {}",
-                pad_right(&display_group(md, config), padding.group)
-            )?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right(display_group(md, config, state), padding.group);
         }
 
         if config.context {
-            write!(
-                out,
-                " {}",
-                pad_right(&item.security_context, padding.context)
-            )?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right(&item.security_context, padding.context);
         }
 
         // Author is only different from owner on GNU/Hurd, so we reuse
         // the owner, since GNU/Hurd is not currently supported by Rust.
         if config.long.author {
-            write!(
-                out,
-                " {}",
-                pad_right(&display_uname(md, config), padding.uname)
-            )?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right(display_uname(md, config, state), padding.uname);
         }
 
         match display_len_or_rdev(md, config) {
             SizeOrDeviceId::Size(size) => {
-                write!(out, " {}", pad_left(&size, padding.size))?;
+                output_display.extend(b" ");
+                output_display.extend_pad_left(&size, padding.size);
             }
             SizeOrDeviceId::Device(major, minor) => {
-                write!(
-                    out,
-                    " {}, {}",
-                    pad_left(
-                        &major,
-                        #[cfg(not(unix))]
-                        0usize,
-                        #[cfg(unix)]
-                        padding.major.max(
-                            padding
-                                .size
-                                .saturating_sub(padding.minor.saturating_add(2usize))
-                        ),
-                    ),
-                    pad_left(
-                        &minor,
-                        #[cfg(not(unix))]
-                        0usize,
-                        #[cfg(unix)]
-                        padding.minor,
+                output_display.extend(b" ");
+                output_display.extend_pad_left(
+                    &major,
+                    #[cfg(not(unix))]
+                    0usize,
+                    #[cfg(unix)]
+                    padding.major.max(
+                        padding
+                            .size
+                            .saturating_sub(padding.minor.saturating_add(2usize)),
                     ),
-                )?;
+                );
+                output_display.extend(b", ");
+                output_display.extend_pad_left(
+                    &minor,
+                    #[cfg(not(unix))]
+                    0usize,
+                    #[cfg(unix)]
+                    padding.minor,
+                );
             }
         };
 
-        let dfn = display_file_name(item, config, None, String::new(), out).contents;
+        output_display.extend(b" ");
+        output_display.extend(display_date(md, config, state).as_bytes());
+        output_display.extend(b" ");
+
+        let item_name = display_item_name(
+            item,
+            config,
+            None,
+            String::new(),
+            state,
+            LazyCell::new(Box::new(|| {
+                ansi_width(&String::from_utf8_lossy(&output_display))
+            })),
+        );
+
+        let displayed_item = if quoted && !os_str_starts_with(&item_name, b"'") {
+            let mut ret: OsString = " ".into();
+            ret.push(item_name);
+            ret
+        } else {
+            item_name
+        };
 
-        write!(
-            out,
-            " {} {}{}",
-            display_date(md, config),
-            dfn,
-            config.line_ending
-        )?;
+        if config.dired {
+            let (start, end) = dired::calculate_dired(
+                &dired.dired_positions,
+                output_display.len(),
+                displayed_item.len(),
+            );
+            dired::update_positions(dired, start, end);
+        }
+        write_os_str(&mut output_display, &displayed_item)?;
+        output_display.extend(config.line_ending.to_string().as_bytes());
     } else {
         #[cfg(unix)]
         let leading_char = {
@@ -2527,53 +2973,67 @@ fn display_item_long(
             }
         };
 
-        write!(
-            out,
-            "{}{} {}",
-            format_args!("{leading_char}?????????"),
-            if item.security_context.len() > 1 {
-                // GNU `ls` uses a "." character to indicate a file with a security context,
-                // but not other alternate access method.
-                "."
-            } else {
-                ""
-            },
-            pad_left("?", padding.link_count)
-        )?;
+        output_display.extend(leading_char.as_bytes());
+        output_display.extend(b"?????????");
+        if item.security_context.len() > 1 {
+            // GNU `ls` uses a "." character to indicate a file with a security context,
+            // but not other alternate access method.
+            output_display.extend(b".");
+        }
+        output_display.extend(b" ");
+        output_display.extend_pad_left("?", padding.link_count);
 
         if config.long.owner {
-            write!(out, " {}", pad_right("?", padding.uname))?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right("?", padding.uname);
         }
 
         if config.long.group {
-            write!(out, " {}", pad_right("?", padding.group))?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right("?", padding.group);
         }
 
         if config.context {
-            write!(
-                out,
-                " {}",
-                pad_right(&item.security_context, padding.context)
-            )?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right(&item.security_context, padding.context);
         }
 
         // Author is only different from owner on GNU/Hurd, so we reuse
         // the owner, since GNU/Hurd is not currently supported by Rust.
         if config.long.author {
-            write!(out, " {}", pad_right("?", padding.uname))?;
+            output_display.extend(b" ");
+            output_display.extend_pad_right("?", padding.uname);
         }
 
-        let dfn = display_file_name(item, config, None, String::new(), out).contents;
+        let displayed_item = display_item_name(
+            item,
+            config,
+            None,
+            String::new(),
+            state,
+            LazyCell::new(Box::new(|| {
+                ansi_width(&String::from_utf8_lossy(&output_display))
+            })),
+        );
         let date_len = 12;
 
-        writeln!(
-            out,
-            " {} {} {}",
-            pad_left("?", padding.size),
-            pad_left("?", date_len),
-            dfn,
-        )?;
+        output_display.extend(b" ");
+        output_display.extend_pad_left("?", padding.size);
+        output_display.extend(b" ");
+        output_display.extend_pad_left("?", date_len);
+        output_display.extend(b" ");
+
+        if config.dired {
+            dired::calculate_and_update_positions(
+                dired,
+                output_display.len(),
+                displayed_item.to_string_lossy().trim().len(),
+            );
+        }
+        write_os_str(&mut output_display, &displayed_item)?;
+        output_display.extend(config.line_ending.to_string().as_bytes());
     }
+    state.out.write_all(&output_display)?;
 
     Ok(())
 }
@@ -2583,70 +3043,45 @@ fn get_inode(metadata: &Metadata) -> String {
     format!("{}", metadata.ino())
 }
 
-// Currently getpwuid is `linux` target only. If it's broken out into
+// Currently getpwuid is `linux` target only. If it's broken state.out into
 // a posix-compliant attribute this can be updated...
 #[cfg(unix)]
-use once_cell::sync::Lazy;
-#[cfg(unix)]
-use std::sync::Mutex;
-#[cfg(unix)]
 use uucore::entries;
 use uucore::fs::FileInformation;
-use uucore::quoting_style;
 
 #[cfg(unix)]
-fn cached_uid2usr(uid: u32) -> String {
-    static UID_CACHE: Lazy<Mutex<HashMap<u32, String>>> = Lazy::new(|| Mutex::new(HashMap::new()));
+fn display_uname<'a>(metadata: &Metadata, config: &Config, state: &'a mut ListState) -> &'a String {
+    let uid = metadata.uid();
 
-    let mut uid_cache = UID_CACHE.lock().unwrap();
-    uid_cache
-        .entry(uid)
-        .or_insert_with(|| entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()))
-        .clone()
+    state.uid_cache.entry(uid).or_insert_with(|| {
+        if config.long.numeric_uid_gid {
+            uid.to_string()
+        } else {
+            entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string())
+        }
+    })
 }
 
 #[cfg(unix)]
-fn display_uname(metadata: &Metadata, config: &Config) -> String {
-    if config.long.numeric_uid_gid {
-        metadata.uid().to_string()
-    } else {
-        cached_uid2usr(metadata.uid())
-    }
-}
-
-#[cfg(all(unix, not(target_os = "redox")))]
-fn cached_gid2grp(gid: u32) -> String {
-    static GID_CACHE: Lazy<Mutex<HashMap<u32, String>>> = Lazy::new(|| Mutex::new(HashMap::new()));
-
-    let mut gid_cache = GID_CACHE.lock().unwrap();
-    gid_cache
-        .entry(gid)
-        .or_insert_with(|| entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()))
-        .clone()
-}
-
-#[cfg(all(unix, not(target_os = "redox")))]
-fn display_group(metadata: &Metadata, config: &Config) -> String {
-    if config.long.numeric_uid_gid {
-        metadata.gid().to_string()
-    } else {
-        cached_gid2grp(metadata.gid())
-    }
-}
-
-#[cfg(target_os = "redox")]
-fn display_group(metadata: &Metadata, config: &Config) -> String {
-    metadata.gid().to_string()
+fn display_group<'a>(metadata: &Metadata, config: &Config, state: &'a mut ListState) -> &'a String {
+    let gid = metadata.gid();
+    state.gid_cache.entry(gid).or_insert_with(|| {
+        if cfg!(target_os = "redox") || config.long.numeric_uid_gid {
+            gid.to_string()
+        } else {
+            entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string())
+        }
+    })
 }
 
 #[cfg(not(unix))]
-fn display_uname(_metadata: &Metadata, _config: &Config) -> String {
-    "somebody".to_string()
+fn display_uname(_metadata: &Metadata, _config: &Config, _state: &mut ListState) -> &'static str {
+    "somebody"
 }
 
 #[cfg(not(unix))]
-fn display_group(_metadata: &Metadata, _config: &Config) -> String {
-    "somegroup".to_string()
+fn display_group(_metadata: &Metadata, _config: &Config, _state: &mut ListState) -> &'static str {
+    "somegroup"
 }
 
 // The implementations for get_time are separated because some options, such
@@ -2667,69 +3102,22 @@ fn get_system_time(md: &Metadata, config: &Config) -> Option<SystemTime> {
         Time::Modification => md.modified().ok(),
         Time::Access => md.accessed().ok(),
         Time::Birth => md.created().ok(),
-        _ => None,
+        Time::Change => None,
     }
 }
 
-fn get_time(md: &Metadata, config: &Config) -> Option<chrono::DateTime<chrono::Local>> {
+fn get_time(md: &Metadata, config: &Config) -> Option<DateTime<Local>> {
     let time = get_system_time(md, config)?;
     Some(time.into())
 }
 
-fn display_date(metadata: &Metadata, config: &Config) -> String {
+fn display_date(metadata: &Metadata, config: &Config, state: &mut ListState) -> String {
     match get_time(metadata, config) {
-        Some(time) => {
-            //Date is recent if from past 6 months
-            //According to GNU a Gregorian year has 365.2425 * 24 * 60 * 60 == 31556952 seconds on the average.
-            let recent = time + chrono::Duration::seconds(31_556_952 / 2) > chrono::Local::now();
-
-            match &config.time_style {
-                TimeStyle::FullIso => time.format("%Y-%m-%d %H:%M:%S.%f %z"),
-                TimeStyle::LongIso => time.format("%Y-%m-%d %H:%M"),
-                TimeStyle::Iso => time.format(if recent { "%m-%d %H:%M" } else { "%Y-%m-%d " }),
-                TimeStyle::Locale => {
-                    let fmt = if recent { "%b %e %H:%M" } else { "%b %e  %Y" };
-
-                    // spell-checker:ignore (word) datetime
-                    //In this version of chrono translating can be done
-                    //The function is chrono::datetime::DateTime::format_localized
-                    //However it's currently still hard to get the current pure-rust-locale
-                    //So it's not yet implemented
-
-                    time.format(fmt)
-                }
-                TimeStyle::Format(e) => time.format(e),
-            }
-            .to_string()
-        }
+        Some(time) => state.time_styler.format(time),
         None => "???".into(),
     }
 }
 
-// There are a few peculiarities to how GNU formats the sizes:
-// 1. One decimal place is given if and only if the size is smaller than 10
-// 2. It rounds sizes up.
-// 3. The human-readable format uses powers for 1024, but does not display the "i"
-//    that is commonly used to denote Kibi, Mebi, etc.
-// 4. Kibi and Kilo are denoted differently ("k" and "K", respectively)
-fn format_prefixed(prefixed: &NumberPrefix<f64>) -> String {
-    match prefixed {
-        NumberPrefix::Standalone(bytes) => bytes.to_string(),
-        NumberPrefix::Prefixed(prefix, bytes) => {
-            // Remove the "i" from "Ki", "Mi", etc. if present
-            let prefix_str = prefix.symbol().trim_end_matches('i');
-
-            // Check whether we get more than 10 if we round up to the first decimal
-            // because we want do display 9.81 as "9.9", not as "10".
-            if (10.0 * bytes).ceil() >= 100.0 {
-                format!("{:.0}{}", bytes.ceil(), prefix_str)
-            } else {
-                format!("{:.1}{}", (10.0 * bytes).ceil() / 10.0, prefix_str)
-            }
-        }
-    }
-}
-
 #[allow(dead_code)]
 enum SizeOrDeviceId {
     Size(String),
@@ -2754,41 +3142,21 @@ fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {
         if ft.is_char_device() || ft.is_block_device() {
             // A type cast is needed here as the `dev_t` type varies across OSes.
             let dev = metadata.rdev() as dev_t;
-            let major = unsafe { major(dev) };
-            let minor = unsafe { minor(dev) };
+            let major = major(dev);
+            let minor = minor(dev);
             return SizeOrDeviceId::Device(major.to_string(), minor.to_string());
         }
     }
-    // Reported file len only adjusted for block_size when block_size is set
-    if let Some(user_block_size) = config.block_size {
-        // ordinary division of unsigned integers rounds down,
-        // this is similar to the Rust API for division that rounds up,
-        // currently in nightly only, however once
-        // https://github.com/rust-lang/rust/pull/88582 : "div_ceil"
-        // is stable we should use that instead
-        let len_adjusted = {
-            let d = metadata.len() / user_block_size;
-            let r = metadata.len() % user_block_size;
-            if r == 0 {
-                d
-            } else {
-                d + 1
-            }
-        };
-        SizeOrDeviceId::Size(display_size(len_adjusted, config))
-    } else {
-        SizeOrDeviceId::Size(display_size(metadata.len(), config))
-    }
+    let len_adjusted = {
+        let d = metadata.len() / config.file_size_block_size;
+        let r = metadata.len() % config.file_size_block_size;
+        if r == 0 { d } else { d + 1 }
+    };
+    SizeOrDeviceId::Size(display_size(len_adjusted, config))
 }
 
 fn display_size(size: u64, config: &Config) -> String {
-    // NOTE: The human-readable behavior deviates from the GNU ls.
-    // The GNU ls uses binary prefixes by default.
-    match config.size_format {
-        SizeFormat::Binary => format_prefixed(&NumberPrefix::binary(size as f64)),
-        SizeFormat::Decimal => format_prefixed(&NumberPrefix::decimal(size as f64)),
-        SizeFormat::Bytes => size.to_string(),
-    }
+    human_readable(size, config.size_format)
 }
 
 #[cfg(unix)]
@@ -2816,7 +3184,11 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
                 Some('=')
             } else if file_type.is_fifo() {
                 Some('|')
-            } else if file_type.is_file() && file_is_executable(path.md(out).as_ref().unwrap()) {
+            } else if file_type.is_file()
+                // Safe unwrapping if the file was removed between listing and display
+                // See https://github.com/uutils/coreutils/issues/5371
+                && path.get_metadata(out).is_some_and(file_is_executable)
+            {
                 Some('*')
             } else {
                 None
@@ -2837,48 +3209,49 @@ fn classify_file(path: &PathData, out: &mut BufWriter<Stdout>) -> Option<char> {
 /// * `config.format` to display symlink targets if `Format::Long`. This function is also
 ///   responsible for coloring symlink target names if `config.color` is specified.
 /// * `config.context` to prepend security context to `name` if compiled with `feat_selinux`.
+/// * `config.hyperlink` decides whether to hyperlink the item
 ///
 /// 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(
+fn display_item_name(
     path: &PathData,
     config: &Config,
     prefix_context: Option<usize>,
     more_info: String,
-    out: &mut BufWriter<Stdout>,
-) -> Cell {
+    state: &mut ListState,
+    current_column: LazyCell<usize, Box<dyn FnOnce() -> usize + '_>>,
+) -> OsString {
     // This is our return value. We start by `&path.display_name` and modify it along the way.
     let mut name = escape_name(&path.display_name, &config.quoting_style);
 
-    // We need to keep track of the width ourselves instead of letting term_grid
-    // infer it because the color codes mess up term_grid's width calculation.
-    let mut width = name.width();
+    let is_wrap =
+        |namelen: usize| config.width != 0 && *current_column + namelen > config.width.into();
 
-    if let Some(ls_colors) = &config.color {
-        let md = path.md(out);
-        name = if md.is_some() {
-            color_name(name, &path.p_buf, md, ls_colors)
-        } else {
-            color_name(
-                name,
-                &path.p_buf,
-                path.p_buf.symlink_metadata().ok().as_ref(),
-                ls_colors,
-            )
-        };
+    if config.hyperlink {
+        name = create_hyperlink(&name, path);
+    }
+
+    if let Some(style_manager) = &mut state.style_manager {
+        let len = name.len();
+        name = color_name(
+            name,
+            path,
+            style_manager,
+            &mut state.out,
+            None,
+            is_wrap(len),
+        );
     }
 
     if config.format != Format::Long && !more_info.is_empty() {
-        // increment width here b/c name was given colors and name.width() is now the wrong
-        // size for display
-        width += more_info.width();
-        name = more_info + &name;
+        let old_name = name;
+        name = more_info.into();
+        name.push(&old_name);
     }
 
     if config.indicator_style != IndicatorStyle::None {
-        let sym = classify_file(path, out);
+        let sym = classify_file(path, &mut state.out);
 
         let char_opt = match config.indicator_style {
             IndicatorStyle::Classify => sym,
@@ -2900,65 +3273,64 @@ fn display_file_name(
         };
 
         if let Some(c) = char_opt {
-            name.push(c);
-            width += 1;
+            name.push(OsStr::new(&c.to_string()));
         }
     }
 
     if config.format == Format::Long
-        && path.file_type(out).is_some()
-        && path.file_type(out).unwrap().is_symlink()
+        && path.file_type(&mut state.out).is_some()
+        && path.file_type(&mut state.out).unwrap().is_symlink()
         && !path.must_dereference
     {
-        if let Ok(target) = path.p_buf.read_link() {
-            name.push_str(" -> ");
-
-            // We might as well color the symlink output after the arrow.
-            // This makes extra system calls, but provides important information that
-            // people run `ls -l --color` are very interested in.
-            if let Some(ls_colors) = &config.color {
-                // We get the absolute path to be able to construct PathData with valid Metadata.
-                // This is because relative symlinks will fail to get_metadata.
-                let mut absolute_target = target.clone();
-                if target.is_relative() {
-                    if let Some(parent) = path.p_buf.parent() {
-                        absolute_target = parent.join(absolute_target);
+        match path.p_buf.read_link() {
+            Ok(target) => {
+                name.push(" -> ");
+
+                // We might as well color the symlink output after the arrow.
+                // This makes extra system calls, but provides important information that
+                // people run `ls -l --color` are very interested in.
+                if let Some(style_manager) = &mut state.style_manager {
+                    // We get the absolute path to be able to construct PathData with valid Metadata.
+                    // This is because relative symlinks will fail to get_metadata.
+                    let mut absolute_target = target.clone();
+                    if target.is_relative() {
+                        if let Some(parent) = path.p_buf.parent() {
+                            absolute_target = parent.join(absolute_target);
+                        }
                     }
-                }
 
-                let target_data = PathData::new(absolute_target, None, None, config, false);
+                    let target_data = PathData::new(absolute_target, None, None, config, false);
 
-                // If we have a symlink to a valid file, we use the metadata of said file.
-                // Because we use an absolute path, we can assume this is guaranteed to exist.
-                // Otherwise, we use path.md(), which will guarantee we color to the same
-                // color of non-existent symlinks according to style_for_path_with_metadata.
-                if path.md(out).is_none()
-                    && get_metadata(target_data.p_buf.as_path(), target_data.must_dereference)
+                    // If we have a symlink to a valid file, we use the metadata of said file.
+                    // Because we use an absolute path, we can assume this is guaranteed to exist.
+                    // Otherwise, we use path.md(), which will guarantee we color to the same
+                    // color of non-existent symlinks according to style_for_path_with_metadata.
+                    if path.get_metadata(&mut state.out).is_none()
+                        && get_metadata_with_deref_opt(
+                            target_data.p_buf.as_path(),
+                            target_data.must_dereference,
+                        )
                         .is_err()
-                {
-                    name.push_str(&path.p_buf.read_link().unwrap().to_string_lossy());
+                    {
+                        name.push(path.p_buf.read_link().unwrap());
+                    } else {
+                        name.push(color_name(
+                            escape_name(target.as_os_str(), &config.quoting_style),
+                            path,
+                            style_manager,
+                            &mut state.out,
+                            Some(&target_data),
+                            is_wrap(name.len()),
+                        ));
+                    }
                 } else {
-                    // Use fn get_metadata instead of md() here and above because ls
-                    // should not exit with an err, if we are unable to obtain the target_metadata
-                    let target_metadata = match get_metadata(
-                        target_data.p_buf.as_path(),
-                        target_data.must_dereference,
-                    ) {
-                        Ok(md) => md,
-                        Err(_) => path.md(out).unwrap().to_owned(),
-                    };
-
-                    name.push_str(&color_name(
-                        escape_name(target.as_os_str(), &config.quoting_style),
-                        &target_data.p_buf,
-                        Some(&target_metadata),
-                        ls_colors,
-                    ));
+                    // If no coloring is required, we just use target as is.
+                    // Apply the right quoting
+                    name.push(escape_name(target.as_os_str(), &config.quoting_style));
                 }
-            } else {
-                // If no coloring is required, we just use target as is.
-                // Apply the right quoting
-                name.push_str(&escape_name(target.as_os_str(), &config.quoting_style));
+            }
+            Err(err) => {
+                show!(LsError::IOErrorContext(path.p_buf.clone(), err, false));
             }
         }
     }
@@ -2968,28 +3340,48 @@ fn display_file_name(
     if config.context {
         if let Some(pad_count) = prefix_context {
             let security_context = if matches!(config.format, Format::Commas) {
-                path.security_context.to_owned()
+                path.security_context.clone()
             } else {
                 pad_left(&path.security_context, pad_count)
             };
-            name = format!("{security_context} {name}");
-            width += security_context.len() + 1;
+            let old_name = name;
+            name = format!("{security_context} ").into();
+            name.push(old_name);
         }
     }
 
-    Cell {
-        contents: name,
-        width,
-    }
+    name
 }
 
-fn color_name(name: String, path: &Path, md: Option<&Metadata>, ls_colors: &LsColors) -> String {
-    match ls_colors.style_for_path_with_metadata(path, md) {
-        Some(style) => {
-            return style.to_nu_ansi_term_style().paint(name).to_string();
-        }
-        None => name,
-    }
+fn create_hyperlink(name: &OsStr, path: &PathData) -> OsString {
+    let hostname = hostname::get().unwrap_or_else(|_| OsString::from(""));
+    let hostname = hostname.to_string_lossy();
+
+    let absolute_path = fs::canonicalize(&path.p_buf).unwrap_or_default();
+    let absolute_path = absolute_path.to_string_lossy();
+
+    #[cfg(not(target_os = "windows"))]
+    let unencoded_chars = "_-.:~/";
+    #[cfg(target_os = "windows")]
+    let unencoded_chars = "_-.:~/\\";
+
+    // percentage encoding of path
+    let absolute_path: String = absolute_path
+        .chars()
+        .map(|c| {
+            if c.is_alphanumeric() || unencoded_chars.contains(c) {
+                c.to_string()
+            } else {
+                format!("%{:02x}", c as u8)
+            }
+        })
+        .collect();
+
+    // \x1b = ESC, \x07 = BEL
+    let mut ret: OsString = format!("\x1b]8;;file://{hostname}{absolute_path}\x07").into();
+    ret.push(name);
+    ret.push("\x1b]8;;\x07");
+    ret
 }
 
 #[cfg(not(unix))]
@@ -3011,21 +3403,20 @@ fn display_inode(metadata: &Metadata) -> String {
 
 // This returns the SELinux security context as UTF8 `String`.
 // In the long term this should be changed to `OsStr`, see discussions at #2621/#2656
-#[allow(unused_variables)]
 fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -> String {
     let substitute_string = "?".to_string();
     // If we must dereference, ensure that the symlink is actually valid even if the system
     // does not support SELinux.
     // Conforms to the GNU coreutils where a dangling symlink results in exit code 1.
     if must_dereference {
-        match get_metadata(p_buf, must_dereference) {
+        match get_metadata_with_deref_opt(p_buf, must_dereference) {
             Err(err) => {
                 // The Path couldn't be dereferenced, so return early and set exit code 1
                 // to indicate a minor error
-                show!(LsError::IOErrorContext(err, p_buf.to_path_buf(), false));
+                show!(LsError::IOErrorContext(p_buf.to_path_buf(), err, false));
                 return substitute_string;
             }
-            Ok(md) => (),
+            Ok(_md) => (),
         }
     }
     if config.selinux_supported {
@@ -3066,7 +3457,7 @@ fn get_security_context(config: &Config, p_buf: &Path, must_dereference: bool) -
 fn calculate_padding_collection(
     items: &[PathData],
     config: &Config,
-    out: &mut BufWriter<Stdout>,
+    state: &mut ListState,
 ) -> PaddingCollection {
     let mut padding_collections = PaddingCollection {
         inode: 1,
@@ -3083,7 +3474,7 @@ fn calculate_padding_collection(
     for item in items {
         #[cfg(unix)]
         if config.inode {
-            let inode_len = if let Some(md) = item.md(out) {
+            let inode_len = if let Some(md) = item.get_metadata(&mut state.out) {
                 display_inode(md).len()
             } else {
                 continue;
@@ -3092,7 +3483,7 @@ fn calculate_padding_collection(
         }
 
         if config.alloc_size {
-            if let Some(md) = item.md(out) {
+            if let Some(md) = item.get_metadata(&mut state.out) {
                 let block_size_len = display_size(get_block_size(md, config), config).len();
                 padding_collections.block_size = block_size_len.max(padding_collections.block_size);
             }
@@ -3101,7 +3492,7 @@ fn calculate_padding_collection(
         if config.format == Format::Long {
             let context_len = item.security_context.len();
             let (link_count_len, uname_len, group_len, size_len, major_len, minor_len) =
-                display_dir_entry_size(item, config, out);
+                display_dir_entry_size(item, config, state);
             padding_collections.link_count = link_count_len.max(padding_collections.link_count);
             padding_collections.uname = uname_len.max(padding_collections.uname);
             padding_collections.group = group_len.max(padding_collections.group);
@@ -3117,7 +3508,7 @@ fn calculate_padding_collection(
                 padding_collections.minor = minor_len.max(padding_collections.minor);
                 padding_collections.size = size_len
                     .max(padding_collections.size)
-                    .max(padding_collections.major + padding_collections.minor + 2usize);
+                    .max(padding_collections.major);
             }
         }
     }
@@ -3129,7 +3520,7 @@ fn calculate_padding_collection(
 fn calculate_padding_collection(
     items: &[PathData],
     config: &Config,
-    out: &mut BufWriter<Stdout>,
+    state: &mut ListState,
 ) -> PaddingCollection {
     let mut padding_collections = PaddingCollection {
         link_count: 1,
@@ -3142,7 +3533,7 @@ fn calculate_padding_collection(
 
     for item in items {
         if config.alloc_size {
-            if let Some(md) = item.md(out) {
+            if let Some(md) = item.get_metadata(&mut state.out) {
                 let block_size_len = display_size(get_block_size(md, config), config).len();
                 padding_collections.block_size = block_size_len.max(padding_collections.block_size);
             }
@@ -3150,7 +3541,7 @@ fn calculate_padding_collection(
 
         let context_len = item.security_context.len();
         let (link_count_len, uname_len, group_len, size_len, _major_len, _minor_len) =
-            display_dir_entry_size(item, config, out);
+            display_dir_entry_size(item, config, state);
         padding_collections.link_count = link_count_len.max(padding_collections.link_count);
         padding_collections.uname = uname_len.max(padding_collections.uname);
         padding_collections.group = group_len.max(padding_collections.group);
@@ -3162,3 +3553,11 @@ fn calculate_padding_collection(
 
     padding_collections
 }
+
+fn os_str_starts_with(haystack: &OsStr, needle: &[u8]) -> bool {
+    os_str_as_bytes_lossy(haystack).starts_with(needle)
+}
+
+fn write_os_str<W: Write>(writer: &mut W, string: &OsStr) -> std::io::Result<()> {
+    writer.write_all(&os_str_as_bytes_lossy(string))
+}
diff --git a/src/uu/mkdir/Cargo.toml b/src/uu/mkdir/Cargo.toml
index c1a6ce2a863..77b664738c5 100644
--- a/src/uu/mkdir/Cargo.toml
+++ b/src/uu/mkdir/Cargo.toml
@@ -1,22 +1,28 @@
 [package]
 name = "uu_mkdir"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "mkdir ~ (uutils) create DIRECTORY"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mkdir"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/mkdir.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["fs", "mode"] }
+uucore = { workspace = true, features = ["fs", "mode", "fsxattr"] }
+
+[features]
+selinux = ["uucore/selinux"]
 
 [[bin]]
 name = "mkdir"
diff --git a/src/uu/mkdir/mkdir.md b/src/uu/mkdir/mkdir.md
index 1698842cd9c..f5dbb25440b 100644
--- a/src/uu/mkdir/mkdir.md
+++ b/src/uu/mkdir/mkdir.md
@@ -3,11 +3,11 @@
 <!-- spell-checker:ignore ugoa -->
 
 ```
-mkdir [OPTION]... [USER]
+mkdir [OPTION]... DIRECTORY...
 ```
 
 Create the given DIRECTORY(ies) if they do not exist
 
 ## After Help
 
-Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+'.
+Each MODE is of the form `[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+`.
diff --git a/src/uu/mkdir/src/mkdir.rs b/src/uu/mkdir/src/mkdir.rs
index 2044855e45e..adef62eee7a 100644
--- a/src/uu/mkdir/src/mkdir.rs
+++ b/src/uu/mkdir/src/mkdir.rs
@@ -7,7 +7,7 @@
 
 use clap::builder::ValueParser;
 use clap::parser::ValuesRef;
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
 #[cfg(not(windows))]
@@ -16,7 +16,7 @@ use uucore::error::{UResult, USimpleError};
 #[cfg(not(windows))]
 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};
+use uucore::{format_usage, help_about, help_section, help_usage, show_if_err};
 
 static DEFAULT_PERM: u32 = 0o777;
 
@@ -29,6 +29,26 @@ mod options {
     pub const PARENTS: &str = "parents";
     pub const VERBOSE: &str = "verbose";
     pub const DIRS: &str = "dirs";
+    pub const SELINUX: &str = "z";
+    pub const CONTEXT: &str = "context";
+}
+
+/// Configuration for directory creation.
+pub struct Config<'a> {
+    /// Create parent directories as needed.
+    pub recursive: bool,
+
+    /// File permissions (octal).
+    pub mode: u32,
+
+    /// Print message for each created directory.
+    pub verbose: bool,
+
+    /// Set SELinux security context.
+    pub set_selinux_context: bool,
+
+    /// Specific SELinux context.
+    pub context: Option<&'a String>,
 }
 
 #[cfg(windows)]
@@ -38,31 +58,27 @@ 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 777
     // Not tested on Windows
     let mut new_mode = DEFAULT_PERM;
-    match matches.get_one::<String>(options::MODE) {
-        Some(m) => {
-            for mode in m.split(',') {
-                if mode.contains(digits) {
-                    new_mode = mode::parse_numeric(new_mode, m, true)?;
+
+    if let Some(m) = matches.get_one::<String>(options::MODE) {
+        for mode in m.split(',') {
+            if mode.chars().any(|c| c.is_ascii_digit()) {
+                new_mode = mode::parse_numeric(new_mode, m, true)?;
+            } else {
+                let cmode = if mode_had_minus_prefix {
+                    // clap parsing is finished, now put prefix back
+                    format!("-{mode}")
                 } else {
-                    let cmode = if mode_had_minus_prefix {
-                        // clap parsing is finished, now put prefix back
-                        format!("-{mode}")
-                    } else {
-                        mode.to_string()
-                    };
-                    new_mode = mode::parse_symbolic(new_mode, &cmode, mode::get_umask(), true)?;
-                }
+                    mode.to_string()
+                };
+                new_mode = mode::parse_symbolic(new_mode, &cmode, mode::get_umask(), true)?;
             }
-            Ok(new_mode)
-        }
-        None => {
-            // If no mode argument is specified return the mode derived from umask
-            Ok(!mode::get_umask() & 0o0777)
         }
+        Ok(new_mode)
+    } else {
+        // If no mode argument is specified return the mode derived from umask
+        Ok(!mode::get_umask() & 0o0777)
     }
 }
 
@@ -95,15 +111,28 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let verbose = matches.get_flag(options::VERBOSE);
     let recursive = matches.get_flag(options::PARENTS);
 
+    // Extract the SELinux related flags and options
+    let set_selinux_context = matches.get_flag(options::SELINUX);
+    let context = matches.get_one::<String>(options::CONTEXT);
+
     match get_mode(&matches, mode_had_minus_prefix) {
-        Ok(mode) => exec(dirs, recursive, mode, verbose),
+        Ok(mode) => {
+            let config = Config {
+                recursive,
+                mode,
+                verbose,
+                set_selinux_context: set_selinux_context || context.is_some(),
+                context,
+            };
+            exec(dirs, &config)
+        }
         Err(f) => Err(USimpleError::new(1, f)),
     }
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -118,6 +147,7 @@ pub fn uu_app() -> Command {
                 .short('p')
                 .long(options::PARENTS)
                 .help("make parent directories as needed")
+                .overrides_with(options::PARENTS)
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -127,10 +157,20 @@ pub fn uu_app() -> Command {
                 .help("print a message for each printed directory")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::SELINUX)
+                .short('Z')
+                .help("set SELinux security context of each created directory to the default type")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(Arg::new(options::CONTEXT).long(options::CONTEXT).value_name("CTX").help(
+            "like -Z, or if CTX is specified then set the SELinux or SMACK security context to CTX",
+        ))
         .arg(
             Arg::new(options::DIRS)
                 .action(ArgAction::Append)
                 .num_args(1..)
+                .required(true)
                 .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::DirPath),
         )
@@ -139,34 +179,50 @@ pub fn uu_app() -> Command {
 /**
  * Create the list of new directories
  */
-fn exec(dirs: ValuesRef<OsString>, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
+fn exec(dirs: ValuesRef<OsString>, config: &Config) -> UResult<()> {
     for dir in dirs {
-        // Special case to match GNU's behavior:
-        // mkdir -p foo/. should work and just create foo/
-        // std::fs::create_dir("foo/."); fails in pure Rust
-        let path = if recursive {
-            dir_strip_dot_for_creation(&PathBuf::from(dir))
-        } else {
-            // Normal case
-            PathBuf::from(dir)
-        };
-        show_if_err!(mkdir(path.as_path(), recursive, mode, verbose));
+        let path_buf = PathBuf::from(dir);
+        let path = path_buf.as_path();
+
+        show_if_err!(mkdir(path, config));
     }
     Ok(())
 }
 
-fn mkdir(path: &Path, recursive: bool, mode: u32, verbose: bool) -> UResult<()> {
-    create_dir(path, recursive, verbose, false)?;
-    chmod(path, mode)
+/// Create directory at a given `path`.
+///
+/// ## Options
+///
+/// * `recursive` --- create parent directories for the `path`, if they do not
+///   exist.
+/// * `mode` --- file mode for the directories (not implemented on windows).
+/// * `verbose` --- print a message for each printed directory.
+///
+/// ## Trailing dot
+///
+/// To match the GNU behavior, a path with the last directory being a single dot
+/// (like `some/path/to/.`) is created (with the dot stripped).
+pub fn mkdir(path: &Path, config: &Config) -> UResult<()> {
+    if path.as_os_str().is_empty() {
+        return Err(USimpleError::new(
+            1,
+            "cannot create directory '': No such file or directory".to_owned(),
+        ));
+    }
+
+    // Special case to match GNU's behavior:
+    // mkdir -p foo/. should work and just create foo/
+    // std::fs::create_dir("foo/."); fails in pure Rust
+    let path_buf = dir_strip_dot_for_creation(path);
+    let path = path_buf.as_path();
+    create_dir(path, false, config)
 }
 
 #[cfg(any(unix, target_os = "redox"))]
 fn chmod(path: &Path, mode: u32) -> UResult<()> {
-    use std::fs::{set_permissions, Permissions};
+    use std::fs::{Permissions, set_permissions};
     use std::os::unix::fs::PermissionsExt;
-
     let mode = Permissions::from_mode(mode);
-
     set_permissions(path, mode)
         .map_err_context(|| format!("cannot set permissions {}", path.quote()))
 }
@@ -177,10 +233,12 @@ fn chmod(_path: &Path, _mode: u32) -> UResult<()> {
     Ok(())
 }
 
+// Return true if the directory at `path` has been created by this call.
 // `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 {
+fn create_dir(path: &Path, is_parent: bool, config: &Config) -> UResult<()> {
+    let path_exists = path.exists();
+    if path_exists && !config.recursive {
         return Err(USimpleError::new(
             1,
             format!("{}: File exists", path.display()),
@@ -190,31 +248,63 @@ fn create_dir(path: &Path, recursive: bool, verbose: bool, is_parent: bool) -> U
         return Ok(());
     }
 
-    if recursive {
+    if config.recursive {
         match path.parent() {
-            Some(p) => create_dir(p, recursive, verbose, true)?,
+            Some(p) => create_dir(p, true, config)?,
             None => {
                 USimpleError::new(1, "failed to create whole tree");
             }
         }
     }
+
     match std::fs::create_dir(path) {
         Ok(()) => {
-            if verbose {
+            if config.verbose {
                 println!(
                     "{}: created directory {}",
                     uucore::util_name(),
                     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)?;
+
+            #[cfg(all(unix, target_os = "linux"))]
+            let new_mode = if path_exists {
+                config.mode
+            } else {
+                // TODO: Make this macos and freebsd compatible by creating a function to get permission bits from
+                // acl in extended attributes
+                let acl_perm_bits = uucore::fsxattr::get_acl_perm_bits_from_xattr(path);
+
+                if is_parent {
+                    (!mode::get_umask() & 0o777) | 0o300 | acl_perm_bits
+                } else {
+                    config.mode | acl_perm_bits
+                }
+            };
+            #[cfg(all(unix, not(target_os = "linux")))]
+            let new_mode = if is_parent {
+                (!mode::get_umask() & 0o777) | 0o300
+            } else {
+                config.mode
+            };
+            #[cfg(windows)]
+            let new_mode = config.mode;
+
+            chmod(path, new_mode)?;
+
+            // Apply SELinux context if requested
+            #[cfg(feature = "selinux")]
+            if config.set_selinux_context && uucore::selinux::is_selinux_enabled() {
+                if let Err(e) = uucore::selinux::set_selinux_security_context(path, config.context)
+                {
+                    let _ = std::fs::remove_dir(path);
+                    return Err(USimpleError::new(1, e.to_string()));
+                }
             }
+
             Ok(())
         }
+
         Err(_) if path.is_dir() => Ok(()),
         Err(e) => Err(e.into()),
     }
diff --git a/src/uu/mkfifo/Cargo.toml b/src/uu/mkfifo/Cargo.toml
index 0c28f52de79..bb87cc80e64 100644
--- a/src/uu/mkfifo/Cargo.toml
+++ b/src/uu/mkfifo/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_mkfifo"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "mkfifo ~ (uutils) create FIFOs (named pipes)"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mkfifo"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/mkfifo.rs"
@@ -17,7 +20,10 @@ path = "src/mkfifo.rs"
 [dependencies]
 clap = { workspace = true }
 libc = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["fs", "mode"] }
+
+[features]
+selinux = ["uucore/selinux"]
 
 [[bin]]
 name = "mkfifo"
diff --git a/src/uu/mkfifo/src/mkfifo.rs b/src/uu/mkfifo/src/mkfifo.rs
index dc1f876fcf1..24c057ebc94 100644
--- a/src/uu/mkfifo/src/mkfifo.rs
+++ b/src/uu/mkfifo/src/mkfifo.rs
@@ -3,9 +3,11 @@
 // 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, Command};
+use clap::{Arg, ArgAction, Command, value_parser};
 use libc::mkfifo;
 use std::ffi::CString;
+use std::fs;
+use std::os::unix::fs::PermissionsExt;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage, show};
@@ -15,48 +17,67 @@ static ABOUT: &str = help_about!("mkfifo.md");
 
 mod options {
     pub static MODE: &str = "mode";
-    pub static SE_LINUX_SECURITY_CONTEXT: &str = "Z";
+    pub static SELINUX: &str = "Z";
     pub static CONTEXT: &str = "context";
     pub static FIFO: &str = "fifo";
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
-    if matches.contains_id(options::CONTEXT) {
-        return Err(USimpleError::new(1, "--context is not implemented"));
-    }
-    if matches.get_flag(options::SE_LINUX_SECURITY_CONTEXT) {
-        return Err(USimpleError::new(1, "-Z is not implemented"));
-    }
-
     let mode = match matches.get_one::<String>(options::MODE) {
+        // if mode is passed, ignore umask
         Some(m) => match usize::from_str_radix(m, 8) {
             Ok(m) => m,
             Err(e) => return Err(USimpleError::new(1, format!("invalid mode: {e}"))),
         },
-        None => 0o666,
+        // Default value + umask if present
+        None => 0o666 & !(uucore::mode::get_umask() as usize),
     };
 
     let fifos: Vec<String> = match matches.get_many::<String>(options::FIFO) {
-        Some(v) => v.clone().map(|s| s.to_owned()).collect(),
+        Some(v) => v.cloned().collect(),
         None => return Err(USimpleError::new(1, "missing operand")),
     };
 
     for f in fifos {
         let err = unsafe {
             let name = CString::new(f.as_bytes()).unwrap();
-            mkfifo(name.as_ptr(), mode as libc::mode_t)
+            mkfifo(name.as_ptr(), 0o666)
         };
         if err == -1 {
             show!(USimpleError::new(
                 1,
-                format!("cannot create fifo {}: File exists", f.quote())
+                format!("cannot create fifo {}: File exists", f.quote()),
             ));
         }
+
+        // Explicitly set the permissions to ignore umask
+        if let Err(e) = fs::set_permissions(&f, fs::Permissions::from_mode(mode as u32)) {
+            return Err(USimpleError::new(
+                1,
+                format!("cannot set permissions on {}: {e}", f.quote()),
+            ));
+        }
+
+        // Apply SELinux context if requested
+        #[cfg(feature = "selinux")]
+        {
+            // Extract the SELinux related flags and options
+            let set_selinux_context = matches.get_flag(options::SELINUX);
+            let context = matches.get_one::<String>(options::CONTEXT);
+
+            if set_selinux_context || context.is_some() {
+                use std::path::Path;
+                if let Err(e) =
+                    uucore::selinux::set_selinux_security_context(Path::new(&f), context)
+                {
+                    let _ = fs::remove_file(f);
+                    return Err(USimpleError::new(1, e.to_string()));
+                }
+            }
+        }
     }
 
     Ok(())
@@ -64,7 +85,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
@@ -73,11 +94,10 @@ pub fn uu_app() -> Command {
                 .short('m')
                 .long(options::MODE)
                 .help("file permissions for the fifo")
-                .default_value("0666")
                 .value_name("MODE"),
         )
         .arg(
-            Arg::new(options::SE_LINUX_SECURITY_CONTEXT)
+            Arg::new(options::SELINUX)
                 .short('Z')
                 .help("set the SELinux security context to default type")
                 .action(ArgAction::SetTrue),
@@ -86,6 +106,9 @@ pub fn uu_app() -> Command {
             Arg::new(options::CONTEXT)
                 .long(options::CONTEXT)
                 .value_name("CTX")
+                .value_parser(value_parser!(String))
+                .num_args(0..=1)
+                .require_equals(true)
                 .help(
                     "like -Z, or if CTX is specified then set the SELinux \
                     or SMACK security context to CTX",
diff --git a/src/uu/mknod/Cargo.toml b/src/uu/mknod/Cargo.toml
index a230bec74ce..49f539eb870 100644
--- a/src/uu/mknod/Cargo.toml
+++ b/src/uu/mknod/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_mknod"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "mknod ~ (uutils) create special file NAME of TYPE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mknod"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 name = "uu_mknod"
@@ -20,6 +23,9 @@ clap = { workspace = true }
 libc = { workspace = true }
 uucore = { workspace = true, features = ["mode"] }
 
+[features]
+selinux = ["uucore/selinux"]
+
 [[bin]]
 name = "mknod"
 path = "src/main.rs"
diff --git a/src/uu/mknod/src/mknod.rs b/src/uu/mknod/src/mknod.rs
index ceafd235b01..076e639ccfb 100644
--- a/src/uu/mknod/src/mknod.rs
+++ b/src/uu/mknod/src/mknod.rs
@@ -5,13 +5,13 @@
 
 // spell-checker:ignore (ToDO) parsemode makedev sysmacros perror IFBLK IFCHR IFIFO
 
-use clap::{crate_version, value_parser, Arg, ArgMatches, Command};
-use libc::{dev_t, mode_t};
+use clap::{Arg, ArgAction, Command, value_parser};
 use libc::{S_IFBLK, S_IFCHR, S_IFIFO, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR};
+use libc::{dev_t, mode_t};
 use std::ffi::CString;
 
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UResult, USimpleError, UUsageError};
+use uucore::error::{UResult, USimpleError, UUsageError, set_exit_code};
 use uucore::{format_usage, help_about, help_section, help_usage};
 
 const ABOUT: &str = help_about!("mknod.md");
@@ -20,17 +20,21 @@ 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;
 
+mod options {
+    pub const MODE: &str = "mode";
+    pub const TYPE: &str = "type";
+    pub const MAJOR: &str = "major";
+    pub const MINOR: &str = "minor";
+    pub const SELINUX: &str = "z";
+    pub const CONTEXT: &str = "context";
+}
+
 #[inline(always)]
 fn makedev(maj: u64, min: u64) -> dev_t {
     // pick up from <sys/sysmacros.h>
     ((min & 0xff) | ((maj & 0xfff) << 8) | ((min & !0xff) << 12) | ((maj & !0xfff) << 32)) as dev_t
 }
 
-#[cfg(windows)]
-fn _mknod(file_name: &str, mode: mode_t, dev: dev_t) -> i32 {
-    panic!("Unsupported for windows platform")
-}
-
 #[derive(Clone, PartialEq)]
 enum FileType {
     Block,
@@ -38,18 +42,40 @@ enum FileType {
     Fifo,
 }
 
-#[cfg(unix)]
-fn _mknod(file_name: &str, mode: mode_t, dev: dev_t) -> i32 {
+impl FileType {
+    fn as_mode(&self) -> mode_t {
+        match self {
+            Self::Block => S_IFBLK,
+            Self::Character => S_IFCHR,
+            Self::Fifo => S_IFIFO,
+        }
+    }
+}
+
+/// Configuration for directory creation.
+pub struct Config<'a> {
+    pub mode: mode_t,
+
+    pub dev: dev_t,
+
+    /// Set SELinux security context.
+    pub set_selinux_context: bool,
+
+    /// Specific SELinux context.
+    pub context: Option<&'a String>,
+}
+
+fn mknod(file_name: &str, config: Config) -> i32 {
     let c_str = CString::new(file_name).expect("Failed to convert to CString");
 
     // the user supplied a mode
-    let set_umask = mode & MODE_RW_UGO != MODE_RW_UGO;
+    let set_umask = config.mode & MODE_RW_UGO != MODE_RW_UGO;
 
     unsafe {
         // store prev umask
         let last_umask = if set_umask { libc::umask(0) } else { 0 };
 
-        let errno = libc::mknod(c_str.as_ptr(), mode, dev);
+        let errno = libc::mknod(c_str.as_ptr(), config.mode, config.dev);
 
         // set umask back to original value
         if set_umask {
@@ -62,70 +88,83 @@ fn _mknod(file_name: &str, mode: mode_t, dev: dev_t) -> i32 {
             // shows the error from the mknod syscall
             libc::perror(c_str.as_ptr());
         }
+
+        // Apply SELinux context if requested
+        #[cfg(feature = "selinux")]
+        if config.set_selinux_context {
+            if let Err(e) = uucore::selinux::set_selinux_security_context(
+                std::path::Path::new(file_name),
+                config.context,
+            ) {
+                // if it fails, delete the file
+                let _ = std::fs::remove_dir(file_name);
+                eprintln!("{}: {}", uucore::util_name(), e);
+                return 1;
+            }
+        }
+
         errno
     }
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-    // Linux-specific options, not implemented
-    // opts.optflag("Z", "", "set the SELinux security context to default type");
-    // opts.optopt("", "context", "like -Z, or if CTX is specified then set the SELinux or SMACK security context to CTX");
-
     let matches = uu_app().try_get_matches_from(args)?;
 
-    let mode = get_mode(&matches).map_err(|e| USimpleError::new(1, e))?;
+    let file_type = matches.get_one::<FileType>("type").unwrap();
+    let mode = get_mode(matches.get_one::<String>("mode")).map_err(|e| USimpleError::new(1, e))?
+        | file_type.as_mode();
 
     let file_name = matches
         .get_one::<String>("name")
         .expect("Missing argument 'NAME'");
 
-    let file_type = matches.get_one::<FileType>("type").unwrap();
-
-    if *file_type == FileType::Fifo {
-        if matches.contains_id("major") || matches.contains_id("minor") {
-            Err(UUsageError::new(
+    // Extract the SELinux related flags and options
+    let set_selinux_context = matches.get_flag(options::SELINUX);
+    let context = matches.get_one::<String>(options::CONTEXT);
+
+    let dev = match (
+        file_type,
+        matches.get_one::<u64>(options::MAJOR),
+        matches.get_one::<u64>(options::MINOR),
+    ) {
+        (FileType::Fifo, None, None) => 0,
+        (FileType::Fifo, _, _) => {
+            return Err(UUsageError::new(
                 1,
                 "Fifos do not have major and minor device numbers.",
-            ))
-        } else {
-            let exit_code = _mknod(file_name, S_IFIFO | mode, 0);
-            set_exit_code(exit_code);
-            Ok(())
+            ));
         }
-    } else {
-        match (
-            matches.get_one::<u64>("major"),
-            matches.get_one::<u64>("minor"),
-        ) {
-            (_, None) | (None, _) => Err(UUsageError::new(
+        (_, Some(&major), Some(&minor)) => makedev(major, minor),
+        _ => {
+            return Err(UUsageError::new(
                 1,
                 "Special files require major and minor device numbers.",
-            )),
-            (Some(&major), Some(&minor)) => {
-                let dev = makedev(major, minor);
-                let exit_code = match file_type {
-                    FileType::Block => _mknod(file_name, S_IFBLK | mode, dev),
-                    FileType::Character => _mknod(file_name, S_IFCHR | mode, dev),
-                    _ => unreachable!("file_type was validated to be only block or character"),
-                };
-                set_exit_code(exit_code);
-                Ok(())
-            }
+            ));
         }
-    }
+    };
+
+    let config = Config {
+        mode,
+        dev,
+        set_selinux_context: set_selinux_context || context.is_some(),
+        context,
+    };
+
+    let exit_code = mknod(file_name, config);
+    set_exit_code(exit_code);
+    Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
         .about(ABOUT)
         .infer_long_args(true)
         .arg(
-            Arg::new("mode")
+            Arg::new(options::MODE)
                 .short('m')
                 .long("mode")
                 .value_name("MODE")
@@ -139,28 +178,43 @@ pub fn uu_app() -> Command {
                 .value_hint(clap::ValueHint::AnyPath),
         )
         .arg(
-            Arg::new("type")
+            Arg::new(options::TYPE)
                 .value_name("TYPE")
                 .help("type of the new file (b, c, u or p)")
                 .required(true)
                 .value_parser(parse_type),
         )
         .arg(
-            Arg::new("major")
-                .value_name("MAJOR")
+            Arg::new(options::MAJOR)
+                .value_name(options::MAJOR)
                 .help("major file type")
                 .value_parser(value_parser!(u64)),
         )
         .arg(
-            Arg::new("minor")
-                .value_name("MINOR")
+            Arg::new(options::MINOR)
+                .value_name(options::MINOR)
                 .help("minor file type")
                 .value_parser(value_parser!(u64)),
         )
+        .arg(
+            Arg::new(options::SELINUX)
+                .short('Z')
+                .help("set SELinux security context of each created directory to the default type")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::CONTEXT)
+                .long(options::CONTEXT)
+                .value_name("CTX")
+                .value_parser(value_parser!(String))
+                .num_args(0..=1)
+                .require_equals(true)
+                .help("like -Z, or if CTX is specified then set the SELinux or SMACK security context to CTX")
+        )
 }
 
-fn get_mode(matches: &ArgMatches) -> Result<mode_t, String> {
-    match matches.get_one::<String>("mode") {
+fn get_mode(str_mode: Option<&String>) -> Result<mode_t, String> {
+    match str_mode {
         None => Ok(MODE_RW_UGO),
         Some(str_mode) => uucore::mode::parse_mode(str_mode)
             .map_err(|e| format!("invalid mode ({e})"))
diff --git a/src/uu/mknod/src/parsemode.rs b/src/uu/mknod/src/parsemode.rs
deleted file mode 100644
index adacaa45bcd..00000000000
--- a/src/uu/mknod/src/parsemode.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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.
-// spell-checker:ignore (path) osrelease
-
-use libc::{mode_t, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR};
-
-use uucore::mode;
-
-pub const MODE_RW_UGO: mode_t = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-
-pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
-    let arr: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-    let result = if mode.contains(arr) {
-        mode::parse_numeric(MODE_RW_UGO as u32, mode)
-    } else {
-        mode::parse_symbolic(MODE_RW_UGO as u32, mode, true)
-    };
-    result.map(|mode| mode as mode_t)
-}
-
-#[cfg(test)]
-mod test {
-    /// Test if the program is running under WSL
-    // ref: <https://github.com/microsoft/WSL/issues/4555> @@ <https://archive.is/dP0bz>
-    // ToDO: test on WSL2 which likely doesn't need special handling; plan change to `is_wsl_1()` if WSL2 is less needy
-    pub fn is_wsl() -> bool {
-        #[cfg(target_os = "linux")]
-        {
-            if let Ok(b) = std::fs::read("/proc/sys/kernel/osrelease") {
-                if let Ok(s) = std::str::from_utf8(&b) {
-                    let a = s.to_ascii_lowercase();
-                    return a.contains("microsoft") || a.contains("wsl");
-                }
-            }
-        }
-        false
-    }
-
-    #[test]
-    fn symbolic_modes() {
-        assert_eq!(super::parse_mode("u+x").unwrap(), 0o766);
-        assert_eq!(
-            super::parse_mode("+x").unwrap(),
-            if is_wsl() { 0o776 } else { 0o777 }
-        );
-        assert_eq!(super::parse_mode("a-w").unwrap(), 0o444);
-        assert_eq!(super::parse_mode("g-r").unwrap(), 0o626);
-    }
-
-    #[test]
-    fn numeric_modes() {
-        assert_eq!(super::parse_mode("644").unwrap(), 0o644);
-        assert_eq!(super::parse_mode("+100").unwrap(), 0o766);
-        assert_eq!(super::parse_mode("-4").unwrap(), 0o662);
-    }
-}
diff --git a/src/uu/mktemp/Cargo.toml b/src/uu/mktemp/Cargo.toml
index 5dbc8492a0b..2b3f798e1bc 100644
--- a/src/uu/mktemp/Cargo.toml
+++ b/src/uu/mktemp/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_mktemp"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "mktemp ~ (uutils) create and display a temporary file or directory from TEMPLATE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mktemp"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/mktemp.rs"
@@ -18,6 +21,7 @@ path = "src/mktemp.rs"
 clap = { workspace = true }
 rand = { workspace = true }
 tempfile = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true }
 
 [[bin]]
diff --git a/src/uu/mktemp/src/mktemp.rs b/src/uu/mktemp/src/mktemp.rs
index 77ef5fcbe22..d689115a6c6 100644
--- a/src/uu/mktemp/src/mktemp.rs
+++ b/src/uu/mktemp/src/mktemp.rs
@@ -5,17 +5,16 @@
 
 // spell-checker:ignore (paths) GPGHome findxs
 
-use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
-use uucore::display::{println_verbatim, Quotable};
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::ValueParser};
+use uucore::display::{Quotable, println_verbatim};
 use uucore::error::{FromIo, UError, UResult, UUsageError};
 use uucore::{format_usage, help_about, help_usage};
 
 use std::env;
-use std::error::Error;
-use std::fmt::Display;
+use std::ffi::OsStr;
 use std::io::ErrorKind;
 use std::iter;
-use std::path::{Path, PathBuf, MAIN_SEPARATOR};
+use std::path::{MAIN_SEPARATOR, Path, PathBuf};
 
 #[cfg(unix)]
 use std::fs;
@@ -24,6 +23,7 @@ use std::os::unix::prelude::PermissionsExt;
 
 use rand::Rng;
 use tempfile::Builder;
+use thiserror::Error;
 
 const ABOUT: &str = help_about!("mktemp.md");
 const USAGE: &str = help_usage!("mktemp.md");
@@ -45,21 +45,35 @@ const TMPDIR_ENV_VAR: &str = "TMPDIR";
 #[cfg(windows)]
 const TMPDIR_ENV_VAR: &str = "TMP";
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum MkTempError {
+    #[error("could not persist file {path}", path = .0.quote())]
     PersistError(PathBuf),
+
+    #[error("with --suffix, template {template} must end in X", template = .0.quote())]
     MustEndInX(String),
+
+    #[error("too few X's in template {template}", template = .0.quote())]
     TooFewXs(String),
 
     /// The template prefix contains a path separator (e.g. `"a/bXXX"`).
+    #[error("invalid template, {template}, contains directory separator", template = .0.quote())]
     PrefixContainsDirSeparator(String),
 
     /// The template suffix contains a path separator (e.g. `"XXXa/b"`).
+    #[error("invalid suffix {suffix}, contains directory separator", suffix = .0.quote())]
     SuffixContainsDirSeparator(String),
+
+    #[error("invalid template, {template}; with --tmpdir, it may not be absolute", template = .0.quote())]
     InvalidTemplate(String),
+
+    #[error("too many templates")]
     TooManyTemplates,
 
     /// When a specified temporary directory could not be found.
+    #[error("failed to create {template_type} via template {template}: No such file or directory",
+            template_type = .0,
+            template = .1.quote())]
     NotFound(String, String),
 }
 
@@ -69,75 +83,35 @@ impl UError for MkTempError {
     }
 }
 
-impl Error for MkTempError {}
-
-impl Display for MkTempError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use MkTempError::*;
-        match self {
-            PersistError(p) => write!(f, "could not persist file {}", p.quote()),
-            MustEndInX(s) => write!(f, "with --suffix, template {} must end in X", s.quote()),
-            TooFewXs(s) => write!(f, "too few X's in template {}", s.quote()),
-            PrefixContainsDirSeparator(s) => {
-                write!(
-                    f,
-                    "invalid template, {}, contains directory separator",
-                    s.quote()
-                )
-            }
-            SuffixContainsDirSeparator(s) => {
-                write!(
-                    f,
-                    "invalid suffix {}, contains directory separator",
-                    s.quote()
-                )
-            }
-            InvalidTemplate(s) => write!(
-                f,
-                "invalid template, {}; with --tmpdir, it may not be absolute",
-                s.quote()
-            ),
-            TooManyTemplates => {
-                write!(f, "too many templates")
-            }
-            NotFound(template_type, s) => write!(
-                f,
-                "failed to create {} via template {}: No such file or directory",
-                template_type,
-                s.quote()
-            ),
-        }
-    }
-}
-
 /// Options parsed from the command-line.
 ///
 /// This provides a layer of indirection between the application logic
 /// and the argument parsing library `clap`, allowing each to vary
 /// independently.
-struct Options {
+#[derive(Clone)]
+pub struct Options {
     /// Whether to create a temporary directory instead of a file.
-    directory: bool,
+    pub directory: bool,
 
     /// Whether to just print the name of a file that would have been created.
-    dry_run: bool,
+    pub dry_run: bool,
 
     /// Whether to suppress file creation error messages.
-    quiet: bool,
+    pub quiet: bool,
 
     /// The directory in which to create the temporary file.
     ///
     /// If `None`, the file will be created in the current directory.
-    tmpdir: Option<PathBuf>,
+    pub tmpdir: Option<PathBuf>,
 
     /// The suffix to append to the temporary file, if any.
-    suffix: Option<String>,
+    pub suffix: Option<String>,
 
     /// Whether to treat the template argument as a single file path component.
-    treat_as_template: bool,
+    pub treat_as_template: bool,
 
     /// The template to use for the name of the temporary file.
-    template: String,
+    pub template: String,
 }
 
 impl Options {
@@ -192,7 +166,7 @@ impl Options {
 /// `num_rand_chars`.
 struct Params {
     /// The directory that will contain the temporary file.
-    directory: String,
+    directory: PathBuf,
 
     /// The (non-random) prefix of the temporary file.
     prefix: String,
@@ -234,8 +208,13 @@ impl Params {
         let (i, j) = match find_last_contiguous_block_of_xs(&options.template) {
             None => {
                 let s = match options.suffix {
+                    // If a suffix is specified, the error message includes the template without the suffix.
+                    Some(_) => options
+                        .template
+                        .chars()
+                        .take(options.template.len())
+                        .collect::<String>(),
                     None => options.template,
-                    Some(s) => format!("{}{}", options.template, s),
                 };
                 return Err(MkTempError::TooFewXs(s));
             }
@@ -297,7 +276,7 @@ impl Params {
         let num_rand_chars = j - i;
 
         Ok(Self {
-            directory,
+            directory: directory.into(),
             prefix,
             num_rand_chars,
             suffix,
@@ -307,8 +286,7 @@ impl Params {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
+    let args: Vec<_> = args.collect();
     let matches = match uu_app().try_get_matches_from(&args) {
         Ok(m) => m,
         Err(e) => {
@@ -332,7 +310,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         // If POSIXLY_CORRECT was set, template MUST be the last argument.
         if matches.contains_id(ARG_TEMPLATE) {
             // Template argument was provided, check if was the last one.
-            if args.last().unwrap() != &options.template {
+            if args.last().unwrap() != OsStr::new(&options.template) {
                 return Err(Box::new(MkTempError::TooManyTemplates));
             }
         }
@@ -357,17 +335,18 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         exec(&tmpdir, &prefix, rand, &suffix, make_dir)
     };
 
-    if suppress_file_err {
+    let res = if suppress_file_err {
         // Mapping all UErrors to ExitCodes prevents the errors from being printed
         res.map_err(|e| e.code().into())
     } else {
         res
-    }
+    };
+    println_verbatim(res?).map_err_context(|| "failed to print directory name".to_owned())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -441,16 +420,16 @@ pub fn uu_app() -> Command {
         .arg(Arg::new(ARG_TEMPLATE).num_args(..=1))
 }
 
-pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<()> {
+fn dry_exec(tmpdir: &Path, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
     let len = prefix.len() + suffix.len() + rand;
     let mut buf = Vec::with_capacity(len);
     buf.extend(prefix.as_bytes());
-    buf.extend(iter::repeat(b'X').take(rand));
+    buf.extend(iter::repeat_n(b'X', rand));
     buf.extend(suffix.as_bytes());
 
     // Randomize.
     let bytes = &mut buf[prefix.len()..prefix.len() + rand];
-    rand::thread_rng().fill(bytes);
+    rand::rng().fill(bytes);
     for byte in bytes {
         *byte = match *byte % 62 {
             v @ 0..=9 => v + b'0',
@@ -462,7 +441,7 @@ pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResul
     // We guarantee utf8.
     let buf = String::from_utf8(buf).unwrap();
     let tmpdir = Path::new(tmpdir).join(buf);
-    println_verbatim(tmpdir).map_err_context(|| "failed to print directory name".to_owned())
+    Ok(tmpdir)
 }
 
 /// Create a temporary directory with the given parameters.
@@ -476,19 +455,25 @@ pub fn dry_exec(tmpdir: &str, prefix: &str, rand: usize, suffix: &str) -> UResul
 ///
 /// If the temporary directory could not be written to disk or if the
 /// given directory `dir` does not exist.
-fn make_temp_dir(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
+fn make_temp_dir(dir: &Path, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
     let mut builder = Builder::new();
     builder.prefix(prefix).rand_bytes(rand).suffix(suffix);
+
+    // On *nix platforms grant read-write-execute for owner only.
+    // The directory is created with these permission at creation time, using mkdir(3) syscall.
+    // This is not relevant on Windows systems. See: https://docs.rs/tempfile/latest/tempfile/#security
+    // `fs` is not imported on Windows anyways.
+    #[cfg(not(windows))]
+    builder.permissions(fs::Permissions::from_mode(0o700));
+
     match builder.tempdir_in(dir) {
         Ok(d) => {
-            // `into_path` consumes the TempDir without removing it
-            let path = d.into_path();
-            #[cfg(not(windows))]
-            fs::set_permissions(&path, fs::Permissions::from_mode(0o700))?;
+            // `keep` consumes the TempDir without removing it
+            let path = d.keep();
             Ok(path)
         }
         Err(e) if e.kind() == ErrorKind::NotFound => {
-            let filename = format!("{}{}{}", prefix, "X".repeat(rand), suffix);
+            let filename = format!("{prefix}{}{suffix}", "X".repeat(rand));
             let path = Path::new(dir).join(filename);
             let s = path.display().to_string();
             Err(MkTempError::NotFound("directory".to_string(), s).into())
@@ -508,7 +493,7 @@ fn make_temp_dir(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<
 ///
 /// If the file could not be written to disk or if the directory does
 /// not exist.
-fn make_temp_file(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
+fn make_temp_file(dir: &Path, prefix: &str, rand: usize, suffix: &str) -> UResult<PathBuf> {
     let mut builder = Builder::new();
     builder.prefix(prefix).rand_bytes(rand).suffix(suffix);
     match builder.tempfile_in(dir) {
@@ -518,7 +503,7 @@ fn make_temp_file(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult
             Err(e) => Err(MkTempError::PersistError(e.file.path().to_path_buf()).into()),
         },
         Err(e) if e.kind() == ErrorKind::NotFound => {
-            let filename = format!("{}{}{}", prefix, "X".repeat(rand), suffix);
+            let filename = format!("{prefix}{}{suffix}", "X".repeat(rand));
             let path = Path::new(dir).join(filename);
             let s = path.display().to_string();
             Err(MkTempError::NotFound("file".to_string(), s).into())
@@ -527,7 +512,7 @@ fn make_temp_file(dir: &str, prefix: &str, rand: usize, suffix: &str) -> UResult
     }
 }
 
-fn exec(dir: &str, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> UResult<()> {
+fn exec(dir: &Path, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> UResult<PathBuf> {
     let path = if make_dir {
         make_temp_dir(dir, prefix, rand, suffix)?
     } else {
@@ -546,7 +531,27 @@ fn exec(dir: &str, prefix: &str, rand: usize, suffix: &str, make_dir: bool) -> U
     // relative path.
     let path = Path::new(dir).join(filename);
 
-    println_verbatim(path).map_err_context(|| "failed to print directory name".to_owned())
+    Ok(path)
+}
+
+/// Create a temporary file or directory
+///
+/// Behavior is determined by the `options` parameter, see [`Options`] for details.
+pub fn mktemp(options: &Options) -> UResult<PathBuf> {
+    // Parse file path parameters from the command-line options.
+    let Params {
+        directory: tmpdir,
+        prefix,
+        num_rand_chars: rand,
+        suffix,
+    } = Params::from(options.clone())?;
+
+    // Create the temporary file or directory, or simulate creating it.
+    if options.dry_run {
+        dry_exec(&tmpdir, &prefix, rand, &suffix)
+    } else {
+        exec(&tmpdir, &prefix, rand, &suffix, options.directory)
+    }
 }
 
 #[cfg(test)]
diff --git a/src/uu/more/Cargo.toml b/src/uu/more/Cargo.toml
index ef224013307..63de2ce91f7 100644
--- a/src/uu/more/Cargo.toml
+++ b/src/uu/more/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_more"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "more ~ (uutils) input perusal filter"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/more"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/more.rs"
@@ -18,13 +21,18 @@ path = "src/more.rs"
 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 }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+crossterm = { workspace = true, features = ["use-dev-tty"] }
+
 [[bin]]
 name = "more"
 path = "src/main.rs"
+
+[dev-dependencies]
+tempfile = { workspace = true }
diff --git a/src/uu/more/more.md b/src/uu/more/more.md
index cb626060ec5..e63ca1a87fb 100644
--- a/src/uu/more/more.md
+++ b/src/uu/more/more.md
@@ -1,7 +1,7 @@
 # more
 
 ```
-more [OPTIONS] <FILE>...
+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 75cf79c07a9..97d911f4f3e 100644
--- a/src/uu/more/src/more.rs
+++ b/src/uu/more/src/more.rs
@@ -3,39 +3,42 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (methods) isnt
-
 use std::{
     fs::File,
-    io::{stdin, stdout, BufReader, Read, Stdout, Write},
+    io::{BufRead, BufReader, Stdin, Stdout, Write, stdin, stdout},
+    panic::set_hook,
     path::Path,
     time::Duration,
 };
 
-use clap::{crate_version, value_parser, Arg, ArgAction, ArgMatches, Command};
-use crossterm::event::KeyEventKind;
+use clap::{Arg, ArgAction, ArgMatches, Command, value_parser};
 use crossterm::{
-    cursor::{MoveTo, MoveUp},
-    event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
-    execute, queue,
+    ExecutableCommand,
+    QueueableCommand, // spell-checker:disable-line
+    cursor::{Hide, MoveTo, Show},
+    event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
     style::Attribute,
-    terminal::{self, Clear, ClearType},
+    terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
+    tty::IsTty,
 };
 
-use is_terminal::IsTerminal;
-use unicode_segmentation::UnicodeSegmentation;
-use unicode_width::UnicodeWidthStr;
-use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::{display::Quotable, show};
 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";
+const BELL: char = '\x07'; // Printing this character will ring the bell
+
+// The prompt to be displayed at the top of the screen when viewing multiple files,
+// with the file name in the middle
+const MULTI_FILE_TOP_PROMPT: &str = "\r::::::::::::::\n\r{}\n\r::::::::::::::\n";
+const HELP_MESSAGE: &str = "[Press space to continue, 'q' to quit.]";
 
 pub mod options {
     pub const SILENT: &str = "silent";
     pub const LOGICAL: &str = "logical";
+    pub const EXIT_ON_EOF: &str = "exit-on-eof";
     pub const NO_PAUSE: &str = "no-pause";
     pub const PRINT_OVER: &str = "print-over";
     pub const CLEAN_PRINT: &str = "clean-print";
@@ -48,15 +51,17 @@ pub mod options {
     pub const FILES: &str = "files";
 }
 
-const MULTI_FILE_TOP_PROMPT: &str = "\r::::::::::::::\n\r{}\n\r::::::::::::::\n";
-
 struct Options {
-    clean_print: bool,
-    from_line: usize,
-    lines: Option<u16>,
-    print_over: bool,
     silent: bool,
+    _logical: bool,     // not implemented
+    _exit_on_eof: bool, // not implemented
+    _no_pause: bool,    // not implemented
+    print_over: bool,
+    clean_print: bool,
     squeeze: bool,
+    lines: Option<u16>,
+    from_line: usize,
+    pattern: Option<String>,
 }
 
 impl Options {
@@ -67,89 +72,84 @@ impl Options {
         ) {
             // 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,
+            (Some(n), _) | (None, Some(n)) if n > 0 => Some(n + 1),
+            _ => None, // Use terminal height
         };
         let from_line = match matches.get_one::<usize>(options::FROM_LINE).copied() {
-            Some(number) if number > 1 => number - 1,
+            Some(number) => number.saturating_sub(1),
             _ => 0,
         };
+        let pattern = matches.get_one::<String>(options::PATTERN).cloned();
         Self {
-            clean_print: matches.get_flag(options::CLEAN_PRINT),
-            from_line,
-            lines,
-            print_over: matches.get_flag(options::PRINT_OVER),
             silent: matches.get_flag(options::SILENT),
+            _logical: matches.get_flag(options::LOGICAL),
+            _exit_on_eof: matches.get_flag(options::EXIT_ON_EOF),
+            _no_pause: matches.get_flag(options::NO_PAUSE),
+            print_over: matches.get_flag(options::PRINT_OVER),
+            clean_print: matches.get_flag(options::CLEAN_PRINT),
             squeeze: matches.get_flag(options::SQUEEZE),
+            lines,
+            from_line,
+            pattern,
         }
     }
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-    let matches = match uu_app().try_get_matches_from(&args) {
-        Ok(m) => m,
-        Err(e) => return Err(e.into()),
-    };
-
+    set_hook(Box::new(|panic_info| {
+        print!("\r");
+        println!("{panic_info}");
+    }));
+    let matches = uu_app().try_get_matches_from(args)?;
     let mut options = Options::from(&matches);
-
-    let mut buff = String::new();
-
     if let Some(files) = matches.get_many::<String>(options::FILES) {
-        let mut stdout = setup_term();
         let length = files.len();
 
         let mut files_iter = files.map(|s| s.as_str()).peekable();
         while let (Some(file), next_file) = (files_iter.next(), files_iter.peek()) {
             let file = Path::new(file);
             if file.is_dir() {
-                terminal::disable_raw_mode().unwrap();
-                return Err(UUsageError::new(
-                    1,
+                show!(UUsageError::new(
+                    0,
                     format!("{} is a directory.", file.quote()),
                 ));
+                continue;
             }
             if !file.exists() {
-                terminal::disable_raw_mode().unwrap();
-                return Err(USimpleError::new(
-                    1,
+                show!(USimpleError::new(
+                    0,
                     format!("cannot open {}: No such file or directory", file.quote()),
                 ));
+                continue;
             }
             let opened_file = match File::open(file) {
                 Err(why) => {
-                    terminal::disable_raw_mode().unwrap();
-                    return Err(USimpleError::new(
-                        1,
+                    show!(USimpleError::new(
+                        0,
                         format!("cannot open {}: {}", file.quote(), why.kind()),
                     ));
+                    continue;
                 }
                 Ok(opened_file) => opened_file,
             };
-            let mut reader = BufReader::new(opened_file);
-            reader.read_to_string(&mut buff).unwrap();
             more(
-                &buff,
-                &mut stdout,
+                InputType::File(BufReader::new(opened_file)),
                 length > 1,
                 file.to_str(),
                 next_file.copied(),
                 &mut 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, false, None, None, &mut options)?;
-        reset_term(&mut stdout);
+        }
     } else {
-        return Err(UUsageError::new(1, "bad usage"));
+        let stdin = stdin();
+        if stdin.is_tty() {
+            // stdin is not a pipe
+            return Err(UUsageError::new(1, "bad usage"));
+        }
+        more(InputType::Stdin(stdin), false, None, None, &mut options)?;
     }
+
     Ok(())
 }
 
@@ -157,51 +157,64 @@ pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
-        .version(crate_version!())
+        .version(uucore::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')
                 .long(options::SILENT)
-                .help("Display help instead of ringing bell")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .help("Display help instead of ringing bell when an illegal key is pressed"),
         )
         .arg(
-            Arg::new(options::CLEAN_PRINT)
+            Arg::new(options::LOGICAL)
+                .short('l')
+                .long(options::LOGICAL)
+                .action(ArgAction::SetTrue)
+                .help("Do not pause after any line containing a ^L (form feed)"),
+        )
+        .arg(
+            Arg::new(options::EXIT_ON_EOF)
+                .short('e')
+                .long(options::EXIT_ON_EOF)
+                .action(ArgAction::SetTrue)
+                .help("Exit on End-Of-File"),
+        )
+        .arg(
+            Arg::new(options::NO_PAUSE)
+                .short('f')
+                .long(options::NO_PAUSE)
+                .action(ArgAction::SetTrue)
+                .help("Count logical lines, rather than screen lines"),
+        )
+        .arg(
+            Arg::new(options::PRINT_OVER)
                 .short('p')
+                .long(options::PRINT_OVER)
+                .action(ArgAction::SetTrue)
+                .help("Do not scroll, clear screen and display text"),
+        )
+        .arg(
+            Arg::new(options::CLEAN_PRINT)
+                .short('c')
                 .long(options::CLEAN_PRINT)
-                .help("Do not scroll, clean screen and display text")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .help("Do not scroll, display text and clean line ends"),
         )
         .arg(
             Arg::new(options::SQUEEZE)
                 .short('s')
                 .long(options::SQUEEZE)
-                .help("Squeeze multiple blank lines into one")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .help("Squeeze multiple blank lines into one"),
         )
         .arg(
             Arg::new(options::PLAIN)
                 .short('u')
                 .long(options::PLAIN)
                 .action(ArgAction::SetTrue)
-                .hide(true),
-        )
-        .arg(
-            Arg::new(options::FROM_LINE)
-                .short('F')
-                .long(options::FROM_LINE)
-                .num_args(1)
-                .value_name("number")
-                .value_parser(value_parser!(usize))
-                .help("Display file beginning from line number"),
+                .hide(true)
+                .help("Suppress underlining"),
         )
         .arg(
             Arg::new(options::LINES)
@@ -217,31 +230,26 @@ pub fn uu_app() -> Command {
                 .long(options::NUMBER)
                 .num_args(1)
                 .value_parser(value_parser!(u16).range(0..))
-                .help("Same as --lines"),
-        )
-        // The commented arguments below are unimplemented:
-        /*
-        .arg(
-            Arg::new(options::LOGICAL)
-                .short('f')
-                .long(options::LOGICAL)
-                .help("Count logical rather than screen lines"),
+                .help("Same as --lines option argument"),
         )
         .arg(
-            Arg::new(options::NO_PAUSE)
-                .short('l')
-                .long(options::NO_PAUSE)
-                .help("Suppress pause after form feed"),
+            Arg::new(options::FROM_LINE)
+                .short('F')
+                .long(options::FROM_LINE)
+                .num_args(1)
+                .value_name("number")
+                .value_parser(value_parser!(usize))
+                .help("Start displaying each file at line number"),
         )
         .arg(
             Arg::new(options::PATTERN)
                 .short('P')
+                .long(options::PATTERN)
                 .allow_hyphen_values(true)
                 .required(false)
-                .takes_value(true)
-                .help("Display file beginning from pattern match"),
+                .value_name("pattern")
+                .help("The string to be searched in each file before starting to display it"),
         )
-        */
         .arg(
             Arg::new(options::FILES)
                 .required(false)
@@ -251,429 +259,864 @@ pub fn uu_app() -> Command {
         )
 }
 
-#[cfg(not(target_os = "fuchsia"))]
-fn setup_term() -> std::io::Stdout {
-    let stdout = stdout();
-    terminal::enable_raw_mode().unwrap();
-    stdout
+enum InputType {
+    File(BufReader<File>),
+    Stdin(Stdin),
+}
+
+impl InputType {
+    fn read_line(&mut self, buf: &mut String) -> std::io::Result<usize> {
+        match self {
+            InputType::File(reader) => reader.read_line(buf),
+            InputType::Stdin(stdin) => stdin.read_line(buf),
+        }
+    }
+
+    fn len(&self) -> std::io::Result<Option<u64>> {
+        let len = match self {
+            InputType::File(reader) => Some(reader.get_ref().metadata()?.len()),
+            InputType::Stdin(_) => None,
+        };
+        Ok(len)
+    }
+}
+
+enum OutputType {
+    Tty(Stdout),
+    Pipe(Box<dyn Write>),
+    #[cfg(test)]
+    Test(Vec<u8>),
+}
+
+impl IsTty for OutputType {
+    fn is_tty(&self) -> bool {
+        matches!(self, Self::Tty(_))
+    }
+}
+
+impl Write for OutputType {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match self {
+            Self::Tty(stdout) => stdout.write(buf),
+            Self::Pipe(writer) => writer.write(buf),
+            #[cfg(test)]
+            Self::Test(vec) => vec.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        match self {
+            Self::Tty(stdout) => stdout.flush(),
+            Self::Pipe(writer) => writer.flush(),
+            #[cfg(test)]
+            Self::Test(vec) => vec.flush(),
+        }
+    }
+}
+
+fn setup_term() -> UResult<OutputType> {
+    let mut stdout = stdout();
+    if stdout.is_tty() {
+        terminal::enable_raw_mode()?;
+        stdout.execute(EnterAlternateScreen)?.execute(Hide)?;
+        Ok(OutputType::Tty(stdout))
+    } else {
+        Ok(OutputType::Pipe(Box::new(stdout)))
+    }
 }
 
 #[cfg(target_os = "fuchsia")]
 #[inline(always)]
-fn setup_term() -> usize {
-    0
+fn setup_term() -> UResult<OutputType> {
+    // no real stdout/tty on Fuchsia, just write into a pipe
+    Ok(OutputType::Pipe(Box::new(stdout())))
 }
 
-#[cfg(not(target_os = "fuchsia"))]
-fn reset_term(stdout: &mut std::io::Stdout) {
-    terminal::disable_raw_mode().unwrap();
-    // Clear the prompt
-    queue!(stdout, terminal::Clear(ClearType::CurrentLine)).unwrap();
-    // Move cursor to the beginning without printing new line
-    print!("\r");
-    stdout.flush().unwrap();
+fn reset_term() -> UResult<()> {
+    let mut stdout = stdout();
+    if stdout.is_tty() {
+        stdout.queue(Show)?.queue(LeaveAlternateScreen)?;
+        terminal::disable_raw_mode()?;
+    } else {
+        stdout.queue(Clear(ClearType::CurrentLine))?;
+        write!(stdout, "\r")?;
+    }
+    stdout.flush()?;
+    Ok(())
 }
 
 #[cfg(target_os = "fuchsia")]
 #[inline(always)]
-fn reset_term(_: &mut usize) {}
+fn reset_term() -> UResult<()> {
+    Ok(())
+}
+
+struct TerminalGuard;
+
+impl Drop for TerminalGuard {
+    fn drop(&mut self) {
+        // Ignore errors in destructor
+        let _ = reset_term();
+    }
+}
 
 fn more(
-    buff: &str,
-    stdout: &mut Stdout,
+    input: InputType,
     multiple_file: bool,
-    file: Option<&str>,
+    file_name: Option<&str>,
     next_file: Option<&str>,
     options: &mut Options,
 ) -> UResult<()> {
-    let (cols, mut rows) = terminal::size().unwrap();
+    // Initialize output
+    let out = setup_term()?;
+    // Ensure raw mode is disabled on drop
+    let _guard = TerminalGuard;
+    // Create pager
+    let (_cols, mut rows) = terminal::size()?;
     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, options);
-
+    let mut pager = Pager::new(input, rows, file_name, next_file, options, out)?;
+    // Start from the specified line
+    pager.handle_from_line()?;
+    // Search for pattern
+    pager.handle_pattern_search()?;
+    // Handle multi-file display header if needed
     if multiple_file {
-        execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
-        stdout.write_all(
-            MULTI_FILE_TOP_PROMPT
-                .replace("{}", file.unwrap_or_default())
-                .as_bytes(),
-        )?;
-        pager.content_rows -= 3;
+        pager.display_multi_file_header()?;
     }
-    pager.draw(stdout, None);
+    // Initial display
+    pager.draw(None)?;
+    // Reset multi-file settings after initial display
     if multiple_file {
+        pager.reset_multi_file_header();
         options.from_line = 0;
-        pager.content_rows += 3;
     }
+    // Main event loop
+    pager.process_events(options)
+}
 
-    if pager.should_close() && next_file.is_none() {
-        return Ok(());
+struct Pager<'a> {
+    /// Source of the content (file, stdin)
+    input: InputType,
+    /// Total size of the file in bytes (only available for file inputs)
+    file_size: Option<u64>,
+    /// Storage for the lines read from the input
+    lines: Vec<String>,
+    /// Running total of byte sizes for each line, used for positioning
+    cumulative_line_sizes: Vec<u64>,
+    /// Index of the line currently displayed at the top of the screen
+    upper_mark: usize,
+    /// Number of rows that can be displayed on the screen at once
+    content_rows: usize,
+    /// Count of blank lines that have been condensed in the current view
+    lines_squeezed: usize,
+    pattern: Option<String>,
+    file_name: Option<&'a str>,
+    next_file: Option<&'a str>,
+    eof_reached: bool,
+    silent: bool,
+    squeeze: bool,
+    stdout: OutputType,
+}
+
+impl<'a> Pager<'a> {
+    fn new(
+        input: InputType,
+        rows: u16,
+        file_name: Option<&'a str>,
+        next_file: Option<&'a str>,
+        options: &Options,
+        stdout: OutputType,
+    ) -> UResult<Self> {
+        // Reserve one line for the status bar, ensuring at least one content row
+        let content_rows = rows.saturating_sub(1).max(1) as usize;
+        let file_size = input.len()?;
+        let pager = Self {
+            input,
+            file_size,
+            lines: Vec::with_capacity(content_rows),
+            cumulative_line_sizes: Vec::new(),
+            upper_mark: options.from_line,
+            content_rows,
+            lines_squeezed: 0,
+            pattern: options.pattern.clone(),
+            file_name,
+            next_file,
+            eof_reached: false,
+            silent: options.silent,
+            squeeze: options.squeeze,
+            stdout,
+        };
+        Ok(pager)
     }
 
-    loop {
-        let mut wrong_key = None;
-        if event::poll(Duration::from_millis(10)).unwrap() {
-            match event::read().unwrap() {
-                Event::Key(KeyEvent {
-                    kind: KeyEventKind::Release,
-                    ..
-                }) => continue,
-                Event::Key(KeyEvent {
-                    code: KeyCode::Char('q'),
+    fn handle_from_line(&mut self) -> UResult<()> {
+        if !self.read_until_line(self.upper_mark)? {
+            write!(
+                self.stdout,
+                "\r{}Cannot seek to line number {} (press RETURN){}",
+                Attribute::Reverse,
+                self.upper_mark + 1,
+                Attribute::Reset,
+            )?;
+            self.stdout.flush()?;
+            self.wait_for_enter_key()?;
+            self.upper_mark = 0;
+        }
+        Ok(())
+    }
+
+    fn read_until_line(&mut self, target_line: usize) -> UResult<bool> {
+        // Read lines until we reach the target line or EOF
+        let mut line = String::new();
+        while self.lines.len() <= target_line {
+            let bytes_read = self.input.read_line(&mut line)?;
+            if bytes_read == 0 {
+                return Ok(false); // EOF
+            }
+            // Track cumulative byte position
+            let last_pos = self.cumulative_line_sizes.last().copied().unwrap_or(0);
+            self.cumulative_line_sizes
+                .push(last_pos + bytes_read as u64);
+            // Remove trailing whitespace
+            line = line.trim_end().to_string();
+            // Store the line (using mem::take to avoid clone)
+            self.lines.push(std::mem::take(&mut line));
+        }
+        Ok(true)
+    }
+
+    fn wait_for_enter_key(&self) -> UResult<()> {
+        if !self.stdout.is_tty() {
+            return Ok(());
+        }
+        loop {
+            if event::poll(Duration::from_millis(100))? {
+                if let Event::Key(KeyEvent {
+                    code: KeyCode::Enter,
                     modifiers: KeyModifiers::NONE,
                     kind: KeyEventKind::Press,
                     ..
-                })
-                | Event::Key(KeyEvent {
-                    code: KeyCode::Char('c'),
-                    modifiers: KeyModifiers::CONTROL,
-                    kind: KeyEventKind::Press,
-                    ..
-                }) => {
-                    reset_term(stdout);
+                }) = event::read()?
+                {
+                    return Ok(());
+                }
+            }
+        }
+    }
+
+    fn handle_pattern_search(&mut self) -> UResult<()> {
+        if self.pattern.is_none() {
+            return Ok(());
+        };
+        match self.search_pattern_in_file() {
+            Some(line) => self.upper_mark = line,
+            None => {
+                self.pattern = None;
+                write!(
+                    self.stdout,
+                    "\r{}Pattern not found (press RETURN){}",
+                    Attribute::Reverse,
+                    Attribute::Reset,
+                )?;
+                self.stdout.flush()?;
+                self.wait_for_enter_key()?;
+            }
+        }
+        Ok(())
+    }
+
+    fn search_pattern_in_file(&mut self) -> Option<usize> {
+        let pattern = self.pattern.clone().expect("pattern should be set");
+        let mut line_num = self.upper_mark;
+        loop {
+            match self.get_line(line_num) {
+                Some(line) if line.contains(&pattern) => return Some(line_num),
+                Some(_) => line_num += 1,
+                None => return None,
+            }
+        }
+    }
+
+    fn get_line(&mut self, index: usize) -> Option<&String> {
+        match self.read_until_line(index) {
+            Ok(true) => self.lines.get(index),
+            _ => None,
+        }
+    }
+
+    fn display_multi_file_header(&mut self) -> UResult<()> {
+        self.stdout.queue(Clear(ClearType::CurrentLine))?;
+        self.stdout.write_all(
+            MULTI_FILE_TOP_PROMPT
+                .replace("{}", self.file_name.unwrap_or_default())
+                .as_bytes(),
+        )?;
+        self.content_rows = self
+            .content_rows
+            .saturating_sub(MULTI_FILE_TOP_PROMPT.lines().count());
+        Ok(())
+    }
+
+    fn reset_multi_file_header(&mut self) {
+        self.content_rows = self
+            .content_rows
+            .saturating_add(MULTI_FILE_TOP_PROMPT.lines().count());
+    }
+
+    fn update_display(&mut self, options: &Options) -> UResult<()> {
+        if options.print_over {
+            self.stdout
+                .execute(MoveTo(0, 0))?
+                .execute(Clear(ClearType::FromCursorDown))?;
+        } else if options.clean_print {
+            self.stdout
+                .execute(Clear(ClearType::All))?
+                .execute(MoveTo(0, 0))?;
+        }
+        Ok(())
+    }
+
+    /// Process user input events until exit
+    fn process_events(&mut self, options: &Options) -> UResult<()> {
+        loop {
+            if !event::poll(Duration::from_millis(100))? {
+                continue;
+            }
+            let mut wrong_key = None;
+            match event::read()? {
+                // --- Quit commands ---
+                Event::Key(
+                    KeyEvent {
+                        code: KeyCode::Char('q'),
+                        modifiers: KeyModifiers::NONE,
+                        kind: KeyEventKind::Press,
+                        ..
+                    }
+                    | KeyEvent {
+                        code: KeyCode::Char('c'),
+                        modifiers: KeyModifiers::CONTROL,
+                        kind: KeyEventKind::Press,
+                        ..
+                    },
+                ) => {
+                    reset_term()?;
                     std::process::exit(0);
                 }
+
+                // --- Forward Navigation ---
                 Event::Key(KeyEvent {
-                    code: KeyCode::Down,
-                    modifiers: KeyModifiers::NONE,
-                    ..
-                })
-                | Event::Key(KeyEvent {
-                    code: KeyCode::PageDown,
-                    modifiers: KeyModifiers::NONE,
-                    ..
-                })
-                | Event::Key(KeyEvent {
-                    code: KeyCode::Char(' '),
+                    code: KeyCode::Down | KeyCode::PageDown | KeyCode::Char(' '),
                     modifiers: KeyModifiers::NONE,
                     ..
                 }) => {
-                    if pager.should_close() {
+                    if self.eof_reached {
                         return Ok(());
-                    } else {
-                        pager.page_down();
                     }
+                    self.page_down();
                 }
                 Event::Key(KeyEvent {
-                    code: KeyCode::Up,
-                    modifiers: KeyModifiers::NONE,
-                    ..
-                })
-                | Event::Key(KeyEvent {
-                    code: KeyCode::PageUp,
+                    code: KeyCode::Enter | KeyCode::Char('j'),
                     modifiers: KeyModifiers::NONE,
                     ..
                 }) => {
-                    pager.page_up();
-                    paging_add_back_message(options, stdout)?;
+                    if self.eof_reached {
+                        return Ok(());
+                    }
+                    self.next_line();
                 }
+
+                // --- Backward Navigation ---
                 Event::Key(KeyEvent {
-                    code: KeyCode::Char('j'),
+                    code: KeyCode::Up | KeyCode::PageUp,
                     modifiers: KeyModifiers::NONE,
                     ..
                 }) => {
-                    if pager.should_close() {
-                        return Ok(());
-                    } else {
-                        pager.next_line();
-                    }
+                    self.page_up();
                 }
                 Event::Key(KeyEvent {
                     code: KeyCode::Char('k'),
                     modifiers: KeyModifiers::NONE,
                     ..
                 }) => {
-                    pager.prev_line();
+                    self.prev_line();
                 }
+
+                // --- Terminal events ---
                 Event::Resize(col, row) => {
-                    pager.page_resize(col, row, options.lines);
+                    self.page_resize(col, row, options.lines);
                 }
+
+                // --- Skip key release events ---
+                Event::Key(KeyEvent {
+                    kind: KeyEventKind::Release,
+                    ..
+                }) => continue,
+
+                // --- Handle unknown keys ---
                 Event::Key(KeyEvent {
                     code: KeyCode::Char(k),
                     ..
                 }) => wrong_key = Some(k),
-                _ => 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();
+                // --- Ignore other events ---
+                _ => continue,
             }
-            pager.draw(stdout, wrong_key);
+            self.update_display(options)?;
+            self.draw(wrong_key)?;
         }
     }
-}
-
-struct Pager<'a> {
-    // The current line at the top of the screen
-    upper_mark: usize,
-    // The number of rows that fit on the screen
-    content_rows: u16,
-    lines: Vec<String>,
-    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>, options: &Options) -> Self {
-        let line_count = lines.len();
-        Self {
-            upper_mark: options.from_line,
-            content_rows: rows.saturating_sub(1),
-            lines,
-            next_file,
-            line_count,
-            silent: options.silent,
-            squeeze: options.squeeze,
-            line_squeezed: 0,
-        }
-    }
-
-    fn should_close(&mut self) -> bool {
-        self.upper_mark
-            .saturating_add(self.content_rows.into())
-            .ge(&self.line_count)
-    }
 
     fn page_down(&mut self) {
-        // If the next page down position __after redraw__ is greater than the total line count,
-        // the upper mark must not grow past top of the screen at the end of the open file.
-        if self
-            .upper_mark
-            .saturating_add(self.content_rows as usize * 2)
-            .ge(&self.line_count)
-        {
-            self.upper_mark = self.line_count - self.content_rows as usize;
-            return;
-        }
+        // Move the viewing window down by the number of lines to display
+        self.upper_mark = self.upper_mark.saturating_add(self.content_rows);
+    }
 
-        self.upper_mark = self.upper_mark.saturating_add(self.content_rows.into());
+    fn next_line(&mut self) {
+        // Move the viewing window down by one line
+        self.upper_mark = self.upper_mark.saturating_add(1);
     }
 
     fn page_up(&mut self) {
-        let content_row_usize: usize = self.content_rows.into();
+        self.eof_reached = false;
+        // Move the viewing window up by the number of lines to display
         self.upper_mark = self
             .upper_mark
-            .saturating_sub(content_row_usize.saturating_add(self.line_squeezed));
-
+            .saturating_sub(self.content_rows.saturating_add(self.lines_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 {
+            // Move upper mark to the first non-empty line
+            while self.upper_mark > 0 {
+                let line = self.lines.get(self.upper_mark).expect("line should exist");
+                if !line.trim().is_empty() {
                     break;
                 }
+                self.upper_mark = self.upper_mark.saturating_sub(1);
             }
         }
     }
 
-    fn next_line(&mut self) {
-        self.upper_mark = self.upper_mark.saturating_add(1);
-    }
-
     fn prev_line(&mut self) {
+        self.eof_reached = false;
+        // Move the viewing window up by one line
         self.upper_mark = self.upper_mark.saturating_sub(1);
     }
 
     // TODO: Deal with column size changes.
-    fn page_resize(&mut self, _: u16, row: u16, option_line: Option<u16>) {
+    fn page_resize(&mut self, _col: u16, row: u16, option_line: Option<u16>) {
         if option_line.is_none() {
-            self.content_rows = row.saturating_sub(1);
+            self.content_rows = row.saturating_sub(1) as usize;
         };
     }
 
-    fn draw(&mut self, stdout: &mut std::io::Stdout, wrong_key: Option<char>) {
-        self.draw_lines(stdout);
-        let lower_mark = self
-            .line_count
-            .min(self.upper_mark.saturating_add(self.content_rows.into()));
-        self.draw_prompt(stdout, lower_mark, wrong_key);
-        stdout.flush().unwrap();
-    }
-
-    fn draw_lines(&mut self, stdout: &mut std::io::Stdout) {
-        execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine)).unwrap();
-
-        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;
-                }
+    fn draw(&mut self, wrong_key: Option<char>) -> UResult<()> {
+        self.draw_lines()?;
+        self.draw_status_bar(wrong_key);
+        self.stdout.flush()?;
+        Ok(())
+    }
+
+    fn draw_lines(&mut self) -> UResult<()> {
+        // Clear current prompt line
+        self.stdout.queue(Clear(ClearType::CurrentLine))?;
+        // Reset squeezed lines counter
+        self.lines_squeezed = 0;
+        // Display lines until we've filled the screen
+        let mut lines_printed = 0;
+        let mut index = self.upper_mark;
+        while lines_printed < self.content_rows {
+            // Load the required line or stop at EOF
+            if !self.read_until_line(index)? {
+                self.eof_reached = true;
+                self.upper_mark = index.saturating_sub(self.content_rows);
+                break;
             }
+            // Skip line if it should be squeezed
+            if self.should_squeeze_line(index) {
+                self.lines_squeezed += 1;
+                index += 1;
+                continue;
+            }
+            // Display the line
+            let mut line = self.lines[index].clone();
+            if let Some(pattern) = &self.pattern {
+                // Highlight the pattern in the line
+                line = line.replace(
+                    pattern,
+                    &format!("{}{pattern}{}", Attribute::Reverse, Attribute::Reset),
+                );
+            };
+            self.stdout.write_all(format!("\r{}\n", line).as_bytes())?;
+            lines_printed += 1;
+            index += 1;
         }
+        // Fill remaining lines with `~`
+        while lines_printed < self.content_rows {
+            self.stdout.write_all(b"\r~\n")?;
+            lines_printed += 1;
+        }
+        Ok(())
+    }
 
-        for line in displayed_lines {
-            stdout.write_all(format!("\r{line}\n").as_bytes()).unwrap();
+    fn should_squeeze_line(&self, index: usize) -> bool {
+        // Only squeeze if enabled and not the first line
+        if !self.squeeze || index == 0 {
+            return false;
+        }
+        // Squeeze only if both current and previous lines are empty
+        match (self.lines.get(index), self.lines.get(index - 1)) {
+            (Some(current), Some(previous)) => current.is_empty() && previous.is_empty(),
+            _ => false,
         }
     }
 
-    fn draw_prompt(&self, stdout: &mut Stdout, lower_mark: usize, wrong_key: Option<char>) {
-        let status_inner = if lower_mark == self.line_count {
-            format!("Next file: {}", self.next_file.unwrap_or_default())
+    fn draw_status_bar(&mut self, wrong_key: Option<char>) {
+        // Calculate the index of the last visible line
+        let lower_mark =
+            (self.upper_mark + self.content_rows).min(self.lines.len().saturating_sub(1));
+        // Determine progress information to display
+        // - Show next file name when at EOF and there is a next file
+        // - Otherwise show percentage of the file read (if available)
+        let progress_info = if self.eof_reached && self.next_file.is_some() {
+            format!(" (Next file: {})", self.next_file.unwrap())
+        } else if let Some(file_size) = self.file_size {
+            // For files, show percentage or END
+            let position = self
+                .cumulative_line_sizes
+                .get(lower_mark)
+                .copied()
+                .unwrap_or_default();
+            if file_size == 0 {
+                " (END)".to_string()
+            } else {
+                let percentage = (position as f64 / file_size as f64 * 100.0).round() as u16;
+                if percentage >= 100 {
+                    " (END)".to_string()
+                } else {
+                    format!(" ({}%)", percentage)
+                }
+            }
         } else {
-            format!(
-                "{}%",
-                (lower_mark as f64 / self.line_count as f64 * 100.0).round() as u16
-            )
+            // For stdin, don't show percentage
+            String::new()
         };
-
-        let status = format!("--More--({status_inner})");
+        // Base status message with progress info
+        let file_name = self.file_name.unwrap_or(":");
+        let status = format!("{file_name}{progress_info}");
+        // Add appropriate user feedback based on silent mode and key input:
+        // - In silent mode: show help text or unknown key message
+        // - In normal mode: ring bell (BELL char) on wrong key or show basic prompt
         let banner = match (self.silent, wrong_key) {
             (true, Some(key)) => format!(
-                "{status} [Unknown key: '{key}'. Press 'h' for instructions. (unimplemented)]"
+                "{status}[Unknown key: '{key}'. Press 'h' for instructions. (unimplemented)]"
             ),
-            (true, None) => format!("{status}[Press space to continue, 'q' to quit.]"),
+            (true, None) => format!("{status}{HELP_MESSAGE}"),
             (false, Some(_)) => format!("{status}{BELL}"),
             (false, None) => status,
         };
-
+        // Draw the status bar at the bottom of the screen
         write!(
-            stdout,
-            "\r{}{}{}",
+            self.stdout,
+            "\r{}{banner}{}",
             Attribute::Reverse,
-            banner,
             Attribute::Reset
         )
         .unwrap();
     }
 }
 
-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())?;
+#[cfg(test)]
+mod tests {
+    use std::{
+        io::Seek,
+        ops::{Deref, DerefMut},
+    };
+
+    use super::*;
+    use tempfile::tempfile;
+
+    impl Deref for OutputType {
+        type Target = Vec<u8>;
+        fn deref(&self) -> &Vec<u8> {
+            match self {
+                OutputType::Test(buf) => buf,
+                _ => unreachable!(),
+            }
+        }
     }
-    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());
+    impl DerefMut for OutputType {
+        fn deref_mut(&mut self) -> &mut Vec<u8> {
+            match self {
+                OutputType::Test(buf) => buf,
+                _ => unreachable!(),
+            }
+        }
+    }
 
-    for l in buff.lines() {
-        lines.append(&mut break_line(l, cols));
+    struct TestPagerBuilder {
+        content: String,
+        options: Options,
+        rows: u16,
+        next_file: Option<&'static str>,
     }
-    lines
-}
 
-fn break_line(line: &str, cols: usize) -> Vec<String> {
-    let width = UnicodeWidthStr::width(line);
-    let mut lines = Vec::new();
-    if width < cols {
-        lines.push(line.to_string());
-        return lines;
+    impl Default for TestPagerBuilder {
+        fn default() -> Self {
+            Self {
+                content: String::new(),
+                options: Options {
+                    silent: false,
+                    _logical: false,
+                    _exit_on_eof: false,
+                    _no_pause: false,
+                    print_over: false,
+                    clean_print: false,
+                    squeeze: false,
+                    lines: None,
+                    from_line: 0,
+                    pattern: None,
+                },
+                rows: 10,
+                next_file: None,
+            }
+        }
     }
 
-    let gr_idx = UnicodeSegmentation::grapheme_indices(line, true);
-    let mut last_index = 0;
-    let mut total_width = 0;
-    for (index, grapheme) in gr_idx {
-        let width = UnicodeWidthStr::width(grapheme);
-        total_width += width;
+    #[allow(dead_code)]
+    impl TestPagerBuilder {
+        fn new(content: &str) -> Self {
+            Self {
+                content: content.to_string(),
+                ..Default::default()
+            }
+        }
+
+        fn build(mut self) -> Pager<'static> {
+            let mut tmpfile = tempfile().unwrap();
+            tmpfile.write_all(self.content.as_bytes()).unwrap();
+            tmpfile.rewind().unwrap();
+            let out = OutputType::Test(Vec::new());
+            if let Some(rows) = self.options.lines {
+                self.rows = rows;
+            }
+            Pager::new(
+                InputType::File(BufReader::new(tmpfile)),
+                self.rows,
+                None,
+                self.next_file,
+                &self.options,
+                out,
+            )
+            .unwrap()
+        }
+
+        fn silent(mut self) -> Self {
+            self.options.silent = true;
+            self
+        }
+
+        fn print_over(mut self) -> Self {
+            self.options.print_over = true;
+            self
+        }
 
-        if total_width > cols {
-            lines.push(line[last_index..index].to_string());
-            last_index = index;
-            total_width = width;
+        fn clean_print(mut self) -> Self {
+            self.options.clean_print = true;
+            self
+        }
+
+        fn squeeze(mut self) -> Self {
+            self.options.squeeze = true;
+            self
+        }
+
+        fn lines(mut self, lines: u16) -> Self {
+            self.options.lines = Some(lines);
+            self
+        }
+
+        #[allow(clippy::wrong_self_convention)]
+        fn from_line(mut self, from_line: usize) -> Self {
+            self.options.from_line = from_line;
+            self
+        }
+
+        fn pattern(mut self, pattern: &str) -> Self {
+            self.options.pattern = Some(pattern.to_owned());
+            self
+        }
+
+        fn rows(mut self, rows: u16) -> Self {
+            self.rows = rows;
+            self
+        }
+
+        fn next_file(mut self, next_file: &'static str) -> Self {
+            self.next_file = Some(next_file);
+            self
         }
     }
 
-    if last_index != line.len() {
-        lines.push(line[last_index..].to_string());
+    #[test]
+    fn test_get_line_and_len() {
+        let content = "a\n\tb\nc\n";
+        let mut pager = TestPagerBuilder::new(content).build();
+        assert_eq!(pager.get_line(1).unwrap(), "\tb");
+        assert_eq!(pager.cumulative_line_sizes.len(), 2);
+        assert_eq!(pager.cumulative_line_sizes[1], 5);
     }
-    lines
-}
 
-#[cfg(test)]
-mod tests {
-    use super::break_line;
-    use unicode_width::UnicodeWidthStr;
+    #[test]
+    fn test_navigate_page() {
+        // create 10 lines "0\n".."9\n"
+        let content = (0..10).map(|i| i.to_string() + "\n").collect::<String>();
+
+        // content_rows = rows - 1 = 10 - 1 = 9
+        let mut pager = TestPagerBuilder::new(&content).build();
+        assert_eq!(pager.upper_mark, 0);
+
+        pager.page_down();
+        assert_eq!(pager.upper_mark, pager.content_rows);
+        pager.draw(None).unwrap();
+        let mut stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("9\n"));
+        assert!(!stdout.contains("8\n"));
+        assert_eq!(pager.upper_mark, 1); // EOF reached: upper_mark = 10 - content_rows = 1
+
+        pager.page_up();
+        assert_eq!(pager.upper_mark, 0);
+
+        pager.next_line();
+        assert_eq!(pager.upper_mark, 1);
+
+        pager.prev_line();
+        assert_eq!(pager.upper_mark, 0);
+        pager.stdout.clear();
+        pager.draw(None).unwrap();
+        stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("0\n"));
+        assert!(!stdout.contains("9\n")); // only lines 0 to 8 should be displayed
+    }
 
     #[test]
-    fn test_break_lines_long() {
-        let mut test_string = String::with_capacity(100);
-        for _ in 0..200 {
-            test_string.push('#');
-        }
+    fn test_silent_mode() {
+        let content = (0..5).map(|i| i.to_string() + "\n").collect::<String>();
+        let mut pager = TestPagerBuilder::new(&content)
+            .from_line(3)
+            .silent()
+            .build();
+        pager.draw_status_bar(None);
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains(HELP_MESSAGE));
+    }
 
-        let lines = break_line(&test_string, 80);
-        let widths: Vec<usize> = lines
-            .iter()
-            .map(|s| UnicodeWidthStr::width(&s[..]))
-            .collect();
+    #[test]
+    fn test_squeeze() {
+        let content = "Line 0\n\n\n\nLine 4\n\n\nLine 7\n";
+        let mut pager = TestPagerBuilder::new(content).lines(6).squeeze().build();
+        assert_eq!(pager.content_rows, 5); // 1 line for the status bar
+
+        // load all lines
+        assert!(pager.read_until_line(7).unwrap());
+        //  back‑to‑back empty lines → should squeeze
+        assert!(pager.should_squeeze_line(2));
+        assert!(pager.should_squeeze_line(3));
+        assert!(pager.should_squeeze_line(6));
+        // non‑blank or first line should not be squeezed
+        assert!(!pager.should_squeeze_line(0));
+        assert!(!pager.should_squeeze_line(1));
+        assert!(!pager.should_squeeze_line(4));
+        assert!(!pager.should_squeeze_line(5));
+        assert!(!pager.should_squeeze_line(7));
 
-        assert_eq!((80, 80, 40), (widths[0], widths[1], widths[2]));
+        pager.draw(None).unwrap();
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("Line 0"));
+        assert!(stdout.contains("Line 4"));
+        assert!(stdout.contains("Line 7"));
     }
 
     #[test]
-    fn test_break_lines_short() {
-        let mut test_string = String::with_capacity(100);
-        for _ in 0..20 {
-            test_string.push('#');
-        }
+    fn test_lines_option() {
+        let content = (0..5).map(|i| i.to_string() + "\n").collect::<String>();
 
-        let lines = break_line(&test_string, 80);
+        // Output zero lines succeeds
+        let mut pager = TestPagerBuilder::new(&content).lines(0).build();
+        pager.draw(None).unwrap();
+        let mut stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(!stdout.is_empty());
 
-        assert_eq!(20, lines[0].len());
+        // Output two lines
+        let mut pager = TestPagerBuilder::new(&content).lines(3).build();
+        assert_eq!(pager.content_rows, 3 - 1); // 1 line for the status bar
+        pager.draw(None).unwrap();
+        stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("0\n"));
+        assert!(stdout.contains("1\n"));
+        assert!(!stdout.contains("2\n"));
     }
 
     #[test]
-    fn test_break_line_zwj() {
-        let mut test_string = String::with_capacity(1100);
-        for _ in 0..20 {
-            test_string.push_str("👩��🔬");
-        }
+    fn test_from_line_option() {
+        let content = (0..5).map(|i| i.to_string() + "\n").collect::<String>();
+
+        // Output from first line
+        let mut pager = TestPagerBuilder::new(&content).from_line(0).build();
+        assert!(pager.handle_from_line().is_ok());
+        pager.draw(None).unwrap();
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("0\n"));
 
-        let lines = break_line(&test_string, 80);
+        // Output from second line
+        pager = TestPagerBuilder::new(&content).from_line(1).build();
+        assert!(pager.handle_from_line().is_ok());
+        pager.draw(None).unwrap();
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("1\n"));
+        assert!(!stdout.contains("0\n"));
 
-        let widths: Vec<usize> = lines
-            .iter()
-            .map(|s| UnicodeWidthStr::width(&s[..]))
-            .collect();
+        // Output from out of range line
+        pager = TestPagerBuilder::new(&content).from_line(99).build();
+        assert!(pager.handle_from_line().is_ok());
+        assert_eq!(pager.upper_mark, 0);
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("Cannot seek to line number 100"));
+    }
+
+    #[test]
+    fn test_search_pattern_found() {
+        let content = "foo\nbar\nbaz\n";
+        let mut pager = TestPagerBuilder::new(content).pattern("bar").build();
+        assert!(pager.handle_pattern_search().is_ok());
+        assert_eq!(pager.upper_mark, 1);
+        pager.draw(None).unwrap();
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("bar"));
+        assert!(!stdout.contains("foo"));
+    }
+
+    #[test]
+    fn test_search_pattern_not_found() {
+        let content = "foo\nbar\nbaz\n";
+        let mut pager = TestPagerBuilder::new(content).pattern("qux").build();
+        assert!(pager.handle_pattern_search().is_ok());
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("Pattern not found"));
+        assert_eq!(pager.pattern, None);
+        assert_eq!(pager.upper_mark, 0);
+    }
+
+    #[test]
+    fn test_wrong_key() {
+        let mut pager = TestPagerBuilder::default().silent().build();
+        pager.draw_status_bar(Some('x'));
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains("Unknown key: 'x'"));
 
-        // Each 👩��🔬 is 6 character width it break line to the closest number to 80 => 6 * 13 = 78
-        assert_eq!((78, 42), (widths[0], widths[1]));
+        pager = TestPagerBuilder::default().build();
+        pager.draw_status_bar(Some('x'));
+        let stdout = String::from_utf8_lossy(&pager.stdout);
+        assert!(stdout.contains(BELL));
     }
 }
diff --git a/src/uu/mv/Cargo.toml b/src/uu/mv/Cargo.toml
index b7fcf2d109b..1cb30bf1473 100644
--- a/src/uu/mv/Cargo.toml
+++ b/src/uu/mv/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_mv"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "mv ~ (uutils) move (rename) SOURCE to DESTINATION"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/mv"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/mv.rs"
@@ -18,12 +21,25 @@ path = "src/mv.rs"
 clap = { workspace = true }
 fs_extra = { workspace = true }
 indicatif = { workspace = true }
+libc = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true, features = [
   "backup-control",
   "fs",
+  "fsxattr",
   "update-control",
 ] }
 
+[target.'cfg(windows)'.dependencies]
+windows-sys = { workspace = true, features = [
+  "Win32_Foundation",
+  "Win32_Security",
+  "Win32_Storage_FileSystem",
+] }
+
+[target.'cfg(unix)'.dependencies]
+libc = { workspace = true }
+
 [[bin]]
 name = "mv"
 path = "src/main.rs"
diff --git a/src/uu/mv/src/error.rs b/src/uu/mv/src/error.rs
index a6605e23234..5049725a67e 100644
--- a/src/uu/mv/src/error.rs
+++ b/src/uu/mv/src/error.rs
@@ -2,41 +2,37 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use std::error::Error;
-use std::fmt::{Display, Formatter, Result};
-
+use thiserror::Error;
 use uucore::error::UError;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum MvError {
+    #[error("cannot stat {0}: No such file or directory")]
     NoSuchFile(String),
+
+    #[error("cannot stat {0}: Not a directory")]
+    CannotStatNotADirectory(String),
+
+    #[error("{0} and {1} are the same file")]
     SameFile(String, String),
-    SelfSubdirectory(String),
+
+    #[error("cannot move {0} to a subdirectory of itself, {1}")]
+    SelfTargetSubdirectory(String, String),
+
+    #[error("cannot overwrite directory {0} with non-directory")]
     DirectoryToNonDirectory(String),
+
+    #[error("cannot overwrite non-directory {1} with directory {0}")]
     NonDirectoryToDirectory(String, String),
+
+    #[error("target {0}: Not a directory")]
     NotADirectory(String),
+
+    #[error("target directory {0}: Not a directory")]
     TargetNotADirectory(String),
+
+    #[error("failed to access {0}: Not a directory")]
+    FailedToAccessNotADirectory(String),
 }
 
-impl Error for MvError {}
 impl UError for MvError {}
-impl Display for MvError {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        match self {
-            Self::NoSuchFile(s) => write!(f, "cannot stat {s}: No such file or directory"),
-            Self::SameFile(s, t) => write!(f, "{s} and {t} are the same file"),
-            Self::SelfSubdirectory(s) => write!(
-                f,
-                "cannot move '{s}' to a subdirectory of itself, '{s}/{s}'"
-            ),
-            Self::DirectoryToNonDirectory(t) => {
-                write!(f, "cannot overwrite directory {t} with non-directory")
-            }
-            Self::NonDirectoryToDirectory(s, t) => {
-                write!(f, "cannot overwrite non-directory {t} with directory {s}")
-            }
-            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 9f7a9661885..edfa505c521 100644
--- a/src/uu/mv/src/mv.rs
+++ b/src/uu/mv/src/mv.rs
@@ -3,52 +3,123 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) sourcepath targetpath
+// spell-checker:ignore (ToDO) sourcepath targetpath nushell canonicalized
 
 mod error;
 
 use clap::builder::ValueParser;
-use clap::{crate_version, error::ErrorKind, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command, error::ErrorKind};
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+
+use std::collections::HashSet;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
 use std::io;
 #[cfg(unix)]
 use std::os::unix;
+#[cfg(unix)]
+use std::os::unix::fs::FileTypeExt;
 #[cfg(windows)]
 use std::os::windows;
-use std::path::{Path, PathBuf};
-use uucore::backup_control::{self, source_is_target_backup, BackupMode};
+use std::path::{Path, PathBuf, absolute};
+
+use uucore::backup_control::{self, source_is_target_backup};
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, FromIo, UError, UResult, USimpleError, UUsageError};
-use uucore::fs::{are_hardlinks_or_one_way_symlink_to_same_file, are_hardlinks_to_same_file};
-use uucore::update_control::{self, UpdateMode};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError, set_exit_code};
+#[cfg(unix)]
+use uucore::fs::make_fifo;
+use uucore::fs::{
+    MissingHandling, ResolveMode, are_hardlinks_or_one_way_symlink_to_same_file,
+    are_hardlinks_to_same_file, canonicalize, path_ends_with_terminator,
+};
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+use uucore::fsxattr;
+use uucore::update_control;
+
+// These are exposed for projects (e.g. nushell) that want to create an `Options` value, which
+// requires these enums
+pub use uucore::{backup_control::BackupMode, update_control::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,
-    TransitProcess, TransitProcessResult,
+    CopyOptions as DirCopyOptions, TransitProcess, TransitProcessResult, get_size as dir_get_size,
+    move_dir, move_dir_with_progress,
 };
 
 use crate::error::MvError;
 
-pub struct Behavior {
-    overwrite: OverwriteMode,
-    backup: BackupMode,
-    suffix: String,
-    update: UpdateMode,
-    target_dir: Option<OsString>,
-    no_target_dir: bool,
-    verbose: bool,
-    strip_slashes: bool,
-    progress_bar: bool,
+/// Options contains all the possible behaviors and flags for mv.
+///
+/// All options are public so that the options can be programmatically
+/// constructed by other crates, such as nushell. That means that this struct is
+/// part of our public API. It should therefore not be changed without good reason.
+///
+/// The fields are documented with the arguments that determine their value.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Options {
+    /// specifies overwrite behavior
+    /// '-n' '--no-clobber'
+    /// '-i' '--interactive'
+    /// '-f' '--force'
+    pub overwrite: OverwriteMode,
+
+    /// `--backup[=CONTROL]`, `-b`
+    pub backup: BackupMode,
+
+    /// '-S' --suffix' backup suffix
+    pub suffix: String,
+
+    /// Available update mode "--update-mode=all|none|older"
+    pub update: UpdateMode,
+
+    /// Specifies target directory
+    /// '-t, --target-directory=DIRECTORY'
+    pub target_dir: Option<OsString>,
+
+    /// Treat destination as a normal file
+    /// '-T, --no-target-directory
+    pub no_target_dir: bool,
+
+    /// '-v, --verbose'
+    pub verbose: bool,
+
+    /// '--strip-trailing-slashes'
+    pub strip_slashes: bool,
+
+    /// '-g, --progress'
+    pub progress_bar: bool,
+
+    /// `--debug`
+    pub debug: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            overwrite: OverwriteMode::default(),
+            backup: BackupMode::default(),
+            suffix: backup_control::DEFAULT_BACKUP_SUFFIX.to_owned(),
+            update: UpdateMode::default(),
+            target_dir: None,
+            no_target_dir: false,
+            verbose: false,
+            strip_slashes: false,
+            progress_bar: false,
+            debug: false,
+        }
+    }
 }
 
-#[derive(Clone, Eq, PartialEq)]
+/// specifies behavior of the overwrite flag
+#[derive(Clone, Debug, Eq, PartialEq, Default)]
 pub enum OverwriteMode {
+    /// '-n' '--no-clobber'   do not overwrite
     NoClobber,
+    /// '-i' '--interactive'  prompt before overwrite
     Interactive,
+    ///'-f' '--force'         overwrite without prompt
+    #[default]
     Force,
 }
 
@@ -65,19 +136,20 @@ static OPT_NO_TARGET_DIRECTORY: &str = "no-target-directory";
 static OPT_VERBOSE: &str = "verbose";
 static OPT_PROGRESS: &str = "progress";
 static ARG_FILES: &str = "files";
+static OPT_DEBUG: &str = "debug";
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let mut app = uu_app();
     let matches = app.try_get_matches_from_mut(args)?;
 
-    if !matches.contains_id(OPT_TARGET_DIRECTORY)
-        && matches
-            .get_many::<OsString>(ARG_FILES)
-            .map(|f| f.len())
-            .unwrap_or(0)
-            == 1
-    {
+    let files: Vec<OsString> = matches
+        .get_many::<OsString>(ARG_FILES)
+        .unwrap_or_default()
+        .cloned()
+        .collect();
+
+    if files.len() == 1 && !matches.contains_id(OPT_TARGET_DIRECTORY) {
         app.error(
             ErrorKind::TooFewValues,
             format!(
@@ -87,20 +159,18 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .exit();
     }
 
-    let files: Vec<OsString> = matches
-        .get_many::<OsString>(ARG_FILES)
-        .unwrap_or_default()
-        .map(|v| v.to_os_string())
-        .collect();
-
     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 {
+    if backup_mode != BackupMode::None
+        && (overwrite_mode == OverwriteMode::NoClobber
+            || update_mode == UpdateMode::None
+            || update_mode == UpdateMode::NoneFail)
+    {
         return Err(UUsageError::new(
             1,
-            "options --backup and --no-clobber are mutually exclusive",
+            "cannot combine --backup with -n/--no-clobber or --update=none-fail",
         ));
     }
 
@@ -116,24 +186,25 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     }
 
-    let behavior = Behavior {
+    let opts = Options {
         overwrite: overwrite_mode,
         backup: backup_mode,
         suffix: backup_suffix,
         update: update_mode,
         target_dir,
         no_target_dir: matches.get_flag(OPT_NO_TARGET_DIRECTORY),
-        verbose: matches.get_flag(OPT_VERBOSE),
+        verbose: matches.get_flag(OPT_VERBOSE) || matches.get_flag(OPT_DEBUG),
         strip_slashes: matches.get_flag(OPT_STRIP_TRAILING_SLASHES),
         progress_bar: matches.get_flag(OPT_PROGRESS),
+        debug: matches.get_flag(OPT_DEBUG),
     };
 
-    exec(&files[..], &behavior)
+    mv(&files[..], &opts)
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(format!(
@@ -218,6 +289,12 @@ pub fn uu_app() -> Command {
                 .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::AnyPath),
         )
+        .arg(
+            Arg::new(OPT_DEBUG)
+                .long(OPT_DEBUG)
+                .help("explain how a file is copied. Implies -v")
+                .action(ArgAction::SetTrue),
+        )
 }
 
 fn determine_overwrite_mode(matches: &ArgMatches) -> OverwriteMode {
@@ -235,10 +312,10 @@ fn determine_overwrite_mode(matches: &ArgMatches) -> OverwriteMode {
     }
 }
 
-fn parse_paths(files: &[OsString], b: &Behavior) -> Vec<PathBuf> {
+fn parse_paths(files: &[OsString], opts: &Options) -> Vec<PathBuf> {
     let paths = files.iter().map(Path::new);
 
-    if b.strip_slashes {
+    if opts.strip_slashes {
         paths
             .map(|p| p.components().as_path().to_owned())
             .collect::<Vec<PathBuf>>()
@@ -247,8 +324,8 @@ fn parse_paths(files: &[OsString], b: &Behavior) -> Vec<PathBuf> {
     }
 }
 
-fn handle_two_paths(source: &Path, target: &Path, b: &Behavior) -> UResult<()> {
-    if b.backup == BackupMode::SimpleBackup && source_is_target_backup(source, target, &b.suffix) {
+fn handle_two_paths(source: &Path, target: &Path, opts: &Options) -> UResult<()> {
+    if opts.backup == BackupMode::Simple && source_is_target_backup(source, target, &opts.suffix) {
         return Err(io::Error::new(
             io::ErrorKind::NotFound,
             format!(
@@ -260,41 +337,44 @@ fn handle_two_paths(source: &Path, target: &Path, b: &Behavior) -> UResult<()> {
         .into());
     }
     if source.symlink_metadata().is_err() {
-        return Err(MvError::NoSuchFile(source.quote().to_string()).into());
+        return Err(if path_ends_with_terminator(source) {
+            MvError::CannotStatNotADirectory(source.quote().to_string()).into()
+        } else {
+            MvError::NoSuchFile(source.quote().to_string()).into()
+        });
     }
 
-    if (source.eq(target)
-        || are_hardlinks_to_same_file(source, target)
-        || are_hardlinks_or_one_way_symlink_to_same_file(source, target))
-        && b.backup == BackupMode::NoBackup
+    let target_is_dir = target.is_dir();
+    let source_is_dir = source.is_dir();
+
+    if path_ends_with_terminator(target)
+        && (!target_is_dir && !source_is_dir)
+        && !opts.no_target_dir
+        && opts.update != UpdateMode::IfOlder
     {
-        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());
-        }
+        return Err(MvError::FailedToAccessNotADirectory(target.quote().to_string()).into());
     }
 
-    if target.is_dir() {
-        if b.no_target_dir {
+    assert_not_same_file(source, target, target_is_dir, opts)?;
+
+    if target_is_dir {
+        if opts.no_target_dir {
             if source.is_dir() {
-                rename(source, target, b, None).map_err_context(|| {
+                rename(source, target, opts, 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)
+            move_files_into_dir(&[source.to_path_buf()], target, opts)
         }
     } else if target.exists() && source.is_dir() {
-        match b.overwrite {
+        match opts.overwrite {
             OverwriteMode::NoClobber => return Ok(()),
             OverwriteMode::Interactive => {
                 if !prompt_yes!("overwrite {}? ", target.quote()) {
-                    return Err(io::Error::new(io::ErrorKind::Other, "").into());
+                    return Err(io::Error::other("").into());
                 }
             }
             OverwriteMode::Force => {}
@@ -305,12 +385,94 @@ fn handle_two_paths(source: &Path, target: &Path, b: &Behavior) -> UResult<()> {
         )
         .into())
     } else {
-        rename(source, target, b, None).map_err(|e| USimpleError::new(1, format!("{e}")))
+        rename(source, target, opts, None).map_err(|e| USimpleError::new(1, format!("{e}")))
+    }
+}
+
+fn assert_not_same_file(
+    source: &Path,
+    target: &Path,
+    target_is_dir: bool,
+    opts: &Options,
+) -> UResult<()> {
+    // we'll compare canonicalized_source and canonicalized_target for same file detection
+    let canonicalized_source = match canonicalize(
+        absolute(source)?,
+        MissingHandling::Normal,
+        ResolveMode::Logical,
+    ) {
+        Ok(source) if source.exists() => source,
+        _ => absolute(source)?, // file or symlink target doesn't exist but its absolute path is still used for comparison
+    };
+
+    // special case if the target exists, is a directory, and the `-T` flag wasn't used
+    let target_is_dir = target_is_dir && !opts.no_target_dir;
+    let canonicalized_target = if target_is_dir {
+        // `mv source_file target_dir` => target_dir/source_file
+        // canonicalize the path that exists (target directory) and join the source file name
+        canonicalize(
+            absolute(target)?,
+            MissingHandling::Normal,
+            ResolveMode::Logical,
+        )?
+        .join(source.file_name().unwrap_or_default())
+    } else {
+        // `mv source target_dir/target` => target_dir/target
+        // we canonicalize target_dir and join /target
+        match absolute(target)?.parent() {
+            Some(parent) if parent.to_str() != Some("") => {
+                canonicalize(parent, MissingHandling::Normal, ResolveMode::Logical)?
+                    .join(target.file_name().unwrap_or_default())
+            }
+            // path.parent() returns Some("") or None if there's no parent
+            _ => absolute(target)?, // absolute paths should always have a parent, but we'll fall back just in case
+        }
+    };
+
+    let same_file = (canonicalized_source.eq(&canonicalized_target)
+        || are_hardlinks_to_same_file(source, target)
+        || are_hardlinks_or_one_way_symlink_to_same_file(source, target))
+        && opts.backup == BackupMode::None;
+
+    // get the expected target path to show in errors
+    // this is based on the argument and not canonicalized
+    let target_display = match source.file_name() {
+        Some(file_name) if target_is_dir => {
+            // join target_dir/source_file in a platform-independent manner
+            let mut path = target
+                .display()
+                .to_string()
+                .trim_end_matches('/')
+                .to_owned();
+
+            path.push('/');
+            path.push_str(&file_name.to_string_lossy());
+
+            path.quote().to_string()
+        }
+        _ => target.quote().to_string(),
+    };
+
+    if same_file
+        && (canonicalized_source.eq(&canonicalized_target)
+            || source.eq(Path::new("."))
+            || source.ends_with("/.")
+            || source.is_file())
+    {
+        return Err(MvError::SameFile(source.quote().to_string(), target_display).into());
+    } else if (same_file || canonicalized_target.starts_with(canonicalized_source))
+        // don't error if we're moving a symlink of a directory into itself
+        && !source.is_symlink()
+    {
+        return Err(
+            MvError::SelfTargetSubdirectory(source.quote().to_string(), target_display).into(),
+        );
     }
+    Ok(())
 }
 
-fn handle_multiple_paths(paths: &[PathBuf], b: &Behavior) -> UResult<()> {
-    if b.no_target_dir {
+fn handle_multiple_paths(paths: &[PathBuf], opts: &Options) -> UResult<()> {
+    if opts.no_target_dir {
         return Err(UUsageError::new(
             1,
             format!("mv: extra operand {}", paths[2].quote()),
@@ -319,33 +481,35 @@ fn handle_multiple_paths(paths: &[PathBuf], b: &Behavior) -> UResult<()> {
     let target_dir = paths.last().unwrap();
     let sources = &paths[..paths.len() - 1];
 
-    move_files_into_dir(sources, target_dir, b)
+    move_files_into_dir(sources, target_dir, opts)
 }
 
-fn exec(files: &[OsString], b: &Behavior) -> UResult<()> {
-    let paths = parse_paths(files, b);
+/// Execute the mv command. This moves 'source' to 'target', where
+/// 'target' is a directory. If 'target' does not exist, and source is a single
+/// file or directory, then 'source' will be renamed to 'target'.
+pub fn mv(files: &[OsString], opts: &Options) -> UResult<()> {
+    let paths = parse_paths(files, opts);
 
-    if let Some(ref name) = b.target_dir {
-        return move_files_into_dir(&paths, &PathBuf::from(name), b);
+    if let Some(ref name) = opts.target_dir {
+        return move_files_into_dir(&paths, &PathBuf::from(name), opts);
     }
 
     match paths.len() {
-        2 => handle_two_paths(&paths[0], &paths[1], b),
-        _ => handle_multiple_paths(&paths, b),
+        2 => handle_two_paths(&paths[0], &paths[1], opts),
+        _ => handle_multiple_paths(&paths, opts),
     }
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UResult<()> {
+fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, options: &Options) -> UResult<()> {
+    // remember the moved destinations for further usage
+    let mut moved_destinations: HashSet<PathBuf> = HashSet::with_capacity(files.len());
+
     if !target_dir.is_dir() {
         return Err(MvError::NotADirectory(target_dir.quote().to_string()).into());
     }
 
-    let canonized_target_dir = target_dir
-        .canonicalize()
-        .unwrap_or_else(|_| target_dir.to_path_buf());
-
-    let multi_progress = b.progress_bar.then(MultiProgress::new);
+    let multi_progress = options.progress_bar.then(MultiProgress::new);
 
     let count_progress = if let Some(ref multi_progress) = multi_progress {
         if files.len() > 1 {
@@ -362,6 +526,11 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
     };
 
     for sourcepath in files {
+        if !sourcepath.exists() {
+            show!(MvError::NoSuchFile(sourcepath.quote().to_string()));
+            continue;
+        }
+
         if let Some(ref pb) = count_progress {
             pb.set_message(sourcepath.to_string_lossy().to_string());
         }
@@ -374,29 +543,27 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
             }
         };
 
+        if moved_destinations.contains(&targetpath) && options.backup != BackupMode::Numbered {
+            // If the target file was already created in this mv call, do not overwrite
+            show!(USimpleError::new(
+                1,
+                format!(
+                    "will not overwrite just-created '{}' with '{}'",
+                    targetpath.display(),
+                    sourcepath.display()
+                ),
+            ));
+            continue;
+        }
+
         // Check if we have mv dir1 dir2 dir2
         // And generate an error if this is the case
-        if let Ok(canonized_source) = sourcepath.canonicalize() {
-            if canonized_source == canonized_target_dir {
-                // User tried to move directory to itself, warning is shown
-                // and process of moving files is continued.
-                show!(USimpleError::new(
-                    1,
-                    format!(
-                        "cannot move '{}' to a subdirectory of itself, '{}/{}'",
-                        sourcepath.display(),
-                        target_dir.display(),
-                        canonized_target_dir.components().last().map_or_else(
-                            || target_dir.display().to_string(),
-                            |dir| { PathBuf::from(dir.as_os_str()).display().to_string() }
-                        )
-                    )
-                ));
-                continue;
-            }
+        if let Err(e) = assert_not_same_file(sourcepath, target_dir, true, options) {
+            show!(e);
+            continue;
         }
 
-        match rename(sourcepath, &targetpath, b, multi_progress.as_ref()) {
+        match rename(sourcepath, &targetpath, options, multi_progress.as_ref()) {
             Err(e) if e.to_string().is_empty() => set_exit_code(1),
             Err(e) => {
                 let e = e.map_err_context(|| {
@@ -413,10 +580,10 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
             }
             Ok(()) => (),
         }
-
         if let Some(ref pb) = count_progress {
             pb.inc(1);
         }
+        moved_destinations.insert(targetpath.clone());
     }
     Ok(())
 }
@@ -424,50 +591,46 @@ fn move_files_into_dir(files: &[PathBuf], target_dir: &Path, b: &Behavior) -> UR
 fn rename(
     from: &Path,
     to: &Path,
-    b: &Behavior,
+    opts: &Options,
     multi_progress: Option<&MultiProgress>,
 ) -> io::Result<()> {
     let mut backup_path = None;
 
     if to.exists() {
-        if b.update == UpdateMode::ReplaceIfOlder && 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 {
+        if opts.update == UpdateMode::None {
+            if opts.debug {
+                println!("skipped {}", to.quote());
+            }
             return Ok(());
         }
 
-        if (b.update == UpdateMode::ReplaceIfOlder)
+        if (opts.update == UpdateMode::IfOlder)
             && fs::metadata(from)?.modified()? <= fs::metadata(to)?.modified()?
         {
             return Ok(());
         }
 
-        match b.overwrite {
+        if opts.update == UpdateMode::NoneFail {
+            let err_msg = format!("not replacing {}", to.quote());
+            return Err(io::Error::other(err_msg));
+        }
+
+        match opts.overwrite {
             OverwriteMode::NoClobber => {
-                let err_msg = if b.verbose {
+                if opts.debug {
                     println!("skipped {}", to.quote());
-                    String::new()
-                } else {
-                    format!("not replacing {}", to.quote())
-                };
-                return Err(io::Error::new(io::ErrorKind::Other, err_msg));
+                }
+                return Ok(());
             }
             OverwriteMode::Interactive => {
                 if !prompt_yes!("overwrite {}?", to.quote()) {
-                    if b.verbose {
-                        println!("skipped {}", to.quote());
-                    }
-                    return Err(io::Error::new(io::ErrorKind::Other, ""));
+                    return Err(io::Error::other(""));
                 }
             }
             OverwriteMode::Force => {}
         };
 
-        backup_path = backup_control::get_backup_path(b.backup, to, &b.suffix);
+        backup_path = backup_control::get_backup_path(opts.backup, to, &opts.suffix);
         if let Some(ref backup_path) = backup_path {
             rename_with_fallback(to, backup_path, multi_progress)?;
         }
@@ -480,14 +643,14 @@ fn rename(
             if is_empty_dir(to) {
                 fs::remove_dir(to)?;
             } else {
-                return Err(io::Error::new(io::ErrorKind::Other, "Directory not empty"));
+                return Err(io::Error::other("Directory not empty"));
             }
         }
     }
 
     rename_with_fallback(from, to, multi_progress)?;
 
-    if b.verbose {
+    if opts.verbose {
         let message = match backup_path {
             Some(path) => format!(
                 "renamed {} -> {} (backup: {})",
@@ -508,6 +671,16 @@ fn rename(
     Ok(())
 }
 
+#[cfg(unix)]
+fn is_fifo(filetype: fs::FileType) -> bool {
+    filetype.is_fifo()
+}
+
+#[cfg(not(unix))]
+fn is_fifo(_filetype: fs::FileType) -> bool {
+    false
+}
+
 /// A wrapper around `fs::rename`, so that if it fails, we try falling back on
 /// copying and removing.
 fn rename_with_fallback(
@@ -515,107 +688,170 @@ fn rename_with_fallback(
     to: &Path,
     multi_progress: Option<&MultiProgress>,
 ) -> io::Result<()> {
-    if fs::rename(from, to).is_err() {
+    fs::rename(from, to).or_else(|err| {
+        #[cfg(windows)]
+        const EXDEV: i32 = windows_sys::Win32::Foundation::ERROR_NOT_SAME_DEVICE as _;
+        #[cfg(unix)]
+        const EXDEV: i32 = libc::EXDEV as _;
+
+        // We will only copy if:
+        // 1. Files are on different devices (EXDEV error)
+        // 2. On Windows, if the target file exists and source file is opened by another process
+        //    (MoveFileExW fails with "Access Denied" even if the source file has FILE_SHARE_DELETE permission)
+        let should_fallback =
+            matches!(err.raw_os_error(), Some(EXDEV)) || (from.is_file() && can_delete_file(from));
+        if !should_fallback {
+            return Err(err);
+        }
         // Get metadata without following symlinks
         let metadata = from.symlink_metadata()?;
         let file_type = metadata.file_type();
-
         if file_type.is_symlink() {
-            rename_symlink_fallback(from, to)?;
+            rename_symlink_fallback(from, to)
         } else if file_type.is_dir() {
-            // We remove the destination directory if it exists to match the
-            // behavior of `fs::rename`. As far as I can tell, `fs_extra`'s
-            // `move_dir` would otherwise behave differently.
-            if to.exists() {
-                fs::remove_dir_all(to)?;
-            }
-            let options = DirCopyOptions {
-                // From the `fs_extra` documentation:
-                // "Recursively copy a directory with a new name or place it
-                // inside the destination. (same behaviors like cp -r in Unix)"
-                copy_inside: true,
-                ..DirCopyOptions::new()
-            };
-
-            // Calculate total size of directory
-            // Silently degrades:
-            //    If finding the total size fails for whatever reason,
-            //    the progress bar wont be shown for this file / dir.
-            //    (Move will probably fail due to permission error later?)
-            let total_size = dir_get_size(from).ok();
-
-            let progress_bar =
-                if let (Some(multi_progress), Some(total_size)) = (multi_progress, total_size) {
-                    let bar = ProgressBar::new(total_size).with_style(
-                        ProgressStyle::with_template(
-                            "{msg}: [{elapsed_precise}] {wide_bar} {bytes:>7}/{total_bytes:7}",
-                        )
-                        .unwrap(),
-                    );
-
-                    Some(multi_progress.add(bar))
-                } else {
-                    None
-                };
-
-            let result = if let Some(ref pb) = progress_bar {
-                move_dir_with_progress(from, to, &options, |process_info: TransitProcess| {
-                    pb.set_position(process_info.copied_bytes);
-                    pb.set_message(process_info.file_name);
-                    TransitProcessResult::ContinueOrAbort
-                })
-            } else {
-                move_dir(from, to, &options)
-            };
-
-            if let Err(err) = result {
-                return match err.kind {
-                    fs_extra::error::ErrorKind::PermissionDenied => Err(io::Error::new(
-                        io::ErrorKind::PermissionDenied,
-                        "Permission denied",
-                    )),
-                    _ => Err(io::Error::new(io::ErrorKind::Other, format!("{err:?}"))),
-                };
-            }
+            rename_dir_fallback(from, to, multi_progress)
+        } else if is_fifo(file_type) {
+            rename_fifo_fallback(from, to)
         } else {
-            fs::copy(from, to).and_then(|_| fs::remove_file(from))?;
+            rename_file_fallback(from, to)
         }
+    })
+}
+
+/// Replace the destination with a new pipe with the same name as the source.
+#[cfg(unix)]
+fn rename_fifo_fallback(from: &Path, to: &Path) -> io::Result<()> {
+    if to.try_exists()? {
+        fs::remove_file(to)?;
     }
+    make_fifo(to).and_then(|_| fs::remove_file(from))
+}
+
+#[cfg(not(unix))]
+fn rename_fifo_fallback(_from: &Path, _to: &Path) -> io::Result<()> {
     Ok(())
 }
 
 /// Move the given symlink to the given destination. On Windows, dangling
 /// symlinks return an error.
-#[inline]
+#[cfg(unix)]
 fn rename_symlink_fallback(from: &Path, to: &Path) -> io::Result<()> {
     let path_symlink_points_to = fs::read_link(from)?;
-    #[cfg(unix)]
-    {
-        unix::fs::symlink(path_symlink_points_to, to).and_then(|_| fs::remove_file(from))?;
-    }
-    #[cfg(windows)]
-    {
-        if path_symlink_points_to.exists() {
-            if path_symlink_points_to.is_dir() {
-                windows::fs::symlink_dir(&path_symlink_points_to, to)?;
-            } else {
-                windows::fs::symlink_file(&path_symlink_points_to, to)?;
-            }
-            fs::remove_file(from)?;
+    unix::fs::symlink(path_symlink_points_to, to).and_then(|_| fs::remove_file(from))
+}
+
+#[cfg(windows)]
+fn rename_symlink_fallback(from: &Path, to: &Path) -> io::Result<()> {
+    let path_symlink_points_to = fs::read_link(from)?;
+    if path_symlink_points_to.exists() {
+        if path_symlink_points_to.is_dir() {
+            windows::fs::symlink_dir(&path_symlink_points_to, to)?;
         } else {
-            return Err(io::Error::new(
-                io::ErrorKind::NotFound,
-                "can't determine symlink type, since it is dangling",
-            ));
+            windows::fs::symlink_file(&path_symlink_points_to, to)?;
         }
+        fs::remove_file(from)
+    } else {
+        Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "can't determine symlink type, since it is dangling",
+        ))
     }
-    #[cfg(not(any(windows, unix)))]
-    {
-        return Err(io::Error::new(
-            io::ErrorKind::Other,
-            "your operating system does not support symlinks",
-        ));
+}
+
+#[cfg(not(any(windows, unix)))]
+fn rename_symlink_fallback(from: &Path, to: &Path) -> io::Result<()> {
+    let path_symlink_points_to = fs::read_link(from)?;
+    Err(io::Error::new(
+        io::ErrorKind::Other,
+        "your operating system does not support symlinks",
+    ))
+}
+
+fn rename_dir_fallback(
+    from: &Path,
+    to: &Path,
+    multi_progress: Option<&MultiProgress>,
+) -> io::Result<()> {
+    // We remove the destination directory if it exists to match the
+    // behavior of `fs::rename`. As far as I can tell, `fs_extra`'s
+    // `move_dir` would otherwise behave differently.
+    if to.exists() {
+        fs::remove_dir_all(to)?;
     }
+    let options = DirCopyOptions {
+        // From the `fs_extra` documentation:
+        // "Recursively copy a directory with a new name or place it
+        // inside the destination. (same behaviors like cp -r in Unix)"
+        copy_inside: true,
+        ..DirCopyOptions::new()
+    };
+
+    // Calculate total size of directory
+    // Silently degrades:
+    //    If finding the total size fails for whatever reason,
+    //    the progress bar wont be shown for this file / dir.
+    //    (Move will probably fail due to permission error later?)
+    let total_size = dir_get_size(from).ok();
+
+    let progress_bar = match (multi_progress, total_size) {
+        (Some(multi_progress), Some(total_size)) => {
+            let template = "{msg}: [{elapsed_precise}] {wide_bar} {bytes:>7}/{total_bytes:7}";
+            let style = ProgressStyle::with_template(template).unwrap();
+            let bar = ProgressBar::new(total_size).with_style(style);
+            Some(multi_progress.add(bar))
+        }
+        (_, _) => None,
+    };
+
+    #[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+    let xattrs =
+        fsxattr::retrieve_xattrs(from).unwrap_or_else(|_| std::collections::HashMap::new());
+
+    let result = if let Some(ref pb) = progress_bar {
+        move_dir_with_progress(from, to, &options, |process_info: TransitProcess| {
+            pb.set_position(process_info.copied_bytes);
+            pb.set_message(process_info.file_name);
+            TransitProcessResult::ContinueOrAbort
+        })
+    } else {
+        move_dir(from, to, &options)
+    };
+
+    #[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+    fsxattr::apply_xattrs(to, xattrs)?;
+
+    match result {
+        Err(err) => match err.kind {
+            fs_extra::error::ErrorKind::PermissionDenied => Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                "Permission denied",
+            )),
+            _ => Err(io::Error::other(format!("{err:?}"))),
+        },
+        _ => Ok(()),
+    }
+}
+
+fn rename_file_fallback(from: &Path, to: &Path) -> io::Result<()> {
+    if to.is_symlink() {
+        fs::remove_file(to).map_err(|err| {
+            let to = to.to_string_lossy();
+            let from = from.to_string_lossy();
+            io::Error::new(
+                err.kind(),
+                format!(
+                    "inter-device move failed: '{from}' to '{to}'\
+                            ; unable to remove target: {err}"
+                ),
+            )
+        })?;
+    }
+    #[cfg(all(unix, not(any(target_os = "macos", target_os = "redox"))))]
+    fs::copy(from, to)
+        .and_then(|_| fsxattr::copy_xattrs(&from, &to))
+        .and_then(|_| fs::remove_file(from))?;
+    #[cfg(any(target_os = "macos", target_os = "redox", not(unix)))]
+    fs::copy(from, to).and_then(|_| fs::remove_file(from))?;
     Ok(())
 }
 
@@ -625,3 +861,55 @@ fn is_empty_dir(path: &Path) -> bool {
         Err(_e) => false,
     }
 }
+
+/// Checks if a file can be deleted by attempting to open it with delete permissions.
+#[cfg(windows)]
+fn can_delete_file(path: &Path) -> bool {
+    use std::{
+        os::windows::ffi::OsStrExt as _,
+        ptr::{null, null_mut},
+    };
+
+    use windows_sys::Win32::{
+        Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
+        Storage::FileSystem::{
+            CreateFileW, DELETE, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_DELETE, FILE_SHARE_READ,
+            FILE_SHARE_WRITE, OPEN_EXISTING,
+        },
+    };
+
+    let wide_path = path
+        .as_os_str()
+        .encode_wide()
+        .chain([0])
+        .collect::<Vec<u16>>();
+
+    let handle = unsafe {
+        CreateFileW(
+            wide_path.as_ptr(),
+            DELETE,
+            FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+            null(),
+            OPEN_EXISTING,
+            FILE_ATTRIBUTE_NORMAL,
+            null_mut(),
+        )
+    };
+
+    if handle == INVALID_HANDLE_VALUE {
+        return false;
+    }
+
+    unsafe { CloseHandle(handle) };
+
+    true
+}
+
+#[cfg(not(windows))]
+fn can_delete_file(_: &Path) -> bool {
+    // On non-Windows platforms, always return false to indicate that we don't need
+    // to try the copy+delete fallback. This is because on Unix-like systems,
+    // rename() failing with errors other than EXDEV means the operation cannot
+    // succeed even with a copy+delete approach (e.g. permission errors).
+    false
+}
diff --git a/src/uu/nice/Cargo.toml b/src/uu/nice/Cargo.toml
index 65e1520d1b3..991f277a181 100644
--- a/src/uu/nice/Cargo.toml
+++ b/src/uu/nice/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_nice"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "nice ~ (uutils) run PROGRAM with modified scheduling priority"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nice"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/nice.rs"
diff --git a/src/uu/nice/src/nice.rs b/src/uu/nice/src/nice.rs
index 3eaeba95657..05ae2fa94da 100644
--- a/src/uu/nice/src/nice.rs
+++ b/src/uu/nice/src/nice.rs
@@ -5,14 +5,14 @@
 
 // spell-checker:ignore (ToDO) getpriority execvp setpriority nstr PRIO cstrs ENOENT
 
-use libc::{c_char, c_int, execvp, PRIO_PROCESS};
+use libc::{PRIO_PROCESS, c_char, c_int, execvp};
 use std::ffi::{CString, OsString};
 use std::io::{Error, Write};
 use std::ptr;
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use uucore::{
-    error::{set_exit_code, UClapError, UResult, USimpleError, UUsageError},
+    error::{UClapError, UResult, USimpleError, UUsageError, set_exit_code},
     format_usage, help_about, help_usage, show_error,
 };
 
@@ -71,8 +71,7 @@ fn standardize_nice_args(mut args: impl uucore::Args) -> impl uucore::Args {
             saw_n = false;
         } else if s.to_str() == Some("-n")
             || s.to_str()
-                .map(|s| is_prefix_of(s, "--adjustment", "--a".len()))
-                .unwrap_or_default()
+                .is_some_and(|s| is_prefix_of(s, "--adjustment", "--a".len()))
         {
             saw_n = true;
         } else if let Ok(s) = s.clone().into_string() {
@@ -132,7 +131,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                     return Err(USimpleError::new(
                         125,
                         format!("\"{nstr}\" is not a valid number: {e}"),
-                    ))
+                    ));
                 }
             }
         }
@@ -191,7 +190,7 @@ pub fn uu_app() -> Command {
         .override_usage(format_usage(USAGE))
         .trailing_var_arg(true)
         .infer_long_args(true)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .arg(
             Arg::new(options::ADJUSTMENT)
                 .short('n')
diff --git a/src/uu/nl/Cargo.toml b/src/uu/nl/Cargo.toml
index db2bfacbd70..b3d6f492de7 100644
--- a/src/uu/nl/Cargo.toml
+++ b/src/uu/nl/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_nl"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "nl ~ (uutils) display input with added line numbers"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nl"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/nl.rs"
diff --git a/src/uu/nl/src/helper.rs b/src/uu/nl/src/helper.rs
index fe550e6a063..3e5a96b9ca2 100644
--- a/src/uu/nl/src/helper.rs
+++ b/src/uu/nl/src/helper.rs
@@ -13,8 +13,17 @@ pub fn parse_options(settings: &mut crate::Settings, opts: &clap::ArgMatches) ->
     // This vector holds error messages encountered.
     let mut errs: Vec<String> = vec![];
     settings.renumber = opts.get_flag(options::NO_RENUMBER);
+    if let Some(delimiter) = opts.get_one::<String>(options::SECTION_DELIMITER) {
+        // check whether the delimiter is a single ASCII char (1 byte)
+        // because GNU nl doesn't add a ':' to single non-ASCII chars
+        settings.section_delimiter = if delimiter.len() == 1 {
+            format!("{delimiter}:")
+        } else {
+            delimiter.clone()
+        };
+    }
     if let Some(val) = opts.get_one::<String>(options::NUMBER_SEPARATOR) {
-        settings.number_separator = val.to_owned();
+        settings.number_separator.clone_from(val);
     }
     settings.number_format = opts
         .get_one::<String>(options::NUMBER_FORMAT)
@@ -27,7 +36,7 @@ pub fn parse_options(settings: &mut crate::Settings, opts: &clap::ArgMatches) ->
     {
         None => {}
         Some(Ok(style)) => settings.header_numbering = style,
-        Some(Err(message)) => errs.push(message.to_string()),
+        Some(Err(message)) => errs.push(message),
     }
     match opts
         .get_one::<String>(options::BODY_NUMBERING)
@@ -36,7 +45,7 @@ pub fn parse_options(settings: &mut crate::Settings, opts: &clap::ArgMatches) ->
     {
         None => {}
         Some(Ok(style)) => settings.body_numbering = style,
-        Some(Err(message)) => errs.push(message.to_string()),
+        Some(Err(message)) => errs.push(message),
     }
     match opts
         .get_one::<String>(options::FOOTER_NUMBERING)
@@ -45,7 +54,7 @@ pub fn parse_options(settings: &mut crate::Settings, opts: &clap::ArgMatches) ->
     {
         None => {}
         Some(Ok(style)) => settings.footer_numbering = style,
-        Some(Err(message)) => errs.push(message.to_string()),
+        Some(Err(message)) => errs.push(message),
     }
     match opts.get_one::<usize>(options::NUMBER_WIDTH) {
         None => {}
diff --git a/src/uu/nl/src/nl.rs b/src/uu/nl/src/nl.rs
index 61a0a9f35f4..6380417e0e8 100644
--- a/src/uu/nl/src/nl.rs
+++ b/src/uu/nl/src/nl.rs
@@ -3,12 +3,12 @@
 // 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, Command};
+use clap::{Arg, ArgAction, Command};
 use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, Read};
+use std::io::{BufRead, BufReader, Read, stdin};
 use std::path::Path;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, help_about, help_section, help_usage};
+use uucore::error::{FromIo, UResult, USimpleError, set_exit_code};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 mod helper;
 
@@ -23,7 +23,7 @@ pub struct Settings {
     body_numbering: NumberingStyle,
     footer_numbering: NumberingStyle,
     // The variable corresponding to -d
-    section_delimiter: [char; 2],
+    section_delimiter: String,
     // The variables corresponding to the options -v, -i, -l, -w.
     starting_line_number: i64,
     line_increment: i64,
@@ -43,7 +43,7 @@ impl Default for Settings {
             header_numbering: NumberingStyle::None,
             body_numbering: NumberingStyle::NonEmpty,
             footer_numbering: NumberingStyle::None,
-            section_delimiter: ['\\', ':'],
+            section_delimiter: String::from("\\:"),
             starting_line_number: 1,
             line_increment: 1,
             join_blank_lines: 1,
@@ -55,6 +55,20 @@ impl Default for Settings {
     }
 }
 
+struct Stats {
+    line_number: Option<i64>,
+    consecutive_empty_lines: u64,
+}
+
+impl Stats {
+    fn new(starting_line_number: i64) -> Self {
+        Self {
+            line_number: Some(starting_line_number),
+            consecutive_empty_lines: 0,
+        }
+    }
+}
+
 // NumberingStyle stores which lines are to be numbered.
 // The possible options are:
 // 1. Number all lines
@@ -120,6 +134,32 @@ impl NumberFormat {
     }
 }
 
+enum SectionDelimiter {
+    Header,
+    Body,
+    Footer,
+}
+
+impl SectionDelimiter {
+    // A valid section delimiter contains the pattern one to three times,
+    // and nothing else.
+    fn parse(s: &str, pattern: &str) -> Option<Self> {
+        if s.is_empty() || pattern.is_empty() {
+            return None;
+        }
+
+        let pattern_count = s.matches(pattern).count();
+        let is_length_ok = pattern_count * pattern.len() == s.len();
+
+        match (pattern_count, is_length_ok) {
+            (3, true) => Some(Self::Header),
+            (2, true) => Some(Self::Body),
+            (1, true) => Some(Self::Footer),
+            _ => None,
+        }
+    }
+}
+
 pub mod options {
     pub const HELP: &str = "help";
     pub const FILE: &str = "file";
@@ -138,8 +178,6 @@ pub mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let mut settings = Settings::default();
@@ -154,36 +192,38 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         ));
     }
 
-    let mut read_stdin = false;
     let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
-        Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+        Some(v) => v.cloned().collect(),
         None => vec!["-".to_owned()],
     };
 
+    let mut stats = Stats::new(settings.starting_line_number);
+
     for file in &files {
         if file == "-" {
-            // If both file names and '-' are specified, we choose to treat first all
-            // regular files, and then read from stdin last.
-            read_stdin = true;
-            continue;
+            let mut buffer = BufReader::new(stdin());
+            nl(&mut buffer, &mut stats, &settings)?;
+        } else {
+            let path = Path::new(file);
+
+            if path.is_dir() {
+                show_error!("{}: Is a directory", path.display());
+                set_exit_code(1);
+            } else {
+                let reader = File::open(path).map_err_context(|| file.to_string())?;
+                let mut buffer = BufReader::new(reader);
+                nl(&mut buffer, &mut stats, &settings)?;
+            }
         }
-        let path = Path::new(file);
-        let reader = File::open(path).map_err_context(|| file.to_string())?;
-        let mut buffer = BufReader::new(reader);
-        nl(&mut buffer, &settings)?;
     }
 
-    if read_stdin {
-        let mut buffer = BufReader::new(stdin());
-        nl(&mut buffer, &settings)?;
-    }
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .about(ABOUT)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
         .infer_long_args(true)
@@ -285,34 +325,30 @@ pub fn uu_app() -> Command {
 }
 
 // nl implements the main functionality for an individual buffer.
-fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
+fn nl<T: Read>(reader: &mut BufReader<T>, stats: &mut Stats, settings: &Settings) -> UResult<()> {
     let mut current_numbering_style = &settings.body_numbering;
-    let mut line_no = settings.starting_line_number;
-    let mut consecutive_empty_lines = 0;
 
     for line in reader.lines() {
         let line = line.map_err_context(|| "could not read line".to_string())?;
 
         if line.is_empty() {
-            consecutive_empty_lines += 1;
+            stats.consecutive_empty_lines += 1;
         } else {
-            consecutive_empty_lines = 0;
+            stats.consecutive_empty_lines = 0;
         };
 
-        // FIXME section delimiters are hardcoded and settings.section_delimiter is ignored
-        // because --section-delimiter is not correctly implemented yet
-        let _ = settings.section_delimiter; // XXX suppress "field never read" warning
-        let new_numbering_style = match line.as_str() {
-            "\\:\\:\\:" => Some(&settings.header_numbering),
-            "\\:\\:" => Some(&settings.body_numbering),
-            "\\:" => Some(&settings.footer_numbering),
-            _ => None,
+        let new_numbering_style = match SectionDelimiter::parse(&line, &settings.section_delimiter)
+        {
+            Some(SectionDelimiter::Header) => Some(&settings.header_numbering),
+            Some(SectionDelimiter::Body) => Some(&settings.body_numbering),
+            Some(SectionDelimiter::Footer) => Some(&settings.footer_numbering),
+            None => None,
         };
 
         if let Some(new_style) = new_numbering_style {
             current_numbering_style = new_style;
             if settings.renumber {
-                line_no = settings.starting_line_number;
+                stats.line_number = Some(settings.starting_line_number);
             }
             println!();
         } else {
@@ -321,7 +357,7 @@ fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
                 // for numbering, and only number the last one
                 NumberingStyle::All
                     if line.is_empty()
-                        && consecutive_empty_lines % settings.join_blank_lines != 0 =>
+                        && stats.consecutive_empty_lines % settings.join_blank_lines != 0 =>
                 {
                     false
                 }
@@ -332,18 +368,20 @@ fn nl<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
             };
 
             if is_line_numbered {
+                let Some(line_number) = stats.line_number else {
+                    return Err(USimpleError::new(1, "line number overflow"));
+                };
                 println!(
-                    "{}{}{}",
+                    "{}{}{line}",
                     settings
                         .number_format
-                        .format(line_no, settings.number_width),
+                        .format(line_number, settings.number_width),
                     settings.number_separator,
-                    line
                 );
                 // update line number for the potential next line
-                match line_no.checked_add(settings.line_increment) {
-                    Some(new_line_no) => line_no = new_line_no,
-                    None => return Err(USimpleError::new(1, "line number overflow")),
+                match line_number.checked_add(settings.line_increment) {
+                    Some(new_line_number) => stats.line_number = Some(new_line_number),
+                    None => stats.line_number = None, // overflow
                 }
             } else {
                 let spaces = " ".repeat(settings.number_width + 1);
@@ -359,6 +397,7 @@ mod test {
     use super::*;
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_format() {
         assert_eq!(NumberFormat::Left.format(12, 1), "12");
         assert_eq!(NumberFormat::Left.format(-12, 1), "-12");
diff --git a/src/uu/nohup/Cargo.toml b/src/uu/nohup/Cargo.toml
index 2a454b9f433..9cb1b3be686 100644
--- a/src/uu/nohup/Cargo.toml
+++ b/src/uu/nohup/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_nohup"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "nohup ~ (uutils) run COMMAND, ignoring hangup signals"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nohup"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/nohup.rs"
@@ -17,8 +20,8 @@ path = "src/nohup.rs"
 [dependencies]
 clap = { workspace = true }
 libc = { workspace = true }
-is-terminal = { workspace = true }
 uucore = { workspace = true, features = ["fs"] }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "nohup"
diff --git a/src/uu/nohup/nohup.md b/src/uu/nohup/nohup.md
index cc35ef9f46c..65ffaec873d 100644
--- a/src/uu/nohup/nohup.md
+++ b/src/uu/nohup/nohup.md
@@ -2,7 +2,7 @@
 
 ```
 nohup COMMAND [ARG]...
-nohup FLAG
+nohup OPTION
 ```
 
 Run COMMAND ignoring hangup signals.
diff --git a/src/uu/nohup/src/nohup.rs b/src/uu/nohup/src/nohup.rs
index fdbed93956b..73003a16416 100644
--- a/src/uu/nohup/src/nohup.rs
+++ b/src/uu/nohup/src/nohup.rs
@@ -5,19 +5,18 @@
 
 // spell-checker:ignore (ToDO) execvp SIGHUP cproc vprocmgr cstrs homeout
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use is_terminal::IsTerminal;
+use clap::{Arg, ArgAction, Command};
+use libc::{SIG_IGN, SIGHUP};
 use libc::{c_char, dup2, execvp, signal};
-use libc::{SIGHUP, SIG_IGN};
 use std::env;
 use std::ffi::CString;
-use std::fmt::{Display, Formatter};
 use std::fs::{File, OpenOptions};
-use std::io::Error;
+use std::io::{Error, IsTerminal};
 use std::os::unix::prelude::*;
 use std::path::{Path, PathBuf};
+use thiserror::Error;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UClapError, UError, UResult};
+use uucore::error::{UClapError, UError, UResult, set_exit_code};
 use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 const ABOUT: &str = help_about!("nohup.md");
@@ -34,15 +33,24 @@ mod options {
     pub const CMD: &str = "cmd";
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum NohupError {
+    #[error("Cannot detach from console")]
     CannotDetach,
-    CannotReplace(&'static str, std::io::Error),
-    OpenFailed(i32, std::io::Error),
-    OpenFailed2(i32, std::io::Error, String, std::io::Error),
-}
 
-impl std::error::Error for NohupError {}
+    #[error("Cannot replace {name}: {err}", name = .0, err = .1)]
+    CannotReplace(&'static str, #[source] Error),
+
+    #[error("failed to open {path}: {err}", path = NOHUP_OUT.quote(), err = .1)]
+    OpenFailed(i32, #[source] Error),
+
+    #[error("failed to open {first_path}: {first_err}\nfailed to open {second_path}: {second_err}",
+            first_path = NOHUP_OUT.quote(),
+            first_err = .1,
+            second_path = .2.quote(),
+            second_err = .3)]
+    OpenFailed2(i32, #[source] Error, String, Error),
+}
 
 impl UError for NohupError {
     fn code(&self) -> i32 {
@@ -53,30 +61,8 @@ impl UError for NohupError {
     }
 }
 
-impl Display for NohupError {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        match self {
-            Self::CannotDetach => write!(f, "Cannot detach from console"),
-            Self::CannotReplace(s, e) => write!(f, "Cannot replace {s}: {e}"),
-            Self::OpenFailed(_, e) => {
-                write!(f, "failed to open {}: {}", NOHUP_OUT.quote(), e)
-            }
-            Self::OpenFailed2(_, e1, s, e2) => write!(
-                f,
-                "failed to open {}: {}\nfailed to open {}: {}",
-                NOHUP_OUT.quote(),
-                e1,
-                s.quote(),
-                e2
-            ),
-        }
-    }
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     replace_fds()?;
@@ -105,7 +91,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -145,13 +131,12 @@ fn replace_fds() -> UResult<()> {
 }
 
 fn find_stdout() -> UResult<File> {
-    let internal_failure_code = match std::env::var("POSIXLY_CORRECT") {
+    let internal_failure_code = match env::var("POSIXLY_CORRECT") {
         Ok(_) => POSIX_NOHUP_FAILURE,
         Err(_) => EXIT_CANCELED,
     };
 
     match OpenOptions::new()
-        .write(true)
         .create(true)
         .append(true)
         .open(Path::new(NOHUP_OUT))
@@ -171,12 +156,7 @@ fn find_stdout() -> UResult<File> {
             let mut homeout = PathBuf::from(home);
             homeout.push(NOHUP_OUT);
             let homeout_str = homeout.to_str().unwrap();
-            match OpenOptions::new()
-                .write(true)
-                .create(true)
-                .append(true)
-                .open(&homeout)
-            {
+            match OpenOptions::new().create(true).append(true).open(&homeout) {
                 Ok(t) => {
                     show_error!(
                         "ignoring input and appending output to {}",
@@ -197,11 +177,18 @@ fn find_stdout() -> UResult<File> {
 }
 
 #[cfg(target_vendor = "apple")]
-extern "C" {
+unsafe extern "C" {
     fn _vprocmgr_detach_from_console(flags: u32) -> *const libc::c_int;
 }
 
-#[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "openbsd"
+))]
+/// # Safety
+/// This function is unsafe because it dereferences a raw pointer.
 unsafe fn _vprocmgr_detach_from_console(_: u32) -> *const libc::c_int {
     std::ptr::null()
 }
diff --git a/src/uu/nproc/Cargo.toml b/src/uu/nproc/Cargo.toml
index b6052de2ed3..904fb23dfa4 100644
--- a/src/uu/nproc/Cargo.toml
+++ b/src/uu/nproc/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_nproc"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "nproc ~ (uutils) display the number of processing units available"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/nproc"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/nproc.rs"
diff --git a/src/uu/nproc/src/nproc.rs b/src/uu/nproc/src/nproc.rs
index d0bd3083d77..a3a80724dc9 100644
--- a/src/uu/nproc/src/nproc.rs
+++ b/src/uu/nproc/src/nproc.rs
@@ -3,9 +3,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) NPROCESSORS nprocs numstr threadstr sysconf
+// spell-checker:ignore (ToDO) NPROCESSORS nprocs numstr sysconf
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::{env, thread};
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
@@ -36,7 +36,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             Err(e) => {
                 return Err(USimpleError::new(
                     1,
-                    format!("{} is not a valid number: {}", numstr.quote(), e),
+                    format!("{} is not a valid number: {e}", numstr.quote()),
                 ));
             }
         },
@@ -47,7 +47,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         // Uses the OpenMP variable to limit the number of threads
         // If the parsing fails, returns the max size (so, no impact)
         // If OMP_THREAD_LIMIT=0, rejects the value
-        Ok(threadstr) => match threadstr.parse() {
+        Ok(threads) => match threads.parse() {
             Ok(0) | Err(_) => usize::MAX,
             Ok(n) => n,
         },
@@ -63,14 +63,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         match env::var("OMP_NUM_THREADS") {
             // Uses the OpenMP variable to force the number of threads
             // If the parsing fails, returns the number of CPU
-            Ok(threadstr) => {
+            Ok(threads) => {
                 // In some cases, OMP_NUM_THREADS can be "x,y,z"
                 // In this case, only take the first one (like GNU)
                 // If OMP_NUM_THREADS=0, rejects the value
-                let thread: Vec<&str> = threadstr.split_terminator(',').collect();
-                match &thread[..] {
-                    [] => available_parallelism(),
-                    [s, ..] => match s.parse() {
+                match threads.split_terminator(',').next() {
+                    None => available_parallelism(),
+                    Some(s) => match s.parse() {
                         Ok(0) | Err(_) => available_parallelism(),
                         Ok(n) => n,
                     },
@@ -94,7 +93,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/numfmt/Cargo.toml b/src/uu/numfmt/Cargo.toml
index 8fbf886a241..e762a7c494c 100644
--- a/src/uu/numfmt/Cargo.toml
+++ b/src/uu/numfmt/Cargo.toml
@@ -1,22 +1,26 @@
 [package]
 name = "uu_numfmt"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "numfmt ~ (uutils) reformat NUMBER"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/numfmt"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/numfmt.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["ranges"] }
+uucore = { workspace = true, features = ["parser", "ranges"] }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "numfmt"
diff --git a/src/uu/numfmt/src/errors.rs b/src/uu/numfmt/src/errors.rs
index 77dd6f0aade..d3dcc48732c 100644
--- a/src/uu/numfmt/src/errors.rs
+++ b/src/uu/numfmt/src/errors.rs
@@ -3,13 +3,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use std::{
-    error::Error,
-    fmt::{Debug, Display},
-};
+use std::fmt::Debug;
+use thiserror::Error;
 use uucore::error::UError;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
+#[error("{0}")]
 pub enum NumfmtError {
     IoError(String),
     IllegalArgument(String),
@@ -25,15 +24,3 @@ impl UError for NumfmtError {
         }
     }
 }
-
-impl Error for NumfmtError {}
-
-impl Display for NumfmtError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::IoError(s) | Self::IllegalArgument(s) | Self::FormattingError(s) => {
-                write!(f, "{s}")
-            }
-        }
-    }
-}
diff --git a/src/uu/numfmt/src/format.rs b/src/uu/numfmt/src/format.rs
index 08bb0c2e774..f74317c3975 100644
--- a/src/uu/numfmt/src/format.rs
+++ b/src/uu/numfmt/src/format.rs
@@ -6,7 +6,7 @@
 use uucore::display::Quotable;
 
 use crate::options::{NumfmtOptions, RoundMethod, TransformOptions};
-use crate::units::{DisplayableSuffix, RawSuffix, Result, Suffix, Unit, IEC_BASES, SI_BASES};
+use crate::units::{DisplayableSuffix, IEC_BASES, RawSuffix, Result, SI_BASES, Suffix, Unit};
 
 /// Iterate over a line's fields, where each field is a contiguous sequence of
 /// non-whitespace, optionally prefixed with one or more characters of leading
@@ -53,11 +53,7 @@ impl<'a> Iterator for WhitespaceSplitter<'a> {
                 .unwrap_or(haystack.len()),
         );
 
-        let (field, rest) = field.split_at(
-            field
-                .find(|c: char| c.is_whitespace())
-                .unwrap_or(field.len()),
-        );
+        let (field, rest) = field.split_at(field.find(char::is_whitespace).unwrap_or(field.len()));
 
         self.s = if rest.is_empty() { None } else { Some(rest) };
 
@@ -107,7 +103,7 @@ fn parse_implicit_precision(s: &str) -> usize {
     match s.split_once('.') {
         Some((_, decimal_part)) => decimal_part
             .chars()
-            .take_while(|c| c.is_ascii_digit())
+            .take_while(char::is_ascii_digit)
             .count(),
         None => 0,
     }
@@ -115,21 +111,18 @@ fn parse_implicit_precision(s: &str) -> usize {
 
 fn remove_suffix(i: f64, s: Option<Suffix>, u: &Unit) -> Result<f64> {
     match (s, u) {
-        (Some((raw_suffix, false)), &Unit::Auto) | (Some((raw_suffix, false)), &Unit::Si) => {
-            match raw_suffix {
-                RawSuffix::K => Ok(i * 1e3),
-                RawSuffix::M => Ok(i * 1e6),
-                RawSuffix::G => Ok(i * 1e9),
-                RawSuffix::T => Ok(i * 1e12),
-                RawSuffix::P => Ok(i * 1e15),
-                RawSuffix::E => Ok(i * 1e18),
-                RawSuffix::Z => Ok(i * 1e21),
-                RawSuffix::Y => Ok(i * 1e24),
-            }
-        }
+        (Some((raw_suffix, false)), &Unit::Auto | &Unit::Si) => match raw_suffix {
+            RawSuffix::K => Ok(i * 1e3),
+            RawSuffix::M => Ok(i * 1e6),
+            RawSuffix::G => Ok(i * 1e9),
+            RawSuffix::T => Ok(i * 1e12),
+            RawSuffix::P => Ok(i * 1e15),
+            RawSuffix::E => Ok(i * 1e18),
+            RawSuffix::Z => Ok(i * 1e21),
+            RawSuffix::Y => Ok(i * 1e24),
+        },
         (Some((raw_suffix, false)), &Unit::Iec(false))
-        | (Some((raw_suffix, true)), &Unit::Auto)
-        | (Some((raw_suffix, true)), &Unit::Iec(true)) => match raw_suffix {
+        | (Some((raw_suffix, true)), &Unit::Auto | &Unit::Iec(true)) => match raw_suffix {
             RawSuffix::K => Ok(i * IEC_BASES[1]),
             RawSuffix::M => Ok(i * IEC_BASES[2]),
             RawSuffix::G => Ok(i * IEC_BASES[3]),
@@ -139,16 +132,11 @@ fn remove_suffix(i: f64, s: Option<Suffix>, u: &Unit) -> Result<f64> {
             RawSuffix::Z => Ok(i * IEC_BASES[7]),
             RawSuffix::Y => Ok(i * IEC_BASES[8]),
         },
-        (None, &Unit::Iec(true)) => {
-            Err(format!("missing 'i' suffix in input: '{i}' (e.g Ki/Mi/Gi)"))
-        }
         (Some((raw_suffix, false)), &Unit::Iec(true)) => Err(format!(
             "missing 'i' suffix in input: '{i}{raw_suffix:?}' (e.g Ki/Mi/Gi)"
         )),
         (Some((raw_suffix, with_i)), &Unit::None) => Err(format!(
-            "rejecting suffix in input: '{}{:?}{}' (consider using --from)",
-            i,
-            raw_suffix,
+            "rejecting suffix in input: '{i}{raw_suffix:?}{}' (consider using --from)",
             if with_i { "i" } else { "" }
         )),
         (None, _) => Ok(i),
@@ -163,11 +151,7 @@ fn transform_from(s: &str, opts: &TransformOptions) -> Result<f64> {
     remove_suffix(i, suffix, &opts.from).map(|n| {
         // GNU numfmt doesn't round values if no --from argument is provided by the user
         if opts.from == Unit::None {
-            if n == -0.0 {
-                0.0
-            } else {
-                n
-            }
+            if n == -0.0 { 0.0 } else { n }
         } else if n < 0.0 {
             -n.abs().ceil()
         } else {
@@ -226,7 +210,7 @@ fn consider_suffix(
     round_method: RoundMethod,
     precision: usize,
 ) -> Result<(f64, Option<Suffix>)> {
-    use crate::units::RawSuffix::*;
+    use crate::units::RawSuffix::{E, G, K, M, P, T, Y, Z};
 
     let abs_n = n.abs();
     let suffixes = [K, M, G, T, P, E, Z, Y];
@@ -278,19 +262,13 @@ fn transform_to(
             format!(
                 "{:.precision$}",
                 round_with_precision(i2, round_method, precision),
-                precision = precision
             )
         }
         Some(s) if precision > 0 => {
-            format!(
-                "{:.precision$}{}",
-                i2,
-                DisplayableSuffix(s),
-                precision = precision
-            )
+            format!("{i2:.precision$}{}", DisplayableSuffix(s, opts.to),)
         }
-        Some(s) if i2.abs() < 10.0 => format!("{:.1}{}", i2, DisplayableSuffix(s)),
-        Some(s) => format!("{:.0}{}", i2, DisplayableSuffix(s)),
+        Some(s) if i2.abs() < 10.0 => format!("{i2:.1}{}", DisplayableSuffix(s, opts.to)),
+        Some(s) => format!("{i2:.0}{}", DisplayableSuffix(s, opts.to)),
     })
 }
 
@@ -334,25 +312,21 @@ fn format_string(
     let padded_number = match padding {
         0 => number_with_suffix,
         p if p > 0 && options.format.zero_padding => {
-            let zero_padded = format!("{:0>padding$}", number_with_suffix, padding = p as usize);
+            let zero_padded = format!("{number_with_suffix:0>padding$}", padding = p as usize);
 
             match implicit_padding.unwrap_or(options.padding) {
                 0 => zero_padded,
-                p if p > 0 => format!("{:>padding$}", zero_padded, padding = p as usize),
-                p => format!("{:<padding$}", zero_padded, padding = p.unsigned_abs()),
+                p if p > 0 => format!("{zero_padded:>padding$}", padding = p as usize),
+                p => format!("{zero_padded:<padding$}", padding = p.unsigned_abs()),
             }
         }
-        p if p > 0 => format!("{:>padding$}", number_with_suffix, padding = p as usize),
-        p => format!(
-            "{:<padding$}",
-            number_with_suffix,
-            padding = p.unsigned_abs()
-        ),
+        p if p > 0 => format!("{number_with_suffix:>padding$}", padding = p as usize),
+        p => format!("{number_with_suffix:<padding$}", padding = p.unsigned_abs()),
     };
 
     Ok(format!(
-        "{}{}{}",
-        options.format.prefix, padded_number, options.format.suffix
+        "{}{padded_number}{}",
+        options.format.prefix, options.format.suffix
     ))
 }
 
@@ -403,12 +377,20 @@ fn format_and_print_whitespace(s: &str, options: &NumfmtOptions) -> Result<()> {
 
             print!("{}", format_string(field, options, implicit_padding)?);
         } else {
+            // the -z option converts an initial \n into a space
+            let prefix = if options.zero_terminated && prefix.starts_with('\n') {
+                print!(" ");
+                &prefix[1..]
+            } else {
+                prefix
+            };
             // print unselected field without conversion
             print!("{prefix}{field}");
         }
     }
 
-    println!();
+    let eol = if options.zero_terminated { '\0' } else { '\n' };
+    print!("{}", eol);
 
     Ok(())
 }
@@ -430,6 +412,7 @@ mod tests {
     use super::*;
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_round_with_precision() {
         let rm = RoundMethod::FromZero;
         assert_eq!(1.0, round_with_precision(0.12345, rm, 0));
diff --git a/src/uu/numfmt/src/numfmt.rs b/src/uu/numfmt/src/numfmt.rs
index 4afe5655552..cfa7c30d898 100644
--- a/src/uu/numfmt/src/numfmt.rs
+++ b/src/uu/numfmt/src/numfmt.rs
@@ -7,13 +7,15 @@ use crate::errors::*;
 use crate::format::format_and_print;
 use crate::options::*;
 use crate::units::{Result, Unit};
-use clap::{crate_version, parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
-use std::io::{BufRead, Write};
+use clap::{Arg, ArgAction, ArgMatches, Command, parser::ValueSource};
+use std::io::{BufRead, Error, Write};
+use std::result::Result as StdResult;
 use std::str::FromStr;
 
 use units::{IEC_BASES, SI_BASES};
 use uucore::display::Quotable;
-use uucore::error::{UError, UResult};
+use uucore::error::UResult;
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::ranges::Range;
 use uucore::{format_usage, help_about, help_section, help_usage, show, show_error};
 
@@ -37,10 +39,29 @@ fn handle_buffer<R>(input: R, options: &NumfmtOptions) -> UResult<()>
 where
     R: BufRead,
 {
-    for (idx, line_result) in input.lines().by_ref().enumerate() {
+    if options.zero_terminated {
+        handle_buffer_iterator(
+            input
+                .split(0)
+                // FIXME: This panics on UTF8 decoding, but this util in general doesn't handle
+                // invalid UTF8
+                .map(|bytes| Ok(String::from_utf8(bytes?).unwrap())),
+            options,
+        )
+    } else {
+        handle_buffer_iterator(input.lines(), options)
+    }
+}
+
+fn handle_buffer_iterator(
+    iter: impl Iterator<Item = StdResult<String, Error>>,
+    options: &NumfmtOptions,
+) -> UResult<()> {
+    let eol = if options.zero_terminated { '\0' } else { '\n' };
+    for (idx, line_result) in iter.enumerate() {
         match line_result {
             Ok(line) if idx < options.header => {
-                println!("{line}");
+                print!("{line}{eol}");
                 Ok(())
             }
             Ok(line) => format_and_handle_validation(line.as_ref(), options),
@@ -62,11 +83,11 @@ fn format_and_handle_validation(input_line: &str, options: &NumfmtOptions) -> UR
                 show!(NumfmtError::FormattingError(error_message));
             }
             InvalidModes::Warn => {
-                show_error!("{}", error_message);
+                show_error!("{error_message}");
             }
             InvalidModes::Ignore => {}
         };
-        println!("{}", input_line);
+        println!("{input_line}");
     }
 
     Ok(())
@@ -132,10 +153,10 @@ fn parse_unit_size_suffix(s: &str) -> Option<usize> {
 }
 
 fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
-    let from = parse_unit(args.get_one::<String>(options::FROM).unwrap())?;
-    let to = parse_unit(args.get_one::<String>(options::TO).unwrap())?;
-    let from_unit = parse_unit_size(args.get_one::<String>(options::FROM_UNIT).unwrap())?;
-    let to_unit = parse_unit_size(args.get_one::<String>(options::TO_UNIT).unwrap())?;
+    let from = parse_unit(args.get_one::<String>(FROM).unwrap())?;
+    let to = parse_unit(args.get_one::<String>(TO).unwrap())?;
+    let from_unit = parse_unit_size(args.get_one::<String>(FROM_UNIT).unwrap())?;
+    let to_unit = parse_unit_size(args.get_one::<String>(TO_UNIT).unwrap())?;
 
     let transform = TransformOptions {
         from,
@@ -144,7 +165,7 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         to_unit,
     };
 
-    let padding = match args.get_one::<String>(options::PADDING) {
+    let padding = match args.get_one::<String>(PADDING) {
         Some(s) => s
             .parse::<isize>()
             .map_err(|_| s)
@@ -156,8 +177,8 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         None => Ok(0),
     }?;
 
-    let header = if args.value_source(options::HEADER) == Some(ValueSource::CommandLine) {
-        let value = args.get_one::<String>(options::HEADER).unwrap();
+    let header = if args.value_source(HEADER) == Some(ValueSource::CommandLine) {
+        let value = args.get_one::<String>(HEADER).unwrap();
 
         value
             .parse::<usize>()
@@ -171,18 +192,18 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         Ok(0)
     }?;
 
-    let fields = args.get_one::<String>(options::FIELD).unwrap().as_str();
+    let fields = args.get_one::<String>(FIELD).unwrap().as_str();
     // a lone "-" means "all fields", even as part of a list of fields
     let fields = if fields.split(&[',', ' ']).any(|x| x == "-") {
         vec![Range {
             low: 1,
-            high: std::usize::MAX,
+            high: usize::MAX,
         }]
     } else {
         Range::from_list(fields)?
     };
 
-    let format = match args.get_one::<String>(options::FORMAT) {
+    let format = match args.get_one::<String>(FORMAT) {
         Some(s) => s.parse()?,
         None => FormatOptions::default(),
     };
@@ -191,18 +212,16 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         return Err("grouping cannot be combined with --to".to_string());
     }
 
-    let delimiter = args
-        .get_one::<String>(options::DELIMITER)
-        .map_or(Ok(None), |arg| {
-            if arg.len() == 1 {
-                Ok(Some(arg.to_string()))
-            } else {
-                Err("the delimiter must be a single character".to_string())
-            }
-        })?;
+    let delimiter = args.get_one::<String>(DELIMITER).map_or(Ok(None), |arg| {
+        if arg.len() == 1 {
+            Ok(Some(arg.to_string()))
+        } else {
+            Err("the delimiter must be a single character".to_string())
+        }
+    })?;
 
     // unwrap is fine because the argument has a default value
-    let round = match args.get_one::<String>(options::ROUND).unwrap().as_str() {
+    let round = match args.get_one::<String>(ROUND).unwrap().as_str() {
         "up" => RoundMethod::Up,
         "down" => RoundMethod::Down,
         "from-zero" => RoundMethod::FromZero,
@@ -211,12 +230,11 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         _ => unreachable!("Should be restricted by clap"),
     };
 
-    let suffix = args
-        .get_one::<String>(options::SUFFIX)
-        .map(|s| s.to_owned());
+    let suffix = args.get_one::<String>(SUFFIX).cloned();
+
+    let invalid = InvalidModes::from_str(args.get_one::<String>(INVALID).unwrap()).unwrap();
 
-    let invalid =
-        InvalidModes::from_str(args.get_one::<String>(options::INVALID).unwrap()).unwrap();
+    let zero_terminated = args.get_flag(ZERO_TERMINATED);
 
     Ok(NumfmtOptions {
         transform,
@@ -228,36 +246,17 @@ fn parse_options(args: &ArgMatches) -> Result<NumfmtOptions> {
         suffix,
         format,
         invalid,
+        zero_terminated,
     })
 }
 
-// If the --format argument and its value are provided separately, they are concatenated to avoid a
-// potential clap error. For example: "--format --%f--" is changed to "--format=--%f--".
-fn concat_format_arg_and_value(args: &[String]) -> Vec<String> {
-    let mut processed_args: Vec<String> = Vec::with_capacity(args.len());
-    let mut iter = args.iter().peekable();
-
-    while let Some(arg) = iter.next() {
-        if arg == "--format" && iter.peek().is_some() {
-            processed_args.push(format!("--format={}", iter.peek().unwrap()));
-            iter.next();
-        } else {
-            processed_args.push(arg.to_string());
-        }
-    }
-
-    processed_args
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app().try_get_matches_from(concat_format_arg_and_value(&args))?;
+    let matches = uu_app().try_get_matches_from(args)?;
 
     let options = parse_options(&matches).map_err(NumfmtError::IllegalArgument)?;
 
-    let result = match matches.get_many::<String>(options::NUMBER) {
+    let result = match matches.get_many::<String>(NUMBER) {
         Some(values) => handle_args(values.map(|s| s.as_str()), &options),
         None => {
             let stdin = std::io::stdin();
@@ -277,64 +276,65 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
         .allow_negative_numbers(true)
         .infer_long_args(true)
         .arg(
-            Arg::new(options::DELIMITER)
+            Arg::new(DELIMITER)
                 .short('d')
-                .long(options::DELIMITER)
+                .long(DELIMITER)
                 .value_name("X")
                 .help("use X instead of whitespace for field delimiter"),
         )
         .arg(
-            Arg::new(options::FIELD)
-                .long(options::FIELD)
+            Arg::new(FIELD)
+                .long(FIELD)
                 .help("replace the numbers in these input fields; see FIELDS below")
                 .value_name("FIELDS")
                 .allow_hyphen_values(true)
-                .default_value(options::FIELD_DEFAULT),
+                .default_value(FIELD_DEFAULT),
         )
         .arg(
-            Arg::new(options::FORMAT)
-                .long(options::FORMAT)
+            Arg::new(FORMAT)
+                .long(FORMAT)
                 .help("use printf style floating-point FORMAT; see FORMAT below for details")
-                .value_name("FORMAT"),
+                .value_name("FORMAT")
+                .allow_hyphen_values(true),
         )
         .arg(
-            Arg::new(options::FROM)
-                .long(options::FROM)
+            Arg::new(FROM)
+                .long(FROM)
                 .help("auto-scale input numbers to UNITs; see UNIT below")
                 .value_name("UNIT")
-                .default_value(options::FROM_DEFAULT),
+                .default_value(FROM_DEFAULT),
         )
         .arg(
-            Arg::new(options::FROM_UNIT)
-                .long(options::FROM_UNIT)
+            Arg::new(FROM_UNIT)
+                .long(FROM_UNIT)
                 .help("specify the input unit size")
                 .value_name("N")
-                .default_value(options::FROM_UNIT_DEFAULT),
+                .default_value(FROM_UNIT_DEFAULT),
         )
         .arg(
-            Arg::new(options::TO)
-                .long(options::TO)
+            Arg::new(TO)
+                .long(TO)
                 .help("auto-scale output numbers to UNITs; see UNIT below")
                 .value_name("UNIT")
-                .default_value(options::TO_DEFAULT),
+                .default_value(TO_DEFAULT),
         )
         .arg(
-            Arg::new(options::TO_UNIT)
-                .long(options::TO_UNIT)
+            Arg::new(TO_UNIT)
+                .long(TO_UNIT)
                 .help("the output unit size")
                 .value_name("N")
-                .default_value(options::TO_UNIT_DEFAULT),
+                .default_value(TO_UNIT_DEFAULT),
         )
         .arg(
-            Arg::new(options::PADDING)
-                .long(options::PADDING)
+            Arg::new(PADDING)
+                .long(PADDING)
                 .help(
                     "pad the output to N characters; positive N will \
                      right-align; negative N will left-align; padding is \
@@ -344,28 +344,34 @@ pub fn uu_app() -> Command {
                 .value_name("N"),
         )
         .arg(
-            Arg::new(options::HEADER)
-                .long(options::HEADER)
+            Arg::new(HEADER)
+                .long(HEADER)
                 .help(
                     "print (without converting) the first N header lines; \
                      N defaults to 1 if not specified",
                 )
                 .num_args(..=1)
                 .value_name("N")
-                .default_missing_value(options::HEADER_DEFAULT)
+                .default_missing_value(HEADER_DEFAULT)
                 .hide_default_value(true),
         )
         .arg(
-            Arg::new(options::ROUND)
-                .long(options::ROUND)
+            Arg::new(ROUND)
+                .long(ROUND)
                 .help("use METHOD for rounding when scaling")
                 .value_name("METHOD")
                 .default_value("from-zero")
-                .value_parser(["up", "down", "from-zero", "towards-zero", "nearest"]),
+                .value_parser(ShortcutValueParser::new([
+                    "up",
+                    "down",
+                    "from-zero",
+                    "towards-zero",
+                    "nearest",
+                ])),
         )
         .arg(
-            Arg::new(options::SUFFIX)
-                .long(options::SUFFIX)
+            Arg::new(SUFFIX)
+                .long(SUFFIX)
                 .help(
                     "print SUFFIX after each formatted number, and accept \
                     inputs optionally ending with SUFFIX",
@@ -373,18 +379,21 @@ pub fn uu_app() -> Command {
                 .value_name("SUFFIX"),
         )
         .arg(
-            Arg::new(options::INVALID)
-                .long(options::INVALID)
+            Arg::new(INVALID)
+                .long(INVALID)
                 .help("set the failure mode for invalid input")
                 .default_value("abort")
                 .value_parser(["abort", "fail", "warn", "ignore"])
                 .value_name("INVALID"),
         )
         .arg(
-            Arg::new(options::NUMBER)
-                .hide(true)
-                .action(ArgAction::Append),
+            Arg::new(ZERO_TERMINATED)
+                .long(ZERO_TERMINATED)
+                .short('z')
+                .help("line delimiter is NUL, not newline")
+                .action(ArgAction::SetTrue),
         )
+        .arg(Arg::new(NUMBER).hide(true).action(ArgAction::Append))
 }
 
 #[cfg(test)]
@@ -392,8 +401,8 @@ mod tests {
     use uucore::error::get_exit_code;
 
     use super::{
-        handle_args, handle_buffer, parse_unit_size, parse_unit_size_suffix, FormatOptions,
-        InvalidModes, NumfmtOptions, Range, RoundMethod, TransformOptions, Unit,
+        FormatOptions, InvalidModes, NumfmtOptions, Range, RoundMethod, TransformOptions, Unit,
+        handle_args, handle_buffer, parse_unit_size, parse_unit_size_suffix,
     };
     use std::io::{BufReader, Error, ErrorKind, Read};
     struct MockBuffer {}
@@ -420,6 +429,7 @@ mod tests {
             suffix: None,
             format: FormatOptions::default(),
             invalid: InvalidModes::Abort,
+            zero_terminated: false,
         }
     }
 
@@ -442,8 +452,8 @@ mod tests {
         options.header = 0;
         let result = handle_buffer(BufReader::new(mock_buffer), &options)
             .expect_err("returned Ok after receiving IO error");
-        let result_debug = format!("{:?}", result);
-        let result_display = format!("{}", result);
+        let result_debug = format!("{result:?}");
+        let result_display = format!("{result}");
         assert_eq!(result_debug, "IoError(\"broken pipe\")");
         assert_eq!(result_display, "broken pipe");
         assert_eq!(result.code(), 1);
@@ -495,8 +505,9 @@ mod tests {
         let mut options = get_valid_options();
         options.invalid = InvalidModes::Fail;
         handle_buffer(BufReader::new(&input_value[..]), &options).unwrap();
-        assert!(
-            get_exit_code() == 2,
+        assert_eq!(
+            get_exit_code(),
+            2,
             "should set exit code 2 for formatting errors"
         );
     }
@@ -516,8 +527,9 @@ mod tests {
         let mut options = get_valid_options();
         options.invalid = InvalidModes::Fail;
         handle_args(input_value, &options).unwrap();
-        assert!(
-            get_exit_code() == 2,
+        assert_eq!(
+            get_exit_code(),
+            2,
             "should set exit code 2 for formatting errors"
         );
     }
diff --git a/src/uu/numfmt/src/options.rs b/src/uu/numfmt/src/options.rs
index 07b364f18d8..72cfe226958 100644
--- a/src/uu/numfmt/src/options.rs
+++ b/src/uu/numfmt/src/options.rs
@@ -26,6 +26,7 @@ pub const TO: &str = "to";
 pub const TO_DEFAULT: &str = "none";
 pub const TO_UNIT: &str = "to-unit";
 pub const TO_UNIT_DEFAULT: &str = "1";
+pub const ZERO_TERMINATED: &str = "zero-terminated";
 
 pub struct TransformOptions {
     pub from: Unit,
@@ -52,6 +53,7 @@ pub struct NumfmtOptions {
     pub suffix: Option<String>,
     pub format: FormatOptions,
     pub invalid: InvalidModes,
+    pub zero_terminated: bool,
 }
 
 #[derive(Clone, Copy)]
@@ -167,7 +169,7 @@ impl FromStr for FormatOptions {
                 _ => {
                     return Err(format!(
                         "invalid format '{s}', directive must be %[0]['][-][N][.][N]f"
-                    ))
+                    ));
                 }
             }
         }
@@ -266,6 +268,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_parse_format_with_invalid_formats() {
         assert!("".parse::<FormatOptions>().is_err());
         assert!("hello".parse::<FormatOptions>().is_err());
diff --git a/src/uu/numfmt/src/units.rs b/src/uu/numfmt/src/units.rs
index 585bae46141..c52dee20c02 100644
--- a/src/uu/numfmt/src/units.rs
+++ b/src/uu/numfmt/src/units.rs
@@ -45,20 +45,21 @@ pub enum RawSuffix {
 
 pub type Suffix = (RawSuffix, WithI);
 
-pub struct DisplayableSuffix(pub Suffix);
+pub struct DisplayableSuffix(pub Suffix, pub Unit);
 
 impl fmt::Display for DisplayableSuffix {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let Self((ref raw_suffix, ref with_i)) = *self;
-        match raw_suffix {
-            RawSuffix::K => write!(f, "K"),
-            RawSuffix::M => write!(f, "M"),
-            RawSuffix::G => write!(f, "G"),
-            RawSuffix::T => write!(f, "T"),
-            RawSuffix::P => write!(f, "P"),
-            RawSuffix::E => write!(f, "E"),
-            RawSuffix::Z => write!(f, "Z"),
-            RawSuffix::Y => write!(f, "Y"),
+        let Self((ref raw_suffix, ref with_i), unit) = *self;
+        match (raw_suffix, unit) {
+            (RawSuffix::K, Unit::Si) => write!(f, "k"),
+            (RawSuffix::K, _) => write!(f, "K"),
+            (RawSuffix::M, _) => write!(f, "M"),
+            (RawSuffix::G, _) => write!(f, "G"),
+            (RawSuffix::T, _) => write!(f, "T"),
+            (RawSuffix::P, _) => write!(f, "P"),
+            (RawSuffix::E, _) => write!(f, "E"),
+            (RawSuffix::Z, _) => write!(f, "Z"),
+            (RawSuffix::Y, _) => write!(f, "Y"),
         }
         .and_then(|()| match with_i {
             true => write!(f, "i"),
diff --git a/src/uu/od/Cargo.toml b/src/uu/od/Cargo.toml
index d369456f32a..a7c9ba33660 100644
--- a/src/uu/od/Cargo.toml
+++ b/src/uu/od/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_od"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "od ~ (uutils) display formatted representation of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/od"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/od.rs"
@@ -18,7 +21,7 @@ path = "src/od.rs"
 byteorder = { workspace = true }
 clap = { workspace = true }
 half = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 
 [[bin]]
 name = "od"
diff --git a/src/uu/od/src/formatteriteminfo.rs b/src/uu/od/src/formatteriteminfo.rs
index 9e3c2e83600..4f53397dd5a 100644
--- a/src/uu/od/src/formatteriteminfo.rs
+++ b/src/uu/od/src/formatteriteminfo.rs
@@ -7,7 +7,7 @@
 use std::fmt;
 
 #[allow(clippy::enum_variant_names)]
-#[derive(Copy)]
+#[derive(Copy, PartialEq, Eq)]
 pub enum FormatWriter {
     IntWriter(fn(u64) -> String),
     FloatWriter(fn(f64) -> String),
@@ -21,21 +21,6 @@ impl Clone for FormatWriter {
     }
 }
 
-impl PartialEq for FormatWriter {
-    fn eq(&self, other: &Self) -> bool {
-        use crate::formatteriteminfo::FormatWriter::*;
-
-        match (self, other) {
-            (IntWriter(a), IntWriter(b)) => a == b,
-            (FloatWriter(a), FloatWriter(b)) => a == b,
-            (MultibyteWriter(a), MultibyteWriter(b)) => *a as usize == *b as usize,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for FormatWriter {}
-
 impl fmt::Debug for FormatWriter {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
diff --git a/src/uu/od/src/inputdecoder.rs b/src/uu/od/src/inputdecoder.rs
index 6f08eba124e..44ad2922843 100644
--- a/src/uu/od/src/inputdecoder.rs
+++ b/src/uu/od/src/inputdecoder.rs
@@ -33,7 +33,7 @@ where
     byte_order: ByteOrder,
 }
 
-impl<'a, I> InputDecoder<'a, I> {
+impl<I> InputDecoder<'_, I> {
     /// Creates a new `InputDecoder` with an allocated buffer of `normal_length` + `peek_length` bytes.
     /// `byte_order` determines how to read multibyte formats from the buffer.
     pub fn new(
@@ -55,7 +55,7 @@ impl<'a, I> InputDecoder<'a, I> {
     }
 }
 
-impl<'a, I> InputDecoder<'a, I>
+impl<I> InputDecoder<'_, I>
 where
     I: PeekRead,
 {
@@ -81,7 +81,7 @@ where
     }
 }
 
-impl<'a, I> HasError for InputDecoder<'a, I>
+impl<I> HasError for InputDecoder<'_, I>
 where
     I: HasError,
 {
@@ -103,7 +103,7 @@ pub struct MemoryDecoder<'a> {
     byte_order: ByteOrder,
 }
 
-impl<'a> MemoryDecoder<'a> {
+impl MemoryDecoder<'_> {
     /// Set a part of the internal buffer to zero.
     /// access to the whole buffer is possible, not just to the valid data.
     pub fn zero_out_buffer(&mut self, start: usize, end: usize) {
@@ -166,6 +166,7 @@ mod tests {
 
     #[test]
     #[allow(clippy::float_cmp)]
+    #[allow(clippy::cognitive_complexity)]
     fn smoke_test() {
         let data = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xff, 0xff];
         let mut input = PeekReader::new(Cursor::new(&data));
@@ -178,8 +179,8 @@ mod tests {
 
         assert_eq!(-2.0, mem.read_float(0, 8));
         assert_eq!(-2.0, mem.read_float(4, 4));
-        assert_eq!(0xc000000000000000, mem.read_uint(0, 8));
-        assert_eq!(0xc0000000, mem.read_uint(4, 4));
+        assert_eq!(0xc000_0000_0000_0000, mem.read_uint(0, 8));
+        assert_eq!(0xc000_0000, mem.read_uint(4, 4));
         assert_eq!(0xc000, mem.read_uint(6, 2));
         assert_eq!(0xc0, mem.read_uint(7, 1));
         assert_eq!(&[0, 0xc0], mem.get_buffer(6));
diff --git a/src/uu/od/src/inputoffset.rs b/src/uu/od/src/inputoffset.rs
index a196000551f..cb5da6639a3 100644
--- a/src/uu/od/src/inputoffset.rs
+++ b/src/uu/od/src/inputoffset.rs
@@ -48,11 +48,11 @@ impl InputOffset {
     pub fn format_byte_offset(&self) -> String {
         match (self.radix, self.label) {
             (Radix::Decimal, None) => format!("{:07}", self.byte_pos),
-            (Radix::Decimal, Some(l)) => format!("{:07} ({:07})", self.byte_pos, l),
+            (Radix::Decimal, Some(l)) => format!("{:07} ({l:07})", self.byte_pos),
             (Radix::Hexadecimal, None) => format!("{:06X}", self.byte_pos),
-            (Radix::Hexadecimal, Some(l)) => format!("{:06X} ({:06X})", self.byte_pos, l),
+            (Radix::Hexadecimal, Some(l)) => format!("{:06X} ({l:06X})", self.byte_pos),
             (Radix::Octal, None) => format!("{:07o}", self.byte_pos),
-            (Radix::Octal, Some(l)) => format!("{:07o} ({:07o})", self.byte_pos, l),
+            (Radix::Octal, Some(l)) => format!("{:07o} ({l:07o})", self.byte_pos),
             (Radix::NoPrefix, None) => String::new(),
             (Radix::NoPrefix, Some(l)) => format!("({l:07o})"),
         }
diff --git a/src/uu/od/src/mockstream.rs b/src/uu/od/src/mockstream.rs
index 925d52f7e58..9904fa9c1da 100644
--- a/src/uu/od/src/mockstream.rs
+++ b/src/uu/od/src/mockstream.rs
@@ -10,7 +10,7 @@ use std::io::{Cursor, Error, ErrorKind, Read, Result};
 ///
 /// # Examples
 ///
-/// ```
+/// ```no_run
 /// use std::io::{Cursor, Read};
 ///
 /// struct CountIo {}
diff --git a/src/uu/od/src/multifilereader.rs b/src/uu/od/src/multifilereader.rs
index f7575e975de..6097c095a4f 100644
--- a/src/uu/od/src/multifilereader.rs
+++ b/src/uu/od/src/multifilereader.rs
@@ -6,8 +6,8 @@
 
 use std::fs::File;
 use std::io;
-use std::io::BufReader;
-use std::vec::Vec;
+#[cfg(unix)]
+use std::os::fd::{AsRawFd, FromRawFd};
 
 use uucore::display::Quotable;
 use uucore::show_error;
@@ -30,7 +30,7 @@ pub trait HasError {
     fn has_error(&self) -> bool;
 }
 
-impl<'b> MultifileReader<'b> {
+impl MultifileReader<'_> {
     pub fn new(fnames: Vec<InputSource>) -> MultifileReader {
         let mut mf = MultifileReader {
             ni: fnames,
@@ -50,21 +50,44 @@ impl<'b> MultifileReader<'b> {
             }
             match self.ni.remove(0) {
                 InputSource::Stdin => {
-                    self.curr_file = Some(Box::new(BufReader::new(std::io::stdin())));
+                    // In order to pass GNU compatibility tests, when the client passes in the
+                    // `-N` flag we must not read any bytes beyond that limit. As such, we need
+                    // to disable the default buffering for stdin below.
+                    // For performance reasons we do still do buffered reads from stdin, but
+                    // the buffering is done elsewhere and in a way that is aware of the `-N`
+                    // limit.
+                    let stdin = io::stdin();
+                    #[cfg(unix)]
+                    {
+                        let stdin_raw_fd = stdin.as_raw_fd();
+                        let stdin_file = unsafe { File::from_raw_fd(stdin_raw_fd) };
+                        self.curr_file = Some(Box::new(stdin_file));
+                    }
+
+                    // For non-unix platforms we don't have GNU compatibility requirements, so
+                    // we don't need to prevent stdin buffering. This is sub-optimal (since
+                    // there will still be additional buffering further up the stack), but
+                    // doesn't seem worth worrying about at this time.
+                    #[cfg(not(unix))]
+                    {
+                        self.curr_file = Some(Box::new(stdin));
+                    }
                     break;
                 }
                 InputSource::FileName(fname) => {
                     match File::open(fname) {
                         Ok(f) => {
-                            self.curr_file = Some(Box::new(BufReader::new(f)));
+                            // No need to wrap `f` in a BufReader - buffered reading is taken care
+                            // of elsewhere.
+                            self.curr_file = Some(Box::new(f));
                             break;
                         }
                         Err(e) => {
                             // If any file can't be opened,
                             // print an error at the time that the file is needed,
-                            // then move on the the next file.
+                            // then move to the next file.
                             // This matches the behavior of the original `od`
-                            show_error!("{}: {}", fname.maybe_quote(), e);
+                            show_error!("{}: {e}", fname.maybe_quote());
                             self.any_err = true;
                         }
                     }
@@ -78,7 +101,7 @@ impl<'b> MultifileReader<'b> {
     }
 }
 
-impl<'b> io::Read for MultifileReader<'b> {
+impl io::Read for MultifileReader<'_> {
     // Fill buf with bytes read from the list of files
     // Returns Ok(<number of bytes read>)
     // Handles io errors itself, thus always returns OK
@@ -97,7 +120,7 @@ impl<'b> io::Read for MultifileReader<'b> {
                             Ok(0) => break,
                             Ok(n) => n,
                             Err(e) => {
-                                show_error!("I/O: {}", e);
+                                show_error!("I/O: {e}");
                                 self.any_err = true;
                                 break;
                             }
@@ -115,7 +138,7 @@ impl<'b> io::Read for MultifileReader<'b> {
     }
 }
 
-impl<'b> HasError for MultifileReader<'b> {
+impl HasError for MultifileReader<'_> {
     fn has_error(&self) -> bool {
         self.any_err
     }
diff --git a/src/uu/od/src/od.rs b/src/uu/od/src/od.rs
index 769dae98e22..652a0ce3f51 100644
--- a/src/uu/od/src/od.rs
+++ b/src/uu/od/src/od.rs
@@ -5,6 +5,7 @@
 
 // spell-checker:ignore (clap) dont
 // spell-checker:ignore (ToDO) formatteriteminfo inputdecoder inputoffset mockstream nrofbytes partialreader odfunc multifile exitcode
+// spell-checker:ignore Anone
 
 mod byteorder_io;
 mod formatteriteminfo;
@@ -25,6 +26,7 @@ mod prn_int;
 
 use std::cmp;
 use std::fmt::Write;
+use std::io::BufReader;
 
 use crate::byteorder_io::ByteOrder;
 use crate::formatteriteminfo::FormatWriter;
@@ -32,17 +34,18 @@ use crate::inputdecoder::{InputDecoder, MemoryDecoder};
 use crate::inputoffset::{InputOffset, Radix};
 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_formats::{ParsedFormatterItemInfo, parse_format_flags};
+use crate::parse_inputs::{CommandLineInputs, parse_inputs};
 use crate::parse_nrofbytes::parse_number_of_bytes;
 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};
+use clap::{Arg, ArgMatches, Command, parser::ValueSource};
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
-use uucore::parse_size::ParseSizeError;
+use uucore::parser::parse_size::ParseSizeError;
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 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
@@ -87,7 +90,7 @@ impl OdOptions {
                     return Err(USimpleError::new(
                         1,
                         format!("Invalid argument --endian={s}"),
-                    ))
+                    ));
                 }
             }
         } else {
@@ -102,7 +105,7 @@ impl OdOptions {
                     return Err(USimpleError::new(
                         1,
                         format_error_message(&e, s, options::SKIP_BYTES),
-                    ))
+                    ));
                 }
             },
         };
@@ -133,7 +136,7 @@ impl OdOptions {
                             return Err(USimpleError::new(
                                 1,
                                 format_error_message(&e, s, options::WIDTH),
-                            ))
+                            ));
                         }
                     }
                 } else {
@@ -146,7 +149,7 @@ impl OdOptions {
             cmp::max(max, next.formatter_item_info.byte_size)
         });
         if line_bytes == 0 || line_bytes % min_bytes != 0 {
-            show_warning!("invalid width {}; using {} instead", line_bytes, min_bytes);
+            show_warning!("invalid width {line_bytes}; using {min_bytes} instead");
             line_bytes = min_bytes;
         }
 
@@ -160,7 +163,7 @@ impl OdOptions {
                     return Err(USimpleError::new(
                         1,
                         format_error_message(&e, s, options::READ_BYTES),
-                    ))
+                    ));
                 }
             },
         };
@@ -168,28 +171,30 @@ impl OdOptions {
         let radix = match matches.get_one::<String>(options::ADDRESS_RADIX) {
             None => Radix::Octal,
             Some(s) => {
+                // Other implementations of od only check the first character of this argument's value.
+                // This means executing `od -Anone` is equivalent to executing `od -An`.
+                // Existing users of od rely on this behavior:
+                // https://github.com/landley/toybox/blob/d50372cad35d5dd12e6391c3c7c901a96122dc67/scripts/make.sh#L239
+                // https://github.com/google/jsonnet/blob/913281d203578bb394995bacc792f2576371e06c/Makefile#L212
                 let st = s.as_bytes();
-                if st.len() == 1 {
-                    let radix: char = *(st
-                        .first()
-                        .expect("byte string of length 1 lacks a 0th elem"))
-                        as char;
-                    match radix {
-                        'd' => Radix::Decimal,
-                        'x' => Radix::Hexadecimal,
-                        'o' => Radix::Octal,
-                        'n' => Radix::NoPrefix,
+                if let Some(u) = st.first() {
+                    match *u {
+                        b'o' => Radix::Octal,
+                        b'd' => Radix::Decimal,
+                        b'x' => Radix::Hexadecimal,
+                        b'n' => Radix::NoPrefix,
                         _ => {
                             return Err(USimpleError::new(
                                 1,
-                                "Radix must be one of [d, o, n, x]".to_string(),
-                            ))
+                                "Radix must be one of [o, d, x, n]".to_string(),
+                            ));
                         }
                     }
                 } else {
+                    // Return an error instead of panicking when `od -A ''` is executed.
                     return Err(USimpleError::new(
                         1,
-                        "Radix must be one of [d, o, n, x]".to_string(),
+                        "Radix cannot be empty, and must be one of [o, d, x, n]".to_string(),
                     ));
                 }
             }
@@ -247,7 +252,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
@@ -287,7 +292,7 @@ pub fn uu_app() -> Command {
             Arg::new(options::ENDIAN)
                 .long(options::ENDIAN)
                 .help("byte order to use for multi-byte formats")
-                .value_parser(["big", "little"])
+                .value_parser(ShortcutValueParser::new(["big", "little"]))
                 .value_name("big|little"),
         )
         .arg(
@@ -518,7 +523,7 @@ where
                 input_offset.increase_position(length as u64);
             }
             Err(e) => {
-                show_error!("{}", e);
+                show_error!("{e}");
                 input_offset.print_final_offset();
                 return Err(1.into());
             }
@@ -571,17 +576,16 @@ fn print_bytes(prefix: &str, input_decoder: &MemoryDecoder, output_info: &Output
                 .saturating_sub(output_text.chars().count());
             write!(
                 output_text,
-                "{:>width$}  {}",
+                "{:>missing_spacing$}  {}",
                 "",
                 format_ascii_dump(input_decoder.get_buffer(0)),
-                width = missing_spacing
             )
             .unwrap();
         }
 
         if first {
             print!("{prefix}"); // print offset
-                                // if printing in multiple formats offset is printed only once
+            // if printing in multiple formats offset is printed only once
             first = false;
         } else {
             // this takes the space of the file offset on subsequent
@@ -600,7 +604,7 @@ fn open_input_peek_reader(
     input_strings: &[String],
     skip_bytes: u64,
     read_bytes: Option<u64>,
-) -> PeekReader<PartialReader<MultifileReader>> {
+) -> PeekReader<BufReader<PartialReader<MultifileReader>>> {
     // should return  "impl PeekRead + Read + HasError" when supported in (stable) rust
     let inputs = input_strings
         .iter()
@@ -612,7 +616,18 @@ fn open_input_peek_reader(
 
     let mf = MultifileReader::new(inputs);
     let pr = PartialReader::new(mf, skip_bytes, read_bytes);
-    PeekReader::new(pr)
+    // Add a BufReader over the top of the PartialReader. This will have the
+    // effect of generating buffered reads to files/stdin, but since these reads
+    // go through MultifileReader (which limits the maximum number of bytes read)
+    // we won't ever read more bytes than were specified with the `-N` flag.
+    let buf_pr = BufReader::new(pr);
+    PeekReader::new(buf_pr)
+}
+
+impl<R: HasError> HasError for BufReader<R> {
+    fn has_error(&self) -> bool {
+        self.get_ref().has_error()
+    }
 }
 
 fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String {
@@ -620,9 +635,11 @@ fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String
     // GNU's od echos affected flag, -N or --read-bytes (-j or --skip-bytes, etc.), depending user's selection
     match error {
         ParseSizeError::InvalidSuffix(_) => {
-            format!("invalid suffix in --{} argument {}", option, s.quote())
+            format!("invalid suffix in --{option} argument {}", s.quote())
+        }
+        ParseSizeError::ParseFailure(_) | ParseSizeError::PhysicalMem(_) => {
+            format!("invalid --{option} argument {}", s.quote())
         }
-        ParseSizeError::ParseFailure(_) => format!("invalid --{} argument {}", option, s.quote()),
-        ParseSizeError::SizeTooBig(_) => format!("--{} argument {} too large", option, s.quote()),
+        ParseSizeError::SizeTooBig(_) => format!("--{option} argument {} too large", s.quote()),
     }
 }
diff --git a/src/uu/od/src/output_info.rs b/src/uu/od/src/output_info.rs
index 96c01f906ed..16329217200 100644
--- a/src/uu/od/src/output_info.rs
+++ b/src/uu/od/src/output_info.rs
@@ -38,8 +38,6 @@ pub struct OutputInfo {
 
     /// The number of bytes in a block. (This is the size of the largest datatype in `spaced_formatters`.)
     pub byte_size_block: usize,
-    /// The width of a block in human readable format. (The size of the largest format.)
-    pub print_width_block: usize,
     /// All formats.
     spaced_formatters: Vec<SpacedFormatterItemInfo>,
     /// determines if duplicate output lines should be printed, or
@@ -78,7 +76,6 @@ impl OutputInfo {
             byte_size_line: line_bytes,
             print_width_line,
             byte_size_block,
-            print_width_block,
             spaced_formatters,
             output_duplicates,
         }
@@ -208,6 +205,7 @@ impl TypeSizeInfo for TypeInfo {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_calculate_alignment() {
     // For this example `byte_size_block` is 8 and 'print_width_block' is 23:
     // 1777777777777777777777 1777777777777777777777
diff --git a/src/uu/od/src/parse_formats.rs b/src/uu/od/src/parse_formats.rs
index 2bb876d2b4b..86f32a25a4a 100644
--- a/src/uu/od/src/parse_formats.rs
+++ b/src/uu/od/src/parse_formats.rs
@@ -274,8 +274,7 @@ fn parse_type_string(params: &str) -> Result<Vec<ParsedFormatterItemInfo>, Strin
     while let Some(type_char) = ch {
         let type_char = format_type(type_char).ok_or_else(|| {
             format!(
-                "unexpected char '{}' in format specification {}",
-                type_char,
+                "unexpected char '{type_char}' in format specification {}",
                 params.quote()
             )
         })?;
@@ -309,8 +308,7 @@ fn parse_type_string(params: &str) -> Result<Vec<ParsedFormatterItemInfo>, Strin
 
         let ft = od_format_type(type_char, byte_size).ok_or_else(|| {
             format!(
-                "invalid size '{}' in format specification {}",
-                byte_size,
+                "invalid size '{byte_size}' in format specification {}",
                 params.quote()
             )
         })?;
diff --git a/src/uu/od/src/parse_inputs.rs b/src/uu/od/src/parse_inputs.rs
index 74dc5a13a83..241d842af9f 100644
--- a/src/uu/od/src/parse_inputs.rs
+++ b/src/uu/od/src/parse_inputs.rs
@@ -213,6 +213,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_parse_inputs_with_offset() {
         // offset is found without filename, so stdin will be used.
         assert_eq!(
@@ -355,6 +356,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_parse_offset_operand() {
         assert_eq!(8, parse_offset_operand_str("10").unwrap()); // default octal
         assert_eq!(0, parse_offset_operand_str("0").unwrap());
diff --git a/src/uu/od/src/parse_nrofbytes.rs b/src/uu/od/src/parse_nrofbytes.rs
index a5c81f68ba9..241e1c6e7ca 100644
--- a/src/uu/od/src/parse_nrofbytes.rs
+++ b/src/uu/od/src/parse_nrofbytes.rs
@@ -2,7 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parser::parse_size::{ParseSizeError, parse_size_u64};
 
 pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
     let mut start = 0;
@@ -15,7 +15,7 @@ pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
     } else if s.starts_with('0') {
         radix = 8;
     } else {
-        return parse_size(&s[start..]);
+        return parse_size_u64(&s[start..]);
     }
 
     let mut ends_with = s.chars().rev();
@@ -79,6 +79,7 @@ pub fn parse_number_of_bytes(s: &str) -> Result<u64, ParseSizeError> {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_parse_number_of_bytes() {
     // octal input
     assert_eq!(8, parse_number_of_bytes("010").unwrap());
diff --git a/src/uu/od/src/partialreader.rs b/src/uu/od/src/partialreader.rs
index 24918f5cfd8..6825f1ae4b9 100644
--- a/src/uu/od/src/partialreader.rs
+++ b/src/uu/od/src/partialreader.rs
@@ -149,11 +149,7 @@ mod tests {
     fn test_read_skipping_huge_number() {
         let mut v = [0; 10];
         // test if it does not eat all memory....
-        let mut sut = PartialReader::new(
-            Cursor::new(&b"abcdefgh"[..]),
-            usize::max_value() as u64,
-            None,
-        );
+        let mut sut = PartialReader::new(Cursor::new(&b"abcdefgh"[..]), u64::MAX, None);
 
         sut.read(v.as_mut()).unwrap_err();
     }
diff --git a/src/uu/od/src/peekreader.rs b/src/uu/od/src/peekreader.rs
index 239faab92ee..82f139c726e 100644
--- a/src/uu/od/src/peekreader.rs
+++ b/src/uu/od/src/peekreader.rs
@@ -186,6 +186,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_peek_read_with_smaller_buffer() {
         let mut sut = PeekReader::new(Cursor::new(&b"abcdefghij"[..]));
 
diff --git a/src/uu/od/src/prn_char.rs b/src/uu/od/src/prn_char.rs
index db12d9d4fc4..36a00a67bb3 100644
--- a/src/uu/od/src/prn_char.rs
+++ b/src/uu/od/src/prn_char.rs
@@ -99,6 +99,7 @@ pub fn format_ascii_dump(bytes: &[u8]) -> String {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_format_item_a() {
     assert_eq!(" nul", format_item_a(0x00));
     assert_eq!(" soh", format_item_a(0x01));
@@ -114,6 +115,7 @@ fn test_format_item_a() {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_format_item_c() {
     assert_eq!("  \\0", format_item_c(&[0x00]));
     assert_eq!(" 001", format_item_c(&[0x01]));
diff --git a/src/uu/od/src/prn_float.rs b/src/uu/od/src/prn_float.rs
index af632d66b24..44033371261 100644
--- a/src/uu/od/src/prn_float.rs
+++ b/src/uu/od/src/prn_float.rs
@@ -3,8 +3,6 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use half::f16;
-use std::f32;
-use std::f64;
 use std::num::FpCategory;
 
 use crate::formatteriteminfo::{FormatWriter, FormatterItemInfo};
@@ -81,84 +79,85 @@ fn format_float(f: f64, width: usize, precision: usize) -> String {
     }
 
     if l >= 0 && l <= (precision as i32 - 1) {
-        format!("{:width$.dec$}", f, dec = (precision - 1) - l as usize)
+        format!("{f:width$.dec$}", dec = (precision - 1) - l as usize)
     } else if l == -1 {
         format!("{f:width$.precision$}")
     } else {
-        format!("{:width$.dec$e}", f, dec = precision - 1)
+        format!("{f:width$.dec$e}", dec = precision - 1)
     }
 }
 
 #[test]
 #[allow(clippy::excessive_precision)]
+#[allow(clippy::cognitive_complexity)]
 fn test_format_flo32() {
     assert_eq!(format_flo32(1.0), "     1.0000000");
-    assert_eq!(format_flo32(9.9999990), "     9.9999990");
+    assert_eq!(format_flo32(9.999_999_0), "     9.9999990");
     assert_eq!(format_flo32(10.0), "     10.000000");
-    assert_eq!(format_flo32(99.999977), "     99.999977");
-    assert_eq!(format_flo32(99.999992), "     99.999992");
+    assert_eq!(format_flo32(99.999_977), "     99.999977");
+    assert_eq!(format_flo32(99.999_992), "     99.999992");
     assert_eq!(format_flo32(100.0), "     100.00000");
     assert_eq!(format_flo32(999.99994), "     999.99994");
     assert_eq!(format_flo32(1000.0), "     1000.0000");
     assert_eq!(format_flo32(9999.9990), "     9999.9990");
     assert_eq!(format_flo32(10000.0), "     10000.000");
     assert_eq!(format_flo32(99999.992), "     99999.992");
-    assert_eq!(format_flo32(100000.0), "     100000.00");
-    assert_eq!(format_flo32(999999.94), "     999999.94");
-    assert_eq!(format_flo32(1000000.0), "     1000000.0");
-    assert_eq!(format_flo32(9999999.0), "     9999999.0");
-    assert_eq!(format_flo32(10000000.0), "      10000000");
-    assert_eq!(format_flo32(99999992.0), "      99999992");
-    assert_eq!(format_flo32(100000000.0), "   1.0000000e8");
-    assert_eq!(format_flo32(9.9999994e8), "   9.9999994e8");
+    assert_eq!(format_flo32(100_000.0), "     100000.00");
+    assert_eq!(format_flo32(999_999.94), "     999999.94");
+    assert_eq!(format_flo32(1_000_000.0), "     1000000.0");
+    assert_eq!(format_flo32(9_999_999.0), "     9999999.0");
+    assert_eq!(format_flo32(10_000_000.0), "      10000000");
+    assert_eq!(format_flo32(99_999_992.0), "      99999992");
+    assert_eq!(format_flo32(100_000_000.0), "   1.0000000e8");
+    assert_eq!(format_flo32(9.999_999_4e8), "   9.9999994e8");
     assert_eq!(format_flo32(1.0e9), "   1.0000000e9");
-    assert_eq!(format_flo32(9.9999990e9), "   9.9999990e9");
+    assert_eq!(format_flo32(9.999_999_0e9), "   9.9999990e9");
     assert_eq!(format_flo32(1.0e10), "  1.0000000e10");
 
     assert_eq!(format_flo32(0.1), "    0.10000000");
-    assert_eq!(format_flo32(0.99999994), "    0.99999994");
-    assert_eq!(format_flo32(0.010000001), "  1.0000001e-2");
-    assert_eq!(format_flo32(0.099999994), "  9.9999994e-2");
+    assert_eq!(format_flo32(0.999_999_94), "    0.99999994");
+    assert_eq!(format_flo32(0.010_000_001), "  1.0000001e-2");
+    assert_eq!(format_flo32(0.099_999_994), "  9.9999994e-2");
     assert_eq!(format_flo32(0.001), "  1.0000000e-3");
-    assert_eq!(format_flo32(0.0099999998), "  9.9999998e-3");
+    assert_eq!(format_flo32(0.009_999_999_8), "  9.9999998e-3");
 
     assert_eq!(format_flo32(-1.0), "    -1.0000000");
-    assert_eq!(format_flo32(-9.9999990), "    -9.9999990");
+    assert_eq!(format_flo32(-9.999_999_0), "    -9.9999990");
     assert_eq!(format_flo32(-10.0), "    -10.000000");
-    assert_eq!(format_flo32(-99.999977), "    -99.999977");
-    assert_eq!(format_flo32(-99.999992), "    -99.999992");
+    assert_eq!(format_flo32(-99.999_977), "    -99.999977");
+    assert_eq!(format_flo32(-99.999_992), "    -99.999992");
     assert_eq!(format_flo32(-100.0), "    -100.00000");
     assert_eq!(format_flo32(-999.99994), "    -999.99994");
     assert_eq!(format_flo32(-1000.0), "    -1000.0000");
     assert_eq!(format_flo32(-9999.9990), "    -9999.9990");
     assert_eq!(format_flo32(-10000.0), "    -10000.000");
     assert_eq!(format_flo32(-99999.992), "    -99999.992");
-    assert_eq!(format_flo32(-100000.0), "    -100000.00");
-    assert_eq!(format_flo32(-999999.94), "    -999999.94");
-    assert_eq!(format_flo32(-1000000.0), "    -1000000.0");
-    assert_eq!(format_flo32(-9999999.0), "    -9999999.0");
-    assert_eq!(format_flo32(-10000000.0), "     -10000000");
-    assert_eq!(format_flo32(-99999992.0), "     -99999992");
-    assert_eq!(format_flo32(-100000000.0), "  -1.0000000e8");
-    assert_eq!(format_flo32(-9.9999994e8), "  -9.9999994e8");
+    assert_eq!(format_flo32(-100_000.0), "    -100000.00");
+    assert_eq!(format_flo32(-999_999.94), "    -999999.94");
+    assert_eq!(format_flo32(-1_000_000.0), "    -1000000.0");
+    assert_eq!(format_flo32(-9_999_999.0), "    -9999999.0");
+    assert_eq!(format_flo32(-10_000_000.0), "     -10000000");
+    assert_eq!(format_flo32(-99_999_992.0), "     -99999992");
+    assert_eq!(format_flo32(-100_000_000.0), "  -1.0000000e8");
+    assert_eq!(format_flo32(-9.999_999_4e8), "  -9.9999994e8");
     assert_eq!(format_flo32(-1.0e9), "  -1.0000000e9");
-    assert_eq!(format_flo32(-9.9999990e9), "  -9.9999990e9");
+    assert_eq!(format_flo32(-9.999_999_0e9), "  -9.9999990e9");
     assert_eq!(format_flo32(-1.0e10), " -1.0000000e10");
 
     assert_eq!(format_flo32(-0.1), "   -0.10000000");
-    assert_eq!(format_flo32(-0.99999994), "   -0.99999994");
-    assert_eq!(format_flo32(-0.010000001), " -1.0000001e-2");
-    assert_eq!(format_flo32(-0.099999994), " -9.9999994e-2");
+    assert_eq!(format_flo32(-0.999_999_94), "   -0.99999994");
+    assert_eq!(format_flo32(-0.010_000_001), " -1.0000001e-2");
+    assert_eq!(format_flo32(-0.099_999_994), " -9.9999994e-2");
     assert_eq!(format_flo32(-0.001), " -1.0000000e-3");
-    assert_eq!(format_flo32(-0.0099999998), " -9.9999998e-3");
+    assert_eq!(format_flo32(-0.009_999_999_8), " -9.9999998e-3");
 
-    assert_eq!(format_flo32(3.4028233e38), "  3.4028233e38");
-    assert_eq!(format_flo32(-3.4028233e38), " -3.4028233e38");
-    assert_eq!(format_flo32(-1.1663108e-38), "-1.1663108e-38");
-    assert_eq!(format_flo32(-4.7019771e-38), "-4.7019771e-38");
+    assert_eq!(format_flo32(3.402_823_3e38), "  3.4028233e38");
+    assert_eq!(format_flo32(-3.402_823_3e38), " -3.4028233e38");
+    assert_eq!(format_flo32(-1.166_310_8e-38), "-1.1663108e-38");
+    assert_eq!(format_flo32(-4.701_977_1e-38), "-4.7019771e-38");
     assert_eq!(format_flo32(1e-45), "         1e-45");
 
-    assert_eq!(format_flo32(-3.402823466e+38), " -3.4028235e38");
+    assert_eq!(format_flo32(-3.402_823_466e+38), " -3.4028235e38");
     assert_eq!(format_flo32(f32::NAN), "           NaN");
     assert_eq!(format_flo32(f32::INFINITY), "           inf");
     assert_eq!(format_flo32(f32::NEG_INFINITY), "          -inf");
@@ -167,16 +166,20 @@ fn test_format_flo32() {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_format_flo64() {
     assert_eq!(format_flo64(1.0), "      1.0000000000000000");
     assert_eq!(format_flo64(10.0), "      10.000000000000000");
-    assert_eq!(format_flo64(1000000000000000.0), "      1000000000000000.0");
     assert_eq!(
-        format_flo64(10000000000000000.0),
+        format_flo64(1_000_000_000_000_000.0),
+        "      1000000000000000.0"
+    );
+    assert_eq!(
+        format_flo64(10_000_000_000_000_000.0),
         "       10000000000000000"
     );
     assert_eq!(
-        format_flo64(100000000000000000.0),
+        format_flo64(100_000_000_000_000_000.0),
         "   1.0000000000000000e17"
     );
 
@@ -184,7 +187,7 @@ fn test_format_flo64() {
     assert_eq!(format_flo64(-0.01), "  -1.0000000000000000e-2");
 
     assert_eq!(
-        format_flo64(-2.2250738585072014e-308),
+        format_flo64(-2.225_073_858_507_201_4e-308),
         "-2.2250738585072014e-308"
     );
     assert_eq!(format_flo64(4e-320), "                  4e-320");
@@ -196,6 +199,7 @@ fn test_format_flo64() {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_format_flo16() {
     assert_eq!(format_flo16(f16::from_bits(0x8400u16)), "-6.104e-5");
     assert_eq!(format_flo16(f16::from_bits(0x8401u16)), "-6.109e-5");
diff --git a/src/uu/od/src/prn_int.rs b/src/uu/od/src/prn_int.rs
index c214b7525eb..f843ff77ca2 100644
--- a/src/uu/od/src/prn_int.rs
+++ b/src/uu/od/src/prn_int.rs
@@ -89,6 +89,7 @@ int_writer_signed!(FORMAT_ITEM_DEC32S, 4, 12, format_item_dec_s32, DEC!()); // m
 int_writer_signed!(FORMAT_ITEM_DEC64S, 8, 21, format_item_dec_s64, DEC!()); // max: -9223372036854775808
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_sign_extend() {
     assert_eq!(
         0xffff_ffff_ffff_ff80u64 as i64,
@@ -179,6 +180,7 @@ fn test_format_item_dec_u() {
 }
 
 #[test]
+#[allow(clippy::cognitive_complexity)]
 fn test_format_item_dec_s() {
     assert_eq!("    0", format_item_dec_s8(0));
     assert_eq!("  127", format_item_dec_s8(0x7f));
diff --git a/src/uu/paste/Cargo.toml b/src/uu/paste/Cargo.toml
index d93d4cbb6b9..7c48c343458 100644
--- a/src/uu/paste/Cargo.toml
+++ b/src/uu/paste/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_paste"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "paste ~ (uutils) merge lines from inputs"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/paste"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/paste.rs"
diff --git a/src/uu/paste/src/paste.rs b/src/uu/paste/src/paste.rs
index 89bba034c3e..98679b74635 100644
--- a/src/uu/paste/src/paste.rs
+++ b/src/uu/paste/src/paste.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 (ToDO) delim
-
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
+use std::cell::{OnceCell, RefCell};
 use std::fs::File;
-use std::io::{stdin, stdout, BufRead, BufReader, Read, Write};
-use std::path::Path;
-use uucore::error::{FromIo, UResult, USimpleError};
+use std::io::{BufRead, BufReader, Stdin, Write, stdin, stdout};
+use std::iter::Cycle;
+use std::rc::Rc;
+use std::slice::Iter;
+use uucore::error::{UResult, USimpleError};
 use uucore::line_ending::LineEnding;
 use uucore::{format_usage, help_about, help_usage};
 
@@ -23,18 +24,6 @@ mod options {
     pub const ZERO_TERMINATED: &str = "zero-terminated";
 }
 
-// Wraps BufReader and stdin
-fn read_until<R: Read>(
-    reader: Option<&mut BufReader<R>>,
-    byte: u8,
-    buf: &mut Vec<u8>,
-) -> std::io::Result<usize> {
-    match reader {
-        Some(reader) => reader.read_until(byte, buf),
-        None => stdin().lock().read_until(byte, buf),
-    }
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
@@ -44,7 +33,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let files = matches
         .get_many::<String>(options::FILE)
         .unwrap()
-        .map(|s| s.to_owned())
+        .cloned()
         .collect();
     let line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
 
@@ -53,7 +42,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -96,123 +85,292 @@ fn paste(
     delimiters: &str,
     line_ending: LineEnding,
 ) -> UResult<()> {
-    let mut files = Vec::with_capacity(filenames.len());
-    for name in filenames {
-        let file = if name == "-" {
-            None
-        } else {
-            let path = Path::new(&name);
-            let r = File::open(path).map_err_context(String::new)?;
-            Some(BufReader::new(r))
-        };
-        files.push(file);
-    }
+    let unescaped_and_encoded_delimiters = parse_delimiters(delimiters)?;
 
-    if delimiters.ends_with('\\') && !delimiters.ends_with("\\\\") {
-        return Err(USimpleError::new(
-            1,
-            format!(
-                "delimiter list ends with an unescaped backslash: {}",
-                delimiters
+    let stdin_once_cell = OnceCell::<Rc<RefCell<Stdin>>>::new();
+
+    let mut input_source_vec = Vec::with_capacity(filenames.len());
+
+    for filename in filenames {
+        let input_source = match filename.as_str() {
+            "-" => InputSource::StandardInput(
+                stdin_once_cell
+                    .get_or_init(|| Rc::new(RefCell::new(stdin())))
+                    .clone(),
             ),
-        ));
+            st => {
+                let file = File::open(st)?;
+
+                InputSource::File(BufReader::new(file))
+            }
+        };
+
+        input_source_vec.push(input_source);
     }
 
-    let delimiters: Vec<char> = unescape(delimiters).chars().collect();
-    let mut delim_count = 0;
-    let mut delim_length = 1;
-    let stdout = stdout();
-    let mut stdout = stdout.lock();
+    let mut stdout = stdout().lock();
+
+    let line_ending_byte = u8::from(line_ending);
+    let line_ending_byte_array_ref = &[line_ending_byte];
+
+    let input_source_vec_len = input_source_vec.len();
+
+    let mut delimiter_state = DelimiterState::new(&unescaped_and_encoded_delimiters);
 
     let mut output = Vec::new();
+
     if serial {
-        for file in &mut files {
+        for input_source in &mut input_source_vec {
             output.clear();
+
             loop {
-                match read_until(file.as_mut(), line_ending as u8, &mut output) {
-                    Ok(0) => break,
-                    Ok(_) => {
-                        if output.ends_with(&[line_ending as u8]) {
-                            output.pop();
-                        }
-                        // a buffer of length four is large enough to encode any char
-                        let mut buffer = [0; 4];
-                        let ch =
-                            delimiters[delim_count % delimiters.len()].encode_utf8(&mut buffer);
-                        delim_length = ch.len();
-
-                        for byte in buffer.iter().take(delim_length) {
-                            output.push(*byte);
-                        }
+                match input_source.read_until(line_ending_byte, &mut output)? {
+                    0 => break,
+                    _ => {
+                        remove_trailing_line_ending_byte(line_ending_byte, &mut output);
+
+                        delimiter_state.write_delimiter(&mut output);
                     }
-                    Err(e) => return Err(e.map_err_context(String::new)),
                 }
-                delim_count += 1;
             }
-            // remove final delimiter
-            output.truncate(output.len() - delim_length);
-
-            write!(
-                stdout,
-                "{}{}",
-                String::from_utf8_lossy(&output),
-                line_ending
-            )?;
+
+            delimiter_state.remove_trailing_delimiter(&mut output);
+
+            stdout.write_all(&output)?;
+            stdout.write_all(line_ending_byte_array_ref)?;
         }
     } else {
-        let mut eof = vec![false; files.len()];
+        let mut eof = vec![false; input_source_vec_len];
+
         loop {
             output.clear();
+
             let mut eof_count = 0;
-            for (i, file) in files.iter_mut().enumerate() {
+
+            for (i, input_source) in input_source_vec.iter_mut().enumerate() {
                 if eof[i] {
                     eof_count += 1;
                 } else {
-                    match read_until(file.as_mut(), line_ending as u8, &mut output) {
-                        Ok(0) => {
+                    match input_source.read_until(line_ending_byte, &mut output)? {
+                        0 => {
                             eof[i] = true;
                             eof_count += 1;
                         }
-                        Ok(_) => {
-                            if output.ends_with(&[line_ending as u8]) {
-                                output.pop();
-                            }
+                        _ => {
+                            remove_trailing_line_ending_byte(line_ending_byte, &mut output);
                         }
-                        Err(e) => return Err(e.map_err_context(String::new)),
                     }
                 }
-                // a buffer of length four is large enough to encode any char
-                let mut buffer = [0; 4];
-                let ch = delimiters[delim_count % delimiters.len()].encode_utf8(&mut buffer);
-                delim_length = ch.len();
 
-                for byte in buffer.iter().take(delim_length) {
-                    output.push(*byte);
-                }
-
-                delim_count += 1;
+                delimiter_state.write_delimiter(&mut output);
             }
-            if files.len() == eof_count {
+
+            if eof_count == input_source_vec_len {
                 break;
             }
-            // Remove final delimiter
-            output.truncate(output.len() - delim_length);
-
-            write!(
-                stdout,
-                "{}{}",
-                String::from_utf8_lossy(&output),
-                line_ending
-            )?;
-            delim_count = 0;
+
+            delimiter_state.remove_trailing_delimiter(&mut output);
+
+            stdout.write_all(&output)?;
+            stdout.write_all(line_ending_byte_array_ref)?;
+
+            // Quote:
+            //     When the -s option is not specified:
+            //     [...]
+            //     The delimiter shall be reset to the first element of list after each file operand is processed.
+            // https://pubs.opengroup.org/onlinepubs/9799919799/utilities/paste.html
+            delimiter_state.reset_to_first_delimiter();
         }
     }
+
     Ok(())
 }
 
-// Unescape all special characters
-fn unescape(s: &str) -> String {
-    s.replace("\\n", "\n")
-        .replace("\\t", "\t")
-        .replace("\\\\", "\\")
+fn parse_delimiters(delimiters: &str) -> UResult<Box<[Box<[u8]>]>> {
+    /// A single backslash char
+    const BACKSLASH: char = '\\';
+
+    fn add_one_byte_single_char_delimiter(vec: &mut Vec<Box<[u8]>>, byte: u8) {
+        vec.push(Box::new([byte]));
+    }
+
+    // a buffer of length four is large enough to encode any char
+    let mut buffer = [0; 4];
+
+    let mut add_single_char_delimiter = |vec: &mut Vec<Box<[u8]>>, ch: char| {
+        let delimiter_encoded = ch.encode_utf8(&mut buffer);
+
+        vec.push(Box::<[u8]>::from(delimiter_encoded.as_bytes()));
+    };
+
+    let mut vec = Vec::<Box<[u8]>>::with_capacity(delimiters.len());
+
+    let mut chars = delimiters.chars();
+
+    // Unescape all special characters
+    while let Some(char) = chars.next() {
+        match char {
+            BACKSLASH => match chars.next() {
+                // "Empty string (not a null character)"
+                // https://pubs.opengroup.org/onlinepubs/9799919799/utilities/paste.html
+                Some('0') => {
+                    vec.push(Box::<[u8; 0]>::new([]));
+                }
+                // "\\" to "\" (U+005C)
+                Some(BACKSLASH) => {
+                    add_one_byte_single_char_delimiter(&mut vec, b'\\');
+                }
+                // "\n" to U+000A
+                Some('n') => {
+                    add_one_byte_single_char_delimiter(&mut vec, b'\n');
+                }
+                // "\t" to U+0009
+                Some('t') => {
+                    add_one_byte_single_char_delimiter(&mut vec, b'\t');
+                }
+                Some(other_char) => {
+                    // "If any other characters follow the <backslash>, the results are unspecified."
+                    // https://pubs.opengroup.org/onlinepubs/9799919799/utilities/paste.html
+                    // However, other implementations remove the backslash
+                    // See "test_posix_unspecified_delimiter"
+                    add_single_char_delimiter(&mut vec, other_char);
+                }
+                None => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("delimiter list ends with an unescaped backslash: {delimiters}"),
+                    ));
+                }
+            },
+            non_backslash_char => {
+                add_single_char_delimiter(&mut vec, non_backslash_char);
+            }
+        }
+    }
+
+    Ok(vec.into_boxed_slice())
+}
+
+fn remove_trailing_line_ending_byte(line_ending_byte: u8, output: &mut Vec<u8>) {
+    if let Some(&byte) = output.last() {
+        if byte == line_ending_byte {
+            assert_eq!(output.pop(), Some(line_ending_byte));
+        }
+    }
+}
+
+enum DelimiterState<'a> {
+    NoDelimiters,
+    OneDelimiter(&'a [u8]),
+    MultipleDelimiters {
+        current_delimiter: &'a [u8],
+        delimiters: &'a [Box<[u8]>],
+        delimiters_iterator: Cycle<Iter<'a, Box<[u8]>>>,
+    },
+}
+
+impl<'a> DelimiterState<'a> {
+    fn new(unescaped_and_encoded_delimiters: &'a [Box<[u8]>]) -> DelimiterState<'a> {
+        match unescaped_and_encoded_delimiters {
+            [] => DelimiterState::NoDelimiters,
+            [only_delimiter] => {
+                // -d '\0' is equivalent to -d ''
+                if only_delimiter.is_empty() {
+                    DelimiterState::NoDelimiters
+                } else {
+                    DelimiterState::OneDelimiter(only_delimiter)
+                }
+            }
+            [first_delimiter, ..] => DelimiterState::MultipleDelimiters {
+                current_delimiter: first_delimiter,
+                delimiters: unescaped_and_encoded_delimiters,
+                delimiters_iterator: unescaped_and_encoded_delimiters.iter().cycle(),
+            },
+        }
+    }
+
+    /// This should only be used to return to the start of the delimiter list after a file has been processed.
+    /// This should only be used when the "serial" option is disabled.
+    /// This is a no-op unless there are multiple delimiters.
+    fn reset_to_first_delimiter(&mut self) {
+        if let DelimiterState::MultipleDelimiters {
+            delimiters_iterator,
+            delimiters,
+            ..
+        } = self
+        {
+            *delimiters_iterator = delimiters.iter().cycle();
+        }
+    }
+
+    /// Remove the trailing delimiter.
+    /// If there are no delimiters, this is a no-op.
+    fn remove_trailing_delimiter(&mut self, output: &mut Vec<u8>) {
+        let delimiter_length = match self {
+            DelimiterState::OneDelimiter(only_delimiter) => only_delimiter.len(),
+            DelimiterState::MultipleDelimiters {
+                current_delimiter, ..
+            } => current_delimiter.len(),
+            DelimiterState::NoDelimiters => {
+                return;
+            }
+        };
+
+        // `delimiter_length` will be zero if the current delimiter is a "\0" delimiter
+        if delimiter_length > 0 {
+            let output_len = output.len();
+
+            if let Some(output_without_delimiter_length) = output_len.checked_sub(delimiter_length)
+            {
+                output.truncate(output_without_delimiter_length);
+            } else {
+                // This branch is NOT unreachable, must be skipped
+                // `output` should be empty in this case
+                assert_eq!(output_len, 0);
+            }
+        }
+    }
+
+    /// Append the current delimiter to `output`.
+    /// If there are no delimiters, this is a no-op.
+    fn write_delimiter(&mut self, output: &mut Vec<u8>) {
+        match self {
+            DelimiterState::OneDelimiter(only_delimiter) => {
+                output.extend_from_slice(only_delimiter);
+            }
+            DelimiterState::MultipleDelimiters {
+                current_delimiter,
+                delimiters_iterator,
+                ..
+            } => {
+                // Unwrap because `delimiters_iterator` is a cycle iter and was created from a non-empty slice
+                let bo = delimiters_iterator.next().unwrap();
+
+                output.extend_from_slice(bo);
+
+                *current_delimiter = bo;
+            }
+            DelimiterState::NoDelimiters => {}
+        }
+    }
+}
+
+enum InputSource {
+    File(BufReader<File>),
+    StandardInput(Rc<RefCell<Stdin>>),
+}
+
+impl InputSource {
+    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> UResult<usize> {
+        let us = match self {
+            InputSource::File(bu) => bu.read_until(byte, buf)?,
+            InputSource::StandardInput(rc) => rc
+                .try_borrow()
+                .map_err(|bo| USimpleError::new(1, format!("{bo}")))?
+                .lock()
+                .read_until(byte, buf)?,
+        };
+
+        Ok(us)
+    }
 }
diff --git a/src/uu/pathchk/Cargo.toml b/src/uu/pathchk/Cargo.toml
index f62c027c4fd..4acd16ac3f9 100644
--- a/src/uu/pathchk/Cargo.toml
+++ b/src/uu/pathchk/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_pathchk"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "pathchk ~ (uutils) diagnose invalid or non-portable PATHNAME"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pathchk"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/pathchk.rs"
diff --git a/src/uu/pathchk/src/pathchk.rs b/src/uu/pathchk/src/pathchk.rs
index 3510a3327b3..183d67a0beb 100644
--- a/src/uu/pathchk/src/pathchk.rs
+++ b/src/uu/pathchk/src/pathchk.rs
@@ -5,11 +5,11 @@
 #![allow(unused_must_use)] // because we of writeln!
 
 // spell-checker:ignore (ToDO) lstat
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::fs;
 use std::io::{ErrorKind, Write};
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UResult, UUsageError};
+use uucore::error::{UResult, UUsageError, set_exit_code};
 use uucore::{format_usage, help_about, help_usage};
 
 // operating mode
@@ -36,8 +36,6 @@ const POSIX_NAME_MAX: usize = 14;
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     // set working mode
@@ -81,7 +79,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -117,7 +115,7 @@ fn check_path(mode: &Mode, path: &[String]) -> bool {
         Mode::Basic => check_basic(path),
         Mode::Extra => check_default(path) && check_extra(path),
         Mode::Both => check_basic(path) && check_extra(path),
-        _ => check_default(path),
+        Mode::Default => check_default(path),
     }
 }
 
@@ -142,9 +140,7 @@ fn check_basic(path: &[String]) -> bool {
         if component_len > POSIX_NAME_MAX {
             writeln!(
                 std::io::stderr(),
-                "limit {} exceeded by length {} of file name component {}",
-                POSIX_NAME_MAX,
-                component_len,
+                "limit {POSIX_NAME_MAX} exceeded by length {component_len} of file name component {}",
                 p.quote()
             );
             return false;
@@ -186,22 +182,31 @@ fn check_default(path: &[String]) -> bool {
     if total_len > libc::PATH_MAX as usize {
         writeln!(
             std::io::stderr(),
-            "limit {} exceeded by length {} of file name {}",
+            "limit {} exceeded by length {total_len} of file name {}",
             libc::PATH_MAX,
-            total_len,
             joined_path.quote()
         );
         return false;
     }
+    if total_len == 0 {
+        // Check whether a file name component is in a directory that is not searchable,
+        // or has some other serious problem. POSIX does not allow "" as a file name,
+        // but some non-POSIX hosts do (as an alias for "."),
+        // so allow "" if `symlink_metadata` (corresponds to `lstat`) does.
+        if fs::symlink_metadata(&joined_path).is_err() {
+            writeln!(std::io::stderr(), "pathchk: '': No such file or directory");
+            return false;
+        }
+    }
+
     // components: length
     for p in path {
         let component_len = p.len();
         if component_len > libc::FILENAME_MAX as usize {
             writeln!(
                 std::io::stderr(),
-                "limit {} exceeded by length {} of file name component {}",
+                "limit {} exceeded by length {component_len} of file name component {}",
                 libc::FILENAME_MAX,
-                component_len,
                 p.quote()
             );
             return false;
@@ -235,8 +240,7 @@ fn check_portable_chars(path_segment: &str) -> bool {
             let invalid = path_segment[i..].chars().next().unwrap();
             writeln!(
                 std::io::stderr(),
-                "nonportable character '{}' in file name component {}",
-                invalid,
+                "nonportable character '{invalid}' in file name component {}",
                 path_segment.quote()
             );
             return false;
diff --git a/src/uu/pinky/Cargo.toml b/src/uu/pinky/Cargo.toml
index f6d291e26e9..2d496f8fca1 100644
--- a/src/uu/pinky/Cargo.toml
+++ b/src/uu/pinky/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_pinky"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "pinky ~ (uutils) display user information"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pinky"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/pinky.rs"
diff --git a/src/uu/pinky/src/pinky.rs b/src/uu/pinky/src/pinky.rs
index 8ac8f6c8446..8246f86556e 100644
--- a/src/uu/pinky/src/pinky.rs
+++ b/src/uu/pinky/src/pinky.rs
@@ -5,22 +5,23 @@
 
 // spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
 
-use uucore::entries::{Locate, Passwd};
-use uucore::error::{FromIo, UResult};
-use uucore::libc::S_IWGRP;
-use uucore::utmpx::{self, time, Utmpx};
-
-use std::io::prelude::*;
-use std::io::BufReader;
+use clap::{Arg, ArgAction, Command};
+use uucore::{format_usage, help_about, help_usage};
 
-use std::fs::File;
-use std::os::unix::fs::MetadataExt;
+mod platform;
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::path::PathBuf;
-use uucore::{format_usage, help_about, help_usage};
+#[cfg(target_env = "musl")]
+const ABOUT: &str = concat!(
+    help_about!("pinky.md"),
+    "\n\nWarning: When built with musl libc, the `pinky` utility may show incomplete \n",
+    "or missing user information due to musl's stub implementation of `utmpx` \n",
+    "functions. This limitation affects the ability to retrieve accurate details \n",
+    "about logged-in users."
+);
 
+#[cfg(not(target_env = "musl"))]
 const ABOUT: &str = help_about!("pinky.md");
+
 const USAGE: &str = help_usage!("pinky.md");
 
 mod options {
@@ -37,92 +38,12 @@ mod options {
     pub const HELP: &str = "help";
 }
 
-fn get_long_usage() -> String {
-    format!(
-        "A lightweight 'finger' program;  print user information.\n\
-         The utmp file will be {}.",
-        utmpx::DEFAULT_FILE
-    )
-}
-
 #[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app()
-        .after_help(get_long_usage())
-        .try_get_matches_from(args)?;
-
-    let users: Vec<String> = matches
-        .get_many::<String>(options::USER)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
-    // If true, display the hours:minutes since each user has touched
-    // the keyboard, or blank if within the last minute, or days followed
-    // by a 'd' if not within the last day.
-    let mut include_idle = true;
-
-    // If true, display a line at the top describing each field.
-    let include_heading = !matches.get_flag(options::OMIT_HEADINGS);
-
-    // if true, display the user's full name from pw_gecos.
-    let mut include_fullname = true;
-
-    // if true, display the user's ~/.project file when doing long format.
-    let include_project = !matches.get_flag(options::OMIT_PROJECT_FILE);
-
-    // if true, display the user's ~/.plan file when doing long format.
-    let include_plan = !matches.get_flag(options::OMIT_PLAN_FILE);
-
-    // if true, display the user's home directory and shell
-    // when doing long format.
-    let include_home_and_shell = !matches.get_flag(options::OMIT_HOME_DIR);
-
-    // if true, use the "short" output format.
-    let do_short_format = !matches.get_flag(options::LONG_FORMAT);
-
-    /* if true, display the ut_host field. */
-    let mut include_where = true;
-
-    if matches.get_flag(options::OMIT_NAME) {
-        include_fullname = false;
-    }
-    if matches.get_flag(options::OMIT_NAME_HOST) {
-        include_fullname = false;
-        include_where = false;
-    }
-    if matches.get_flag(options::OMIT_NAME_HOST_TIME) {
-        include_fullname = false;
-        include_idle = false;
-        include_where = false;
-    }
-
-    let pk = Pinky {
-        include_idle,
-        include_heading,
-        include_fullname,
-        include_project,
-        include_plan,
-        include_home_and_shell,
-        include_where,
-        names: users,
-    };
-
-    if do_short_format {
-        match pk.short_pinky() {
-            Ok(_) => Ok(()),
-            Err(e) => Err(e.map_err_context(String::new)),
-        }
-    } else {
-        pk.long_pinky();
-        Ok(())
-    }
-}
+use platform::uumain;
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -197,17 +118,6 @@ pub fn uu_app() -> Command {
         )
 }
 
-struct Pinky {
-    include_idle: bool,
-    include_heading: bool,
-    include_fullname: bool,
-    include_project: bool,
-    include_plan: bool,
-    include_where: bool,
-    include_home_and_shell: bool,
-    names: Vec<String>,
-}
-
 pub trait Capitalize {
     fn capitalize(&self) -> String;
 }
@@ -225,180 +135,3 @@ impl Capitalize for str {
             })
     }
 }
-
-fn idle_string(when: i64) -> String {
-    thread_local! {
-        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
-    }
-    NOW.with(|n| {
-        let duration = n.unix_timestamp() - when;
-        if duration < 60 {
-            // less than 1min
-            "     ".to_owned()
-        } else if duration < 24 * 3600 {
-            // less than 1day
-            let hours = duration / (60 * 60);
-            let minutes = (duration % (60 * 60)) / 60;
-            format!("{hours:02}:{minutes:02}")
-        } else {
-            // more than 1day
-            let days = duration / (24 * 3600);
-            format!("{days}d")
-        }
-    })
-}
-
-fn time_string(ut: &Utmpx) -> String {
-    // "%b %e %H:%M"
-    let time_format: Vec<time::format_description::FormatItem> =
-        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
-            .unwrap();
-    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
-}
-
-fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
-    let mut gecos = if let Some(gecos) = &pw.user_info {
-        gecos.clone()
-    } else {
-        return None;
-    };
-    if let Some(n) = gecos.find(',') {
-        gecos.truncate(n);
-    }
-    Some(gecos.replace('&', &pw.name.capitalize()))
-}
-
-impl Pinky {
-    fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
-        let mut pts_path = PathBuf::from("/dev");
-        pts_path.push(ut.tty_device().as_str());
-
-        let mesg;
-        let last_change;
-
-        match pts_path.metadata() {
-            #[allow(clippy::unnecessary_cast)]
-            Ok(meta) => {
-                mesg = if meta.mode() & S_IWGRP as u32 == 0 {
-                    '*'
-                } else {
-                    ' '
-                };
-                last_change = meta.atime();
-            }
-            _ => {
-                mesg = '?';
-                last_change = 0;
-            }
-        }
-
-        print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
-
-        if self.include_fullname {
-            let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
-                gecos_to_fullname(&pw)
-            } else {
-                None
-            };
-            if let Some(fullname) = fullname {
-                print!(" {fullname:<19.19}");
-            } else {
-                print!(" {:19}", "        ???");
-            }
-        }
-
-        print!(" {}{:<8.*}", mesg, utmpx::UT_LINESIZE, ut.tty_device());
-
-        if self.include_idle {
-            if last_change == 0 {
-                print!(" {:<6}", "?????");
-            } else {
-                print!(" {:<6}", idle_string(last_change));
-            }
-        }
-
-        print!(" {}", time_string(ut));
-
-        let mut s = ut.host();
-        if self.include_where && !s.is_empty() {
-            s = ut.canon_host()?;
-            print!(" {s}");
-        }
-
-        println!();
-        Ok(())
-    }
-
-    fn print_heading(&self) {
-        print!("{:<8}", "Login");
-        if self.include_fullname {
-            print!(" {:<19}", "Name");
-        }
-        print!(" {:<9}", " TTY");
-        if self.include_idle {
-            print!(" {:<6}", "Idle");
-        }
-        print!(" {:<16}", "When");
-        if self.include_where {
-            print!(" Where");
-        }
-        println!();
-    }
-
-    fn short_pinky(&self) -> std::io::Result<()> {
-        if self.include_heading {
-            self.print_heading();
-        }
-        for ut in Utmpx::iter_all_records() {
-            if ut.is_user_process()
-                && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
-            {
-                self.print_entry(&ut)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn long_pinky(&self) {
-        for u in &self.names {
-            print!("Login name: {u:<28}In real life: ");
-            if let Ok(pw) = Passwd::locate(u.as_str()) {
-                let fullname = gecos_to_fullname(&pw).unwrap_or_default();
-                let user_dir = pw.user_dir.unwrap_or_default();
-                let user_shell = pw.user_shell.unwrap_or_default();
-                println!(" {fullname}");
-                if self.include_home_and_shell {
-                    print!("Directory: {user_dir:<29}");
-                    println!("Shell:  {user_shell}");
-                }
-                if self.include_project {
-                    let mut p = PathBuf::from(&user_dir);
-                    p.push(".project");
-                    if let Ok(f) = File::open(p) {
-                        print!("Project: ");
-                        read_to_console(f);
-                    }
-                }
-                if self.include_plan {
-                    let mut p = PathBuf::from(&user_dir);
-                    p.push(".plan");
-                    if let Ok(f) = File::open(p) {
-                        println!("Plan:");
-                        read_to_console(f);
-                    }
-                }
-                println!();
-            } else {
-                println!(" ???");
-            }
-        }
-    }
-}
-
-fn read_to_console<F: Read>(f: F) {
-    let mut reader = BufReader::new(f);
-    let mut iobuf = Vec::new();
-    if reader.read_to_end(&mut iobuf).is_ok() {
-        print!("{}", String::from_utf8_lossy(&iobuf));
-    }
-}
diff --git a/src/uu/pinky/src/platform/mod.rs b/src/uu/pinky/src/platform/mod.rs
new file mode 100644
index 00000000000..e0e87dca1bf
--- /dev/null
+++ b/src/uu/pinky/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// 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.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/pinky/src/platform/openbsd.rs b/src/uu/pinky/src/platform/openbsd.rs
new file mode 100644
index 00000000000..7e6970c1f09
--- /dev/null
+++ b/src/uu/pinky/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// 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.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+
+    println!("unsupported command on OpenBSD");
+    Ok(())
+}
diff --git a/src/uu/pinky/src/platform/unix.rs b/src/uu/pinky/src/platform/unix.rs
new file mode 100644
index 00000000000..5c74abc3db5
--- /dev/null
+++ b/src/uu/pinky/src/platform/unix.rs
@@ -0,0 +1,291 @@
+// 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.
+
+// spell-checker:ignore (ToDO) BUFSIZE gecos fullname, mesg iobuf
+
+use crate::Capitalize;
+use crate::options;
+use crate::uu_app;
+
+use uucore::entries::{Locate, Passwd};
+use uucore::error::{FromIo, UResult};
+use uucore::libc::S_IWGRP;
+use uucore::utmpx::{self, Utmpx, time};
+
+use std::io::BufReader;
+use std::io::prelude::*;
+
+use std::fs::File;
+use std::os::unix::fs::MetadataExt;
+
+use std::path::PathBuf;
+
+fn get_long_usage() -> String {
+    format!(
+        "A lightweight 'finger' program;  print user information.\n\
+         The utmp file will be {}.",
+        utmpx::DEFAULT_FILE
+    )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app()
+        .after_help(get_long_usage())
+        .try_get_matches_from(args)?;
+
+    let users: Vec<String> = matches
+        .get_many::<String>(options::USER)
+        .map(|v| v.map(ToString::to_string).collect())
+        .unwrap_or_default();
+
+    // If true, display the hours:minutes since each user has touched
+    // the keyboard, or blank if within the last minute, or days followed
+    // by a 'd' if not within the last day.
+    let mut include_idle = true;
+
+    // If true, display a line at the top describing each field.
+    let include_heading = !matches.get_flag(options::OMIT_HEADINGS);
+
+    // if true, display the user's full name from pw_gecos.
+    let mut include_fullname = true;
+
+    // if true, display the user's ~/.project file when doing long format.
+    let include_project = !matches.get_flag(options::OMIT_PROJECT_FILE);
+
+    // if true, display the user's ~/.plan file when doing long format.
+    let include_plan = !matches.get_flag(options::OMIT_PLAN_FILE);
+
+    // if true, display the user's home directory and shell
+    // when doing long format.
+    let include_home_and_shell = !matches.get_flag(options::OMIT_HOME_DIR);
+
+    // if true, use the "short" output format.
+    let do_short_format = !matches.get_flag(options::LONG_FORMAT);
+
+    /* if true, display the ut_host field. */
+    let mut include_where = true;
+
+    if matches.get_flag(options::OMIT_NAME) {
+        include_fullname = false;
+    }
+    if matches.get_flag(options::OMIT_NAME_HOST) {
+        include_fullname = false;
+        include_where = false;
+    }
+    if matches.get_flag(options::OMIT_NAME_HOST_TIME) {
+        include_fullname = false;
+        include_idle = false;
+        include_where = false;
+    }
+
+    let pk = Pinky {
+        include_idle,
+        include_heading,
+        include_fullname,
+        include_project,
+        include_plan,
+        include_home_and_shell,
+        include_where,
+        names: users,
+    };
+
+    if do_short_format {
+        match pk.short_pinky() {
+            Ok(_) => Ok(()),
+            Err(e) => Err(e.map_err_context(String::new)),
+        }
+    } else {
+        pk.long_pinky();
+        Ok(())
+    }
+}
+
+struct Pinky {
+    include_idle: bool,
+    include_heading: bool,
+    include_fullname: bool,
+    include_project: bool,
+    include_plan: bool,
+    include_where: bool,
+    include_home_and_shell: bool,
+    names: Vec<String>,
+}
+
+fn idle_string(when: i64) -> String {
+    thread_local! {
+        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap_or_else(|_| time::OffsetDateTime::now_utc());
+    }
+    NOW.with(|n| {
+        let duration = n.unix_timestamp() - when;
+        if duration < 60 {
+            // less than 1min
+            "     ".to_owned()
+        } else if duration < 24 * 3600 {
+            // less than 1day
+            let hours = duration / (60 * 60);
+            let minutes = (duration % (60 * 60)) / 60;
+            format!("{hours:02}:{minutes:02}")
+        } else {
+            // more than 1day
+            let days = duration / (24 * 3600);
+            format!("{days}d")
+        }
+    })
+}
+
+fn time_string(ut: &Utmpx) -> String {
+    // "%b %e %H:%M"
+    let time_format: Vec<time::format_description::FormatItem> =
+        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
+            .unwrap();
+    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+}
+
+fn gecos_to_fullname(pw: &Passwd) -> Option<String> {
+    let mut gecos = if let Some(gecos) = &pw.user_info {
+        gecos.clone()
+    } else {
+        return None;
+    };
+    if let Some(n) = gecos.find(',') {
+        gecos.truncate(n);
+    }
+    Some(gecos.replace('&', &pw.name.capitalize()))
+}
+
+impl Pinky {
+    fn print_entry(&self, ut: &Utmpx) -> std::io::Result<()> {
+        let mut pts_path = PathBuf::from("/dev");
+        pts_path.push(ut.tty_device().as_str());
+
+        let mesg;
+        let last_change;
+
+        match pts_path.metadata() {
+            #[allow(clippy::unnecessary_cast)]
+            Ok(meta) => {
+                mesg = if meta.mode() & S_IWGRP as u32 == 0 {
+                    '*'
+                } else {
+                    ' '
+                };
+                last_change = meta.atime();
+            }
+            _ => {
+                mesg = '?';
+                last_change = 0;
+            }
+        }
+
+        print!("{1:<8.0$}", utmpx::UT_NAMESIZE, ut.user());
+
+        if self.include_fullname {
+            let fullname = if let Ok(pw) = Passwd::locate(ut.user().as_ref()) {
+                gecos_to_fullname(&pw)
+            } else {
+                None
+            };
+            if let Some(fullname) = fullname {
+                print!(" {fullname:<19.19}");
+            } else {
+                print!(" {:19}", "        ???");
+            }
+        }
+
+        print!(" {mesg}{:<8.*}", utmpx::UT_LINESIZE, ut.tty_device());
+
+        if self.include_idle {
+            if last_change == 0 {
+                print!(" {:<6}", "?????");
+            } else {
+                print!(" {:<6}", idle_string(last_change));
+            }
+        }
+
+        print!(" {}", time_string(ut));
+
+        let mut s = ut.host();
+        if self.include_where && !s.is_empty() {
+            s = ut.canon_host()?;
+            print!(" {s}");
+        }
+
+        println!();
+        Ok(())
+    }
+
+    fn print_heading(&self) {
+        print!("{:<8}", "Login");
+        if self.include_fullname {
+            print!(" {:<19}", "Name");
+        }
+        print!(" {:<9}", " TTY");
+        if self.include_idle {
+            print!(" {:<6}", "Idle");
+        }
+        print!(" {:<16}", "When");
+        if self.include_where {
+            print!(" Where");
+        }
+        println!();
+    }
+
+    fn short_pinky(&self) -> std::io::Result<()> {
+        if self.include_heading {
+            self.print_heading();
+        }
+        for ut in Utmpx::iter_all_records() {
+            if ut.is_user_process()
+                && (self.names.is_empty() || self.names.iter().any(|n| n.as_str() == ut.user()))
+            {
+                self.print_entry(&ut)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn long_pinky(&self) {
+        for u in &self.names {
+            print!("Login name: {u:<28}In real life: ");
+            if let Ok(pw) = Passwd::locate(u.as_str()) {
+                let fullname = gecos_to_fullname(&pw).unwrap_or_default();
+                let user_dir = pw.user_dir.unwrap_or_default();
+                let user_shell = pw.user_shell.unwrap_or_default();
+                println!(" {fullname}");
+                if self.include_home_and_shell {
+                    print!("Directory: {user_dir:<29}");
+                    println!("Shell:  {user_shell}");
+                }
+                if self.include_project {
+                    let mut p = PathBuf::from(&user_dir);
+                    p.push(".project");
+                    if let Ok(f) = File::open(p) {
+                        print!("Project: ");
+                        read_to_console(f);
+                    }
+                }
+                if self.include_plan {
+                    let mut p = PathBuf::from(&user_dir);
+                    p.push(".plan");
+                    if let Ok(f) = File::open(p) {
+                        println!("Plan:");
+                        read_to_console(f);
+                    }
+                }
+                println!();
+            } else {
+                println!(" ???");
+            }
+        }
+    }
+}
+
+fn read_to_console<F: Read>(f: F) {
+    let mut reader = BufReader::new(f);
+    let mut iobuf = Vec::new();
+    if reader.read_to_end(&mut iobuf).is_ok() {
+        print!("{}", String::from_utf8_lossy(&iobuf));
+    }
+}
diff --git a/src/uu/pr/Cargo.toml b/src/uu/pr/Cargo.toml
index 4453d1cbaa6..abacaa9f071 100644
--- a/src/uu/pr/Cargo.toml
+++ b/src/uu/pr/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_pr"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "pr ~ (uutils) convert text files for printing"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pr"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/pr.rs"
@@ -17,10 +20,10 @@ path = "src/pr.rs"
 [dependencies]
 clap = { workspace = true }
 uucore = { workspace = true, features = ["entries"] }
-quick-error = { workspace = true }
 itertools = { workspace = true }
 regex = { workspace = true }
 chrono = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "pr"
diff --git a/src/uu/pr/pr.md b/src/uu/pr/pr.md
index 2c246b25f1c..cd2f552f3de 100644
--- a/src/uu/pr/pr.md
+++ b/src/uu/pr/pr.md
@@ -1,7 +1,7 @@
 # pr
 
 ```
-pr [OPTIONS] [files]...
+pr [OPTION]... [FILE]...
 ```
 
 Write content of given file or standard input to standard output with pagination filter
diff --git a/src/uu/pr/src/pr.rs b/src/uu/pr/src/pr.rs
index ef178a888cf..e24f9cf18e5 100644
--- a/src/uu/pr/src/pr.rs
+++ b/src/uu/pr/src/pr.rs
@@ -7,17 +7,15 @@
 // spell-checker:ignore (ToDO) adFfmprt, kmerge
 
 use chrono::{DateTime, Local};
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use itertools::Itertools;
-use quick_error::ResultExt;
 use regex::Regex;
-use std::convert::From;
-use std::fs::{metadata, File};
-use std::io::{stdin, stdout, BufRead, BufReader, Lines, Read, Write};
+use std::fs::{File, metadata};
+use std::io::{BufRead, BufReader, Lines, Read, Write, stdin, stdout};
 #[cfg(unix)]
 use std::os::unix::fs::FileTypeExt;
+use thiserror::Error;
 
-use quick_error::quick_error;
 use uucore::display::Quotable;
 use uucore::error::UResult;
 use uucore::{format_usage, help_about, help_section, help_usage};
@@ -135,40 +133,26 @@ impl From<std::io::Error> for PrError {
     }
 }
 
-quick_error! {
-    #[derive(Debug)]
-    enum PrError {
-        Input(err: std::io::Error, path: String) {
-            context(path: &'a str, err: std::io::Error) -> (err, path.to_owned())
-            display("pr: Reading from input {0} gave error", path)
-            source(err)
-        }
-
-        UnknownFiletype(path: String) {
-            display("pr: {0}: unknown filetype", path)
-        }
-
-        EncounteredErrors(msg: String) {
-            display("pr: {0}", msg)
-        }
-
-        IsDirectory(path: String) {
-            display("pr: {0}: Is a directory", path)
-        }
-
-        IsSocket(path: String) {
-            display("pr: cannot open {}, Operation not supported on socket", path)
-        }
-
-        NotExists(path: String) {
-            display("pr: cannot open {}, No such file or directory", path)
-        }
-    }
+#[derive(Debug, Error)]
+enum PrError {
+    #[error("pr: Reading from input {1} gave error")]
+    Input(std::io::Error, String),
+    #[error("pr: {0}: unknown filetype")]
+    UnknownFiletype(String),
+    #[error("pr: {0}")]
+    EncounteredErrors(String),
+    #[error("pr: {0}: Is a directory")]
+    IsDirectory(String),
+    #[cfg(not(windows))]
+    #[error("pr: cannot open {0}, Operation not supported on socket")]
+    IsSocket(String),
+    #[error("pr: cannot open {0}, No such file or directory")]
+    NotExists(String),
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -387,13 +371,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let opt_args = recreate_arguments(&args);
 
     let mut command = uu_app();
-    let matches = match command.try_get_matches_from_mut(opt_args) {
-        Ok(m) => m,
-        Err(e) => {
-            e.print()?;
-            return Ok(());
-        }
-    };
+    let matches = command.try_get_matches_from_mut(opt_args)?;
 
     let mut files = matches
         .get_many::<String>(options::FILES)
@@ -477,7 +455,7 @@ fn parse_usize(matches: &ArgMatches, opt: &str) -> Option<Result<usize, PrError>
         let i = value_to_parse.0;
         let option = value_to_parse.1;
         i.parse().map_err(|_e| {
-            PrError::EncounteredErrors(format!("invalid {} argument {}", option, i.quote()))
+            PrError::EncounteredErrors(format!("invalid {option} argument {}", i.quote()))
         })
     };
     matches
@@ -577,18 +555,19 @@ fn build_options(
 
     // +page option is less priority than --pages
     let page_plus_re = Regex::new(r"\s*\+(\d+:*\d*)\s*").unwrap();
-    let start_page_in_plus_option = match page_plus_re.captures(free_args).map(|i| {
+    let res = page_plus_re.captures(free_args).map(|i| {
         let unparsed_num = i.get(1).unwrap().as_str().trim();
         let x: Vec<_> = unparsed_num.split(':').collect();
         x[0].to_string().parse::<usize>().map_err(|_e| {
             PrError::EncounteredErrors(format!("invalid {} argument {}", "+", unparsed_num.quote()))
         })
-    }) {
+    });
+    let start_page_in_plus_option = match res {
         Some(res) => res?,
         None => 1,
     };
 
-    let end_page_in_plus_option = match page_plus_re
+    let res = page_plus_re
         .captures(free_args)
         .map(|i| i.get(1).unwrap().as_str().trim())
         .filter(|i| i.contains(':'))
@@ -601,7 +580,8 @@ fn build_options(
                     unparsed_num.quote()
                 ))
             })
-        }) {
+        });
+    let end_page_in_plus_option = match res {
         Some(res) => Some(res?),
         None => None,
     };
@@ -616,27 +596,27 @@ fn build_options(
         })
     };
 
-    let start_page = match matches
+    let res = matches
         .get_one::<String>(options::PAGES)
         .map(|i| {
             let x: Vec<_> = i.split(':').collect();
             x[0].to_string()
         })
-        .map(invalid_pages_map)
-    {
+        .map(invalid_pages_map);
+    let start_page = match res {
         Some(res) => res?,
         None => start_page_in_plus_option,
     };
 
-    let end_page = match matches
+    let res = matches
         .get_one::<String>(options::PAGES)
         .filter(|i| i.contains(':'))
         .map(|i| {
             let x: Vec<_> = i.split(':').collect();
             x[1].to_string()
         })
-        .map(invalid_pages_map)
-    {
+        .map(invalid_pages_map);
+    let end_page = match res {
         Some(res) => Some(res?),
         None => end_page_in_plus_option,
     };
@@ -660,8 +640,7 @@ fn build_options(
 
     let page_length_le_ht = page_length < (HEADER_LINES_PER_PAGE + TRAILER_LINES_PER_PAGE);
 
-    let display_header_and_trailer =
-        !(page_length_le_ht) && !matches.get_flag(options::OMIT_HEADER);
+    let display_header_and_trailer = !page_length_le_ht && !matches.get_flag(options::OMIT_HEADER);
 
     let content_lines_per_page = if page_length_le_ht {
         page_length
@@ -707,12 +686,13 @@ fn build_options(
 
     let re_col = Regex::new(r"\s*-(\d+)\s*").unwrap();
 
-    let start_column_option = match re_col.captures(free_args).map(|i| {
+    let res = re_col.captures(free_args).map(|i| {
         let unparsed_num = i.get(1).unwrap().as_str().trim();
         unparsed_num.parse::<usize>().map_err(|_e| {
             PrError::EncounteredErrors(format!("invalid {} argument {}", "-", unparsed_num.quote()))
         })
-    }) {
+    });
+    let start_column_option = match res {
         Some(res) => Some(res?),
         None => None,
     };
@@ -800,9 +780,9 @@ fn open(path: &str) -> Result<Box<dyn Read>, PrError> {
                 #[cfg(unix)]
                 ft if ft.is_socket() => Err(PrError::IsSocket(path_string)),
                 ft if ft.is_dir() => Err(PrError::IsDirectory(path_string)),
-                ft if ft.is_file() || ft.is_symlink() => {
-                    Ok(Box::new(File::open(path).context(path)?) as Box<dyn Read>)
-                }
+                ft if ft.is_file() || ft.is_symlink() => Ok(Box::new(
+                    File::open(path).map_err(|e| PrError::Input(e, path.to_string()))?,
+                ) as Box<dyn Read>),
                 _ => Err(PrError::UnknownFiletype(path_string)),
             }
         })
@@ -921,7 +901,7 @@ fn read_stream_and_create_pages(
                 let current_page = x + 1;
 
                 current_page >= start_page
-                    && last_page.map_or(true, |last_page| current_page <= last_page)
+                    && last_page.is_none_or(|last_page| current_page <= last_page)
             }),
     )
 }
@@ -960,7 +940,7 @@ fn mpr(paths: &[&str], options: &OutputOptions) -> Result<i32, PrError> {
                 a.group_key < b.group_key
             }
         })
-        .group_by(|file_line| file_line.group_key);
+        .chunk_by(|file_line| file_line.group_key);
 
     let start_page = options.start_page;
     let mut lines = Vec::new();
@@ -1090,7 +1070,7 @@ fn write_columns(
         for (i, cell) in row.iter().enumerate() {
             if cell.is_none() && options.merge_files_print.is_some() {
                 out.write_all(
-                    get_line_for_printing(options, &blank_line, columns, i, &line_width, indexes)
+                    get_line_for_printing(options, &blank_line, columns, i, line_width, indexes)
                         .as_bytes(),
                 )?;
             } else if cell.is_none() {
@@ -1100,7 +1080,7 @@ fn write_columns(
                 let file_line = cell.unwrap();
 
                 out.write_all(
-                    get_line_for_printing(options, file_line, columns, i, &line_width, indexes)
+                    get_line_for_printing(options, file_line, columns, i, line_width, indexes)
                         .as_bytes(),
                 )?;
                 lines_printed += 1;
@@ -1121,15 +1101,14 @@ fn get_line_for_printing(
     file_line: &FileLine,
     columns: usize,
     index: usize,
-    line_width: &Option<usize>,
+    line_width: Option<usize>,
     indexes: usize,
 ) -> String {
     let blank_line = String::new();
     let formatted_line_number = get_formatted_line_number(options, file_line.line_number, index);
 
     let mut complete_line = format!(
-        "{}{}",
-        formatted_line_number,
+        "{formatted_line_number}{}",
         file_line.line_content.as_ref().unwrap()
     );
 
@@ -1146,8 +1125,7 @@ fn get_line_for_printing(
     };
 
     format!(
-        "{}{}{}",
-        offset_spaces,
+        "{offset_spaces}{}{sep}",
         line_width
             .map(|i| {
                 let min_width = (i - (columns - 1)) / columns;
@@ -1160,7 +1138,6 @@ fn get_line_for_printing(
                 complete_line.chars().take(min_width).collect()
             })
             .unwrap_or(complete_line),
-        sep
     )
 }
 
@@ -1173,11 +1150,7 @@ fn get_formatted_line_number(opts: &OutputOptions, line_number: usize, index: us
         let width = num_opt.width;
         let separator = &num_opt.separator;
         if line_str.len() >= width {
-            format!(
-                "{:>width$}{}",
-                &line_str[line_str.len() - width..],
-                separator
-            )
+            format!("{:>width$}{separator}", &line_str[line_str.len() - width..],)
         } else {
             format!("{line_str:>width$}{separator}")
         }
@@ -1191,8 +1164,8 @@ fn get_formatted_line_number(opts: &OutputOptions, line_number: usize, index: us
 fn header_content(options: &OutputOptions, page: usize) -> Vec<String> {
     if options.display_header_and_trailer {
         let first_line = format!(
-            "{} {} Page {}",
-            options.last_modified_time, options.header, page
+            "{} {} Page {page}",
+            options.last_modified_time, options.header
         );
         vec![
             String::new(),
diff --git a/src/uu/printenv/Cargo.toml b/src/uu/printenv/Cargo.toml
index 72965811011..2b8b23ab8c2 100644
--- a/src/uu/printenv/Cargo.toml
+++ b/src/uu/printenv/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_printenv"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "printenv ~ (uutils) display value of environment VAR"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/printenv"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/printenv.rs"
diff --git a/src/uu/printenv/printenv.md b/src/uu/printenv/printenv.md
index 929da7947b5..f67d46a23dd 100644
--- a/src/uu/printenv/printenv.md
+++ b/src/uu/printenv/printenv.md
@@ -1,7 +1,7 @@
 # printenv
 
 ```
-printenv [VARIABLE]... [OPTION]...
+printenv [OPTION]... [VARIABLE]...
 ```
 
 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 cab24336f60..4584a09b858 100644
--- a/src/uu/printenv/src/printenv.rs
+++ b/src/uu/printenv/src/printenv.rs
@@ -3,9 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-/* last synced with: printenv (GNU coreutils) 8.13 */
-
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::env;
 use uucore::{error::UResult, format_usage, help_about, help_usage};
 
@@ -52,16 +50,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     }
 
-    if error_found {
-        Err(1.into())
-    } else {
-        Ok(())
-    }
+    if error_found { Err(1.into()) } else { Ok(()) }
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/printf/Cargo.toml b/src/uu/printf/Cargo.toml
index d55d3732a3a..7b5a2dadbfd 100644
--- a/src/uu/printf/Cargo.toml
+++ b/src/uu/printf/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_printf"
-version = "0.0.21"
-authors = ["Nathan Ross", "uutils developers"]
-license = "MIT"
 description = "printf ~ (uutils) FORMAT and display ARGUMENTS"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/printf"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/printf.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["memo"] }
+uucore = { workspace = true, features = ["format", "quoting-style"] }
 
 [[bin]]
 name = "printf"
diff --git a/src/uu/printf/printf.md b/src/uu/printf/printf.md
index 60b50354c6f..791cc8be1f2 100644
--- a/src/uu/printf/printf.md
+++ b/src/uu/printf/printf.md
@@ -1,9 +1,10 @@
-<!-- spell-checker:ignore formatstring templating parameterizing each's -->
+<!-- spell-checker:ignore templating parameterizing each's -->
 
 # printf
 
 ```
-printf FORMATSTRING [ARGUMENT]...
+printf FORMAT [ARGUMENT]...
+printf OPTION
 ```
 
 Print output based off of the format string and proceeding arguments.
@@ -78,6 +79,9 @@ Fields
             second parameter is min-width, integer
             output below that width is padded with leading zeroes
 
+* `%q`:       ARGUMENT is printed in a format that can be reused as shell input, escaping non-printable
+            characters with the proposed POSIX $'' syntax.
+
 * `%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.
@@ -181,6 +185,11 @@ All string fields have a 'max width' parameter
       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.)
 
+* `%q`:  escaped string - the string in a format that can be reused as input by most shells.
+      Non-printable characters are escaped with the POSIX proposed ‘$''’ syntax,
+      and shell meta-characters are quoted appropriately.
+      This is an equivalent format to ls --quoting=shell-escape output.
+
 #### CHAR SUBSTITUTIONS
 
 The character field does not have a secondary parameter.
diff --git a/src/uu/printf/src/printf.rs b/src/uu/printf/src/printf.rs
index a6205f7cb39..887ad4107a7 100644
--- a/src/uu/printf/src/printf.rs
+++ b/src/uu/printf/src/printf.rs
@@ -2,14 +2,12 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-#![allow(dead_code)]
-// spell-checker:ignore (change!) each's
-// spell-checker:ignore (ToDO) LONGHELP FORMATSTRING templating parameterizing formatstr
-
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
+use std::io::stdout;
+use std::ops::ControlFlow;
 use uucore::error::{UResult, UUsageError};
-use uucore::memo::printf;
-use uucore::{format_usage, help_about, help_section, help_usage};
+use uucore::format::{FormatArgument, FormatArguments, FormatItem, parse_spec_and_escape};
+use uucore::{format_usage, help_about, help_section, help_usage, os_str_as_bytes, show_warning};
 
 const VERSION: &str = "version";
 const HELP: &str = "help";
@@ -18,31 +16,71 @@ const ABOUT: &str = help_about!("printf.md");
 const AFTER_HELP: &str = help_section!("after help", "printf.md");
 
 mod options {
-    pub const FORMATSTRING: &str = "FORMATSTRING";
+    pub const FORMAT: &str = "FORMAT";
     pub const ARGUMENT: &str = "ARGUMENT";
 }
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
     let matches = uu_app().get_matches_from(args);
 
-    let format_string = matches
-        .get_one::<String>(options::FORMATSTRING)
+    let format = matches
+        .get_one::<std::ffi::OsString>(options::FORMAT)
         .ok_or_else(|| UUsageError::new(1, "missing operand"))?;
-    let values: Vec<String> = match matches.get_many::<String>(options::ARGUMENT) {
-        Some(s) => s.map(|s| s.to_string()).collect(),
+    let format = os_str_as_bytes(format)?;
+
+    let values: Vec<_> = match matches.get_many::<std::ffi::OsString>(options::ARGUMENT) {
+        // FIXME: use os_str_as_bytes once FormatArgument supports Vec<u8>
+        Some(s) => s
+            .map(|os_string| {
+                FormatArgument::Unparsed(std::ffi::OsStr::to_string_lossy(os_string).to_string())
+            })
+            .collect(),
         None => vec![],
     };
 
-    printf(format_string, &values[..])?;
+    let mut format_seen = false;
+    // Parse and process the format string
+    let mut args = FormatArguments::new(&values);
+    for item in parse_spec_and_escape(format) {
+        if let Ok(FormatItem::Spec(_)) = item {
+            format_seen = true;
+        }
+        match item?.write(stdout(), &mut args)? {
+            ControlFlow::Continue(()) => {}
+            ControlFlow::Break(()) => return Ok(()),
+        };
+    }
+    args.start_next_batch();
+
+    // Without format specs in the string, the iter would not consume any args,
+    // leading to an infinite loop. Thus, we exit early.
+    if !format_seen {
+        if !args.is_exhausted() {
+            let Some(FormatArgument::Unparsed(arg_str)) = args.peek_arg() else {
+                unreachable!("All args are transformed to Unparsed")
+            };
+            show_warning!("ignoring excess arguments, starting with '{arg_str}'");
+        }
+        return Ok(());
+    }
+
+    while !args.is_exhausted() {
+        for item in parse_spec_and_escape(format) {
+            match item?.write(stdout(), &mut args)? {
+                ControlFlow::Continue(()) => {}
+                ControlFlow::Break(()) => return Ok(()),
+            };
+        }
+        args.start_next_batch();
+    }
+
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .allow_hyphen_values(true)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -60,6 +98,10 @@ pub fn uu_app() -> Command {
                 .help("Print version information")
                 .action(ArgAction::Version),
         )
-        .arg(Arg::new(options::FORMATSTRING))
-        .arg(Arg::new(options::ARGUMENT).action(ArgAction::Append))
+        .arg(Arg::new(options::FORMAT).value_parser(clap::value_parser!(std::ffi::OsString)))
+        .arg(
+            Arg::new(options::ARGUMENT)
+                .action(ArgAction::Append)
+                .value_parser(clap::value_parser!(std::ffi::OsString)),
+        )
 }
diff --git a/src/uu/ptx/Cargo.toml b/src/uu/ptx/Cargo.toml
index 96d635caff6..1b180a7f86d 100644
--- a/src/uu/ptx/Cargo.toml
+++ b/src/uu/ptx/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_ptx"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "ptx ~ (uutils) display a permuted index of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ptx"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/ptx.rs"
@@ -18,6 +21,7 @@ path = "src/ptx.rs"
 clap = { workspace = true }
 regex = { workspace = true }
 uucore = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "ptx"
diff --git a/src/uu/ptx/src/ptx.rs b/src/uu/ptx/src/ptx.rs
index 1e9532a3a12..bb5b2928283 100644
--- a/src/uu/ptx/src/ptx.rs
+++ b/src/uu/ptx/src/ptx.rs
@@ -5,25 +5,23 @@
 
 // spell-checker:ignore (ToDOs) corasick memchr Roff trunc oset iset CHARCLASS
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use regex::Regex;
 use std::cmp;
 use std::collections::{BTreeSet, HashMap, HashSet};
-use std::default::Default;
-use std::error::Error;
-use std::fmt::{Display, Formatter, Write as FmtWrite};
+use std::fmt::Write as FmtWrite;
 use std::fs::File;
-use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
+use std::io::{BufRead, BufReader, BufWriter, Read, Write, stdin, stdout};
 use std::num::ParseIntError;
+
+use clap::{Arg, ArgAction, Command};
+use regex::Regex;
+use thiserror::Error;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
+use uucore::error::{FromIo, UError, UResult, UUsageError};
 use uucore::{format_usage, help_about, help_usage};
 
 const USAGE: &str = help_usage!("ptx.md");
 const ABOUT: &str = help_about!("ptx.md");
 
-const REGEX_CHARCLASS: &str = "^-]\\";
-
 #[derive(Debug)]
 enum OutFormat {
     Dumb,
@@ -72,8 +70,12 @@ fn read_word_filter_file(
         .get_one::<String>(option)
         .expect("parsing options failed!")
         .to_string();
-    let file = File::open(filename)?;
-    let reader = BufReader::new(file);
+    let reader: BufReader<Box<dyn Read>> = BufReader::new(if filename == "-" {
+        Box::new(stdin())
+    } else {
+        let file = File::open(filename)?;
+        Box::new(file)
+    });
     let mut words: HashSet<String> = HashSet::new();
     for word in reader.lines() {
         words.insert(word?);
@@ -89,7 +91,12 @@ fn read_char_filter_file(
     let filename = matches
         .get_one::<String>(option)
         .expect("parsing options failed!");
-    let mut reader = File::open(filename)?;
+    let mut reader: Box<dyn Read> = if filename == "-" {
+        Box::new(stdin())
+    } else {
+        let file = File::open(filename)?;
+        Box::new(file)
+    };
     let mut buffer = String::new();
     reader.read_to_string(&mut buffer)?;
     Ok(buffer.chars().collect())
@@ -130,7 +137,7 @@ impl WordFilter {
                 HashSet::new() // really only chars found in file
             } else {
                 // GNU off means at least these are considered
-                [' ', '\t', '\n'].iter().cloned().collect()
+                [' ', '\t', '\n'].iter().copied().collect()
             };
             hs.extend(chars);
             Some(hs)
@@ -156,18 +163,10 @@ impl WordFilter {
         let reg = match arg_reg {
             Some(arg_reg) => arg_reg,
             None => {
-                if break_set.is_some() {
+                if let Some(break_set) = break_set {
                     format!(
                         "[^{}]+",
-                        break_set
-                            .unwrap()
-                            .into_iter()
-                            .map(|c| if REGEX_CHARCLASS.contains(c) {
-                                format!("\\{c}")
-                            } else {
-                                c.to_string()
-                            })
-                            .collect::<String>()
+                        regex::escape(&break_set.into_iter().collect::<String>())
                     )
                 } else if config.gnu_ext {
                     "\\w+".to_owned()
@@ -196,35 +195,25 @@ struct WordRef {
     filename: String,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum PtxError {
+    #[error("There is no dumb format with GNU extensions disabled")]
     DumbFormat,
+    #[error("{0} not implemented yet")]
     NotImplemented(&'static str),
+    #[error("{0}")]
     ParseError(ParseIntError),
 }
 
-impl Error for PtxError {}
 impl UError for PtxError {}
 
-impl Display for PtxError {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        match self {
-            Self::DumbFormat => {
-                write!(f, "There is no dumb format with GNU extensions disabled")
-            }
-            Self::NotImplemented(s) => write!(f, "{s} not implemented yet"),
-            Self::ParseError(e) => e.fmt(f),
-        }
-    }
-}
-
 fn get_config(matches: &clap::ArgMatches) -> UResult<Config> {
     let mut config = Config::default();
     let err_msg = "parsing options failed";
     if matches.get_flag(options::TRADITIONAL) {
         config.gnu_ext = false;
         config.format = OutFormat::Roff;
-        config.context_regex = "[^ \t\n]+".to_owned();
+        "[^ \t\n]+".clone_into(&mut config.context_regex);
     } else {
         return Err(PtxError::NotImplemented("GNU extensions").into());
     }
@@ -261,10 +250,17 @@ fn get_config(matches: &clap::ArgMatches) -> UResult<Config> {
             .parse()
             .map_err(PtxError::ParseError)?;
     }
-    if matches.get_flag(options::FORMAT_ROFF) {
+    if let Some(format) = matches.get_one::<String>(options::FORMAT) {
+        config.format = match format.as_str() {
+            "roff" => OutFormat::Roff,
+            "tex" => OutFormat::Tex,
+            _ => unreachable!("should be caught by clap"),
+        };
+    }
+    if matches.get_flag(options::format::ROFF) {
         config.format = OutFormat::Roff;
     }
-    if matches.get_flag(options::FORMAT_TEX) {
+    if matches.get_flag(options::format::TEX) {
         config.format = OutFormat::Tex;
     }
     Ok(config)
@@ -278,20 +274,10 @@ struct FileContent {
 
 type FileMap = HashMap<String, FileContent>;
 
-fn read_input(input_files: &[String], config: &Config) -> std::io::Result<FileMap> {
+fn read_input(input_files: &[String]) -> std::io::Result<FileMap> {
     let mut file_map: FileMap = HashMap::new();
-    let mut files = Vec::new();
-    if input_files.is_empty() {
-        files.push("-");
-    } else if config.gnu_ext {
-        for file in input_files {
-            files.push(file);
-        }
-    } else {
-        files.push(&input_files[0]);
-    }
     let mut offset: usize = 0;
-    for filename in files {
+    for filename in input_files {
         let reader: BufReader<Box<dyn Read>> = BufReader::new(if filename == "-" {
             Box::new(stdin())
         } else {
@@ -338,14 +324,14 @@ fn create_word_set(config: &Config, filter: &WordFilter, file_map: &FileMap) ->
                     continue;
                 }
                 let mut word = line[beg..end].to_owned();
-                if filter.only_specified && !(filter.only_set.contains(&word)) {
+                if filter.only_specified && !filter.only_set.contains(&word) {
                     continue;
                 }
                 if filter.ignore_specified && filter.ignore_set.contains(&word) {
                     continue;
                 }
                 if config.ignore_case {
-                    word = word.to_lowercase();
+                    word = word.to_uppercase();
                 }
                 word_set.insert(WordRef {
                     word,
@@ -534,9 +520,9 @@ fn get_output_chunks(
 
     // put left context truncation string if needed
     if before_beg != 0 && head_beg == head_end {
-        before = format!("{}{}", config.trunc_str, before);
+        before = format!("{}{before}", config.trunc_str);
     } else if before_beg != 0 && head_beg != 0 {
-        head = format!("{}{}", config.trunc_str, head);
+        head = format!("{}{head}", config.trunc_str);
     }
 
     (tail, before, after, head)
@@ -566,26 +552,14 @@ fn format_tex_line(
 ) -> String {
     let mut output = String::new();
     write!(output, "\\{} ", config.macro_name).unwrap();
-    let all_before = if config.input_ref {
-        let before = &line[0..word_ref.position];
-        let before_start_trim_offset =
-            word_ref.position - before.trim_start_matches(reference).trim_start().len();
-        let before_end_index = before.len();
-        &chars_line[before_start_trim_offset..cmp::max(before_end_index, before_start_trim_offset)]
-    } else {
-        let before_chars_trim_idx = (0, word_ref.position);
-        &chars_line[before_chars_trim_idx.0..before_chars_trim_idx.1]
-    };
-    let keyword = &line[word_ref.position..word_ref.position_end];
-    let after_chars_trim_idx = (word_ref.position_end, chars_line.len());
-    let all_after = &chars_line[after_chars_trim_idx.0..after_chars_trim_idx.1];
-    let (tail, before, after, head) = get_output_chunks(all_before, keyword, all_after, config);
+    let (tail, before, keyword, after, head) =
+        prepare_line_chunks(config, word_ref, line, chars_line, reference);
     write!(
         output,
         "{{{0}}}{{{1}}}{{{2}}}{{{3}}}{{{4}}}",
         format_tex_field(&tail),
         format_tex_field(&before),
-        format_tex_field(keyword),
+        format_tex_field(&keyword),
         format_tex_field(&after),
         format_tex_field(&head),
     )
@@ -609,26 +583,14 @@ fn format_roff_line(
 ) -> String {
     let mut output = String::new();
     write!(output, ".{}", config.macro_name).unwrap();
-    let all_before = if config.input_ref {
-        let before = &line[0..word_ref.position];
-        let before_start_trim_offset =
-            word_ref.position - before.trim_start_matches(reference).trim_start().len();
-        let before_end_index = before.len();
-        &chars_line[before_start_trim_offset..cmp::max(before_end_index, before_start_trim_offset)]
-    } else {
-        let before_chars_trim_idx = (0, word_ref.position);
-        &chars_line[before_chars_trim_idx.0..before_chars_trim_idx.1]
-    };
-    let keyword = &line[word_ref.position..word_ref.position_end];
-    let after_chars_trim_idx = (word_ref.position_end, chars_line.len());
-    let all_after = &chars_line[after_chars_trim_idx.0..after_chars_trim_idx.1];
-    let (tail, before, after, head) = get_output_chunks(all_before, keyword, all_after, config);
+    let (tail, before, keyword, after, head) =
+        prepare_line_chunks(config, word_ref, line, chars_line, reference);
     write!(
         output,
         " \"{}\" \"{}\" \"{}{}\" \"{}\"",
         format_roff_field(&tail),
         format_roff_field(&before),
-        format_roff_field(keyword),
+        format_roff_field(&keyword),
         format_roff_field(&after),
         format_roff_field(&head)
     )
@@ -639,6 +601,46 @@ fn format_roff_line(
     output
 }
 
+/// Extract and prepare text chunks for formatting in both TeX and roff output
+fn prepare_line_chunks(
+    config: &Config,
+    word_ref: &WordRef,
+    line: &str,
+    chars_line: &[char],
+    reference: &str,
+) -> (String, String, String, String, String) {
+    // Convert byte positions to character positions
+    let ref_char_position = line[..word_ref.position].chars().count();
+    let char_position_end = ref_char_position
+        + line[word_ref.position..word_ref.position_end]
+            .chars()
+            .count();
+
+    // Extract the text before the keyword
+    let all_before = if config.input_ref {
+        let before = &line[..word_ref.position];
+        let before_char_count = before.chars().count();
+        let trimmed_char_count = before
+            .trim_start_matches(reference)
+            .trim_start()
+            .chars()
+            .count();
+        let trim_offset = before_char_count - trimmed_char_count;
+        &chars_line[trim_offset..before_char_count]
+    } else {
+        &chars_line[..ref_char_position]
+    };
+
+    // Extract the keyword and text after it
+    let keyword = line[word_ref.position..word_ref.position_end].to_string();
+    let all_after = &chars_line[char_position_end..];
+
+    // Get formatted output chunks
+    let (tail, before, after, head) = get_output_chunks(all_before, &keyword, all_after, config);
+
+    (tail, before, keyword, after, head)
+}
+
 fn write_traditional_output(
     config: &Config,
     file_map: &FileMap,
@@ -648,7 +650,8 @@ fn write_traditional_output(
     let mut writer: BufWriter<Box<dyn Write>> = BufWriter::new(if output_filename == "-" {
         Box::new(stdout())
     } else {
-        let file = File::create(output_filename).map_err_context(String::new)?;
+        let file = File::create(output_filename)
+            .map_err_context(|| output_filename.maybe_quote().to_string())?;
         Box::new(file)
     });
 
@@ -688,21 +691,28 @@ fn write_traditional_output(
                 return Err(PtxError::DumbFormat.into());
             }
         };
-        writeln!(writer, "{output_line}").map_err_context(String::new)?;
+        writeln!(writer, "{output_line}").map_err_context(|| "write failed".into())?;
     }
+
+    writer.flush().map_err_context(|| "write failed".into())?;
+
     Ok(())
 }
 
 mod options {
+    pub mod format {
+        pub static ROFF: &str = "roff";
+        pub static TEX: &str = "tex";
+    }
+
     pub static FILE: &str = "file";
     pub static AUTO_REFERENCE: &str = "auto-reference";
     pub static TRADITIONAL: &str = "traditional";
     pub static FLAG_TRUNCATION: &str = "flag-truncation";
     pub static MACRO_NAME: &str = "macro-name";
-    pub static FORMAT_ROFF: &str = "format=roff";
+    pub static FORMAT: &str = "format";
     pub static RIGHT_SIDE_REFS: &str = "right-side-refs";
     pub static SENTENCE_REGEXP: &str = "sentence-regexp";
-    pub static FORMAT_TEX: &str = "format=tex";
     pub static WORD_REGEXP: &str = "word-regexp";
     pub static BREAK_FILE: &str = "break-file";
     pub static IGNORE_CASE: &str = "ignore-case";
@@ -715,31 +725,48 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
+    let config = get_config(&matches)?;
 
-    let mut input_files: Vec<String> = match &matches.get_many::<String>(options::FILE) {
-        Some(v) => v.clone().map(|v| v.to_owned()).collect(),
-        None => vec!["-".to_string()],
-    };
+    let input_files;
+    let output_file;
+
+    let mut files = matches
+        .get_many::<String>(options::FILE)
+        .into_iter()
+        .flatten()
+        .cloned();
+
+    if !config.gnu_ext {
+        input_files = vec![files.next().unwrap_or("-".to_string())];
+        output_file = files.next().unwrap_or("-".to_string());
+        if let Some(file) = files.next() {
+            return Err(UUsageError::new(
+                1,
+                format!("extra operand {}", file.quote()),
+            ));
+        }
+    } else {
+        input_files = {
+            let mut files = files.collect::<Vec<_>>();
+            if files.is_empty() {
+                files.push("-".to_string());
+            }
+            files
+        };
+        output_file = "-".to_string();
+    }
 
-    let config = get_config(&matches)?;
     let word_filter = WordFilter::new(&matches, &config)?;
-    let file_map = read_input(&input_files, &config).map_err_context(String::new)?;
+    let file_map = read_input(&input_files).map_err_context(String::new)?;
     let word_set = create_word_set(&config, &word_filter, &file_map);
-    let output_file = if !config.gnu_ext && input_files.len() == 2 {
-        input_files.pop().unwrap()
-    } else {
-        "-".to_string()
-    };
     write_traditional_output(&config, &file_map, &word_set, &output_file)
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .about(ABOUT)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
@@ -777,10 +804,24 @@ pub fn uu_app() -> Command {
                 .value_name("STRING"),
         )
         .arg(
-            Arg::new(options::FORMAT_ROFF)
+            Arg::new(options::FORMAT)
+                .long(options::FORMAT)
+                .hide(true)
+                .value_parser(["roff", "tex"])
+                .overrides_with_all([options::FORMAT, options::format::ROFF, options::format::TEX]),
+        )
+        .arg(
+            Arg::new(options::format::ROFF)
                 .short('O')
-                .long(options::FORMAT_ROFF)
                 .help("generate output as roff directives")
+                .overrides_with_all([options::FORMAT, options::format::ROFF, options::format::TEX])
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::format::TEX)
+                .short('T')
+                .help("generate output as TeX directives")
+                .overrides_with_all([options::FORMAT, options::format::ROFF, options::format::TEX])
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -797,13 +838,6 @@ pub fn uu_app() -> Command {
                 .help("for end of lines or end of sentences")
                 .value_name("REGEXP"),
         )
-        .arg(
-            Arg::new(options::FORMAT_TEX)
-                .short('T')
-                .long(options::FORMAT_TEX)
-                .help("generate output as TeX directives")
-                .action(ArgAction::SetTrue),
-        )
         .arg(
             Arg::new(options::WORD_REGEXP)
                 .short('W')
diff --git a/src/uu/pwd/Cargo.toml b/src/uu/pwd/Cargo.toml
index 1567a935f9a..aafd8c52efc 100644
--- a/src/uu/pwd/Cargo.toml
+++ b/src/uu/pwd/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_pwd"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "pwd ~ (uutils) display current working directory"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/pwd"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/pwd.rs"
diff --git a/src/uu/pwd/src/pwd.rs b/src/uu/pwd/src/pwd.rs
index fde2357e212..b924af241fe 100644
--- a/src/uu/pwd/src/pwd.rs
+++ b/src/uu/pwd/src/pwd.rs
@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 
 use clap::ArgAction;
-use clap::{crate_version, Arg, Command};
+use clap::{Arg, Command};
 use std::env;
 use std::io;
 use std::path::PathBuf;
@@ -140,7 +140,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/readlink/Cargo.toml b/src/uu/readlink/Cargo.toml
index 309d4079429..dd52e1d69da 100644
--- a/src/uu/readlink/Cargo.toml
+++ b/src/uu/readlink/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_readlink"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "readlink ~ (uutils) display resolved path of PATHNAME"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/readlink"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/readlink.rs"
diff --git a/src/uu/readlink/src/readlink.rs b/src/uu/readlink/src/readlink.rs
index 2febe51af48..211422e035f 100644
--- a/src/uu/readlink/src/readlink.rs
+++ b/src/uu/readlink/src/readlink.rs
@@ -5,13 +5,13 @@
 
 // spell-checker:ignore (ToDO) errno
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::fs;
-use std::io::{stdout, Write};
+use std::io::{Write, stdout};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
+use uucore::fs::{MissingHandling, ResolveMode, canonicalize};
 use uucore::line_ending::LineEnding;
 use uucore::{format_usage, help_about, help_usage, show_error};
 
@@ -84,15 +84,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 show(&path, line_ending).map_err_context(String::new)?;
             }
             Err(err) => {
-                if verbose {
-                    return Err(USimpleError::new(
+                return if verbose {
+                    Err(USimpleError::new(
                         1,
                         err.map_err_context(move || f.maybe_quote().to_string())
                             .to_string(),
-                    ));
+                    ))
                 } else {
-                    return Err(1.into());
-                }
+                    Err(1.into())
+                };
             }
         }
     }
@@ -101,7 +101,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/realpath/Cargo.toml b/src/uu/realpath/Cargo.toml
index e458bf89d13..9060e38db58 100644
--- a/src/uu/realpath/Cargo.toml
+++ b/src/uu/realpath/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_realpath"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "realpath ~ (uutils) display resolved absolute path of PATHNAME"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/realpath"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/realpath.rs"
diff --git a/src/uu/realpath/src/realpath.rs b/src/uu/realpath/src/realpath.rs
index 64806fbabf6..94532b75505 100644
--- a/src/uu/realpath/src/realpath.rs
+++ b/src/uu/realpath/src/realpath.rs
@@ -5,23 +5,21 @@
 
 // spell-checker:ignore (ToDO) retcode
 
-use clap::{
-    builder::NonEmptyStringValueParser, crate_version, Arg, ArgAction, ArgMatches, Command,
-};
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::NonEmptyStringValueParser};
 use std::{
-    io::{stdout, Write},
+    io::{Write, stdout},
     path::{Path, PathBuf},
 };
 use uucore::fs::make_path_relative_to;
 use uucore::{
-    display::{print_verbatim, Quotable},
-    error::{FromIo, UResult},
+    display::{Quotable, print_verbatim},
+    error::{FromIo, UClapError, UResult},
     format_usage,
-    fs::{canonicalize, MissingHandling, ResolveMode},
+    fs::{MissingHandling, ResolveMode, canonicalize},
     help_about, help_usage,
     line_ending::LineEnding,
+    show_if_err,
 };
-use uucore::{error::UClapError, show, show_if_err};
 
 static ABOUT: &str = help_about!("realpath.md");
 const USAGE: &str = help_usage!("realpath.md");
@@ -90,7 +88,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -266,11 +264,11 @@ fn resolve_path(
 /// Conditionally converts an absolute path to a relative form,
 /// according to the rules:
 /// 1. if only `relative_to` is given, the result is relative to `relative_to`
-/// 1. if only `relative_base` is given, it checks whether given `path` is a descendant
-/// of `relative_base`, on success the result is relative to `relative_base`, otherwise
-/// the result is the given `path`
-/// 1. if both `relative_to` and `relative_base` are given, the result is relative to `relative_to`
-/// if `path` is a descendant of `relative_base`, otherwise the result is `path`
+/// 2. if only `relative_base` is given, it checks whether given `path` is a descendant
+///    of `relative_base`, on success the result is relative to `relative_base`, otherwise
+///    the result is the given `path`
+/// 3. if both `relative_to` and `relative_base` are given, the result is relative to `relative_to`
+///    if `path` is a descendant of `relative_base`, otherwise the result is `path`
 ///
 /// For more information see
 /// <https://www.gnu.org/software/coreutils/manual/html_node/Realpath-usage-examples.html>
diff --git a/src/uu/relpath/Cargo.toml b/src/uu/relpath/Cargo.toml
deleted file mode 100644
index 0df32efd2b7..00000000000
--- a/src/uu/relpath/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-name = "uu_relpath"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
-description = "relpath ~ (uutils) display relative path of PATHNAME_TO from PATHNAME_FROM"
-
-homepage = "https://github.com/uutils/coreutils"
-repository = "https://github.com/uutils/coreutils/tree/main/src/uu/relpath"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
-
-[lib]
-path = "src/relpath.rs"
-
-[dependencies]
-clap = { workspace = true }
-uucore = { workspace = true, features = ["fs"] }
-
-[[bin]]
-name = "relpath"
-path = "src/main.rs"
diff --git a/src/uu/relpath/LICENSE b/src/uu/relpath/LICENSE
deleted file mode 120000
index 5853aaea53b..00000000000
--- a/src/uu/relpath/LICENSE
+++ /dev/null
@@ -1 +0,0 @@
-../../../LICENSE
\ No newline at end of file
diff --git a/src/uu/relpath/relpath.md b/src/uu/relpath/relpath.md
deleted file mode 100644
index a1ff9bf4a37..00000000000
--- a/src/uu/relpath/relpath.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# 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/main.rs b/src/uu/relpath/src/main.rs
deleted file mode 100644
index b7dba76ce4d..00000000000
--- a/src/uu/relpath/src/main.rs
+++ /dev/null
@@ -1 +0,0 @@
-uucore::bin!(uu_relpath);
diff --git a/src/uu/relpath/src/relpath.rs b/src/uu/relpath/src/relpath.rs
deleted file mode 100644
index 46dd0d6631e..00000000000
--- a/src/uu/relpath/src/relpath.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-// 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.
-
-// spell-checker:ignore (ToDO) subpath absto absfrom absbase
-
-use clap::{crate_version, Arg, Command};
-use std::env;
-use std::path::{Path, PathBuf};
-use uucore::display::println_verbatim;
-use uucore::error::{FromIo, UResult};
-use uucore::fs::{canonicalize, MissingHandling, ResolveMode};
-use uucore::{format_usage, help_about, help_usage};
-
-const USAGE: &str = help_usage!("relpath.md");
-const ABOUT: &str = help_about!("relpath.md");
-
-mod options {
-    pub const DIR: &str = "DIR";
-    pub const TO: &str = "TO";
-    pub const FROM: &str = "FROM";
-}
-
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
-    let matches = uu_app().get_matches_from(args);
-
-    let to = Path::new(matches.get_one::<String>(options::TO).unwrap()).to_path_buf(); // required
-    let from = match matches.get_one::<String>(options::FROM) {
-        Some(p) => Path::new(p).to_path_buf(),
-        None => env::current_dir().unwrap(),
-    };
-    let absto = canonicalize(to, MissingHandling::Normal, ResolveMode::Logical)
-        .map_err_context(String::new)?;
-    let absfrom = canonicalize(from, MissingHandling::Normal, ResolveMode::Logical)
-        .map_err_context(String::new)?;
-
-    if matches.contains_id(options::DIR) {
-        let base = Path::new(&matches.get_one::<String>(options::DIR).unwrap()).to_path_buf();
-        let absbase = canonicalize(base, MissingHandling::Normal, ResolveMode::Logical)
-            .map_err_context(String::new)?;
-        if !absto.as_path().starts_with(absbase.as_path())
-            || !absfrom.as_path().starts_with(absbase.as_path())
-        {
-            return println_verbatim(absto).map_err_context(String::new);
-        }
-    }
-
-    let mut suffix_pos = 0;
-    for (f, t) in absfrom.components().zip(absto.components()) {
-        if f == t {
-            suffix_pos += 1;
-        } else {
-            break;
-        }
-    }
-
-    let mut result = PathBuf::new();
-    absfrom
-        .components()
-        .skip(suffix_pos)
-        .map(|_| result.push(".."))
-        .last();
-    absto
-        .components()
-        .skip(suffix_pos)
-        .map(|x| result.push(x.as_os_str()))
-        .last();
-
-    println_verbatim(result).map_err_context(String::new)
-}
-
-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::DIR).short('d').help(
-            "If any of FROM and TO is not subpath of DIR, output absolute path instead of relative",
-        ))
-        .arg(Arg::new(options::TO).value_hint(clap::ValueHint::AnyPath))
-        .arg(Arg::new(options::FROM).value_hint(clap::ValueHint::AnyPath))
-}
diff --git a/src/uu/rm/Cargo.toml b/src/uu/rm/Cargo.toml
index 87fccbfa875..28366060e9f 100644
--- a/src/uu/rm/Cargo.toml
+++ b/src/uu/rm/Cargo.toml
@@ -1,22 +1,24 @@
 [package]
 name = "uu_rm"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "rm ~ (uutils) remove PATHNAME"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/rm"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/rm.rs"
 
 [dependencies]
 clap = { workspace = true }
-walkdir = { workspace = true }
 uucore = { workspace = true, features = ["fs"] }
 
 [target.'cfg(unix)'.dependencies]
diff --git a/src/uu/rm/src/rm.rs b/src/uu/rm/src/rm.rs
index d9421d0ae71..863336f5d14 100644
--- a/src/uu/rm/src/rm.rs
+++ b/src/uu/rm/src/rm.rs
@@ -3,37 +3,91 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (path) eacces
+// spell-checker:ignore (path) eacces inacc rm-r4
 
-use clap::{builder::ValueParser, crate_version, parser::ValueSource, Arg, ArgAction, Command};
-use std::collections::VecDeque;
+use clap::{Arg, ArgAction, Command, builder::ValueParser, parser::ValueSource};
 use std::ffi::{OsStr, OsString};
-use std::fs::{self, File, Metadata};
-use std::io::ErrorKind;
+use std::fs::{self, Metadata};
+use std::io::{IsTerminal, stdin};
 use std::ops::BitOr;
+#[cfg(not(windows))]
+use std::os::unix::ffi::OsStrExt;
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+use std::path::MAIN_SEPARATOR;
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::{format_usage, help_about, help_section, help_usage, prompt_yes, show_error};
-use walkdir::{DirEntry, WalkDir};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::{
+    format_usage, help_about, help_section, help_usage, os_str_as_bytes, prompt_yes, show_error,
+};
 
 #[derive(Eq, PartialEq, Clone, Copy)]
-enum InteractiveMode {
+/// Enum, determining when the `rm` will prompt the user about the file deletion
+pub enum InteractiveMode {
+    /// Never prompt
     Never,
+    /// Prompt once before removing more than three files, or when removing
+    /// recursively.
     Once,
+    /// Prompt before every removal
     Always,
+    /// Prompt only on write-protected files
     PromptProtected,
 }
 
-struct Options {
-    force: bool,
-    interactive: InteractiveMode,
+/// Options for the `rm` command
+///
+/// All options are public so that the options can be programmatically
+/// constructed by other crates, such as Nushell. That means that this struct
+/// is part of our public API. It should therefore not be changed without good
+/// reason.
+///
+/// The fields are documented with the arguments that determine their value.
+pub struct Options {
+    /// `-f`, `--force`
+    pub force: bool,
+    /// Iterative mode, determines when the command will prompt.
+    ///
+    /// Set by the following arguments:
+    /// - `-i`: [`InteractiveMode::Always`]
+    /// - `-I`: [`InteractiveMode::Once`]
+    /// - `--interactive`: sets one of the above or [`InteractiveMode::Never`]
+    /// - `-f`: implicitly sets [`InteractiveMode::Never`]
+    ///
+    /// If no other option sets this mode, [`InteractiveMode::PromptProtected`]
+    /// is used
+    pub interactive: InteractiveMode,
     #[allow(dead_code)]
-    one_fs: bool,
-    preserve_root: bool,
-    recursive: bool,
-    dir: bool,
-    verbose: bool,
+    /// `--one-file-system`
+    pub one_fs: bool,
+    /// `--preserve-root`/`--no-preserve-root`
+    pub preserve_root: bool,
+    /// `-r`, `--recursive`
+    pub recursive: bool,
+    /// `-d`, `--dir`
+    pub dir: bool,
+    /// `-v`, `--verbose`
+    pub verbose: bool,
+    #[doc(hidden)]
+    /// `---presume-input-tty`
+    /// Always use `None`; GNU flag for testing use only
+    pub __presume_input_tty: Option<bool>,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            force: false,
+            interactive: InteractiveMode::PromptProtected,
+            one_fs: false,
+            preserve_root: true,
+            recursive: false,
+            dir: false,
+            verbose: false,
+            __presume_input_tty: None,
+        }
+    }
 }
 
 const ABOUT: &str = help_about!("rm.md");
@@ -99,7 +153,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                             return Err(USimpleError::new(
                                 1,
                                 format!("Invalid argument to interactive ({val})"),
-                            ))
+                            ));
                         }
                     }
                 } else {
@@ -111,6 +165,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             recursive: matches.get_flag(OPT_RECURSIVE),
             dir: matches.get_flag(OPT_DIR),
             verbose: matches.get_flag(OPT_VERBOSE),
+            __presume_input_tty: if matches.get_flag(PRESUME_INPUT_TTY) {
+                Some(true)
+            } else {
+                None
+            },
         };
         if options.interactive == InteractiveMode::Once && (options.recursive || files.len() > 3) {
             let msg: String = format!(
@@ -127,7 +186,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                     "?"
                 }
             );
-            if !prompt_yes!("{}", msg) {
+            if !prompt_yes!("{msg}") {
                 return Ok(());
             }
         }
@@ -141,7 +200,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -249,11 +308,18 @@ pub fn uu_app() -> Command {
 }
 
 // TODO: implement one-file-system (this may get partially implemented in walkdir)
-fn remove(files: &[&OsStr], options: &Options) -> bool {
+/// Remove (or unlink) the given files
+///
+/// Returns true if it has encountered an error.
+///
+/// Behavior is determined by the `options` parameter, see [`Options`] for
+/// details.
+pub fn remove(files: &[&OsStr], options: &Options) -> bool {
     let mut had_err = false;
 
     for filename in files {
         let file = Path::new(filename);
+
         had_err = match file.symlink_metadata() {
             Ok(metadata) => {
                 if metadata.is_dir() {
@@ -264,11 +330,12 @@ fn remove(files: &[&OsStr], options: &Options) -> bool {
                     remove_file(file, options)
                 }
             }
+
             Err(_e) => {
                 // TODO: actually print out the specific error
                 // 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.
+                // outputting the error, but there's no easy way.
                 if options.force {
                     false
                 } else {
@@ -286,75 +353,180 @@ fn remove(files: &[&OsStr], options: &Options) -> bool {
     had_err
 }
 
-#[allow(clippy::cognitive_complexity)]
-fn handle_dir(path: &Path, options: &Options) -> bool {
-    let mut had_err = false;
+/// Whether the given directory is empty.
+///
+/// `path` must be a directory. If there is an error reading the
+/// contents of the directory, this returns `false`.
+fn is_dir_empty(path: &Path) -> bool {
+    match fs::read_dir(path) {
+        Err(_) => false,
+        Ok(iter) => iter.count() == 0,
+    }
+}
 
-    let is_root = path.has_root() && path.parent().is_none();
-    if options.recursive && (!is_root || !options.preserve_root) {
-        if options.interactive != InteractiveMode::Always && !options.verbose {
-            if let Err(e) = fs::remove_dir_all(path) {
-                had_err = true;
-                if e.kind() == std::io::ErrorKind::PermissionDenied {
-                    // GNU compatibility (rm/fail-eacces.sh)
-                    // here, GNU doesn't use some kind of remove_dir_all
-                    // It will show directory+file
-                    show_error!("cannot remove {}: {}", path.quote(), "Permission denied");
-                } else {
-                    show_error!("cannot remove {}: {}", path.quote(), e);
+#[cfg(unix)]
+fn is_readable_metadata(metadata: &Metadata) -> bool {
+    let mode = metadata.permissions().mode();
+    (mode & 0o400) > 0
+}
+
+/// Whether the given file or directory is readable.
+#[cfg(unix)]
+fn is_readable(path: &Path) -> bool {
+    match fs::metadata(path) {
+        Err(_) => false,
+        Ok(metadata) => is_readable_metadata(&metadata),
+    }
+}
+
+/// Whether the given file or directory is readable.
+#[cfg(not(unix))]
+fn is_readable(_path: &Path) -> bool {
+    true
+}
+
+#[cfg(unix)]
+fn is_writable_metadata(metadata: &Metadata) -> bool {
+    let mode = metadata.permissions().mode();
+    (mode & 0o200) > 0
+}
+
+/// Whether the given file or directory is writable.
+#[cfg(unix)]
+fn is_writable(path: &Path) -> bool {
+    match fs::metadata(path) {
+        Err(_) => false,
+        Ok(metadata) => is_writable_metadata(&metadata),
+    }
+}
+
+/// Whether the given file or directory is writable.
+#[cfg(not(unix))]
+fn is_writable(_path: &Path) -> bool {
+    // TODO Not yet implemented.
+    true
+}
+
+/// Recursively remove the directory tree rooted at the given path.
+///
+/// If `path` is a file or a symbolic link, just remove it. If it is a
+/// directory, remove all of its entries recursively and then remove the
+/// directory itself. In case of an error, print the error message to
+/// `stderr` and return `true`. If there were no errors, return `false`.
+fn remove_dir_recursive(path: &Path, options: &Options) -> bool {
+    // Special case: if we cannot access the metadata because the
+    // filename is too long, fall back to try
+    // `fs::remove_dir_all()`.
+    //
+    // TODO This is a temporary bandage; we shouldn't need to do this
+    // at all. Instead of using the full path like "x/y/z", which
+    // causes a `InvalidFilename` error when trying to access the file
+    // metadata, we should be able to use just the last part of the
+    // path, "z", and know that it is relative to the parent, "x/y".
+    if let Some(s) = path.to_str() {
+        if s.len() > 1000 {
+            match fs::remove_dir_all(path) {
+                Ok(_) => return false,
+                Err(e) => {
+                    let e = e.map_err_context(|| format!("cannot remove {}", path.quote()));
+                    show_error!("{e}");
+                    return true;
                 }
             }
-        } else {
-            let mut dirs: VecDeque<DirEntry> = VecDeque::new();
-            // The Paths to not descend into. We need to this because WalkDir doesn't have a way, afaik, to not descend into a directory
-            // So we have to just ignore paths as they come up if they start with a path we aren't descending into
-            let mut not_descended: Vec<PathBuf> = Vec::new();
+        }
+    }
+
+    // Base case 1: this is a file or a symbolic link.
+    //
+    // The symbolic link case is important because it could be a link to
+    // a directory and we don't want to recurse. In particular, this
+    // avoids an infinite recursion in the case of a link to the current
+    // directory, like `ln -s . link`.
+    if !path.is_dir() || path.is_symlink() {
+        return remove_file(path, options);
+    }
+
+    // Base case 2: this is a non-empty directory, but the user
+    // doesn't want to descend into it.
+    if options.interactive == InteractiveMode::Always
+        && !is_dir_empty(path)
+        && !prompt_descend(path)
+    {
+        return false;
+    }
 
-            'outer: for entry in WalkDir::new(path) {
+    // Recursive case: this is a directory.
+    let mut error = false;
+    match fs::read_dir(path) {
+        Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+            // This is not considered an error.
+        }
+        Err(_) => error = true,
+        Ok(iter) => {
+            for entry in iter {
                 match entry {
+                    Err(_) => error = true,
                     Ok(entry) => {
-                        if options.interactive == InteractiveMode::Always {
-                            for not_descend in &not_descended {
-                                if entry.path().starts_with(not_descend) {
-                                    // We don't need to continue the rest of code in this loop if we are in a directory we don't want to descend into
-                                    continue 'outer;
-                                }
-                            }
-                        }
-                        let file_type = entry.file_type();
-                        if file_type.is_dir() {
-                            // If we are in Interactive Mode Always and the directory isn't empty we ask if we should descend else we push this directory onto dirs vector
-                            if options.interactive == InteractiveMode::Always
-                                && fs::read_dir(entry.path()).unwrap().count() != 0
-                            {
-                                // If we don't descend we push this directory onto our not_descended vector else we push this directory onto dirs vector
-                                if prompt_descend(entry.path()) {
-                                    dirs.push_back(entry);
-                                } else {
-                                    not_descended.push(entry.path().to_path_buf());
-                                }
-                            } else {
-                                dirs.push_back(entry);
-                            }
-                        } else {
-                            had_err = remove_file(entry.path(), options).bitor(had_err);
-                        }
-                    }
-                    Err(e) => {
-                        had_err = true;
-                        show_error!("recursing in {}: {}", path.quote(), e);
+                        let child_error = remove_dir_recursive(&entry.path(), options);
+                        error = error || child_error;
                     }
                 }
             }
+        }
+    }
 
-            for dir in dirs.iter().rev() {
-                had_err = remove_dir(dir.path(), options).bitor(had_err);
-            }
+    // Ask the user whether to remove the current directory.
+    if options.interactive == InteractiveMode::Always && !prompt_dir(path, options) {
+        return false;
+    }
+
+    // Try removing the directory itself.
+    match fs::remove_dir(path) {
+        Err(_) if !error && !is_readable(path) => {
+            // For compatibility with GNU test case
+            // `tests/rm/unread2.sh`, show "Permission denied" in this
+            // case instead of "Directory not empty".
+            show_error!("cannot remove {}: Permission denied", path.quote());
+            error = true;
         }
+        Err(e) if !error => {
+            let e = e.map_err_context(|| format!("cannot remove {}", path.quote()));
+            show_error!("{e}");
+            error = true;
+        }
+        Err(_) => {
+            // If there has already been at least one error when
+            // trying to remove the children, then there is no need to
+            // show another error message as we return from each level
+            // of the recursion.
+        }
+        Ok(_) if options.verbose => println!("removed directory {}", normalize(path).quote()),
+        Ok(_) => {}
+    }
+
+    error
+}
+
+fn handle_dir(path: &Path, options: &Options) -> bool {
+    let mut had_err = false;
+
+    let path = clean_trailing_slashes(path);
+    if path_is_current_or_parent_directory(path) {
+        show_error!(
+            "refusing to remove '.' or '..' directory: skipping '{}'",
+            path.display()
+        );
+        return true;
+    }
+
+    let is_root = path.has_root() && path.parent().is_none();
+    if options.recursive && (!is_root || !options.preserve_root) {
+        had_err = remove_dir_recursive(path, options);
     } else if options.dir && (!is_root || !options.preserve_root) {
         had_err = remove_dir(path, options).bitor(had_err);
     } else if options.recursive {
-        show_error!("could not remove directory {}", path.quote());
+        show_error!("it is dangerous to operate recursively on '{MAIN_SEPARATOR}'");
+        show_error!("use --no-preserve-root to override this failsafe");
         had_err = true;
     } else {
         show_error!(
@@ -367,49 +539,35 @@ fn handle_dir(path: &Path, options: &Options) -> bool {
     had_err
 }
 
+/// Remove the given directory, asking the user for permission if necessary.
+///
+/// Returns true if it has encountered an error.
 fn remove_dir(path: &Path, options: &Options) -> bool {
-    if prompt_dir(path, options) {
-        if let Ok(mut read_dir) = fs::read_dir(path) {
-            if options.dir || options.recursive {
-                if read_dir.next().is_none() {
-                    match fs::remove_dir(path) {
-                        Ok(_) => {
-                            if options.verbose {
-                                println!("removed directory {}", normalize(path).quote());
-                            }
-                        }
-                        Err(e) => {
-                            if e.kind() == std::io::ErrorKind::PermissionDenied {
-                                // GNU compatibility (rm/fail-eacces.sh)
-                                show_error!(
-                                    "cannot remove {}: {}",
-                                    path.quote(),
-                                    "Permission denied"
-                                );
-                            } else {
-                                show_error!("cannot remove {}: {}", path.quote(), e);
-                            }
-                            return true;
-                        }
-                    }
-                } else {
-                    // directory can be read but is not empty
-                    show_error!("cannot remove {}: Directory not empty", path.quote());
-                    return true;
-                }
-            } else {
-                // called to remove a symlink_dir (windows) without "-r"/"-R" or "-d"
-                show_error!("cannot remove {}: Is a directory", path.quote());
-                return true;
+    // Ask the user for permission.
+    if !prompt_dir(path, options) {
+        return false;
+    }
+
+    // Called to remove a symlink_dir (windows) without "-r"/"-R" or "-d".
+    if !options.dir && !options.recursive {
+        show_error!("cannot remove {}: Is a directory", path.quote());
+        return true;
+    }
+
+    // Try to remove the directory.
+    match fs::remove_dir(path) {
+        Ok(_) => {
+            if options.verbose {
+                println!("removed directory {}", normalize(path).quote());
             }
-        } else {
-            // GNU's rm shows this message if directory is empty but not readable
-            show_error!("cannot remove {}: Directory not empty", path.quote());
-            return true;
+            false
+        }
+        Err(e) => {
+            let e = e.map_err_context(|| format!("cannot remove {}", path.quote()));
+            show_error!("{e}");
+            true
         }
     }
-
-    false
 }
 
 fn remove_file(path: &Path, options: &Options) -> bool {
@@ -425,7 +583,7 @@ fn remove_file(path: &Path, options: &Options) -> bool {
                     // GNU compatibility (rm/fail-eacces.sh)
                     show_error!("cannot remove {}: {}", path.quote(), "Permission denied");
                 } else {
-                    show_error!("cannot remove {}: {}", path.quote(), e);
+                    show_error!("cannot remove {}: {e}", path.quote());
                 }
                 return true;
             }
@@ -450,7 +608,6 @@ fn prompt_dir(path: &Path, options: &Options) -> bool {
     }
 }
 
-#[allow(clippy::cognitive_complexity)]
 fn prompt_file(path: &Path, options: &Options) -> bool {
     // If interactive is Never we never want to send prompts
     if options.interactive == InteractiveMode::Never {
@@ -464,81 +621,87 @@ fn prompt_file(path: &Path, options: &Options) -> bool {
             }
         }
     }
-    // File::open(path) doesn't open the file in write mode so we need to use file options to open it in also write mode to check if it can written too
-    match File::options().read(true).write(true).open(path) {
-        Ok(file) => {
-            if let Ok(metadata) = file.metadata() {
-                if metadata.permissions().readonly() {
-                    if metadata.len() == 0 {
-                        prompt_yes!(
-                            "remove write-protected regular empty file {}?",
-                            path.quote()
-                        )
-                    } else {
-                        prompt_yes!("remove write-protected regular file {}?", path.quote())
-                    }
-                } else if options.interactive == InteractiveMode::Always {
-                    if metadata.len() == 0 {
-                        prompt_yes!("remove regular empty file {}?", path.quote())
-                    } else {
-                        prompt_yes!("remove file {}?", path.quote())
-                    }
-                } else {
-                    true
-                }
-            } else {
-                true
-            }
-        }
-        Err(err) => {
-            if err.kind() == ErrorKind::PermissionDenied {
-                match fs::metadata(path) {
-                    Ok(metadata) if metadata.len() == 0 => {
-                        prompt_yes!(
-                            "remove write-protected regular empty file {}?",
-                            path.quote()
-                        )
-                    }
-                    _ => prompt_yes!("remove write-protected regular file {}?", path.quote()),
-                }
-            } else {
-                true
-            }
-        }
+
+    let Ok(metadata) = fs::metadata(path) else {
+        return true;
+    };
+
+    if options.interactive == InteractiveMode::Always && is_writable(path) {
+        return if metadata.len() == 0 {
+            prompt_yes!("remove regular empty file {}?", path.quote())
+        } else {
+            prompt_yes!("remove file {}?", path.quote())
+        };
     }
+    prompt_file_permission_readonly(path, options)
 }
 
-// For directories finding if they are writable or not is a hassle. In Unix we can use the built-in rust crate to to check mode bits. But other os don't have something similar afaik
+fn prompt_file_permission_readonly(path: &Path, options: &Options) -> bool {
+    let stdin_ok = options.__presume_input_tty.unwrap_or(false) || stdin().is_terminal();
+    match (stdin_ok, fs::metadata(path), options.interactive) {
+        (false, _, InteractiveMode::PromptProtected) => true,
+        (_, Ok(_), _) if is_writable(path) => true,
+        (_, Ok(metadata), _) if metadata.len() == 0 => prompt_yes!(
+            "remove write-protected regular empty file {}?",
+            path.quote()
+        ),
+        _ => prompt_yes!("remove write-protected regular file {}?", path.quote()),
+    }
+}
+
+// For directories finding if they are writable or not is a hassle. In Unix we can use the built-in rust crate to check mode bits. But other os don't have something similar afaik
 // Most cases are covered by keep eye out for edge cases
 #[cfg(unix)]
 fn handle_writable_directory(path: &Path, options: &Options, metadata: &Metadata) -> bool {
-    use std::os::unix::fs::PermissionsExt;
-    let mode = metadata.permissions().mode();
-    // Check if directory has user write permissions
-    // Why is S_IWUSR showing up as a u16 on macos?
-    #[allow(clippy::unnecessary_cast)]
-    let user_writable = (mode & (libc::S_IWUSR as u32)) != 0;
-    if !user_writable {
-        prompt_yes!("remove write-protected directory {}?", path.quote())
-    } else if options.interactive == InteractiveMode::Always {
-        prompt_yes!("remove directory {}?", path.quote())
-    } else {
-        true
+    let stdin_ok = options.__presume_input_tty.unwrap_or(false) || stdin().is_terminal();
+    match (
+        stdin_ok,
+        is_readable_metadata(metadata),
+        is_writable_metadata(metadata),
+        options.interactive,
+    ) {
+        (false, _, _, InteractiveMode::PromptProtected) => true,
+        (_, false, false, _) => prompt_yes!(
+            "attempt removal of inaccessible directory {}?",
+            path.quote()
+        ),
+        (_, false, true, InteractiveMode::Always) => prompt_yes!(
+            "attempt removal of inaccessible directory {}?",
+            path.quote()
+        ),
+        (_, true, false, _) => prompt_yes!("remove write-protected directory {}?", path.quote()),
+        (_, _, _, InteractiveMode::Always) => prompt_yes!("remove directory {}?", path.quote()),
+        (_, _, _, _) => true,
     }
 }
 
+/// Checks if the path is referring to current or parent directory , if it is referring to current or any parent directory in the file tree e.g  '/../..' , '../..'
+fn path_is_current_or_parent_directory(path: &Path) -> bool {
+    let path_str = os_str_as_bytes(path.as_os_str());
+    let dir_separator = MAIN_SEPARATOR as u8;
+    if let Ok(path_bytes) = path_str {
+        return path_bytes == ([b'.'])
+            || path_bytes == ([b'.', b'.'])
+            || path_bytes.ends_with(&[dir_separator, b'.'])
+            || path_bytes.ends_with(&[dir_separator, b'.', b'.'])
+            || path_bytes.ends_with(&[dir_separator, b'.', dir_separator])
+            || path_bytes.ends_with(&[dir_separator, b'.', b'.', dir_separator]);
+    }
+    false
+}
+
 // For windows we can use windows metadata trait and file attributes to see if a directory is readonly
 #[cfg(windows)]
 fn handle_writable_directory(path: &Path, options: &Options, metadata: &Metadata) -> bool {
     use std::os::windows::prelude::MetadataExt;
     use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_READONLY;
     let not_user_writable = (metadata.file_attributes() & FILE_ATTRIBUTE_READONLY) != 0;
-    if not_user_writable {
-        prompt_yes!("remove write-protected directory {}?", path.quote())
-    } else if options.interactive == InteractiveMode::Always {
-        prompt_yes!("remove directory {}?", path.quote())
-    } else {
-        true
+    let stdin_ok = options.__presume_input_tty.unwrap_or(false) || stdin().is_terminal();
+    match (stdin_ok, not_user_writable, options.interactive) {
+        (false, _, InteractiveMode::PromptProtected) => true,
+        (_, true, _) => prompt_yes!("remove write-protected directory {}?", path.quote()),
+        (_, _, InteractiveMode::Always) => prompt_yes!("remove directory {}?", path.quote()),
+        (_, _, _) => true,
     }
 }
 
@@ -553,6 +716,40 @@ fn handle_writable_directory(path: &Path, options: &Options, metadata: &Metadata
     }
 }
 
+/// Removes trailing slashes, for example 'd/../////' yield 'd/../' required to fix rm-r4 GNU test
+fn clean_trailing_slashes(path: &Path) -> &Path {
+    let path_str = os_str_as_bytes(path.as_os_str());
+    let dir_separator = MAIN_SEPARATOR as u8;
+
+    if let Ok(path_bytes) = path_str {
+        let mut idx = if path_bytes.len() > 1 {
+            path_bytes.len() - 1
+        } else {
+            return path;
+        };
+        // Checks if element at the end is a '/'
+        if path_bytes[idx] == dir_separator {
+            for i in (1..path_bytes.len()).rev() {
+                // Will break at the start of the continuous sequence of '/', eg: "abc//////" , will break at
+                // "abc/", this will clean ////// to the root '/', so we have to be careful to not
+                // delete the root.
+                if path_bytes[i - 1] != dir_separator {
+                    idx = i;
+                    break;
+                }
+            }
+            #[cfg(unix)]
+            return Path::new(OsStr::from_bytes(&path_bytes[0..=idx]));
+
+            #[cfg(not(unix))]
+            // Unwrapping is fine here as os_str_as_bytes() would return an error on non unix
+            // systems with non utf-8 characters and thus bypass the if let Ok branch
+            return Path::new(std::str::from_utf8(&path_bytes[0..=idx]).unwrap());
+        }
+    }
+    path
+}
+
 fn prompt_descend(path: &Path) -> bool {
     prompt_yes!("descend into directory {}?", path.quote())
 }
@@ -578,3 +775,17 @@ fn is_symlink_dir(metadata: &Metadata) -> bool {
     metadata.file_type().is_symlink()
         && ((metadata.file_attributes() & FILE_ATTRIBUTE_DIRECTORY) != 0)
 }
+
+mod tests {
+
+    #[test]
+    // Testing whether path the `/////` collapses to `/`
+    fn test_collapsible_slash_path() {
+        use std::path::Path;
+
+        use crate::clean_trailing_slashes;
+        let path = Path::new("/////");
+
+        assert_eq!(Path::new("/"), clean_trailing_slashes(path));
+    }
+}
diff --git a/src/uu/rmdir/Cargo.toml b/src/uu/rmdir/Cargo.toml
index 41d2f7432d1..03ec352799b 100644
--- a/src/uu/rmdir/Cargo.toml
+++ b/src/uu/rmdir/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_rmdir"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "rmdir ~ (uutils) remove empty DIRECTORY"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/rmdir"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/rmdir.rs"
diff --git a/src/uu/rmdir/src/rmdir.rs b/src/uu/rmdir/src/rmdir.rs
index ef152f01a7b..8c9dc12b665 100644
--- a/src/uu/rmdir/src/rmdir.rs
+++ b/src/uu/rmdir/src/rmdir.rs
@@ -6,13 +6,13 @@
 // spell-checker:ignore (ToDO) ENOTDIR
 
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::ffi::OsString;
 use std::fs::{read_dir, remove_dir};
 use std::io;
 use std::path::Path;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, strip_errno, UResult};
+use uucore::error::{UResult, set_exit_code, strip_errno};
 
 use uucore::{format_usage, help_about, help_usage, show_error, util_name};
 
@@ -163,8 +163,8 @@ struct Opts {
 }
 
 pub fn uu_app() -> Command {
-    Command::new(uucore::util_name())
-        .version(crate_version!())
+    Command::new(util_name())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -195,6 +195,7 @@ pub fn uu_app() -> Command {
             Arg::new(ARG_DIRS)
                 .action(ArgAction::Append)
                 .num_args(1..)
+                .required(true)
                 .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::DirPath),
         )
diff --git a/src/uu/runcon/Cargo.toml b/src/uu/runcon/Cargo.toml
index ac4ec54d5f0..d010a8ad8f2 100644
--- a/src/uu/runcon/Cargo.toml
+++ b/src/uu/runcon/Cargo.toml
@@ -1,21 +1,25 @@
 [package]
 name = "uu_runcon"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "runcon ~ (uutils) run command with specified security context"
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/runcon"
 keywords = ["coreutils", "uutils", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+authors.workspace = true
+categories.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/runcon.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["entries", "fs", "perms"] }
+uucore = { workspace = true, features = ["entries", "fs", "perms", "selinux"] }
 selinux = { workspace = true }
 thiserror = { workspace = true }
 libc = { workspace = true }
diff --git a/src/uu/runcon/runcon.md b/src/uu/runcon/runcon.md
index 1911c50447c..53884b703be 100644
--- a/src/uu/runcon/runcon.md
+++ b/src/uu/runcon/runcon.md
@@ -1,8 +1,8 @@
 # runcon
 
 ```
-runcon [CONTEXT COMMAND [ARG...]]
-runcon [-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [ARG...]";
+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.
@@ -15,4 +15,4 @@ If none of --compute, --type, --user, --role or --range is specified, then the f
 
 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.
+If neither CONTEXT nor COMMAND is specified, the current security context is printed.
diff --git a/src/uu/runcon/src/errors.rs b/src/uu/runcon/src/errors.rs
index 5b628294060..4b4a9e1e65d 100644
--- a/src/uu/runcon/src/errors.rs
+++ b/src/uu/runcon/src/errors.rs
@@ -2,6 +2,8 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+#![cfg(target_os = "linux")]
+
 use std::ffi::OsString;
 use std::fmt::{Display, Formatter, Write};
 use std::io;
@@ -26,7 +28,7 @@ pub(crate) enum Error {
     #[error("No command is specified")]
     MissingCommand,
 
-    #[error("SELinux is not enabled")]
+    #[error("runcon may be used only on a SELinux kernel")]
     SELinuxNotEnabled,
 
     #[error(transparent)]
@@ -87,7 +89,6 @@ where
         err = source;
         write!(writer, ": {err}")?;
     }
-    write!(writer, ".")?;
     Ok(())
 }
 
@@ -118,3 +119,17 @@ impl Display for RunconError {
         write_full_error(f, &self.inner)
     }
 }
+
+impl UError for Error {
+    fn code(&self) -> i32 {
+        match self {
+            Self::MissingCommand => error_exit_status::ANOTHER_ERROR,
+            Self::SELinuxNotEnabled => error_exit_status::ANOTHER_ERROR,
+            Self::NotUTF8(_) => error_exit_status::ANOTHER_ERROR,
+            Self::CommandLine(e) => e.exit_code(),
+            Self::SELinux { .. } => error_exit_status::ANOTHER_ERROR,
+            Self::Io { .. } => error_exit_status::ANOTHER_ERROR,
+            Self::Io1 { .. } => error_exit_status::ANOTHER_ERROR,
+        }
+    }
+}
diff --git a/src/uu/runcon/src/main.rs b/src/uu/runcon/src/main.rs
index 1d3cef4cb80..ab4c4b15944 100644
--- a/src/uu/runcon/src/main.rs
+++ b/src/uu/runcon/src/main.rs
@@ -1 +1,2 @@
+#![cfg(target_os = "linux")]
 uucore::bin!(uu_runcon);
diff --git a/src/uu/runcon/src/runcon.rs b/src/uu/runcon/src/runcon.rs
index a802542b2a2..658aa33b252 100644
--- a/src/uu/runcon/src/runcon.rs
+++ b/src/uu/runcon/src/runcon.rs
@@ -3,11 +3,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore (vars) RFILE
+#![cfg(target_os = "linux")]
 
 use clap::builder::ValueParser;
-use uucore::error::{UResult, UUsageError};
+use uucore::error::{UClapError, UError, UResult};
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use selinux::{OpaqueSecurityContext, SecurityClass, SecurityContext};
 use uucore::{format_usage, help_about, help_section, help_usage};
 
@@ -42,20 +43,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let options = match parse_command_line(config, args) {
         Ok(r) => r,
         Err(r) => {
-            if let Error::CommandLine(ref r) = r {
-                match r.kind() {
-                    clap::error::ErrorKind::DisplayHelp
-                    | clap::error::ErrorKind::DisplayVersion => {
-                        println!("{r}");
-                        return Ok(());
-                    }
-                    _ => {}
-                }
-            }
-            return Err(UUsageError::new(
-                error_exit_status::ANOTHER_ERROR,
-                format!("{r}"),
-            ));
+            return Err(r);
         }
     };
 
@@ -101,7 +89,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(DESCRIPTION)
         .override_usage(format_usage(USAGE))
@@ -198,8 +186,8 @@ struct Options {
     arguments: Vec<OsString>,
 }
 
-fn parse_command_line(config: Command, args: impl uucore::Args) -> Result<Options> {
-    let matches = config.try_get_matches_from(args)?;
+fn parse_command_line(config: Command, args: impl uucore::Args) -> UResult<Options> {
+    let matches = config.try_get_matches_from(args).with_exit_code(125)?;
 
     let compute_transition_context = matches.get_flag(options::COMPUTE);
 
@@ -233,7 +221,7 @@ fn parse_command_line(config: Command, args: impl uucore::Args) -> Result<Option
         // runcon CONTEXT COMMAND [args]
 
         args.next()
-            .ok_or(Error::MissingCommand)
+            .ok_or_else(|| Box::new(Error::MissingCommand) as Box<dyn UError>)
             .map(move |command| Options {
                 mode: CommandLineMode::PlainContext { context, command },
                 arguments: args.collect(),
@@ -283,7 +271,7 @@ fn set_next_exec_context(context: &OpaqueSecurityContext) -> Result<()> {
 }
 
 fn get_plain_context(context: &OsStr) -> Result<OpaqueSecurityContext> {
-    if selinux::kernel_support() == selinux::KernelSupport::Unsupported {
+    if !uucore::selinux::is_selinux_enabled() {
         return Err(Error::SELinuxNotEnabled);
     }
 
@@ -354,7 +342,7 @@ fn get_custom_context(
     use OpaqueSecurityContext as OSC;
     type SetNewValueProc = fn(&OSC, &CStr) -> selinux::errors::Result<()>;
 
-    if selinux::kernel_support() == selinux::KernelSupport::Unsupported {
+    if !uucore::selinux::is_selinux_enabled() {
         return Err(Error::SELinuxNotEnabled);
     }
 
diff --git a/src/uu/seq/BENCHMARKING.md b/src/uu/seq/BENCHMARKING.md
index c4b24b8d201..5758d2a77fd 100644
--- a/src/uu/seq/BENCHMARKING.md
+++ b/src/uu/seq/BENCHMARKING.md
@@ -15,11 +15,81 @@ Next, build the `seq` binary under the release profile:
 cargo build --release -p uu_seq
 ```
 
-Finally, you can compare the performance of the two versions of `head`
+Finally, you can compare the performance of the two versions of `seq`
 by running, for example,
 
 ```shell
-hyperfine "seq 1000000" "target/release/seq 1000000"
+hyperfine -L seq seq,target/release/seq "{seq} 1000000"
 ```
 
+## Interesting test cases
+
+Performance characteristics may vary a lot depending on the parameters,
+and if custom formatting is required. In particular, it does appear
+that the GNU implementation is heavily optimized for positive integer
+outputs (which is probably the most common use case for `seq`).
+
+Specifying a format or fixed width will slow down the
+execution a lot (~15-20 times on GNU `seq`):
+```shell
+hyperfine -L seq seq,target/release/seq "{seq} -f%g 1000000"
+hyperfine -L seq seq,target/release/seq "{seq} -w 1000000"
+```
+
+Floating point increments, or any negative bound, also degrades the
+performance (~10-15 times on GNU `seq`):
+```shell
+hyperfine -L seq seq,./target/release/seq "{seq} 0 0.000001 1"
+hyperfine -L seq seq,./target/release/seq "{seq} -100 1 1000000"
+```
+
+It is also interesting to compare performance with large precision
+format. But in this case, the output itself should also be compared,
+as GNU `seq` may not provide the same precision (`uutils` version of
+`seq` provides arbitrary precision, while GNU `seq` appears to be
+limited to `long double` on the given platform, i.e. 64/80/128-bit
+float):
+```shell
+hyperfine -L seq seq,target/release/seq "{seq} -f%.30f 0 0.000001 1"
+```
+
+## Optimizations
+
+### Buffering stdout
+
+The original `uutils` implementation of `seq` did unbuffered writes
+to stdout, causing a large number of system calls (and therefore a large amount
+of system time). Simply wrapping `stdout` in a `BufWriter` increased performance
+by about 2 times for a floating point increment test case, leading to similar
+performance compared with GNU `seq`.
+
+### Directly print strings
+
+As expected, directly printing a string:
+```rust
+stdout.write_all(separator.as_bytes())?
+```
+is quite a bit faster than using format to do the same operation:
+```rust
+write!(stdout, "{separator}")?
+```
+
+The change above resulted in a ~10% speedup.
+
+### Fast increment path
+
+When dealing with positive integer values (first/increment/last), and
+the default format is used, we use a custom fast path that does arithmetic
+on u8 arrays (i.e. strings), instead of repeatedly calling into
+formatting format.
+
+This provides _massive_ performance gains, in the order of 10-20x compared
+with the default implementation, at the expense of some added code complexity.
+
+Just from performance numbers, it is clear that GNU `seq` uses similar
+tricks, but we are more liberal on when we use our fast path (e.g. large
+increments are supported, equal width is supported). Our fast path
+implementation gets within ~10% of `seq` performance when its fast
+path is activated.
+
 [0]: https://github.com/sharkdp/hyperfine
diff --git a/src/uu/seq/Cargo.toml b/src/uu/seq/Cargo.toml
index f25d995a2d6..5973b515798 100644
--- a/src/uu/seq/Cargo.toml
+++ b/src/uu/seq/Cargo.toml
@@ -1,16 +1,16 @@
-# spell-checker:ignore bigdecimal
+# spell-checker:ignore bigdecimal cfgs extendedbigdecimal
 [package]
 name = "uu_seq"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "seq ~ (uutils) display a sequence of numbers"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/seq"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
 
 [lib]
 path = "src/seq.rs"
@@ -20,8 +20,25 @@ bigdecimal = { workspace = true }
 clap = { workspace = true }
 num-bigint = { workspace = true }
 num-traits = { workspace = true }
-uucore = { workspace = true, features = ["memo"] }
+thiserror = { workspace = true }
+uucore = { workspace = true, features = [
+  "extendedbigdecimal",
+  "fast-inc",
+  "format",
+  "parser",
+  "quoting-style",
+] }
 
 [[bin]]
 name = "seq"
 path = "src/main.rs"
+
+# FIXME: this is the only crate that has a separate lints configuration,
+#        which for now means a full copy of all clippy and rust lints here.
+[lints.clippy]
+all = { level = "deny", priority = -1 }
+
+# Allow "fuzzing" as a "cfg" condition name
+# https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }
diff --git a/src/uu/seq/seq.md b/src/uu/seq/seq.md
index 8e67391e487..d747e4a0263 100644
--- a/src/uu/seq/seq.md
+++ b/src/uu/seq/seq.md
@@ -1,9 +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
 ```
+
+Display numbers from FIRST to LAST, in steps of INCREMENT.
diff --git a/src/uu/seq/src/error.rs b/src/uu/seq/src/error.rs
index e81c30fe673..819368aad98 100644
--- a/src/uu/seq/src/error.rs
+++ b/src/uu/seq/src/error.rs
@@ -4,30 +4,41 @@
 // file that was distributed with this source code.
 // spell-checker:ignore numberparse
 //! Errors returned by seq.
-use std::error::Error;
-use std::fmt::Display;
-
+use crate::numberparse::ParseNumberError;
+use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::UError;
 
-use crate::numberparse::ParseNumberError;
-
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum SeqError {
     /// An error parsing the input arguments.
     ///
     /// The parameters are the [`String`] argument as read from the
     /// command line and the underlying parsing error itself.
+    #[error("invalid {} argument: {}", parse_error_type(.1), .0.quote())]
     ParseError(String, ParseNumberError),
 
     /// The increment argument was zero, which is not allowed.
     ///
     /// The parameter is the increment argument as a [`String`] as read
     /// from the command line.
+    #[error("invalid Zero increment value: {}", .0.quote())]
     ZeroIncrement(String),
 
     /// No arguments were passed to this function, 1 or more is required
+    #[error("missing operand")]
     NoArguments,
+
+    /// Both a format and equal width where passed to seq
+    #[error("format string may not be specified when printing equal width strings")]
+    FormatAndEqualWidth,
+}
+
+fn parse_error_type(e: &ParseNumberError) -> &'static str {
+    match e {
+        ParseNumberError::Float => "floating point",
+        ParseNumberError::Nan => "'not-a-number'",
+    }
 }
 
 impl UError for SeqError {
@@ -40,22 +51,3 @@ impl UError for SeqError {
         true
     }
 }
-
-impl Error for SeqError {}
-
-impl Display for SeqError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::ParseError(s, e) => {
-                let error_type = match e {
-                    ParseNumberError::Float => "floating point",
-                    ParseNumberError::Nan => "'not-a-number'",
-                    ParseNumberError::Hex => "hexadecimal",
-                };
-                write!(f, "invalid {error_type} argument: {}", s.quote())
-            }
-            Self::ZeroIncrement(s) => write!(f, "invalid Zero increment value: {}", s.quote()),
-            Self::NoArguments => write!(f, "missing operand"),
-        }
-    }
-}
diff --git a/src/uu/seq/src/extendedbigint.rs b/src/uu/seq/src/extendedbigint.rs
deleted file mode 100644
index 6828fba2df2..00000000000
--- a/src/uu/seq/src/extendedbigint.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-// 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.
-// spell-checker:ignore bigint extendedbigint extendedbigdecimal
-//! An arbitrary precision integer that can also represent infinity, NaN, etc.
-//!
-//! Usually infinity, NaN, and negative zero are only represented for
-//! floating point numbers. The [`ExtendedBigInt`] enumeration provides
-//! a representation of those things with the set of integers. The
-//! finite values are stored as [`BigInt`] instances.
-//!
-//! # Examples
-//!
-//! Addition works for [`ExtendedBigInt`] as it does for floats. For
-//! example, adding infinity to any finite value results in infinity:
-//!
-//! ```rust,ignore
-//! let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-//! let summand2 = ExtendedBigInt::Infinity;
-//! assert_eq!(summand1 + summand2, ExtendedBigInt::Infinity);
-//! ```
-use std::cmp::Ordering;
-use std::fmt::Display;
-use std::ops::Add;
-
-use num_bigint::BigInt;
-use num_bigint::ToBigInt;
-use num_traits::One;
-use num_traits::Zero;
-
-use crate::extendedbigdecimal::ExtendedBigDecimal;
-
-#[derive(Debug, Clone)]
-pub enum ExtendedBigInt {
-    BigInt(BigInt),
-    Infinity,
-    MinusInfinity,
-    MinusZero,
-    Nan,
-}
-
-impl ExtendedBigInt {
-    /// The integer number one.
-    pub fn one() -> Self {
-        // We would like to implement `num_traits::One`, but it requires
-        // a multiplication implementation, and we don't want to
-        // implement that here.
-        Self::BigInt(BigInt::one())
-    }
-}
-
-impl From<ExtendedBigDecimal> for ExtendedBigInt {
-    fn from(big_decimal: ExtendedBigDecimal) -> Self {
-        match big_decimal {
-            // TODO When can this fail?
-            ExtendedBigDecimal::BigDecimal(x) => Self::BigInt(x.to_bigint().unwrap()),
-            ExtendedBigDecimal::Infinity => Self::Infinity,
-            ExtendedBigDecimal::MinusInfinity => Self::MinusInfinity,
-            ExtendedBigDecimal::MinusZero => Self::MinusZero,
-            ExtendedBigDecimal::Nan => Self::Nan,
-        }
-    }
-}
-
-impl Display for ExtendedBigInt {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::BigInt(n) => n.fmt(f),
-            Self::Infinity => f32::INFINITY.fmt(f),
-            Self::MinusInfinity => f32::NEG_INFINITY.fmt(f),
-            Self::MinusZero => "-0".fmt(f),
-            Self::Nan => "nan".fmt(f),
-        }
-    }
-}
-
-impl Zero for ExtendedBigInt {
-    fn zero() -> Self {
-        Self::BigInt(BigInt::zero())
-    }
-    fn is_zero(&self) -> bool {
-        match self {
-            Self::BigInt(n) => n.is_zero(),
-            Self::MinusZero => true,
-            _ => false,
-        }
-    }
-}
-
-impl Add for ExtendedBigInt {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        match (self, other) {
-            (Self::BigInt(m), Self::BigInt(n)) => Self::BigInt(m.add(n)),
-            (Self::BigInt(_), Self::MinusInfinity) => Self::MinusInfinity,
-            (Self::BigInt(_), Self::Infinity) => Self::Infinity,
-            (Self::BigInt(_), Self::Nan) => Self::Nan,
-            (Self::BigInt(m), Self::MinusZero) => Self::BigInt(m),
-            (Self::Infinity, Self::BigInt(_)) => Self::Infinity,
-            (Self::Infinity, Self::Infinity) => Self::Infinity,
-            (Self::Infinity, Self::MinusZero) => Self::Infinity,
-            (Self::Infinity, Self::MinusInfinity) => Self::Nan,
-            (Self::Infinity, Self::Nan) => Self::Nan,
-            (Self::MinusInfinity, Self::BigInt(_)) => Self::MinusInfinity,
-            (Self::MinusInfinity, Self::MinusInfinity) => Self::MinusInfinity,
-            (Self::MinusInfinity, Self::MinusZero) => Self::MinusInfinity,
-            (Self::MinusInfinity, Self::Infinity) => Self::Nan,
-            (Self::MinusInfinity, Self::Nan) => Self::Nan,
-            (Self::Nan, _) => Self::Nan,
-            (Self::MinusZero, other) => other,
-        }
-    }
-}
-
-impl PartialEq for ExtendedBigInt {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::BigInt(m), Self::BigInt(n)) => m.eq(n),
-            (Self::BigInt(_), Self::MinusInfinity) => false,
-            (Self::BigInt(_), Self::Infinity) => false,
-            (Self::BigInt(_), Self::Nan) => false,
-            (Self::BigInt(_), Self::MinusZero) => false,
-            (Self::Infinity, Self::BigInt(_)) => false,
-            (Self::Infinity, Self::Infinity) => true,
-            (Self::Infinity, Self::MinusZero) => false,
-            (Self::Infinity, Self::MinusInfinity) => false,
-            (Self::Infinity, Self::Nan) => false,
-            (Self::MinusInfinity, Self::BigInt(_)) => false,
-            (Self::MinusInfinity, Self::Infinity) => false,
-            (Self::MinusInfinity, Self::MinusZero) => false,
-            (Self::MinusInfinity, Self::MinusInfinity) => true,
-            (Self::MinusInfinity, Self::Nan) => false,
-            (Self::Nan, _) => false,
-            (Self::MinusZero, Self::BigInt(_)) => false,
-            (Self::MinusZero, Self::Infinity) => false,
-            (Self::MinusZero, Self::MinusZero) => true,
-            (Self::MinusZero, Self::MinusInfinity) => false,
-            (Self::MinusZero, Self::Nan) => false,
-        }
-    }
-}
-
-impl PartialOrd for ExtendedBigInt {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        match (self, other) {
-            (Self::BigInt(m), Self::BigInt(n)) => m.partial_cmp(n),
-            (Self::BigInt(_), Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::BigInt(_), Self::Infinity) => Some(Ordering::Less),
-            (Self::BigInt(_), Self::Nan) => None,
-            (Self::BigInt(m), Self::MinusZero) => m.partial_cmp(&BigInt::zero()),
-            (Self::Infinity, Self::BigInt(_)) => Some(Ordering::Greater),
-            (Self::Infinity, Self::Infinity) => Some(Ordering::Equal),
-            (Self::Infinity, Self::MinusZero) => Some(Ordering::Greater),
-            (Self::Infinity, Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::Infinity, Self::Nan) => None,
-            (Self::MinusInfinity, Self::BigInt(_)) => Some(Ordering::Less),
-            (Self::MinusInfinity, Self::Infinity) => Some(Ordering::Less),
-            (Self::MinusInfinity, Self::MinusZero) => Some(Ordering::Less),
-            (Self::MinusInfinity, Self::MinusInfinity) => Some(Ordering::Equal),
-            (Self::MinusInfinity, Self::Nan) => None,
-            (Self::Nan, _) => None,
-            (Self::MinusZero, Self::BigInt(n)) => BigInt::zero().partial_cmp(n),
-            (Self::MinusZero, Self::Infinity) => Some(Ordering::Less),
-            (Self::MinusZero, Self::MinusZero) => Some(Ordering::Equal),
-            (Self::MinusZero, Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::MinusZero, Self::Nan) => None,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use num_bigint::BigInt;
-    use num_traits::Zero;
-
-    use crate::extendedbigint::ExtendedBigInt;
-
-    #[test]
-    fn test_addition_infinity() {
-        let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-        let summand2 = ExtendedBigInt::Infinity;
-        assert_eq!(summand1 + summand2, ExtendedBigInt::Infinity);
-    }
-
-    #[test]
-    fn test_addition_minus_infinity() {
-        let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-        let summand2 = ExtendedBigInt::MinusInfinity;
-        assert_eq!(summand1 + summand2, ExtendedBigInt::MinusInfinity);
-    }
-
-    #[test]
-    fn test_addition_nan() {
-        let summand1 = ExtendedBigInt::BigInt(BigInt::zero());
-        let summand2 = ExtendedBigInt::Nan;
-        let sum = summand1 + summand2;
-        match sum {
-            ExtendedBigInt::Nan => (),
-            _ => unreachable!(),
-        }
-    }
-
-    #[test]
-    fn test_display() {
-        assert_eq!(format!("{}", ExtendedBigInt::BigInt(BigInt::zero())), "0");
-        assert_eq!(format!("{}", ExtendedBigInt::MinusZero), "-0");
-        assert_eq!(format!("{}", ExtendedBigInt::Infinity), "inf");
-        assert_eq!(format!("{}", ExtendedBigInt::MinusInfinity), "-inf");
-        assert_eq!(format!("{}", ExtendedBigInt::Nan), "nan");
-    }
-}
diff --git a/src/uu/seq/src/number.rs b/src/uu/seq/src/number.rs
index 85bc327ff46..f23e42b1cf8 100644
--- a/src/uu/seq/src/number.rs
+++ b/src/uu/seq/src/number.rs
@@ -2,80 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore extendedbigdecimal extendedbigint
-//! A type to represent the possible start, increment, and end values for seq.
-//!
-//! The [`Number`] enumeration represents the possible values for the
-//! start, increment, and end values for `seq`. These may be integers,
-//! floating point numbers, negative zero, etc. A [`Number`] can be
-//! parsed from a string by calling [`str::parse`].
+// spell-checker:ignore extendedbigdecimal
 use num_traits::Zero;
 
-use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-
-/// An integral or floating point number.
-#[derive(Debug, PartialEq)]
-pub enum Number {
-    Int(ExtendedBigInt),
-    Float(ExtendedBigDecimal),
-}
-
-impl Number {
-    /// Decide whether this number is zero (either positive or negative).
-    pub fn is_zero(&self) -> bool {
-        // We would like to implement `num_traits::Zero`, but it
-        // requires an addition implementation, and we don't want to
-        // implement that here.
-        match self {
-            Self::Int(n) => n.is_zero(),
-            Self::Float(x) => x.is_zero(),
-        }
-    }
-
-    /// Convert this number into an `ExtendedBigDecimal`.
-    pub fn into_extended_big_decimal(self) -> ExtendedBigDecimal {
-        match self {
-            Self::Int(n) => ExtendedBigDecimal::from(n),
-            Self::Float(x) => x,
-        }
-    }
-
-    /// The integer number one.
-    pub fn one() -> Self {
-        // We would like to implement `num_traits::One`, but it requires
-        // a multiplication implementation, and we don't want to
-        // implement that here.
-        Self::Int(ExtendedBigInt::one())
-    }
-
-    /// Round this number towards the given other number.
-    ///
-    /// If `other` is greater, then round up. If `other` is smaller,
-    /// then round down.
-    pub fn round_towards(self, other: &ExtendedBigInt) -> ExtendedBigInt {
-        match self {
-            // If this number is already an integer, it is already
-            // rounded to the nearest integer in the direction of
-            // `other`.
-            Self::Int(num) => num,
-            // Otherwise, if this number is a float, we need to decide
-            // whether `other` is larger or smaller than it, and thus
-            // whether to round up or round down, respectively.
-            Self::Float(num) => {
-                let other: ExtendedBigDecimal = From::from(other.clone());
-                if other > num {
-                    num.ceil()
-                } else {
-                    // If they are equal, then `self` is already an
-                    // integer, so calling `floor()` does no harm and
-                    // will just return that integer anyway.
-                    num.floor()
-                }
-            }
-        }
-    }
-}
+use uucore::extendedbigdecimal::ExtendedBigDecimal;
 
 /// A number with a specified number of integer and fractional digits.
 ///
@@ -83,17 +13,27 @@ impl Number {
 /// on how many significant digits to use when displaying the number.
 /// The [`PreciseNumber::num_integral_digits`] field also includes the width needed to
 /// display the "-" character for a negative number.
+/// [`PreciseNumber::num_fractional_digits`] provides the number of decimal digits after
+/// the decimal point (a.k.a. precision), or None if that number cannot intuitively be
+/// obtained (i.e. hexadecimal floats).
+/// Note: Those 2 fields should not necessarily be interpreted literally, but as matching
+/// GNU `seq` behavior: the exact way of guessing desired precision from user input is a
+/// matter of interpretation.
 ///
 /// You can get an instance of this struct by calling [`str::parse`].
 #[derive(Debug)]
 pub struct PreciseNumber {
-    pub number: Number,
+    pub number: ExtendedBigDecimal,
     pub num_integral_digits: usize,
-    pub num_fractional_digits: usize,
+    pub num_fractional_digits: Option<usize>,
 }
 
 impl PreciseNumber {
-    pub fn new(number: Number, num_integral_digits: usize, num_fractional_digits: usize) -> Self {
+    pub fn new(
+        number: ExtendedBigDecimal,
+        num_integral_digits: usize,
+        num_fractional_digits: Option<usize>,
+    ) -> Self {
         Self {
             number,
             num_integral_digits,
@@ -106,7 +46,7 @@ impl PreciseNumber {
         // We would like to implement `num_traits::One`, but it requires
         // a multiplication implementation, and we don't want to
         // implement that here.
-        Self::new(Number::one(), 1, 0)
+        Self::new(ExtendedBigDecimal::one(), 1, Some(0))
     }
 
     /// Decide whether this number is zero (either positive or negative).
diff --git a/src/uu/seq/src/numberparse.rs b/src/uu/seq/src/numberparse.rs
index b22cf90c05c..a53d6ee2050 100644
--- a/src/uu/seq/src/numberparse.rs
+++ b/src/uu/seq/src/numberparse.rs
@@ -2,398 +2,138 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore extendedbigdecimal extendedbigint bigdecimal numberparse
+// spell-checker:ignore extendedbigdecimal bigdecimal numberparse hexadecimalfloat
 //! Parsing numbers for use in `seq`.
 //!
 //! This module provides an implementation of [`FromStr`] for the
 //! [`PreciseNumber`] struct.
 use std::str::FromStr;
 
-use bigdecimal::BigDecimal;
-use num_bigint::BigInt;
-use num_bigint::Sign;
-use num_traits::Num;
-use num_traits::Zero;
+use uucore::parser::num_parser::{ExtendedParser, ExtendedParserError};
 
-use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-use crate::number::Number;
 use crate::number::PreciseNumber;
+use uucore::extendedbigdecimal::ExtendedBigDecimal;
 
 /// An error returned when parsing a number fails.
 #[derive(Debug, PartialEq, Eq)]
 pub enum ParseNumberError {
     Float,
     Nan,
-    Hex,
 }
 
-/// Decide whether a given string and its parsed `BigInt` is negative zero.
-fn is_minus_zero_int(s: &str, n: &BigInt) -> bool {
-    s.starts_with('-') && n == &BigInt::zero()
-}
-
-/// Decide whether a given string and its parsed `BigDecimal` is negative zero.
-fn is_minus_zero_float(s: &str, x: &BigDecimal) -> bool {
-    s.starts_with('-') && x == &BigDecimal::zero()
-}
-
-/// Parse a number with neither a decimal point nor an exponent.
-///
-/// # Errors
-///
-/// This function returns an error if the input string is a variant of
-/// "NaN" or if no [`BigInt`] could be parsed from the string.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// let actual = "0".parse::<Number>().unwrap().number;
-/// let expected = Number::BigInt(BigInt::zero());
-/// assert_eq!(actual, expected);
-/// ```
-fn parse_no_decimal_no_exponent(s: &str) -> Result<PreciseNumber, ParseNumberError> {
-    match s.parse::<BigInt>() {
-        Ok(n) => {
-            // If `s` is '-0', then `parse()` returns `BigInt::zero()`,
-            // but we need to return `Number::MinusZeroInt` instead.
-            if is_minus_zero_int(s, &n) {
-                Ok(PreciseNumber::new(
-                    Number::Int(ExtendedBigInt::MinusZero),
-                    s.len(),
-                    0,
-                ))
+// Compute the number of integral and fractional digits in input string,
+// and wrap the result in a PreciseNumber.
+// We know that the string has already been parsed correctly, so we don't
+// need to be too careful.
+fn compute_num_digits(input: &str, ebd: ExtendedBigDecimal) -> PreciseNumber {
+    let input = input.to_lowercase();
+    let input = input.trim_start();
+
+    // Leading + is ignored for this.
+    let input = input.strip_prefix('+').unwrap_or(input);
+
+    // Integral digits for any hex number is ill-defined (0 is fine as an output)
+    // Fractional digits for an floating hex number is ill-defined, return None
+    // as we'll totally ignore that number for precision computations.
+    // Still return 0 for hex integers though.
+    if input.starts_with("0x") || input.starts_with("-0x") {
+        return PreciseNumber {
+            number: ebd,
+            num_integral_digits: 0,
+            num_fractional_digits: if input.contains(".") || input.contains("p") {
+                None
             } else {
-                Ok(PreciseNumber::new(
-                    Number::Int(ExtendedBigInt::BigInt(n)),
-                    s.len(),
-                    0,
-                ))
-            }
-        }
-        Err(_) => {
-            // Possibly "NaN" or "inf".
-            //
-            // TODO In Rust v1.53.0, this change
-            // https://github.com/rust-lang/rust/pull/78618 improves the
-            // parsing of floats to include being able to parse "NaN"
-            // and "inf". So when the minimum version of this crate is
-            // increased to 1.53.0, we should just use the built-in
-            // `f32` parsing instead.
-            if s.eq_ignore_ascii_case("inf") {
-                Ok(PreciseNumber::new(
-                    Number::Float(ExtendedBigDecimal::Infinity),
-                    0,
-                    0,
-                ))
-            } else if s.eq_ignore_ascii_case("-inf") {
-                Ok(PreciseNumber::new(
-                    Number::Float(ExtendedBigDecimal::MinusInfinity),
-                    0,
-                    0,
-                ))
-            } else if s.eq_ignore_ascii_case("nan") || s.eq_ignore_ascii_case("-nan") {
-                Err(ParseNumberError::Nan)
-            } else {
-                Err(ParseNumberError::Float)
-            }
-        }
-    }
-}
-
-/// Parse a number with an exponent but no decimal point.
-///
-/// # Errors
-///
-/// This function returns an error if `s` is not a valid number.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// let actual = "1e2".parse::<Number>().unwrap().number;
-/// let expected = "100".parse::<BigInt>().unwrap();
-/// assert_eq!(actual, expected);
-/// ```
-fn parse_exponent_no_decimal(s: &str, j: usize) -> Result<PreciseNumber, ParseNumberError> {
-    let exponent: i64 = s[j + 1..].parse().map_err(|_| ParseNumberError::Float)?;
-    // If the exponent is strictly less than zero, then the number
-    // should be treated as a floating point number that will be
-    // displayed in decimal notation. For example, "1e-2" will be
-    // displayed as "0.01", but "1e2" will be displayed as "100",
-    // without a decimal point.
-    let x: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
-    let num_integral_digits = if is_minus_zero_float(s, &x) {
-        2
-    } else {
-        let total = j as i64 + exponent;
-        let result = if total < 1 {
-            1
-        } else {
-            total.try_into().unwrap()
+                Some(0)
+            },
         };
-        if x.sign() == Sign::Minus {
-            result + 1
-        } else {
-            result
-        }
-    };
-    let num_fractional_digits = if exponent < 0 { -exponent as usize } else { 0 };
-
-    if exponent < 0 {
-        if is_minus_zero_float(s, &x) {
-            Ok(PreciseNumber::new(
-                Number::Float(ExtendedBigDecimal::MinusZero),
-                num_integral_digits,
-                num_fractional_digits,
-            ))
-        } else {
-            Ok(PreciseNumber::new(
-                Number::Float(ExtendedBigDecimal::BigDecimal(x)),
-                num_integral_digits,
-                num_fractional_digits,
-            ))
-        }
-    } else {
-        let zeros = "0".repeat(exponent.try_into().unwrap());
-        let expanded = [&s[0..j], &zeros].concat();
-        parse_no_decimal_no_exponent(&expanded)
     }
-}
 
-/// Parse a number with a decimal point but no exponent.
-///
-/// # Errors
-///
-/// This function returns an error if `s` is not a valid number.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// let actual = "1.2".parse::<Number>().unwrap().number;
-/// let expected = "1.2".parse::<BigDecimal>().unwrap();
-/// assert_eq!(actual, expected);
-/// ```
-fn parse_decimal_no_exponent(s: &str, i: usize) -> Result<PreciseNumber, ParseNumberError> {
-    let x: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
-
-    // The number of integral digits is the number of chars until the period.
-    //
-    // This includes the negative sign if there is one. Also, it is
-    // possible that a number is expressed as "-.123" instead of
-    // "-0.123", but when we display the number we want it to include
-    // the leading 0.
-    let num_integral_digits = if s.starts_with("-.") { i + 1 } else { i };
-    let num_fractional_digits = s.len() - (i + 1);
-    if is_minus_zero_float(s, &x) {
-        Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::MinusZero),
-            num_integral_digits,
-            num_fractional_digits,
-        ))
-    } else {
-        Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::BigDecimal(x)),
-            num_integral_digits,
-            num_fractional_digits,
-        ))
-    }
-}
-
-/// Parse a number with both a decimal point and an exponent.
-///
-/// # Errors
-///
-/// This function returns an error if `s` is not a valid number.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// let actual = "1.2e3".parse::<Number>().unwrap().number;
-/// let expected = "1200".parse::<BigInt>().unwrap();
-/// assert_eq!(actual, expected);
-/// ```
-fn parse_decimal_and_exponent(
-    s: &str,
-    i: usize,
-    j: usize,
-) -> Result<PreciseNumber, ParseNumberError> {
-    // Because of the match guard, this subtraction will not underflow.
-    let num_digits_between_decimal_point_and_e = (j - (i + 1)) as i64;
-    let exponent: i64 = s[j + 1..].parse().map_err(|_| ParseNumberError::Float)?;
-    let val: BigDecimal = s.parse().map_err(|_| ParseNumberError::Float)?;
-
-    let num_integral_digits = {
-        let minimum: usize = {
-            let integral_part: f64 = s[..j].parse().map_err(|_| ParseNumberError::Float)?;
-            if integral_part.is_sign_negative() {
-                2
-            } else {
-                1
-            }
-        };
-        // Special case: if the string is "-.1e2", we need to treat it
-        // as if it were "-0.1e2".
-        let total = if s.starts_with("-.") {
-            i as i64 + exponent + 1
-        } else {
-            i as i64 + exponent
-        };
-        if total < minimum as i64 {
-            minimum
-        } else {
-            total.try_into().unwrap()
+    // Split the exponent part, if any
+    let parts: Vec<&str> = input.split("e").collect();
+    debug_assert!(parts.len() <= 2);
+
+    // Count all the digits up to `.`, `-` sign is included.
+    let (mut int_digits, mut frac_digits) = match parts[0].find(".") {
+        Some(i) => {
+            // Cover special case .X and -.X where we behave as if there was a leading 0:
+            // 0.X, -0.X.
+            let int_digits = match i {
+                0 => 1,
+                1 if parts[0].starts_with("-") => 2,
+                _ => i,
+            };
+
+            (int_digits, parts[0].len() - i - 1)
         }
+        None => (parts[0].len(), 0),
     };
 
-    let num_fractional_digits = if num_digits_between_decimal_point_and_e < exponent {
-        0
-    } else {
-        (num_digits_between_decimal_point_and_e - exponent)
-            .try_into()
-            .unwrap()
-    };
-
-    if num_digits_between_decimal_point_and_e <= exponent {
-        if is_minus_zero_float(s, &val) {
-            Ok(PreciseNumber::new(
-                Number::Int(ExtendedBigInt::MinusZero),
-                num_integral_digits,
-                num_fractional_digits,
-            ))
+    // If there is an exponent, reparse that (yes this is not optimal,
+    // but we can't necessarily exactly recover that from the parsed number).
+    if parts.len() == 2 {
+        let exp = parts[1].parse::<i64>().unwrap_or(0);
+        // For positive exponents, effectively expand the number. Ignore negative exponents.
+        // Also ignore overflowed exponents (unwrap_or(0)).
+        if exp > 0 {
+            int_digits += exp.try_into().unwrap_or(0)
+        };
+        frac_digits = if exp < frac_digits as i64 {
+            // Subtract from i128 to avoid any overflow
+            (frac_digits as i128 - exp as i128).try_into().unwrap_or(0)
         } else {
-            let zeros: String = "0".repeat(
-                (exponent - num_digits_between_decimal_point_and_e)
-                    .try_into()
-                    .unwrap(),
-            );
-            let expanded = [&s[0..i], &s[i + 1..j], &zeros].concat();
-            let n = expanded
-                .parse::<BigInt>()
-                .map_err(|_| ParseNumberError::Float)?;
-            Ok(PreciseNumber::new(
-                Number::Int(ExtendedBigInt::BigInt(n)),
-                num_integral_digits,
-                num_fractional_digits,
-            ))
+            0
         }
-    } else if is_minus_zero_float(s, &val) {
-        Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::MinusZero),
-            num_integral_digits,
-            num_fractional_digits,
-        ))
-    } else {
-        Ok(PreciseNumber::new(
-            Number::Float(ExtendedBigDecimal::BigDecimal(val)),
-            num_integral_digits,
-            num_fractional_digits,
-        ))
-    }
-}
-
-/// Parse a hexadecimal integer from a string.
-///
-/// # Errors
-///
-/// This function returns an error if no [`BigInt`] could be parsed from
-/// the string.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// let actual = "0x0".parse::<Number>().unwrap().number;
-/// let expected = Number::BigInt(BigInt::zero());
-/// assert_eq!(actual, expected);
-/// ```
-fn parse_hexadecimal(s: &str) -> Result<PreciseNumber, ParseNumberError> {
-    let (is_neg, s) = if s.starts_with('-') {
-        (true, &s[3..])
-    } else {
-        (false, &s[2..])
-    };
-
-    if s.starts_with('-') || s.starts_with('+') {
-        // Even though this is more like an invalid hexadecimal number,
-        // GNU reports this as an invalid floating point number, so we
-        // use `ParseNumberError::Float` to match that behavior.
-        return Err(ParseNumberError::Float);
     }
 
-    let num = BigInt::from_str_radix(s, 16).map_err(|_| ParseNumberError::Hex)?;
-
-    match (is_neg, num == BigInt::zero()) {
-        (true, true) => Ok(PreciseNumber::new(
-            Number::Int(ExtendedBigInt::MinusZero),
-            2,
-            0,
-        )),
-        (true, false) => Ok(PreciseNumber::new(
-            Number::Int(ExtendedBigInt::BigInt(-num)),
-            0,
-            0,
-        )),
-        (false, _) => Ok(PreciseNumber::new(
-            Number::Int(ExtendedBigInt::BigInt(num)),
-            0,
-            0,
-        )),
+    PreciseNumber {
+        number: ebd,
+        num_integral_digits: int_digits,
+        num_fractional_digits: Some(frac_digits),
     }
 }
 
+// Note: We could also have provided an `ExtendedParser` implementation for
+// PreciseNumber, but we want a simpler custom error.
 impl FromStr for PreciseNumber {
     type Err = ParseNumberError;
-    fn from_str(mut s: &str) -> Result<Self, Self::Err> {
-        // Trim leading whitespace.
-        s = s.trim_start();
-
-        // Trim a single leading "+" character.
-        if s.starts_with('+') {
-            s = &s[1..];
-        }
-
-        // Check if the string seems to be in hexadecimal format.
-        //
-        // May be 0x123 or -0x123, so the index `i` may be either 0 or 1.
-        if let Some(i) = s.to_lowercase().find("0x") {
-            if i <= 1 {
-                return parse_hexadecimal(s);
-            }
-        }
+    fn from_str(input: &str) -> Result<Self, Self::Err> {
+        let ebd = match ExtendedBigDecimal::extended_parse(input) {
+            Ok(ebd) => match ebd {
+                // Handle special values
+                ExtendedBigDecimal::BigDecimal(_) | ExtendedBigDecimal::MinusZero => {
+                    // TODO: GNU `seq` treats small numbers < 1e-4950 as 0, we could do the same
+                    // to avoid printing senselessly small numbers.
+                    ebd
+                }
+                ExtendedBigDecimal::Infinity | ExtendedBigDecimal::MinusInfinity => {
+                    return Ok(PreciseNumber {
+                        number: ebd,
+                        num_integral_digits: 0,
+                        num_fractional_digits: Some(0),
+                    });
+                }
+                ExtendedBigDecimal::Nan | ExtendedBigDecimal::MinusNan => {
+                    return Err(ParseNumberError::Nan);
+                }
+            },
+            Err(ExtendedParserError::Underflow(ebd)) => ebd, // Treat underflow as 0
+            Err(_) => return Err(ParseNumberError::Float),
+        };
 
-        // Find the decimal point and the exponent symbol. Parse the
-        // number differently depending on its form. This is important
-        // because the form of the input dictates how the output will be
-        // presented.
-        match (s.find('.'), s.find('e')) {
-            // For example, "123456" or "inf".
-            (None, None) => parse_no_decimal_no_exponent(s),
-            // For example, "123e456" or "1e-2".
-            (None, Some(j)) => parse_exponent_no_decimal(s, j),
-            // For example, "123.456".
-            (Some(i), None) => parse_decimal_no_exponent(s, i),
-            // For example, "123.456e789".
-            (Some(i), Some(j)) if i < j => parse_decimal_and_exponent(s, i, j),
-            // For example, "1e2.3" or "1.2.3".
-            _ => Err(ParseNumberError::Float),
-        }
+        Ok(compute_num_digits(input, ebd))
     }
 }
 
 #[cfg(test)]
 mod tests {
-
     use bigdecimal::BigDecimal;
-    use num_bigint::BigInt;
-    use num_traits::Zero;
+    use uucore::extendedbigdecimal::ExtendedBigDecimal;
 
-    use crate::extendedbigdecimal::ExtendedBigDecimal;
-    use crate::extendedbigint::ExtendedBigInt;
-    use crate::number::Number;
     use crate::number::PreciseNumber;
     use crate::numberparse::ParseNumberError;
 
     /// Convenience function for parsing a [`Number`] and unwrapping.
-    fn parse(s: &str) -> Number {
+    fn parse(s: &str) -> ExtendedBigDecimal {
         s.parse::<PreciseNumber>().unwrap().number
     }
 
@@ -404,45 +144,54 @@ mod tests {
 
     /// Convenience function for getting the number of fractional digits.
     fn num_fractional_digits(s: &str) -> usize {
-        s.parse::<PreciseNumber>().unwrap().num_fractional_digits
+        s.parse::<PreciseNumber>()
+            .unwrap()
+            .num_fractional_digits
+            .unwrap()
+    }
+
+    /// Convenience function for making sure the number of fractional digits is "None"
+    fn num_fractional_digits_is_none(s: &str) -> bool {
+        s.parse::<PreciseNumber>()
+            .unwrap()
+            .num_fractional_digits
+            .is_none()
     }
 
     #[test]
     fn test_parse_minus_zero_int() {
-        assert_eq!(parse("-0e0"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0e-0"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0e1"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0e+1"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0.0e1"), Number::Int(ExtendedBigInt::MinusZero));
-        assert_eq!(parse("-0x0"), Number::Int(ExtendedBigInt::MinusZero));
+        assert_eq!(parse("-0e0"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e-0"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e+1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0.0e1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0x0"), ExtendedBigDecimal::MinusZero);
     }
 
     #[test]
     fn test_parse_minus_zero_float() {
-        assert_eq!(parse("-0.0"), Number::Float(ExtendedBigDecimal::MinusZero));
-        assert_eq!(parse("-0e-1"), Number::Float(ExtendedBigDecimal::MinusZero));
-        assert_eq!(
-            parse("-0.0e-1"),
-            Number::Float(ExtendedBigDecimal::MinusZero)
-        );
+        assert_eq!(parse("-0.0"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0e-1"), ExtendedBigDecimal::MinusZero);
+        assert_eq!(parse("-0.0e-1"), ExtendedBigDecimal::MinusZero);
     }
 
     #[test]
     fn test_parse_big_int() {
-        assert_eq!(parse("0"), Number::Int(ExtendedBigInt::zero()));
-        assert_eq!(parse("0.1e1"), Number::Int(ExtendedBigInt::one()));
+        assert_eq!(parse("0"), ExtendedBigDecimal::zero());
+        assert_eq!(parse("0.1e1"), ExtendedBigDecimal::one());
+        assert_eq!(parse("0.1E1"), ExtendedBigDecimal::one());
         assert_eq!(
             parse("1.0e1"),
-            Number::Int(ExtendedBigInt::BigInt("10".parse::<BigInt>().unwrap()))
+            ExtendedBigDecimal::BigDecimal("10".parse::<BigDecimal>().unwrap())
         );
     }
 
     #[test]
     fn test_parse_hexadecimal_big_int() {
-        assert_eq!(parse("0x0"), Number::Int(ExtendedBigInt::zero()));
+        assert_eq!(parse("0x0"), ExtendedBigDecimal::zero());
         assert_eq!(
             parse("0x10"),
-            Number::Int(ExtendedBigInt::BigInt("16".parse::<BigInt>().unwrap()))
+            ExtendedBigDecimal::BigDecimal("16".parse::<BigDecimal>().unwrap())
         );
     }
 
@@ -450,44 +199,34 @@ mod tests {
     fn test_parse_big_decimal() {
         assert_eq!(
             parse("0.0"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "0.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("0.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse(".0"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "0.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("0.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse("1.0"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "1.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("1.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse("10e-1"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "1.0".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("1.0".parse::<BigDecimal>().unwrap())
         );
         assert_eq!(
             parse("-1e-3"),
-            Number::Float(ExtendedBigDecimal::BigDecimal(
-                "-0.001".parse::<BigDecimal>().unwrap()
-            ))
+            ExtendedBigDecimal::BigDecimal("-0.001".parse::<BigDecimal>().unwrap())
         );
     }
 
     #[test]
     fn test_parse_inf() {
-        assert_eq!(parse("inf"), Number::Float(ExtendedBigDecimal::Infinity));
-        assert_eq!(parse("+inf"), Number::Float(ExtendedBigDecimal::Infinity));
-        assert_eq!(
-            parse("-inf"),
-            Number::Float(ExtendedBigDecimal::MinusInfinity)
-        );
+        assert_eq!(parse("inf"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("infinity"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("+inf"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("+infinity"), ExtendedBigDecimal::Infinity);
+        assert_eq!(parse("-inf"), ExtendedBigDecimal::MinusInfinity);
+        assert_eq!(parse("-infinity"), ExtendedBigDecimal::MinusInfinity);
     }
 
     #[test]
@@ -514,7 +253,7 @@ mod tests {
     fn test_parse_invalid_hex() {
         assert_eq!(
             "0xg".parse::<PreciseNumber>().unwrap_err(),
-            ParseNumberError::Hex
+            ParseNumberError::Float
         );
     }
 
@@ -543,6 +282,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_num_integral_digits() {
         // no decimal, no exponent
         assert_eq!(num_integral_digits("123"), 3);
@@ -552,12 +292,12 @@ mod tests {
         assert_eq!(num_integral_digits("-.1"), 2);
         // exponent, no decimal
         assert_eq!(num_integral_digits("123e4"), 3 + 4);
-        assert_eq!(num_integral_digits("123e-4"), 1);
+        assert_eq!(num_integral_digits("123e-4"), 3);
         assert_eq!(num_integral_digits("-1e-3"), 2);
         // decimal and exponent
         assert_eq!(num_integral_digits("123.45e6"), 3 + 6);
-        assert_eq!(num_integral_digits("123.45e-6"), 1);
-        assert_eq!(num_integral_digits("123.45e-1"), 2);
+        assert_eq!(num_integral_digits("123.45e-6"), 3);
+        assert_eq!(num_integral_digits("123.45e-1"), 3);
         assert_eq!(num_integral_digits("-0.1e0"), 2);
         assert_eq!(num_integral_digits("-0.1e2"), 4);
         assert_eq!(num_integral_digits("-.1e0"), 2);
@@ -583,6 +323,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_num_fractional_digits() {
         // no decimal, no exponent
         assert_eq!(num_fractional_digits("123"), 0);
@@ -617,5 +358,23 @@ mod tests {
         assert_eq!(num_fractional_digits("-0.0"), 1);
         assert_eq!(num_fractional_digits("-0e-1"), 1);
         assert_eq!(num_fractional_digits("-0.0e-1"), 2);
+        // Hexadecimal numbers
+        assert_eq!(num_fractional_digits("0xff"), 0);
+        assert!(num_fractional_digits_is_none("0xff.1"));
+    }
+
+    #[test]
+    fn test_parse_min_exponents() {
+        // Make sure exponents < i64::MIN do not cause errors
+        assert!("1e-9223372036854775807".parse::<PreciseNumber>().is_ok());
+        assert!("1e-9223372036854775808".parse::<PreciseNumber>().is_ok());
+        assert!("1e-92233720368547758080".parse::<PreciseNumber>().is_ok());
+    }
+
+    #[test]
+    fn test_parse_max_exponents() {
+        // Make sure exponents much bigger than i64::MAX cause errors
+        assert!("1e9223372036854775807".parse::<PreciseNumber>().is_ok());
+        assert!("1e92233720368547758070".parse::<PreciseNumber>().is_err());
     }
 }
diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs
index 4f04b377eae..af7ca2f84d0 100644
--- a/src/uu/seq/src/seq.rs
+++ b/src/uu/seq/src/seq.rs
@@ -2,28 +2,30 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (ToDO) istr chiter argptr ilen extendedbigdecimal extendedbigint numberparse
-use std::io::{stdout, ErrorKind, Write};
-use std::process::exit;
+// spell-checker:ignore (ToDO) bigdecimal extendedbigdecimal numberparse hexadecimalfloat biguint
+use std::ffi::OsString;
+use std::io::{BufWriter, ErrorKind, Write, stdout};
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
+use num_bigint::BigUint;
+use num_traits::ToPrimitive;
 use num_traits::Zero;
 
-use uucore::error::FromIo;
-use uucore::error::UResult;
-use uucore::memo::printf;
-use uucore::show;
-use uucore::{format_usage, help_about, help_usage};
+use uucore::error::{FromIo, UResult};
+use uucore::extendedbigdecimal::ExtendedBigDecimal;
+use uucore::format::num_format::FloatVariant;
+use uucore::format::{Format, num_format};
+use uucore::{fast_inc::fast_inc, format_usage, help_about, help_usage};
 
 mod error;
-mod extendedbigdecimal;
-mod extendedbigint;
+
+// public to allow fuzzing
+#[cfg(fuzzing)]
+pub mod number;
+#[cfg(not(fuzzing))]
 mod number;
 mod numberparse;
 use crate::error::SeqError;
-use crate::extendedbigdecimal::ExtendedBigDecimal;
-use crate::extendedbigint::ExtendedBigInt;
-use crate::number::Number;
 use crate::number::PreciseNumber;
 
 const ABOUT: &str = help_about!("seq.md");
@@ -44,19 +46,54 @@ struct SeqOptions<'a> {
     format: Option<&'a str>,
 }
 
-/// A range of integers.
-///
-/// The elements are (first, increment, last).
-type RangeInt = (ExtendedBigInt, ExtendedBigInt, ExtendedBigInt);
-
 /// A range of floats.
 ///
 /// The elements are (first, increment, last).
 type RangeFloat = (ExtendedBigDecimal, ExtendedBigDecimal, ExtendedBigDecimal);
 
+// Turn short args with attached value, for example "-s,", into two args "-s" and "," to make
+// them work with clap.
+fn split_short_args_with_value(args: impl uucore::Args) -> impl uucore::Args {
+    let mut v: Vec<OsString> = Vec::new();
+
+    for arg in args {
+        let bytes = arg.as_encoded_bytes();
+
+        if bytes.len() > 2
+            && (bytes.starts_with(b"-f") || bytes.starts_with(b"-s") || bytes.starts_with(b"-t"))
+        {
+            let (short_arg, value) = bytes.split_at(2);
+            // SAFETY:
+            // Both `short_arg` and `value` only contain content that originated from `OsStr::as_encoded_bytes`
+            v.push(unsafe { OsString::from_encoded_bytes_unchecked(short_arg.to_vec()) });
+            v.push(unsafe { OsString::from_encoded_bytes_unchecked(value.to_vec()) });
+        } else {
+            v.push(arg);
+        }
+    }
+
+    v.into_iter()
+}
+
+fn select_precision(
+    first: &PreciseNumber,
+    increment: &PreciseNumber,
+    last: &PreciseNumber,
+) -> Option<usize> {
+    match (
+        first.num_fractional_digits,
+        increment.num_fractional_digits,
+        last.num_fractional_digits,
+    ) {
+        (Some(0), Some(0), Some(0)) => Some(0),
+        (Some(f), Some(i), Some(_)) => Some(f.max(i)),
+        _ => None,
+    }
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
+    let matches = uu_app().try_get_matches_from(split_short_args_with_value(args))?;
 
     let numbers_option = matches.get_many::<String>(ARG_NUMBERS);
 
@@ -69,8 +106,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let options = SeqOptions {
         separator: matches
             .get_one::<String>(OPT_SEPARATOR)
-            .map(|s| s.as_str())
-            .unwrap_or("\n")
+            .map_or("\n", |s| s.as_str())
             .to_string(),
         terminator: matches
             .get_one::<String>(OPT_TERMINATOR)
@@ -81,6 +117,10 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         format: matches.get_one::<String>(OPT_FORMAT).map(|s| s.as_str()),
     };
 
+    if options.equal_width && options.format.is_some() {
+        return Err(SeqError::FormatAndEqualWidth.into());
+    }
+
     let first = if numbers.len() > 1 {
         match numbers[0].parse() {
             Ok(num) => num,
@@ -111,53 +151,77 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     };
 
-    let padding = first
-        .num_integral_digits
-        .max(increment.num_integral_digits)
-        .max(last.num_integral_digits);
-    let largest_dec = first
-        .num_fractional_digits
-        .max(increment.num_fractional_digits);
-
-    let result = match (first.number, increment.number, last.number) {
-        (Number::Int(first), Number::Int(increment), last) => {
-            let last = last.round_towards(&first);
-            print_seq_integers(
-                (first, increment, last),
-                &options.separator,
-                &options.terminator,
-                options.equal_width,
+    // If a format was passed on the command line, use that.
+    // If not, use some default format based on parameters precision.
+    let (format, padding, fast_allowed) = match options.format {
+        Some(str) => (
+            Format::<num_format::Float, &ExtendedBigDecimal>::parse(str)?,
+            0,
+            false,
+        ),
+        None => {
+            let precision = select_precision(&first, &increment, &last);
+
+            let padding = if options.equal_width {
+                let precision_value = precision.unwrap_or(0);
+                first
+                    .num_integral_digits
+                    .max(increment.num_integral_digits)
+                    .max(last.num_integral_digits)
+                    + if precision_value > 0 {
+                        precision_value + 1
+                    } else {
+                        0
+                    }
+            } else {
+                0
+            };
+
+            let formatter = match precision {
+                // format with precision: decimal floats and integers
+                Some(precision) => num_format::Float {
+                    variant: FloatVariant::Decimal,
+                    width: padding,
+                    alignment: num_format::NumberAlignment::RightZero,
+                    precision: Some(precision),
+                    ..Default::default()
+                },
+                // format without precision: hexadecimal floats
+                None => num_format::Float {
+                    variant: FloatVariant::Shortest,
+                    ..Default::default()
+                },
+            };
+            // Allow fast printing if precision is 0 (integer inputs), `print_seq` will do further checks.
+            (
+                Format::from_formatter(formatter),
                 padding,
-                options.format,
+                precision == Some(0),
             )
         }
-        (first, increment, last) => print_seq(
-            (
-                first.into_extended_big_decimal(),
-                increment.into_extended_big_decimal(),
-                last.into_extended_big_decimal(),
-            ),
-            largest_dec,
-            &options.separator,
-            &options.terminator,
-            options.equal_width,
-            padding,
-            options.format,
-        ),
     };
+
+    let result = print_seq(
+        (first.number, increment.number, last.number),
+        &options.separator,
+        &options.terminator,
+        &format,
+        fast_allowed,
+        padding,
+    );
+
     match result {
-        Ok(_) => Ok(()),
+        Ok(()) => Ok(()),
         Err(err) if err.kind() == ErrorKind::BrokenPipe => Ok(()),
-        Err(e) => Err(e.map_err_context(|| "write error".into())),
+        Err(err) => Err(err.map_err_context(|| "write error".into())),
     }
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .trailing_var_arg(true)
-        .allow_negative_numbers(true)
         .infer_long_args(true)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .arg(
@@ -186,12 +250,81 @@ pub fn uu_app() -> Command {
                 .help("use printf style floating-point FORMAT"),
         )
         .arg(
+            // we use allow_hyphen_values instead of allow_negative_numbers because clap removed
+            // the support for "exotic" negative numbers like -.1 (see https://github.com/clap-rs/clap/discussions/5837)
             Arg::new(ARG_NUMBERS)
+                .allow_hyphen_values(true)
                 .action(ArgAction::Append)
                 .num_args(1..=3),
         )
 }
 
+/// Integer print, default format, positive increment: fast code path
+/// that avoids reformating digit at all iterations.
+fn fast_print_seq(
+    mut stdout: impl Write,
+    first: &BigUint,
+    increment: u64,
+    last: &BigUint,
+    separator: &str,
+    terminator: &str,
+    padding: usize,
+) -> std::io::Result<()> {
+    // Nothing to do, just return.
+    if last < first {
+        return Ok(());
+    }
+
+    // Do at most u64::MAX loops. We can print in the order of 1e8 digits per second,
+    // u64::MAX is 1e19, so it'd take hundreds of years for this to complete anyway.
+    // TODO: we can move this test to `print_seq` if we care about this case.
+    let loop_cnt = ((last - first) / increment).to_u64().unwrap_or(u64::MAX);
+
+    // Format the first number.
+    let first_str = first.to_string();
+
+    // Makeshift log10.ceil
+    let last_length = last.to_string().len();
+
+    // Allocate a large u8 buffer, that contains a preformatted string
+    // of the number followed by the `separator`.
+    //
+    // | ... head space ... | number | separator |
+    // ^0                   ^ start  ^ num_end   ^ size (==buf.len())
+    //
+    // We keep track of start in this buffer, as the number grows.
+    // When printing, we take a slice between start and end.
+    let size = last_length.max(padding) + separator.len();
+    // Fill with '0', this is needed for equal_width, and harmless otherwise.
+    let mut buf = vec![b'0'; size];
+    let buf = buf.as_mut_slice();
+
+    let num_end = buf.len() - separator.len();
+    let mut start = num_end - first_str.len();
+
+    // Initialize buf with first and separator.
+    buf[start..num_end].copy_from_slice(first_str.as_bytes());
+    buf[num_end..].copy_from_slice(separator.as_bytes());
+
+    // Normally, if padding is > 0, it should be equal to last_length,
+    // so start would be == 0, but there are corner cases.
+    start = start.min(num_end - padding);
+
+    // Prepare the number to increment with as a string
+    let inc_str = increment.to_string();
+    let inc_str = inc_str.as_bytes();
+
+    for _ in 0..loop_cnt {
+        stdout.write_all(&buf[start..])?;
+        fast_inc(buf, &mut start, num_end, inc_str);
+    }
+    // Write the last number without separator, but with terminator.
+    stdout.write_all(&buf[start..num_end])?;
+    write!(stdout, "{terminator}")?;
+    stdout.flush()?;
+    Ok(())
+}
+
 fn done_printing<T: Zero + PartialOrd>(next: &T, increment: &T, last: &T) -> bool {
     if increment >= &T::zero() {
         next > last
@@ -200,152 +333,57 @@ fn done_printing<T: Zero + PartialOrd>(next: &T, increment: &T, last: &T) -> boo
     }
 }
 
-/// Write a big decimal formatted according to the given parameters.
-fn write_value_float(
-    writer: &mut impl Write,
-    value: &ExtendedBigDecimal,
-    width: usize,
-    precision: usize,
-) -> std::io::Result<()> {
-    let value_as_str =
-        if *value == ExtendedBigDecimal::Infinity || *value == ExtendedBigDecimal::MinusInfinity {
-            format!("{value:>width$.precision$}")
-        } else {
-            format!("{value:>0width$.precision$}")
-        };
-    write!(writer, "{value_as_str}")
-}
-
-/// Write a big int formatted according to the given parameters.
-fn write_value_int(
-    writer: &mut impl Write,
-    value: &ExtendedBigInt,
-    width: usize,
-    pad: bool,
-) -> std::io::Result<()> {
-    let value_as_str = if pad {
-        if *value == ExtendedBigInt::MinusZero {
-            format!("{value:0<width$}")
-        } else {
-            format!("{value:>0width$}")
-        }
-    } else {
-        format!("{value}")
-    };
-    write!(writer, "{value_as_str}")
-}
-
-// TODO `print_seq()` and `print_seq_integers()` are nearly identical,
-// they could be refactored into a single more general function.
-
-/// Floating point based code path
+/// Arbitrary precision decimal number code path ("slow" path)
 fn print_seq(
     range: RangeFloat,
-    largest_dec: usize,
     separator: &str,
     terminator: &str,
-    pad: bool,
-    padding: usize,
-    format: Option<&str>,
+    format: &Format<num_format::Float, &ExtendedBigDecimal>,
+    fast_allowed: bool,
+    padding: usize, // Used by fast path only
 ) -> std::io::Result<()> {
-    let stdout = stdout();
-    let mut stdout = stdout.lock();
+    let stdout = stdout().lock();
+    let mut stdout = BufWriter::new(stdout);
     let (first, increment, last) = range;
-    let mut value = first;
-    let padding = if pad { padding + 1 + largest_dec } else { 0 };
-    let mut is_first_iteration = true;
-    while !done_printing(&value, &increment, &last) {
-        if !is_first_iteration {
-            write!(stdout, "{separator}")?;
-        }
-        // If there was an argument `-f FORMAT`, then use that format
-        // template instead of the default formatting strategy.
-        //
-        // TODO The `printf()` method takes a string as its second
-        // parameter but we have an `ExtendedBigDecimal`. In order to
-        // satisfy the signature of the function, we convert the
-        // `ExtendedBigDecimal` into a string. The `printf()`
-        // logic will subsequently parse that string into something
-        // similar to an `ExtendedBigDecimal` again before rendering
-        // it as a string and ultimately writing to `stdout`. We
-        // shouldn't have to do so much converting back and forth via
-        // strings.
-        match format {
-            Some(f) => {
-                let s = format!("{value}");
-                if let Err(x) = printf(f, &[s]) {
-                    show!(x);
-                    exit(1);
-                }
-            }
-            None => write_value_float(&mut stdout, &value, padding, largest_dec)?,
+
+    if fast_allowed {
+        // Test if we can use fast code path.
+        // First try to convert the range to BigUint (u64 for the increment).
+        let (first_bui, increment_u64, last_bui) = (
+            first.to_biguint(),
+            increment.to_biguint().and_then(|x| x.to_u64()),
+            last.to_biguint(),
+        );
+        if let (Some(first_bui), Some(increment_u64), Some(last_bui)) =
+            (first_bui, increment_u64, last_bui)
+        {
+            return fast_print_seq(
+                stdout,
+                &first_bui,
+                increment_u64,
+                &last_bui,
+                separator,
+                terminator,
+                padding,
+            );
         }
-        // TODO Implement augmenting addition.
-        value = value + increment.clone();
-        is_first_iteration = false;
-    }
-    if !is_first_iteration {
-        write!(stdout, "{terminator}")?;
     }
-    stdout.flush()?;
-    Ok(())
-}
 
-/// Print an integer sequence.
-///
-/// This function prints a sequence of integers defined by `range`,
-/// which defines the first integer, last integer, and increment of the
-/// range. The `separator` is inserted between each integer and
-/// `terminator` is inserted at the end.
-///
-/// The `pad` parameter indicates whether to pad numbers to the width
-/// given in `padding`.
-///
-/// If `is_first_minus_zero` is `true`, then the `first` parameter is
-/// printed as if it were negative zero, even though no such number
-/// exists as an integer (negative zero only exists for floating point
-/// numbers). Only set this to `true` if `first` is actually zero.
-fn print_seq_integers(
-    range: RangeInt,
-    separator: &str,
-    terminator: &str,
-    pad: bool,
-    padding: usize,
-    format: Option<&str>,
-) -> std::io::Result<()> {
-    let stdout = stdout();
-    let mut stdout = stdout.lock();
-    let (first, increment, last) = range;
     let mut value = first;
+
     let mut is_first_iteration = true;
     while !done_printing(&value, &increment, &last) {
         if !is_first_iteration {
-            write!(stdout, "{separator}")?;
-        }
-        // If there was an argument `-f FORMAT`, then use that format
-        // template instead of the default formatting strategy.
-        //
-        // The `printf()` function takes in the template and
-        // the current value and writes the result to `stdout`.
-        //
-        // TODO See similar comment about formatting in `print_seq()`.
-        match format {
-            Some(f) => {
-                let s = format!("{value}");
-                if let Err(x) = printf(f, &[s]) {
-                    show!(x);
-                    exit(1);
-                }
-            }
-            None => write_value_int(&mut stdout, &value, padding, pad)?,
+            stdout.write_all(separator.as_bytes())?;
         }
+        format.fmt(&mut stdout, &value)?;
         // TODO Implement augmenting addition.
         value = value + increment.clone();
         is_first_iteration = false;
     }
-
     if !is_first_iteration {
-        write!(stdout, "{terminator}")?;
+        stdout.write_all(terminator.as_bytes())?;
     }
+    stdout.flush()?;
     Ok(())
 }
diff --git a/src/uu/shred/Cargo.toml b/src/uu/shred/Cargo.toml
index 70045eaf07f..6b90299a16d 100644
--- a/src/uu/shred/Cargo.toml
+++ b/src/uu/shred/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_shred"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "shred ~ (uutils) hide former FILE contents with repeated overwrites"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/shred"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/shred.rs"
@@ -17,7 +20,7 @@ path = "src/shred.rs"
 [dependencies]
 clap = { workspace = true }
 rand = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 libc = { workspace = true }
 
 [[bin]]
diff --git a/src/uu/shred/src/shred.rs b/src/uu/shred/src/shred.rs
index 9b1f7fc9831..30777e28acd 100644
--- a/src/uu/shred/src/shred.rs
+++ b/src/uu/shred/src/shred.rs
@@ -5,19 +5,20 @@
 
 // spell-checker:ignore (words) wipesync prefill
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 #[cfg(unix)]
 use libc::S_IWUSR;
-use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
+use rand::{Rng, SeedableRng, rngs::StdRng, seq::SliceRandom};
 use std::fs::{self, File, OpenOptions};
-use std::io::{self, Seek, Write};
+use std::io::{self, Read, 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::parse_size::parse_size;
-use uucore::{format_usage, help_about, help_section, help_usage, show, show_error, show_if_err};
+use uucore::parser::parse_size::parse_size_u64;
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
+use uucore::{format_usage, help_about, help_section, help_usage, show_error, show_if_err};
 
 const ABOUT: &str = help_about!("shred.md");
 const USAGE: &str = help_usage!("shred.md");
@@ -28,10 +29,18 @@ pub mod options {
     pub const FILE: &str = "file";
     pub const ITERATIONS: &str = "iterations";
     pub const SIZE: &str = "size";
+    pub const WIPESYNC: &str = "u";
     pub const REMOVE: &str = "remove";
     pub const VERBOSE: &str = "verbose";
     pub const EXACT: &str = "exact";
     pub const ZERO: &str = "zero";
+    pub const RANDOM_SOURCE: &str = "random-source";
+
+    pub mod remove {
+        pub const UNLINK: &str = "unlink";
+        pub const WIPE: &str = "wipe";
+        pub const WIPESYNC: &str = "wipesync";
+    }
 }
 
 // This block size seems to match GNU (2^16 = 65536)
@@ -41,10 +50,15 @@ const NAME_CHARSET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN
 const PATTERN_LENGTH: usize = 3;
 const PATTERN_BUFFER_SIZE: usize = BLOCK_SIZE + PATTERN_LENGTH - 1;
 
+/// Optimal block size for the filesystem. This constant is used for data size alignment, similar
+/// to the behavior of GNU shred. Usually, optimal block size is a 4K block (2^12), which is why
+/// it's defined as a constant. However, it's possible to get the actual size at runtime using, for
+/// example, `std::os::unix::fs::MetadataExt::blksize()`.
+const OPTIMAL_IO_BLOCK_SIZE: usize = 1 << 12;
+
 /// 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.
+/// A single-byte pattern is equivalent to a multi-byte pattern of that byte three times.
 const PATTERNS: [Pattern; 22] = [
     Pattern::Single(b'\x00'),
     Pattern::Single(b'\xFF'),
@@ -81,6 +95,14 @@ enum PassType {
     Random,
 }
 
+#[derive(PartialEq, Clone, Copy)]
+enum RemoveMethod {
+    None,     // Default method. Only obfuscate the file data
+    Unlink,   // The same as 'None' + unlink the file
+    Wipe,     // The same as 'Unlink' + obfuscate the file name before unlink
+    WipeSync, // The same as 'Wipe' sync the file name changes
+}
+
 /// 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
@@ -131,16 +153,25 @@ impl Iterator for FilenameIter {
     }
 }
 
+enum RandomSource {
+    System,
+    Read(File),
+}
+
 /// 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 {
+enum BytesWriter<'a> {
     Random {
         rng: StdRng,
         buffer: [u8; BLOCK_SIZE],
     },
+    RandomFile {
+        rng_file: &'a File,
+        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
@@ -156,12 +187,18 @@ enum BytesWriter {
     },
 }
 
-impl BytesWriter {
-    fn from_pass_type(pass: &PassType) -> Self {
+impl<'a> BytesWriter<'a> {
+    fn from_pass_type(pass: &PassType, random_source: &'a RandomSource) -> Self {
         match pass {
-            PassType::Random => Self::Random {
-                rng: StdRng::from_entropy(),
-                buffer: [0; BLOCK_SIZE],
+            PassType::Random => match random_source {
+                RandomSource::System => Self::Random {
+                    rng: StdRng::from_os_rng(),
+                    buffer: [0; BLOCK_SIZE],
+                },
+                RandomSource::Read(file) => Self::RandomFile {
+                    rng_file: file,
+                    buffer: [0; BLOCK_SIZE],
+                },
             },
             PassType::Pattern(pattern) => {
                 // Copy the pattern in chunks rather than simply one byte at a time
@@ -182,17 +219,22 @@ impl BytesWriter {
         }
     }
 
-    fn bytes_for_pass(&mut self, size: usize) -> &[u8] {
+    fn bytes_for_pass(&mut self, size: usize) -> Result<&[u8], io::Error> {
         match self {
             Self::Random { rng, buffer } => {
                 let bytes = &mut buffer[..size];
                 rng.fill(bytes);
-                bytes
+                Ok(bytes)
+            }
+            Self::RandomFile { rng_file, buffer } => {
+                let bytes = &mut buffer[..size];
+                rng_file.read_exact(bytes)?;
+                Ok(bytes)
             }
             Self::Pattern { offset, buffer } => {
                 let bytes = &buffer[*offset..size + *offset];
                 *offset = (*offset + size) % PATTERN_LENGTH;
-                bytes
+                Ok(bytes)
             }
         }
     }
@@ -200,8 +242,6 @@ impl BytesWriter {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     if !matches.contains_id(options::FILE) {
@@ -215,23 +255,40 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
                 return Err(USimpleError::new(
                     1,
                     format!("invalid number of passes: {}", s.quote()),
-                ))
+                ));
             }
         },
         None => unreachable!(),
     };
 
-    // TODO: implement --remove HOW
-    //       The optional HOW parameter indicates how to remove a directory entry:
-    //         - 'unlink' => use a standard unlink call.
-    //         - 'wipe' => also first obfuscate bytes in the name.
-    //         - 'wipesync' => also sync each obfuscated byte to disk.
-    //       The default mode is 'wipesync', but note it can be expensive.
-
+    let random_source = match matches.get_one::<String>(options::RANDOM_SOURCE) {
+        Some(filepath) => RandomSource::Read(File::open(filepath).map_err(|_| {
+            USimpleError::new(
+                1,
+                format!("cannot open random source: {}", filepath.quote()),
+            )
+        })?),
+        None => RandomSource::System,
+    };
     // TODO: implement --random-source
 
+    let remove_method = if matches.get_flag(options::WIPESYNC) {
+        RemoveMethod::WipeSync
+    } else if matches.contains_id(options::REMOVE) {
+        match matches
+            .get_one::<String>(options::REMOVE)
+            .map(AsRef::as_ref)
+        {
+            Some(options::remove::UNLINK) => RemoveMethod::Unlink,
+            Some(options::remove::WIPE) => RemoveMethod::Wipe,
+            Some(options::remove::WIPESYNC) => RemoveMethod::WipeSync,
+            _ => unreachable!("should be caught by clap"),
+        }
+    } else {
+        RemoveMethod::None
+    };
+
     let force = matches.get_flag(options::FORCE);
-    let remove = matches.get_flag(options::REMOVE);
     let size_arg = matches
         .get_one::<String>(options::SIZE)
         .map(|s| s.to_string());
@@ -242,7 +299,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     for path_str in matches.get_many::<String>(options::FILE).unwrap() {
         show_if_err!(wipe_file(
-            path_str, iterations, remove, size, exact, zero, verbose, force,
+            path_str,
+            iterations,
+            remove_method,
+            size,
+            exact,
+            zero,
+            &random_source,
+            verbose,
+            force,
         ));
     }
     Ok(())
@@ -250,7 +315,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -278,12 +343,26 @@ pub fn uu_app() -> Command {
                 .help("shred this many bytes (suffixes like K, M, G accepted)"),
         )
         .arg(
-            Arg::new(options::REMOVE)
+            Arg::new(options::WIPESYNC)
                 .short('u')
-                .long(options::REMOVE)
-                .help("truncate and remove file after overwriting;  See below")
+                .help("deallocate and remove file after overwriting")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::REMOVE)
+                .long(options::REMOVE)
+                .value_name("HOW")
+                .value_parser(ShortcutValueParser::new([
+                    options::remove::UNLINK,
+                    options::remove::WIPE,
+                    options::remove::WIPESYNC,
+                ]))
+                .num_args(0..=1)
+                .require_equals(true)
+                .default_missing_value(options::remove::WIPESYNC)
+                .help("like -u but give control on HOW to delete;  See below")
+                .action(ArgAction::Set),
+        )
         .arg(
             Arg::new(options::VERBOSE)
                 .long(options::VERBOSE)
@@ -308,6 +387,13 @@ pub fn uu_app() -> Command {
                 .help("add a final overwrite with zeros to hide shredding")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new(options::RANDOM_SOURCE)
+                .long(options::RANDOM_SOURCE)
+                .help("take random bytes from FILE")
+                .value_hint(clap::ValueHint::FilePath)
+                .action(ArgAction::Set),
+        )
         // Positional arguments
         .arg(
             Arg::new(options::FILE)
@@ -319,10 +405,11 @@ pub fn uu_app() -> Command {
 fn get_size(size_str_opt: Option<String>) -> Option<u64> {
     size_str_opt
         .as_ref()
-        .and_then(|size| parse_size(size.as_str()).ok())
+        .and_then(|size| parse_size_u64(size.as_str()).ok())
         .or_else(|| {
             if let Some(size) = size_str_opt {
                 show_error!("invalid file size: {}", size.quote());
+                // TODO: replace with our error management
                 std::process::exit(1);
             }
             None
@@ -332,8 +419,8 @@ fn get_size(size_str_opt: Option<String>) -> Option<u64> {
 fn pass_name(pass_type: &PassType) -> String {
     match pass_type {
         PassType::Random => String::from("random"),
-        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}"),
+        PassType::Pattern(Pattern::Single(byte)) => format!("{byte:02x}{byte:02x}{byte:02x}"),
+        PassType::Pattern(Pattern::Multi([a, b, c])) => format!("{a:02x}{b:02x}{c:02x}"),
     }
 }
 
@@ -342,10 +429,11 @@ fn pass_name(pass_type: &PassType) -> String {
 fn wipe_file(
     path_str: &str,
     n_passes: usize,
-    remove: bool,
+    remove_method: RemoveMethod,
     size: Option<u64>,
     exact: bool,
     zero: bool,
+    random_source: &RandomSource,
     verbose: bool,
     force: bool,
 ) -> UResult<()> {
@@ -364,17 +452,18 @@ fn wipe_file(
         ));
     }
 
+    let metadata = fs::metadata(path).map_err_context(String::new)?;
+
     // If force is true, set file permissions to not-readonly.
     if force {
-        let metadata = fs::metadata(path).map_err_context(String::new)?;
         let mut perms = metadata.permissions();
         #[cfg(unix)]
-        #[allow(clippy::useless_conversion)]
+        #[allow(clippy::useless_conversion, clippy::unnecessary_cast)]
         {
             // 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));
+            // NOTE: S_IWUSR type is u16 on macOS, i32 on Redox.
+            if (perms.mode() & (S_IWUSR as u32)) == 0 {
+                perms.set_mode(S_IWUSR as u32);
             }
         }
         #[cfg(not(unix))]
@@ -386,38 +475,45 @@ fn wipe_file(
 
     // Fill up our pass sequence
     let mut pass_sequence = Vec::new();
+    if metadata.len() != 0 {
+        // Only add passes if the file is non-empty
 
-    if n_passes <= 3 {
-        // Only random passes if n_passes <= 3
-        for _ in 0..n_passes {
+        if n_passes <= 3 {
+            // Only random passes if n_passes <= 3
+            for _ in 0..n_passes {
+                pass_sequence.push(PassType::Random);
+            }
+        } else {
+            // Add initial random to avoid O(n) operation later
             pass_sequence.push(PassType::Random);
-        }
-    } 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 {
-                pass_sequence.push(PassType::Pattern(p));
+            let n_random = (n_passes / 10).max(3); // Minimum 3 random passes; ratio of 10 after
+            let n_fixed = n_passes - n_random;
+            // Fill it with Patterns and all but the first and last random, then shuffle it
+            let n_full_arrays = n_fixed / PATTERNS.len(); // How many times can we go through all the patterns?
+            let remainder = n_fixed % PATTERNS.len(); // How many do we get through on our last time through, excluding randoms?
+
+            for _ in 0..n_full_arrays {
+                for p in PATTERNS {
+                    pass_sequence.push(PassType::Pattern(p));
+                }
+            }
+            for pattern in PATTERNS.into_iter().take(remainder) {
+                pass_sequence.push(PassType::Pattern(pattern));
+            }
+            // add random passes except one each at the beginning and end
+            for _ in 0..n_random - 2 {
+                pass_sequence.push(PassType::Random);
             }
-        }
-        for pattern in PATTERNS.into_iter().take(remainder) {
-            pass_sequence.push(PassType::Pattern(pattern));
-        }
-        let mut rng = rand::thread_rng();
-        pass_sequence.shuffle(&mut rng); // randomize the order of application
 
-        let n_random = 3 + n_passes / 10; // Minimum 3 random passes; ratio of 10 after
-                                          // Evenly space random passes; ensures one at the beginning and end
-        for i in 0..n_random {
-            pass_sequence[i * (n_passes - 1) / (n_random - 1)] = PassType::Random;
+            let mut rng = rand::rng();
+            pass_sequence[1..].shuffle(&mut rng); // randomize the order of application
+            pass_sequence.push(PassType::Random); // add the last random pass
         }
-    }
 
-    // --zero specifies whether we want one final pass of 0x00 on our file
-    if zero {
-        pass_sequence.push(PassType::Pattern(PATTERNS[0]));
+        // --zero specifies whether we want one final pass of 0x00 on our file
+        if zero {
+            pass_sequence.push(PassType::Pattern(PATTERNS[0]));
+        }
     }
 
     let total_passes = pass_sequence.len();
@@ -429,81 +525,81 @@ fn wipe_file(
 
     let size = match size {
         Some(size) => size,
-        None => get_file_size(path)?,
+        None => metadata.len(),
     };
 
     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
-                );
-            }
+            show_error!(
+                "{}: pass {}/{total_passes} ({pass_name})...",
+                path.maybe_quote(),
+                i + 1,
+            );
         }
         // 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())));
+        show_if_err!(
+            do_pass(&mut file, &pass_type, exact, random_source, size)
+                .map_err_context(|| format!("{}: File write pass failed", path.maybe_quote()))
+        );
     }
 
-    if remove {
-        do_remove(path, path_str, verbose)
+    if remove_method != RemoveMethod::None {
+        do_remove(path, path_str, verbose, remove_method)
             .map_err_context(|| format!("{}: failed to remove file", path.maybe_quote()))?;
     }
     Ok(())
 }
 
+fn split_on_blocks(file_size: u64, exact: bool) -> (u64, u64) {
+    // OPTIMAL_IO_BLOCK_SIZE must not exceed BLOCK_SIZE. Violating this may cause overflows due
+    // to alignment or performance issues.This kind of misconfiguration is
+    // highly unlikely but would indicate a serious error.
+    const _: () = assert!(OPTIMAL_IO_BLOCK_SIZE <= BLOCK_SIZE);
+
+    let file_size = if exact {
+        file_size
+    } else {
+        // The main idea here is to align the file size to the OPTIMAL_IO_BLOCK_SIZE, and then
+        // split it into BLOCK_SIZE + remaining bytes. Since the input data is already aligned to N
+        // * OPTIMAL_IO_BLOCK_SIZE, the output file size will also be aligned and correct.
+        file_size.div_ceil(OPTIMAL_IO_BLOCK_SIZE as u64) * OPTIMAL_IO_BLOCK_SIZE as u64
+    };
+    (file_size / BLOCK_SIZE as u64, file_size % BLOCK_SIZE as u64)
+}
+
 fn do_pass(
     file: &mut File,
     pass_type: &PassType,
     exact: bool,
+    random_source: &RandomSource,
     file_size: u64,
 ) -> Result<(), io::Error> {
     // We might be at the end of the file due to a previous iteration, so rewind.
     file.rewind()?;
 
-    let mut writer = BytesWriter::from_pass_type(pass_type);
+    let mut writer = BytesWriter::from_pass_type(pass_type, random_source);
+    let (number_of_blocks, bytes_left) = split_on_blocks(file_size, exact);
 
     // 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);
+    for _ in 0..number_of_blocks {
+        let block = writer.bytes_for_pass(BLOCK_SIZE)?;
         file.write_all(block)?;
     }
 
-    // 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)?;
-    }
+    // Then we write remaining data which is smaller than the BLOCK_SIZE
+    let block = writer.bytes_for_pass(bytes_left as usize)?;
+    file.write_all(block)?;
 
     file.sync_data()?;
 
     Ok(())
 }
 
-fn get_file_size(path: &Path) -> Result<u64, io::Error> {
-    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> {
+fn wipe_name(orig_path: &Path, verbose: bool, remove_method: RemoveMethod) -> Option<PathBuf> {
     let file_name_len = orig_path.file_name().unwrap().to_str().unwrap().len();
 
     let mut last_path = PathBuf::from(orig_path);
@@ -524,28 +620,30 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
                         show_error!(
                             "{}: renamed to {}",
                             last_path.maybe_quote(),
-                            new_path.quote()
+                            new_path.display()
                         );
                     }
 
-                    // Sync every file rename
-                    let new_file = OpenOptions::new()
-                        .write(true)
-                        .open(new_path.clone())
-                        .expect("Failed to open renamed file for syncing");
-                    new_file.sync_all().expect("Failed to sync renamed file");
+                    if remove_method == RemoveMethod::WipeSync {
+                        // Sync every file rename
+                        let new_file = OpenOptions::new()
+                            .write(true)
+                            .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) => {
                     show_error!(
-                        "{}: Couldn't rename to {}: {}",
+                        "{}: Couldn't rename to {}: {e}",
                         last_path.maybe_quote(),
                         new_path.quote(),
-                        e
                     );
-                    return None;
+                    // TODO: replace with our error management
+                    std::process::exit(1);
                 }
             }
         }
@@ -554,12 +652,23 @@ fn wipe_name(orig_path: &Path, verbose: bool) -> Option<PathBuf> {
     Some(last_path)
 }
 
-fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::Error> {
+fn do_remove(
+    path: &Path,
+    orig_filename: &str,
+    verbose: bool,
+    remove_method: RemoveMethod,
+) -> Result<(), io::Error> {
     if verbose {
         show_error!("{}: removing", orig_filename.maybe_quote());
     }
 
-    if let Some(rp) = wipe_name(path, verbose) {
+    let remove_path = if remove_method == RemoveMethod::Unlink {
+        Some(path.with_file_name(orig_filename))
+    } else {
+        wipe_name(path, verbose, remove_method)
+    };
+
+    if let Some(rp) = remove_path {
         fs::remove_file(rp)?;
     }
 
@@ -569,3 +678,40 @@ fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::{BLOCK_SIZE, OPTIMAL_IO_BLOCK_SIZE, split_on_blocks};
+
+    #[test]
+    fn test_align_non_exact_control_values() {
+        // Note: This test only makes sense for the default values of BLOCK_SIZE and
+        // OPTIMAL_IO_BLOCK_SIZE.
+        assert_eq!(split_on_blocks(1, false), (0, 4096));
+        assert_eq!(split_on_blocks(4095, false), (0, 4096));
+        assert_eq!(split_on_blocks(4096, false), (0, 4096));
+        assert_eq!(split_on_blocks(4097, false), (0, 8192));
+        assert_eq!(split_on_blocks(65535, false), (1, 0));
+        assert_eq!(split_on_blocks(65536, false), (1, 0));
+        assert_eq!(split_on_blocks(65537, false), (1, 4096));
+    }
+
+    #[test]
+    fn test_align_non_exact_cycle() {
+        for size in 1..BLOCK_SIZE as u64 * 2 {
+            let (number_of_blocks, bytes_left) = split_on_blocks(size, false);
+            let test_size = number_of_blocks * BLOCK_SIZE as u64 + bytes_left;
+            assert_eq!(test_size % OPTIMAL_IO_BLOCK_SIZE as u64, 0);
+        }
+    }
+
+    #[test]
+    fn test_align_exact_cycle() {
+        for size in 1..BLOCK_SIZE as u64 * 2 {
+            let (number_of_blocks, bytes_left) = split_on_blocks(size, true);
+            let test_size = number_of_blocks * BLOCK_SIZE as u64 + bytes_left;
+            assert_eq!(test_size, size);
+        }
+    }
+}
diff --git a/src/uu/shuf/BENCHMARKING.md b/src/uu/shuf/BENCHMARKING.md
index 6fa9028afce..d16b1afb03b 100644
--- a/src/uu/shuf/BENCHMARKING.md
+++ b/src/uu/shuf/BENCHMARKING.md
@@ -3,7 +3,7 @@
 # Benchmarking shuf
 
 `shuf` is a simple utility, but there are at least two important cases
-benchmark: with and without repetition.
+to benchmark: with and without repetition.
 
 When benchmarking changes, make sure to always build with the `--release` flag.
 You can compare with another branch by compiling on that branch and then
@@ -28,11 +28,11 @@ a range of numbers to randomly sample from. An example of a command that works
 well for testing:
 
 ```shell
-hyperfine --warmup 10 "target/release/shuf -i 0-10000000"
+hyperfine --warmup 10 "target/release/shuf -i 0-10000000 > /dev/null"
 ```
 
 To measure the time taken by shuffling an input file, the following command can
-be used::
+be used:
 
 ```shell
 hyperfine --warmup 10 "target/release/shuf input.txt > /dev/null"
@@ -49,5 +49,14 @@ should be benchmarked separately. In this case, we have to pass the `-n` flag or
 the command will run forever. An example of a hyperfine command is
 
 ```shell
-hyperfine --warmup 10 "target/release/shuf -r -n 10000000 -i 0-1000"
+hyperfine --warmup 10 "target/release/shuf -r -n 10000000 -i 0-1000 > /dev/null"
+```
+
+## With huge interval ranges
+
+When `shuf` runs with huge interval ranges, special care must be taken, so it
+should be benchmarked separately also. An example of a hyperfine command is
+
+```shell
+hyperfine --warmup 10 "target/release/shuf -n 100 -i 1000-2000000000 > /dev/null"
 ```
diff --git a/src/uu/shuf/Cargo.toml b/src/uu/shuf/Cargo.toml
index 2f0466b86fa..83dca2bb65e 100644
--- a/src/uu/shuf/Cargo.toml
+++ b/src/uu/shuf/Cargo.toml
@@ -1,22 +1,24 @@
 [package]
 name = "uu_shuf"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "shuf ~ (uutils) display random permutations of input lines"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/shuf"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/shuf.rs"
 
 [dependencies]
 clap = { workspace = true }
-memchr = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
 uucore = { workspace = true }
diff --git a/src/uu/shuf/shuf.md b/src/uu/shuf/shuf.md
index b59799c3378..7bc1e0a6d60 100644
--- a/src/uu/shuf/shuf.md
+++ b/src/uu/shuf/shuf.md
@@ -3,7 +3,7 @@
 ```
 shuf [OPTION]... [FILE]
 shuf -e [OPTION]... [ARG]...
-shuf -i LO-HI [OPTION]...;
+shuf -i LO-HI [OPTION]...
 ```
 
 Shuffle the input by outputting a random permutation of input lines.
diff --git a/src/uu/shuf/src/rand_read_adapter.rs b/src/uu/shuf/src/rand_read_adapter.rs
index 728bc0cfbbd..3f504c03d2b 100644
--- a/src/uu/shuf/src/rand_read_adapter.rs
+++ b/src/uu/shuf/src/rand_read_adapter.rs
@@ -16,7 +16,7 @@
 use std::fmt;
 use std::io::Read;
 
-use rand_core::{impls, Error, RngCore};
+use rand_core::{RngCore, impls};
 
 /// An RNG that reads random bytes straight from any type supporting
 /// [`std::io::Read`], for example files.
@@ -30,11 +30,10 @@ use rand_core::{impls, Error, RngCore};
 ///
 /// `ReadRng` uses [`std::io::Read::read_exact`], which retries on interrupts.
 /// All other errors from the underlying reader, including when it does not
-/// have enough data, will only be reported through [`try_fill_bytes`].
+/// have enough data, will only be reported through `try_fill_bytes`.
 /// The other [`RngCore`] methods will panic in case of an error.
 ///
 /// [`OsRng`]: rand::rngs::OsRng
-/// [`try_fill_bytes`]: RngCore::try_fill_bytes
 #[derive(Debug)]
 pub struct ReadRng<R> {
     reader: R,
@@ -45,6 +44,14 @@ impl<R: Read> ReadRng<R> {
     pub fn new(r: R) -> Self {
         Self { reader: r }
     }
+
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), ReadError> {
+        if dest.is_empty() {
+            return Ok(());
+        }
+        // Use `std::io::read_exact`, which retries on `ErrorKind::Interrupted`.
+        self.reader.read_exact(dest).map_err(ReadError)
+    }
 }
 
 impl<R: Read> RngCore for ReadRng<R> {
@@ -61,16 +68,6 @@ impl<R: Read> RngCore for ReadRng<R> {
             panic!("reading random bytes from Read implementation failed; error: {err}");
         });
     }
-
-    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
-        if dest.is_empty() {
-            return Ok(());
-        }
-        // Use `std::io::read_exact`, which retries on `ErrorKind::Interrupted`.
-        self.reader
-            .read_exact(dest)
-            .map_err(|e| Error::new(ReadError(e)))
-    }
 }
 
 /// `ReadRng` error type
@@ -128,7 +125,7 @@ mod test {
         let mut rng = ReadRng::new(&v[..]);
         rng.fill_bytes(&mut w);
 
-        assert!(v == w);
+        assert_eq!(v, w);
     }
 
     #[test]
diff --git a/src/uu/shuf/src/shuf.rs b/src/uu/shuf/src/shuf.rs
index 1b21b953274..9c08ea28d6f 100644
--- a/src/uu/shuf/src/shuf.rs
+++ b/src/uu/shuf/src/shuf.rs
@@ -3,24 +3,30 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) cmdline evec seps rvec fdata
+// spell-checker:ignore (ToDO) cmdline evec nonrepeating seps shufable rvec fdata
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use memchr::memchr_iter;
+use clap::builder::ValueParser;
+use clap::{Arg, ArgAction, Command};
 use rand::prelude::SliceRandom;
-use rand::RngCore;
+use rand::seq::IndexedRandom;
+use rand::{Rng, RngCore};
+use std::collections::HashSet;
+use std::ffi::{OsStr, OsString};
 use std::fs::File;
-use std::io::{stdin, stdout, BufReader, BufWriter, Read, Write};
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
+use std::io::{BufWriter, Error, Read, Write, stdin, stdout};
+use std::ops::RangeInclusive;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+use uucore::display::{OsWrite, Quotable};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
 use uucore::{format_usage, help_about, help_usage};
 
 mod rand_read_adapter;
 
 enum Mode {
-    Default(String),
-    Echo(Vec<String>),
-    InputRange((usize, usize)),
+    Default(PathBuf),
+    Echo(Vec<OsString>),
+    InputRange(RangeInclusive<usize>),
 }
 
 static USAGE: &str = help_usage!("shuf.md");
@@ -28,8 +34,8 @@ static ABOUT: &str = help_about!("shuf.md");
 
 struct Options {
     head_count: usize,
-    output: Option<String>,
-    random_source: Option<String>,
+    output: Option<PathBuf>,
+    random_source: Option<PathBuf>,
     repeat: bool,
     sep: u8,
 }
@@ -42,74 +48,93 @@ mod options {
     pub static RANDOM_SOURCE: &str = "random-source";
     pub static REPEAT: &str = "repeat";
     pub static ZERO_TERMINATED: &str = "zero-terminated";
-    pub static FILE: &str = "file";
+    pub static FILE_OR_ARGS: &str = "file-or-args";
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
-    let mode = if let Some(args) = matches.get_many::<String>(options::ECHO) {
-        Mode::Echo(args.map(String::from).collect())
-    } else if let Some(range) = matches.get_one::<String>(options::INPUT_RANGE) {
-        match parse_range(range) {
-            Ok(m) => Mode::InputRange(m),
-            Err(msg) => {
-                return Err(USimpleError::new(1, msg));
-            }
-        }
-    } else {
-        Mode::Default(
+    let mode = if matches.get_flag(options::ECHO) {
+        Mode::Echo(
             matches
-                .get_one::<String>(options::FILE)
-                .map(|s| s.as_str())
-                .unwrap_or("-")
-                .to_string(),
+                .get_many(options::FILE_OR_ARGS)
+                .unwrap_or_default()
+                .cloned()
+                .collect(),
         )
+    } else if let Some(range) = matches.get_one(options::INPUT_RANGE).cloned() {
+        Mode::InputRange(range)
+    } else {
+        let mut operands = matches
+            .get_many::<OsString>(options::FILE_OR_ARGS)
+            .unwrap_or_default();
+        let file = operands.next().cloned().unwrap_or("-".into());
+        if let Some(second_file) = operands.next() {
+            return Err(UUsageError::new(
+                1,
+                format!("unexpected argument {} found", second_file.quote()),
+            ));
+        };
+        Mode::Default(file.into())
     };
 
     let options = Options {
-        head_count: {
-            let headcounts = matches
-                .get_many::<String>(options::HEAD_COUNT)
-                .unwrap_or_default()
-                .map(|s| s.to_owned())
-                .collect();
-            match parse_head_count(headcounts) {
-                Ok(val) => val,
-                Err(msg) => return Err(USimpleError::new(1, msg)),
-            }
-        },
-        output: matches.get_one::<String>(options::OUTPUT).map(String::from),
-        random_source: matches
-            .get_one::<String>(options::RANDOM_SOURCE)
-            .map(String::from),
+        // GNU shuf takes the lowest value passed, so we imitate that.
+        // It's probably a bug or an implementation artifact though.
+        // Busybox takes the final value which is more typical: later
+        // options override earlier options.
+        head_count: matches
+            .get_many::<usize>(options::HEAD_COUNT)
+            .unwrap_or_default()
+            .copied()
+            .min()
+            .unwrap_or(usize::MAX),
+        output: matches.get_one(options::OUTPUT).cloned(),
+        random_source: matches.get_one(options::RANDOM_SOURCE).cloned(),
         repeat: matches.get_flag(options::REPEAT),
         sep: if matches.get_flag(options::ZERO_TERMINATED) {
-            0x00_u8
+            b'\0'
         } else {
-            0x0a_u8
+            b'\n'
         },
     };
 
+    let mut output = BufWriter::new(match options.output {
+        None => Box::new(stdout()) as Box<dyn OsWrite>,
+        Some(ref s) => {
+            let file = File::create(s)
+                .map_err_context(|| format!("failed to open {} for writing", s.quote()))?;
+            Box::new(file) as Box<dyn OsWrite>
+        }
+    });
+
+    if options.head_count == 0 {
+        // In this case we do want to touch the output file but we can quit immediately.
+        return Ok(());
+    }
+
+    let mut rng = match options.random_source {
+        Some(ref r) => {
+            let file = File::open(r)
+                .map_err_context(|| format!("failed to open random source {}", r.quote()))?;
+            WrappedRng::RngFile(rand_read_adapter::ReadRng::new(file))
+        }
+        None => WrappedRng::RngDefault(rand::rng()),
+    };
+
     match mode {
         Mode::Echo(args) => {
-            let mut evec = args.iter().map(String::as_bytes).collect::<Vec<_>>();
-            find_seps(&mut evec, options.sep);
-            shuf_bytes(&mut evec, options)?;
+            let mut evec: Vec<&OsStr> = args.iter().map(AsRef::as_ref).collect();
+            shuf_exec(&mut evec, &options, &mut rng, &mut output)?;
         }
-        Mode::InputRange((b, e)) => {
-            let rvec = (b..e).map(|x| format!("{x}")).collect::<Vec<String>>();
-            let mut rvec = rvec.iter().map(String::as_bytes).collect::<Vec<&[u8]>>();
-            shuf_bytes(&mut rvec, options)?;
+        Mode::InputRange(mut range) => {
+            shuf_exec(&mut range, &options, &mut rng, &mut output)?;
         }
         Mode::Default(filename) => {
             let fdata = read_input_file(&filename)?;
-            let mut fdata = vec![&fdata[..]];
-            find_seps(&mut fdata, options.sep);
-            shuf_bytes(&mut fdata, options)?;
+            let mut items = split_seps(&fdata, options.sep);
+            shuf_exec(&mut items, &options, &mut rng, &mut output)?;
         }
     }
 
@@ -119,18 +144,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
         .about(ABOUT)
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
-        .args_override_self(true)
         .arg(
             Arg::new(options::ECHO)
                 .short('e')
                 .long(options::ECHO)
-                .value_name("ARG")
                 .help("treat each ARG as an input line")
-                .use_value_delimiter(false)
-                .num_args(0..)
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::ECHO)
                 .conflicts_with(options::INPUT_RANGE),
         )
         .arg(
@@ -139,14 +162,17 @@ pub fn uu_app() -> Command {
                 .long(options::INPUT_RANGE)
                 .value_name("LO-HI")
                 .help("treat each number LO through HI as an input line")
-                .conflicts_with(options::FILE),
+                .value_parser(parse_range)
+                .conflicts_with(options::FILE_OR_ARGS),
         )
         .arg(
             Arg::new(options::HEAD_COUNT)
                 .short('n')
                 .long(options::HEAD_COUNT)
                 .value_name("COUNT")
-                .help("output at most COUNT lines"),
+                .action(ArgAction::Append)
+                .help("output at most COUNT lines")
+                .value_parser(usize::from_str),
         )
         .arg(
             Arg::new(options::OUTPUT)
@@ -154,6 +180,7 @@ pub fn uu_app() -> Command {
                 .long(options::OUTPUT)
                 .value_name("FILE")
                 .help("write result to FILE instead of standard output")
+                .value_parser(ValueParser::path_buf())
                 .value_hint(clap::ValueHint::FilePath),
         )
         .arg(
@@ -161,6 +188,7 @@ pub fn uu_app() -> Command {
                 .long(options::RANDOM_SOURCE)
                 .value_name("FILE")
                 .help("get random bytes from FILE")
+                .value_parser(ValueParser::path_buf())
                 .value_hint(clap::ValueHint::FilePath),
         )
         .arg(
@@ -168,133 +196,266 @@ pub fn uu_app() -> Command {
                 .short('r')
                 .long(options::REPEAT)
                 .help("output lines can be repeated")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::REPEAT),
         )
         .arg(
             Arg::new(options::ZERO_TERMINATED)
                 .short('z')
                 .long(options::ZERO_TERMINATED)
                 .help("line delimiter is NUL, not newline")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::ZERO_TERMINATED),
+        )
+        .arg(
+            Arg::new(options::FILE_OR_ARGS)
+                .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
+                .value_hint(clap::ValueHint::FilePath),
         )
-        .arg(Arg::new(options::FILE).value_hint(clap::ValueHint::FilePath))
 }
 
-fn read_input_file(filename: &str) -> UResult<Vec<u8>> {
-    let mut file = BufReader::new(if filename == "-" {
-        Box::new(stdin()) as Box<dyn Read>
+fn read_input_file(filename: &Path) -> UResult<Vec<u8>> {
+    if filename.as_os_str() == "-" {
+        let mut data = Vec::new();
+        stdin()
+            .read_to_end(&mut data)
+            .map_err_context(|| "read error".into())?;
+        Ok(data)
     } else {
-        let file = File::open(filename)
-            .map_err_context(|| format!("failed to open {}", filename.quote()))?;
-        Box::new(file) as Box<dyn Read>
-    });
+        std::fs::read(filename).map_err_context(|| filename.maybe_quote().to_string())
+    }
+}
 
-    let mut data = Vec::new();
-    file.read_to_end(&mut data)
-        .map_err_context(|| format!("failed reading {}", filename.quote()))?;
+fn split_seps(data: &[u8], sep: u8) -> Vec<&[u8]> {
+    // A single trailing separator is ignored.
+    // If data is empty (and does not even contain a single 'sep'
+    // to indicate the presence of an empty element), then behave
+    // as if the input contained no elements at all.
+    let mut elements: Vec<&[u8]> = data.split(|&b| b == sep).collect();
+    if elements.last().is_some_and(|e| e.is_empty()) {
+        elements.pop();
+    }
+    elements
+}
 
-    Ok(data)
+trait Shufable {
+    type Item: Writable;
+    fn is_empty(&self) -> bool;
+    fn choose(&self, rng: &mut WrappedRng) -> Self::Item;
+    fn partial_shuffle<'b>(
+        &'b mut self,
+        rng: &'b mut WrappedRng,
+        amount: usize,
+    ) -> impl Iterator<Item = Self::Item>;
 }
 
-fn find_seps(data: &mut Vec<&[u8]>, sep: u8) {
-    // need to use for loop so we don't borrow the vector as we modify it in place
-    // basic idea:
-    // * We don't care about the order of the result. This lets us slice the slices
-    //   without making a new vector.
-    // * Starting from the end of the vector, we examine each element.
-    // * If that element contains the separator, we remove it from the vector,
-    //   and then sub-slice it into slices that do not contain the separator.
-    // * We maintain the invariant throughout that each element in the vector past
-    //   the ith element does not have any separators remaining.
-    for i in (0..data.len()).rev() {
-        if data[i].contains(&sep) {
-            let this = data.swap_remove(i);
-            let mut p = 0;
-            for i in memchr_iter(sep, this) {
-                data.push(&this[p..i]);
-                p = i + 1;
+impl<'a> Shufable for Vec<&'a [u8]> {
+    type Item = &'a [u8];
+    fn is_empty(&self) -> bool {
+        (**self).is_empty()
+    }
+    fn choose(&self, rng: &mut WrappedRng) -> Self::Item {
+        // Note: "copied()" only copies the reference, not the entire [u8].
+        // Returns None if the slice is empty. We checked this before, so
+        // this is safe.
+        (**self).choose(rng).unwrap()
+    }
+    fn partial_shuffle<'b>(
+        &'b mut self,
+        rng: &'b mut WrappedRng,
+        amount: usize,
+    ) -> impl Iterator<Item = Self::Item> {
+        // Note: "copied()" only copies the reference, not the entire [u8].
+        (**self).partial_shuffle(rng, amount).0.iter().copied()
+    }
+}
+
+impl<'a> Shufable for Vec<&'a OsStr> {
+    type Item = &'a OsStr;
+    fn is_empty(&self) -> bool {
+        (**self).is_empty()
+    }
+    fn choose(&self, rng: &mut WrappedRng) -> Self::Item {
+        (**self).choose(rng).unwrap()
+    }
+    fn partial_shuffle<'b>(
+        &'b mut self,
+        rng: &'b mut WrappedRng,
+        amount: usize,
+    ) -> impl Iterator<Item = Self::Item> {
+        (**self).partial_shuffle(rng, amount).0.iter().copied()
+    }
+}
+
+impl Shufable for RangeInclusive<usize> {
+    type Item = usize;
+    fn is_empty(&self) -> bool {
+        self.is_empty()
+    }
+    fn choose(&self, rng: &mut WrappedRng) -> usize {
+        rng.random_range(self.clone())
+    }
+    fn partial_shuffle<'b>(
+        &'b mut self,
+        rng: &'b mut WrappedRng,
+        amount: usize,
+    ) -> impl Iterator<Item = Self::Item> {
+        NonrepeatingIterator::new(self.clone(), rng, amount)
+    }
+}
+
+enum NumberSet {
+    AlreadyListed(HashSet<usize>),
+    Remaining(Vec<usize>),
+}
+
+struct NonrepeatingIterator<'a> {
+    range: RangeInclusive<usize>,
+    rng: &'a mut WrappedRng,
+    remaining_count: usize,
+    buf: NumberSet,
+}
+
+impl<'a> NonrepeatingIterator<'a> {
+    fn new(range: RangeInclusive<usize>, rng: &'a mut WrappedRng, amount: usize) -> Self {
+        let capped_amount = if range.start() > range.end() {
+            0
+        } else if range == (0..=usize::MAX) {
+            amount
+        } else {
+            amount.min(range.end() - range.start() + 1)
+        };
+        NonrepeatingIterator {
+            range,
+            rng,
+            remaining_count: capped_amount,
+            buf: NumberSet::AlreadyListed(HashSet::default()),
+        }
+    }
+
+    fn produce(&mut self) -> usize {
+        debug_assert!(self.range.start() <= self.range.end());
+        match &mut self.buf {
+            NumberSet::AlreadyListed(already_listed) => {
+                let chosen = loop {
+                    let guess = self.rng.random_range(self.range.clone());
+                    let newly_inserted = already_listed.insert(guess);
+                    if newly_inserted {
+                        break guess;
+                    }
+                };
+                // Once a significant fraction of the interval has already been enumerated,
+                // the number of attempts to find a number that hasn't been chosen yet increases.
+                // Therefore, we need to switch at some point from "set of already returned values" to "list of remaining values".
+                let range_size = (self.range.end() - self.range.start()).saturating_add(1);
+                if number_set_should_list_remaining(already_listed.len(), range_size) {
+                    let mut remaining = self
+                        .range
+                        .clone()
+                        .filter(|n| !already_listed.contains(n))
+                        .collect::<Vec<_>>();
+                    assert!(remaining.len() >= self.remaining_count);
+                    remaining.partial_shuffle(&mut self.rng, self.remaining_count);
+                    remaining.truncate(self.remaining_count);
+                    self.buf = NumberSet::Remaining(remaining);
+                }
+                chosen
             }
-            if p < this.len() {
-                data.push(&this[p..]);
+            NumberSet::Remaining(remaining_numbers) => {
+                debug_assert!(!remaining_numbers.is_empty());
+                // We only enter produce() when there is at least one actual element remaining, so popping must always return an element.
+                remaining_numbers.pop().unwrap()
             }
         }
     }
 }
 
-fn shuf_bytes(input: &mut Vec<&[u8]>, opts: Options) -> UResult<()> {
-    let mut output = BufWriter::new(match opts.output {
-        None => Box::new(stdout()) as Box<dyn Write>,
-        Some(s) => {
-            let file = File::create(&s[..])
-                .map_err_context(|| format!("failed to open {} for writing", s.quote()))?;
-            Box::new(file) as Box<dyn Write>
-        }
-    });
+impl Iterator for NonrepeatingIterator<'_> {
+    type Item = usize;
 
-    let mut rng = match opts.random_source {
-        Some(r) => {
-            let file = File::open(&r[..])
-                .map_err_context(|| format!("failed to open random source {}", r.quote()))?;
-            WrappedRng::RngFile(rand_read_adapter::ReadRng::new(file))
+    fn next(&mut self) -> Option<usize> {
+        if self.range.is_empty() || self.remaining_count == 0 {
+            return None;
         }
-        None => WrappedRng::RngDefault(rand::thread_rng()),
-    };
+        self.remaining_count -= 1;
+        Some(self.produce())
+    }
+}
 
-    if input.is_empty() {
-        return Ok(());
+// This could be a method, but it is much easier to test as a stand-alone function.
+fn number_set_should_list_remaining(listed_count: usize, range_size: usize) -> bool {
+    // Arbitrarily determine the switchover point to be around 25%. This is because:
+    // - HashSet has a large space overhead for the hash table load factor.
+    // - This means that somewhere between 25-40%, the memory required for a "positive" HashSet and a "negative" Vec should be the same.
+    // - HashSet has a small but non-negligible overhead for each lookup, so we have a slight preference for Vec anyway.
+    // - At 25%, on average 1.33 attempts are needed to find a number that hasn't been taken yet.
+    // - Finally, "24%" is computationally the simplest:
+    listed_count >= range_size / 4
+}
+
+trait Writable {
+    fn write_all_to(&self, output: &mut impl OsWrite) -> Result<(), Error>;
+}
+
+impl Writable for &[u8] {
+    fn write_all_to(&self, output: &mut impl OsWrite) -> Result<(), Error> {
+        output.write_all(self)
     }
+}
 
+impl Writable for &OsStr {
+    fn write_all_to(&self, output: &mut impl OsWrite) -> Result<(), Error> {
+        output.write_all_os(self)
+    }
+}
+
+impl Writable for usize {
+    fn write_all_to(&self, output: &mut impl OsWrite) -> Result<(), Error> {
+        write!(output, "{self}")
+    }
+}
+
+fn shuf_exec(
+    input: &mut impl Shufable,
+    opts: &Options,
+    rng: &mut WrappedRng,
+    output: &mut BufWriter<Box<dyn OsWrite>>,
+) -> UResult<()> {
+    let ctx = || "write failed".to_string();
     if opts.repeat {
+        if input.is_empty() {
+            return Err(USimpleError::new(1, "no lines to repeat"));
+        }
         for _ in 0..opts.head_count {
-            // Returns None is the slice is empty. We checked this before, so
-            // this is safe.
-            let r = input.choose(&mut rng).unwrap();
-
-            output
-                .write_all(r)
-                .map_err_context(|| "write failed".to_string())?;
-            output
-                .write_all(&[opts.sep])
-                .map_err_context(|| "write failed".to_string())?;
+            let r = input.choose(rng);
+
+            r.write_all_to(output).map_err_context(ctx)?;
+            output.write_all(&[opts.sep]).map_err_context(ctx)?;
         }
     } else {
-        let (shuffled, _) = input.partial_shuffle(&mut rng, opts.head_count);
+        let shuffled = input.partial_shuffle(rng, opts.head_count);
         for r in shuffled {
-            output
-                .write_all(r)
-                .map_err_context(|| "write failed".to_string())?;
-            output
-                .write_all(&[opts.sep])
-                .map_err_context(|| "write failed".to_string())?;
+            r.write_all_to(output).map_err_context(ctx)?;
+            output.write_all(&[opts.sep]).map_err_context(ctx)?;
         }
     }
 
     Ok(())
 }
 
-fn parse_range(input_range: &str) -> Result<(usize, usize), String> {
+fn parse_range(input_range: &str) -> Result<RangeInclusive<usize>, String> {
     if let Some((from, to)) = input_range.split_once('-') {
-        let begin = from
-            .parse::<usize>()
-            .map_err(|_| format!("invalid input range: {}", from.quote()))?;
-        let end = to
-            .parse::<usize>()
-            .map_err(|_| format!("invalid input range: {}", to.quote()))?;
-        Ok((begin, end + 1))
-    } else {
-        Err(format!("invalid input range: {}", input_range.quote()))
-    }
-}
-
-fn parse_head_count(headcounts: Vec<String>) -> Result<usize, String> {
-    let mut result = std::usize::MAX;
-    for count in headcounts {
-        match count.parse::<usize>() {
-            Ok(pv) => result = std::cmp::min(result, pv),
-            Err(_) => return Err(format!("invalid line count: {}", count.quote())),
+        let begin = from.parse::<usize>().map_err(|e| e.to_string())?;
+        let end = to.parse::<usize>().map_err(|e| e.to_string())?;
+        if begin <= end || begin == end + 1 {
+            Ok(begin..=end)
+        } else {
+            Err("start exceeds end".into())
         }
+    } else {
+        Err("missing '-'".into())
     }
-    Ok(result)
 }
 
 enum WrappedRng {
@@ -323,11 +484,111 @@ impl RngCore for WrappedRng {
             Self::RngDefault(r) => r.fill_bytes(dest),
         }
     }
+}
 
-    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
-        match self {
-            Self::RngFile(r) => r.try_fill_bytes(dest),
-            Self::RngDefault(r) => r.try_fill_bytes(dest),
-        }
+#[cfg(test)]
+mod test_split_seps {
+    use super::split_seps;
+
+    #[test]
+    fn test_empty_input() {
+        assert!(split_seps(b"", b'\n').is_empty());
+    }
+
+    #[test]
+    fn test_single_blank_line() {
+        assert_eq!(split_seps(b"\n", b'\n'), &[b""]);
+    }
+
+    #[test]
+    fn test_with_trailing() {
+        assert_eq!(split_seps(b"a\nb\nc\n", b'\n'), &[b"a", b"b", b"c"]);
+    }
+
+    #[test]
+    fn test_without_trailing() {
+        assert_eq!(split_seps(b"a\nb\nc", b'\n'), &[b"a", b"b", b"c"]);
+    }
+}
+
+#[cfg(test)]
+// Since the computed value is a bool, it is more readable to write the expected value out:
+#[allow(clippy::bool_assert_comparison)]
+mod test_number_set_decision {
+    use super::number_set_should_list_remaining;
+
+    #[test]
+    fn test_stay_positive_large_remaining_first() {
+        assert_eq!(false, number_set_should_list_remaining(0, usize::MAX));
+    }
+
+    #[test]
+    fn test_stay_positive_large_remaining_second() {
+        assert_eq!(false, number_set_should_list_remaining(1, usize::MAX));
+    }
+
+    #[test]
+    fn test_stay_positive_large_remaining_tenth() {
+        assert_eq!(false, number_set_should_list_remaining(9, usize::MAX));
+    }
+
+    #[test]
+    fn test_stay_positive_smallish_range_first() {
+        assert_eq!(false, number_set_should_list_remaining(0, 12345));
+    }
+
+    #[test]
+    fn test_stay_positive_smallish_range_second() {
+        assert_eq!(false, number_set_should_list_remaining(1, 12345));
+    }
+
+    #[test]
+    fn test_stay_positive_smallish_range_tenth() {
+        assert_eq!(false, number_set_should_list_remaining(9, 12345));
+    }
+
+    #[test]
+    fn test_stay_positive_small_range_not_too_early() {
+        assert_eq!(false, number_set_should_list_remaining(1, 10));
+    }
+
+    // Don't want to test close to the border, in case we decide to change the threshold.
+    // However, at 50% coverage, we absolutely should switch:
+    #[test]
+    fn test_switch_half() {
+        assert_eq!(true, number_set_should_list_remaining(1234, 2468));
+    }
+
+    // Ensure that the decision is monotonous:
+    #[test]
+    fn test_switch_late1() {
+        assert_eq!(true, number_set_should_list_remaining(12340, 12345));
+    }
+
+    #[test]
+    fn test_switch_late2() {
+        assert_eq!(true, number_set_should_list_remaining(12344, 12345));
+    }
+
+    // Ensure that we are overflow-free:
+    #[test]
+    fn test_no_crash_exceed_max_size1() {
+        assert_eq!(false, number_set_should_list_remaining(12345, usize::MAX));
+    }
+
+    #[test]
+    fn test_no_crash_exceed_max_size2() {
+        assert_eq!(
+            true,
+            number_set_should_list_remaining(usize::MAX - 1, usize::MAX)
+        );
+    }
+
+    #[test]
+    fn test_no_crash_exceed_max_size3() {
+        assert_eq!(
+            true,
+            number_set_should_list_remaining(usize::MAX, usize::MAX)
+        );
     }
 }
diff --git a/src/uu/sleep/Cargo.toml b/src/uu/sleep/Cargo.toml
index 454f2297ed5..26c813e29ad 100644
--- a/src/uu/sleep/Cargo.toml
+++ b/src/uu/sleep/Cargo.toml
@@ -1,23 +1,25 @@
 [package]
 name = "uu_sleep"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "sleep ~ (uutils) pause for DURATION"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sleep"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/sleep.rs"
 
 [dependencies]
 clap = { workspace = true }
-fundu = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 
 [[bin]]
 name = "sleep"
diff --git a/src/uu/sleep/src/sleep.rs b/src/uu/sleep/src/sleep.rs
index b1d6bd89958..2b533eadebb 100644
--- a/src/uu/sleep/src/sleep.rs
+++ b/src/uu/sleep/src/sleep.rs
@@ -8,11 +8,12 @@ use std::time::Duration;
 
 use uucore::{
     error::{UResult, USimpleError, UUsageError},
-    format_usage, help_about, help_section, help_usage, show_error,
+    format_usage, help_about, help_section, help_usage,
+    parser::parse_time,
+    show_error,
 };
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use fundu::{self, DurationParser, ParseError, SaturatingInto};
+use clap::{Arg, ArgAction, Command};
 
 static ABOUT: &str = help_about!("sleep.md");
 const USAGE: &str = help_usage!("sleep.md");
@@ -45,7 +46,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -61,37 +62,17 @@ pub fn uu_app() -> Command {
 fn sleep(args: &[&str]) -> UResult<()> {
     let mut arg_error = false;
 
-    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()) {
+        .filter_map(|input| match parse_time::from_str(input, true) {
             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}");
-
+                show_error!("{error}");
                 None
             }
         })
-        .fold(Duration::ZERO, |acc, n| {
-            acc.saturating_add(SaturatingInto::<std::time::Duration>::saturating_into(n))
-        });
+        .fold(Duration::ZERO, |acc, n| acc.saturating_add(n));
 
     if arg_error {
         return Err(UUsageError::new(1, ""));
diff --git a/src/uu/sort/BENCHMARKING.md b/src/uu/sort/BENCHMARKING.md
index 0cc344c3118..d3fdd80d480 100644
--- a/src/uu/sort/BENCHMARKING.md
+++ b/src/uu/sort/BENCHMARKING.md
@@ -24,8 +24,19 @@ Run `cargo build --release` before benchmarking after you make a change!
 
 ## 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:
+  ```
+  shuf -i 1-1000000 -n 1000000 > shuffled_numbers.txt
+  # or
+  seq 1 1000000 | sort -R > shuffled_numbers.txt
+  ```
+- Benchmark numeric sorting with hyperfine
+  ```
+  hyperfine --warmup 3 \
+    '/tmp/gnu-sort -n /tmp/shuffled_numbers.txt'
+    '/tmp/uu_before sort -n /tmp/shuffled_numbers.txt'
+    '/tmp/uu_after sort -n /tmp/shuffled_numbers.txt'
+  ```
 
 ## Sorting numbers with -g
 
@@ -48,7 +59,7 @@ rand = "0.8.3"
 ```rust
 use rand::prelude::*;
 fn main() {
-    let suffixes = ['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+    let suffixes = ['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y', 'R', 'Q'];
     let mut rng = thread_rng();
     for _ in 0..100000 {
         println!(
diff --git a/src/uu/sort/Cargo.toml b/src/uu/sort/Cargo.toml
index 359a2b01274..67676d809f7 100644
--- a/src/uu/sort/Cargo.toml
+++ b/src/uu/sort/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_sort"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "sort ~ (uutils) sort input lines"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sort"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/sort.rs"
@@ -26,8 +29,12 @@ rand = { workspace = true }
 rayon = { workspace = true }
 self_cell = { workspace = true }
 tempfile = { workspace = true }
+thiserror = { workspace = true }
 unicode-width = { workspace = true }
-uucore = { workspace = true, features = ["fs"] }
+uucore = { workspace = true, features = ["fs", "parser", "version-cmp"] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+nix = { workspace = true }
 
 [[bin]]
 name = "sort"
diff --git a/src/uu/sort/src/check.rs b/src/uu/sort/src/check.rs
index 763b6deb733..699ecae3d20 100644
--- a/src/uu/sort/src/check.rs
+++ b/src/uu/sort/src/check.rs
@@ -6,8 +6,9 @@
 //! Check if a file is ordered
 
 use crate::{
+    GlobalSettings, SortError,
     chunks::{self, Chunk, RecycledChunk},
-    compare_by, open, GlobalSettings, SortError,
+    compare_by, open,
 };
 use itertools::Itertools;
 use std::{
@@ -15,7 +16,7 @@ use std::{
     ffi::OsStr,
     io::Read,
     iter,
-    sync::mpsc::{sync_channel, Receiver, SyncSender},
+    sync::mpsc::{Receiver, SyncSender, sync_channel},
     thread,
 };
 use uucore::error::UResult;
diff --git a/src/uu/sort/src/chunks.rs b/src/uu/sort/src/chunks.rs
index 525a9f66b1d..8f423701ac0 100644
--- a/src/uu/sort/src/chunks.rs
+++ b/src/uu/sort/src/chunks.rs
@@ -17,7 +17,7 @@ use memchr::memchr_iter;
 use self_cell::self_cell;
 use uucore::error::{UResult, USimpleError};
 
-use crate::{numeric_str_cmp::NumInfo, GeneralF64ParseResult, GlobalSettings, Line, SortError};
+use crate::{GeneralF64ParseResult, GlobalSettings, Line, SortError, numeric_str_cmp::NumInfo};
 
 self_cell!(
     /// The chunk that is passed around between threads.
@@ -42,6 +42,7 @@ pub struct LineData<'a> {
     pub selections: Vec<&'a str>,
     pub num_infos: Vec<NumInfo>,
     pub parsed_floats: Vec<GeneralF64ParseResult>,
+    pub line_num_floats: Vec<Option<f64>>,
 }
 
 impl Chunk {
@@ -52,6 +53,7 @@ impl Chunk {
             contents.line_data.selections.clear();
             contents.line_data.num_infos.clear();
             contents.line_data.parsed_floats.clear();
+            contents.line_data.line_num_floats.clear();
             let lines = unsafe {
                 // SAFETY: It is safe to (temporarily) transmute to a vector of lines with a longer lifetime,
                 // because the vector is empty.
@@ -73,6 +75,7 @@ impl Chunk {
                 selections,
                 std::mem::take(&mut contents.line_data.num_infos),
                 std::mem::take(&mut contents.line_data.parsed_floats),
+                std::mem::take(&mut contents.line_data.line_num_floats),
             )
         });
         RecycledChunk {
@@ -80,6 +83,7 @@ impl Chunk {
             selections: recycled_contents.1,
             num_infos: recycled_contents.2,
             parsed_floats: recycled_contents.3,
+            line_num_floats: recycled_contents.4,
             buffer: self.into_owner(),
         }
     }
@@ -97,6 +101,7 @@ pub struct RecycledChunk {
     selections: Vec<&'static str>,
     num_infos: Vec<NumInfo>,
     parsed_floats: Vec<GeneralF64ParseResult>,
+    line_num_floats: Vec<Option<f64>>,
     buffer: Vec<u8>,
 }
 
@@ -107,6 +112,7 @@ impl RecycledChunk {
             selections: Vec::new(),
             num_infos: Vec::new(),
             parsed_floats: Vec::new(),
+            line_num_floats: Vec::new(),
             buffer: vec![0; capacity],
         }
     }
@@ -149,6 +155,7 @@ pub fn read<T: Read>(
         selections,
         num_infos,
         parsed_floats,
+        line_num_floats,
         mut buffer,
     } = recycled_chunk;
     if buffer.len() < carry_over.len() {
@@ -184,6 +191,7 @@ pub fn read<T: Read>(
                 selections,
                 num_infos,
                 parsed_floats,
+                line_num_floats,
             };
             parse_lines(read, &mut lines, &mut line_data, separator, settings);
             Ok(ChunkContents { lines, line_data })
@@ -207,6 +215,7 @@ fn parse_lines<'a>(
     assert!(line_data.selections.is_empty());
     assert!(line_data.num_infos.is_empty());
     assert!(line_data.parsed_floats.is_empty());
+    assert!(line_data.line_num_floats.is_empty());
     let mut token_buffer = vec![];
     lines.extend(
         read.split(separator as char)
@@ -227,12 +236,12 @@ fn parse_lines<'a>(
 ///
 /// * `file`: The file to start reading from.
 /// * `next_files`: When `file` reaches EOF, it is updated to `next_files.next()` if that is `Some`,
-///    and this function continues reading.
+///   and this function continues reading.
 /// * `buffer`: The buffer that is filled with bytes. Its contents will mostly be overwritten (see `start_offset`
 ///   as well). It will be grown up to `max_buffer_size` if necessary, but it will always grow to read at least two lines.
 /// * `max_buffer_size`: Grow the buffer to at most this length. If None, the buffer will not grow, unless needed to read at least two lines.
 /// * `start_offset`: The amount of bytes at the start of `buffer` that were carried over
-///    from the previous read and should not be overwritten.
+///   from the previous read and should not be overwritten.
 /// * `separator`: The byte that separates lines.
 ///
 /// # Returns
diff --git a/src/uu/sort/src/ext_sort.rs b/src/uu/sort/src/ext_sort.rs
index 08de4e33e0e..7a65fea5b5c 100644
--- a/src/uu/sort/src/ext_sort.rs
+++ b/src/uu/sort/src/ext_sort.rs
@@ -22,18 +22,19 @@ use std::{
 use itertools::Itertools;
 use uucore::error::UResult;
 
+use crate::Output;
 use crate::chunks::RecycledChunk;
 use crate::merge::ClosedTmpFile;
 use crate::merge::WriteableCompressedTmpFile;
 use crate::merge::WriteablePlainTmpFile;
 use crate::merge::WriteableTmpFile;
 use crate::tmp_dir::TmpDirWrapper;
-use crate::Output;
 use crate::{
+    GlobalSettings,
     chunks::{self, Chunk},
-    compare_by, merge, sort_by, GlobalSettings,
+    compare_by, merge, sort_by,
 };
-use crate::{print_sorted, Line};
+use crate::{Line, print_sorted};
 
 const START_BUFFER_SIZE: usize = 8_000;
 
@@ -98,12 +99,12 @@ fn reader_writer<
     )?;
     match read_result {
         ReadResult::WroteChunksToFile { tmp_files } => {
-            let merger = merge::merge_with_file_limit::<_, _, Tmp>(
+            merge::merge_with_file_limit::<_, _, Tmp>(
                 tmp_files.into_iter().map(|c| c.reopen()),
                 settings,
+                output,
                 tmp_dir,
             )?;
-            merger.write_all(settings, output)?;
         }
         ReadResult::SortedSingleChunk(chunk) => {
             if settings.unique {
@@ -114,9 +115,9 @@ fn reader_writer<
                     }),
                     settings,
                     output,
-                );
+                )?;
             } else {
-                print_sorted(chunk.lines().iter(), settings, output);
+                print_sorted(chunk.lines().iter(), settings, output)?;
             }
         }
         ReadResult::SortedTwoChunks([a, b]) => {
@@ -137,9 +138,9 @@ fn reader_writer<
                         .map(|(line, _)| line),
                     settings,
                     output,
-                );
+                )?;
             } else {
-                print_sorted(merged_iter.map(|(line, _)| line), settings, output);
+                print_sorted(merged_iter.map(|(line, _)| line), settings, output)?;
             }
         }
         ReadResult::EmptyInput => {
@@ -224,15 +225,12 @@ fn read_write_loop<I: WriteableTmpFile>(
     let mut sender_option = Some(sender);
     let mut tmp_files = vec![];
     loop {
-        let mut chunk = match receiver.recv() {
-            Ok(it) => it,
-            _ => {
-                return Ok(ReadResult::WroteChunksToFile { tmp_files });
-            }
+        let Ok(chunk) = receiver.recv() else {
+            return Ok(ReadResult::WroteChunksToFile { tmp_files });
         };
 
         let tmp_file = write::<I>(
-            &mut chunk,
+            &chunk,
             tmp_dir.next_file()?,
             settings.compress_prog.as_deref(),
             separator,
@@ -262,7 +260,7 @@ fn read_write_loop<I: WriteableTmpFile>(
 /// Write the lines in `chunk` to `file`, separated by `separator`.
 /// `compress_prog` is used to optionally compress file contents.
 fn write<I: WriteableTmpFile>(
-    chunk: &mut Chunk,
+    chunk: &Chunk,
     file: (File, PathBuf),
     compress_prog: Option<&str>,
     separator: u8,
diff --git a/src/uu/sort/src/merge.rs b/src/uu/sort/src/merge.rs
index c0457ffa4dc..fb7e2c8bf11 100644
--- a/src/uu/sort/src/merge.rs
+++ b/src/uu/sort/src/merge.rs
@@ -20,19 +20,18 @@ use std::{
     path::{Path, PathBuf},
     process::{Child, ChildStdin, ChildStdout, Command, Stdio},
     rc::Rc,
-    sync::mpsc::{channel, sync_channel, Receiver, Sender, SyncSender},
+    sync::mpsc::{Receiver, Sender, SyncSender, channel, sync_channel},
     thread::{self, JoinHandle},
 };
 
 use compare::Compare;
-use itertools::Itertools;
-use uucore::error::UResult;
+use uucore::error::{FromIo, UResult};
 
 use crate::{
+    GlobalSettings, Output, SortError,
     chunks::{self, Chunk, RecycledChunk},
     compare_by, open,
     tmp_dir::TmpDirWrapper,
-    GlobalSettings, Output, SortError,
 };
 
 /// If the output file occurs in the input files as well, copy the contents of the output file
@@ -51,7 +50,7 @@ fn replace_output_file_in_input_files(
                         *file = copy.clone().into_os_string();
                     } else {
                         let (_file, copy_path) = tmp_dir.next_file()?;
-                        std::fs::copy(file_path, &copy_path)
+                        fs::copy(file_path, &copy_path)
                             .map_err(|error| SortError::OpenTmpFileFailed { error })?;
                         *file = copy_path.clone().into_os_string();
                         copy = Some(copy_path);
@@ -67,58 +66,63 @@ fn replace_output_file_in_input_files(
 ///
 /// If `settings.merge_batch_size` is greater than the length of `files`, intermediate files will be used.
 /// If `settings.compress_prog` is `Some`, intermediate files will be compressed with it.
-pub fn merge<'a>(
+pub fn merge(
     files: &mut [OsString],
-    settings: &'a GlobalSettings,
-    output: Option<&str>,
+    settings: &GlobalSettings,
+    output: Output,
     tmp_dir: &mut TmpDirWrapper,
-) -> UResult<FileMerger<'a>> {
-    replace_output_file_in_input_files(files, output, tmp_dir)?;
+) -> UResult<()> {
+    replace_output_file_in_input_files(files, output.as_output_name(), tmp_dir)?;
+    let files = files
+        .iter()
+        .map(|file| open(file).map(|file| PlainMergeInput { inner: file }));
     if settings.compress_prog.is_none() {
-        merge_with_file_limit::<_, _, WriteablePlainTmpFile>(
-            files
-                .iter()
-                .map(|file| open(file).map(|file| PlainMergeInput { inner: file })),
-            settings,
-            tmp_dir,
-        )
+        merge_with_file_limit::<_, _, WriteablePlainTmpFile>(files, settings, output, tmp_dir)
     } else {
-        merge_with_file_limit::<_, _, WriteableCompressedTmpFile>(
-            files
-                .iter()
-                .map(|file| open(file).map(|file| PlainMergeInput { inner: file })),
-            settings,
-            tmp_dir,
-        )
+        merge_with_file_limit::<_, _, WriteableCompressedTmpFile>(files, settings, output, tmp_dir)
     }
 }
 
 // Merge already sorted `MergeInput`s.
 pub fn merge_with_file_limit<
-    'a,
     M: MergeInput + 'static,
     F: ExactSizeIterator<Item = UResult<M>>,
     Tmp: WriteableTmpFile + 'static,
 >(
     files: F,
-    settings: &'a GlobalSettings,
+    settings: &GlobalSettings,
+    output: Output,
     tmp_dir: &mut TmpDirWrapper,
-) -> UResult<FileMerger<'a>> {
-    if files.len() > settings.merge_batch_size {
-        let mut remaining_files = files.len();
-        let batches = files.chunks(settings.merge_batch_size);
-        let mut batches = batches.into_iter();
+) -> UResult<()> {
+    if files.len() <= settings.merge_batch_size {
+        let merger = merge_without_limit(files, settings);
+        merger?.write_all(settings, output)
+    } else {
         let mut temporary_files = vec![];
-        while remaining_files != 0 {
-            // Work around the fact that `Chunks` is not an `ExactSizeIterator`.
-            remaining_files = remaining_files.saturating_sub(settings.merge_batch_size);
-            let merger = merge_without_limit(batches.next().unwrap(), settings)?;
+        let mut batch = vec![];
+        for file in files {
+            batch.push(file);
+            if batch.len() >= settings.merge_batch_size {
+                assert_eq!(batch.len(), settings.merge_batch_size);
+                let merger = merge_without_limit(batch.into_iter(), settings)?;
+                batch = vec![];
+
+                let mut tmp_file =
+                    Tmp::create(tmp_dir.next_file()?, settings.compress_prog.as_deref())?;
+                merger.write_all_to(settings, tmp_file.as_write())?;
+                temporary_files.push(tmp_file.finished_writing()?);
+            }
+        }
+        // Merge any remaining files that didn't get merged in a full batch above.
+        if !batch.is_empty() {
+            assert!(batch.len() < settings.merge_batch_size);
+            let merger = merge_without_limit(batch.into_iter(), settings)?;
+
             let mut tmp_file =
                 Tmp::create(tmp_dir.next_file()?, settings.compress_prog.as_deref())?;
             merger.write_all_to(settings, tmp_file.as_write())?;
             temporary_files.push(tmp_file.finished_writing()?);
         }
-        assert!(batches.next().is_none());
         merge_with_file_limit::<_, _, Tmp>(
             temporary_files
                 .into_iter()
@@ -127,10 +131,9 @@ pub fn merge_with_file_limit<
                         dyn FnMut(Tmp::Closed) -> UResult<<Tmp::Closed as ClosedTmpFile>::Reopened>,
                     >),
             settings,
+            output,
             tmp_dir,
         )
-    } else {
-        merge_without_limit(files, settings)
     }
 }
 
@@ -260,27 +263,34 @@ struct PreviousLine {
 }
 
 /// Merges files together. This is **not** an iterator because of lifetime problems.
-pub struct FileMerger<'a> {
+struct FileMerger<'a> {
     heap: binary_heap_plus::BinaryHeap<MergeableFile, FileComparator<'a>>,
     request_sender: Sender<(usize, RecycledChunk)>,
     prev: Option<PreviousLine>,
     reader_join_handle: JoinHandle<UResult<()>>,
 }
 
-impl<'a> FileMerger<'a> {
+impl FileMerger<'_> {
     /// Write the merged contents to the output file.
-    pub fn write_all(self, settings: &GlobalSettings, output: Output) -> UResult<()> {
+    fn write_all(self, settings: &GlobalSettings, output: Output) -> UResult<()> {
         let mut out = output.into_write();
         self.write_all_to(settings, &mut out)
     }
 
-    pub fn write_all_to(mut self, settings: &GlobalSettings, out: &mut impl Write) -> UResult<()> {
-        while self.write_next(settings, out) {}
+    fn write_all_to(mut self, settings: &GlobalSettings, out: &mut impl Write) -> UResult<()> {
+        while self
+            .write_next(settings, out)
+            .map_err_context(|| "write failed".into())?
+        {}
         drop(self.request_sender);
         self.reader_join_handle.join().unwrap()
     }
 
-    fn write_next(&mut self, settings: &GlobalSettings, out: &mut impl Write) -> bool {
+    fn write_next(
+        &mut self,
+        settings: &GlobalSettings,
+        out: &mut impl Write,
+    ) -> std::io::Result<bool> {
         if let Some(file) = self.heap.peek() {
             let prev = self.prev.replace(PreviousLine {
                 chunk: file.current_chunk.clone(),
@@ -300,12 +310,12 @@ impl<'a> FileMerger<'a> {
                             file.current_chunk.line_data(),
                         );
                         if cmp == Ordering::Equal {
-                            return;
+                            return Ok(());
                         }
                     }
                 }
-                current_line.print(out, settings);
-            });
+                current_line.print(out, settings)
+            })?;
 
             let was_last_line_for_file = file.current_chunk.lines().len() == file.line_idx + 1;
 
@@ -332,7 +342,7 @@ impl<'a> FileMerger<'a> {
                 }
             }
         }
-        !self.heap.is_empty()
+        Ok(!self.heap.is_empty())
     }
 }
 
@@ -341,7 +351,7 @@ struct FileComparator<'a> {
     settings: &'a GlobalSettings,
 }
 
-impl<'a> Compare<MergeableFile> for FileComparator<'a> {
+impl Compare<MergeableFile> for FileComparator<'_> {
     fn compare(&self, a: &MergeableFile, b: &MergeableFile) -> Ordering {
         let mut cmp = compare_by(
             &a.current_chunk.lines()[a.line_idx],
@@ -362,10 +372,7 @@ 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!(
-        child.wait().map(|e| e.code()),
-        Ok(Some(0)) | Ok(None) | Err(_)
-    ) {
+    if matches!(child.wait().map(|e| e.code()), Ok(Some(0) | None) | Err(_)) {
         Ok(())
     } else {
         Err(SortError::CompressProgTerminatedAbnormally {
diff --git a/src/uu/sort/src/numeric_str_cmp.rs b/src/uu/sort/src/numeric_str_cmp.rs
index 661f536a38c..d3d04a348f6 100644
--- a/src/uu/sort/src/numeric_str_cmp.rs
+++ b/src/uu/sort/src/numeric_str_cmp.rs
@@ -82,7 +82,10 @@ impl NumInfo {
             if Self::is_invalid_char(char, &mut had_decimal_pt, parse_settings) {
                 return if let Some(start) = start {
                     let has_si_unit = parse_settings.accept_si_units
-                        && matches!(char, 'K' | 'k' | 'M' | 'G' | 'T' | 'P' | 'E' | 'Z' | 'Y');
+                        && matches!(
+                            char,
+                            'K' | 'k' | 'M' | 'G' | 'T' | 'P' | 'E' | 'Z' | 'Y' | 'R' | 'Q'
+                        );
                     (
                         Self { exponent, sign },
                         start..if has_si_unit { idx + 1 } else { idx },
@@ -176,6 +179,8 @@ fn get_unit(unit: Option<char>) -> u8 {
             'E' => 6,
             'Z' => 7,
             'Y' => 8,
+            'R' => 9,
+            'Q' => 10,
             _ => 0,
         }
     } else {
@@ -221,8 +226,8 @@ pub fn numeric_str_cmp((a, a_info): (&str, &NumInfo), (b, b_info): (&str, &NumIn
         a_info.exponent.cmp(&b_info.exponent)
     } else {
         // walk the characters from the front until we find a difference
-        let mut a_chars = a.chars().filter(|c| c.is_ascii_digit());
-        let mut b_chars = b.chars().filter(|c| c.is_ascii_digit());
+        let mut a_chars = a.chars().filter(char::is_ascii_digit);
+        let mut b_chars = b.chars().filter(char::is_ascii_digit);
         loop {
             let a_next = a_chars.next();
             let b_next = b_chars.next();
@@ -233,14 +238,14 @@ pub fn numeric_str_cmp((a, a_info): (&str, &NumInfo), (b, b_info): (&str, &NumIn
                         Ordering::Equal
                     } else {
                         Ordering::Greater
-                    }
+                    };
                 }
                 (None, Some(c)) => {
                     break if c == '0' && b_chars.all(|c| c == '0') {
                         Ordering::Equal
                     } else {
                         Ordering::Less
-                    }
+                    };
                 }
                 (Some(a_char), Some(b_char)) => {
                     let ord = a_char.cmp(&b_char);
@@ -394,8 +399,8 @@ mod tests {
         let (a_info, a_range) = NumInfo::parse(a, &NumInfoParseSettings::default());
         let (b_info, b_range) = NumInfo::parse(b, &NumInfoParseSettings::default());
         let ordering = numeric_str_cmp(
-            (&a[a_range.to_owned()], &a_info),
-            (&b[b_range.to_owned()], &b_info),
+            (&a[a_range.clone()], &a_info),
+            (&b[b_range.clone()], &b_info),
         );
         assert_eq!(ordering, expected);
         let ordering = numeric_str_cmp((&b[b_range], &b_info), (&a[a_range], &a_info));
diff --git a/src/uu/sort/src/sort.rs b/src/uu/sort/src/sort.rs
index 4e6e841874b..2e44fba2955 100644
--- a/src/uu/sort/src/sort.rs
+++ b/src/uu/sort/src/sort.rs
@@ -7,7 +7,7 @@
 // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sort.html
 // https://www.gnu.org/software/coreutils/manual/html_node/sort-invocation.html
 
-// spell-checker:ignore (misc) HFKJFK Mbdfhn
+// spell-checker:ignore (misc) HFKJFK Mbdfhn getrlimit RLIMIT_NOFILE rlim
 
 mod check;
 mod chunks;
@@ -19,32 +19,36 @@ mod tmp_dir;
 
 use chunks::LineData;
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use custom_str_cmp::custom_str_cmp;
 use ext_sort::ext_sort;
 use fnv::FnvHasher;
-use numeric_str_cmp::{human_numeric_str_cmp, numeric_str_cmp, NumInfo, NumInfoParseSettings};
-use rand::{thread_rng, Rng};
+#[cfg(target_os = "linux")]
+use nix::libc::{RLIMIT_NOFILE, getrlimit, rlimit};
+use numeric_str_cmp::{NumInfo, NumInfoParseSettings, human_numeric_str_cmp, numeric_str_cmp};
+use rand::{Rng, rng};
 use rayon::prelude::*;
 use std::cmp::Ordering;
 use std::env;
-use std::error::Error;
 use std::ffi::{OsStr, OsString};
-use std::fmt::Display;
 use std::fs::{File, OpenOptions};
 use std::hash::{Hash, Hasher};
-use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
+use std::io::{BufRead, BufReader, BufWriter, Read, Write, stdin, stdout};
+use std::num::IntErrorKind;
 use std::ops::Range;
 use std::path::Path;
 use std::path::PathBuf;
 use std::str::Utf8Error;
+use thiserror::Error;
 use unicode_width::UnicodeWidthStr;
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, strip_errno, UError, UResult, USimpleError, UUsageError};
+use uucore::error::{FromIo, strip_errno};
+use uucore::error::{UError, UResult, USimpleError, UUsageError, set_exit_code};
 use uucore::line_ending::LineEnding;
-use uucore::parse_size::{ParseSizeError, Parser};
+use uucore::parser::parse_size::{ParseSizeError, Parser};
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::version_cmp::version_cmp;
-use uucore::{format_usage, help_about, help_section, help_usage};
+use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 use crate::tmp_dir::TmpDirWrapper;
 
@@ -116,42 +120,46 @@ const POSITIVE: char = '+';
 // available memory into consideration, instead of relying on this constant only.
 const DEFAULT_BUF_SIZE: usize = 1_000_000_000; // 1 GB
 
-#[derive(Debug)]
-enum SortError {
+#[derive(Debug, Error)]
+pub enum SortError {
+    #[error("{}", format_disorder(.file, .line_number, .line, .silent))]
     Disorder {
         file: OsString,
         line_number: usize,
         line: String,
         silent: bool,
     },
-    OpenFailed {
-        path: String,
-        error: std::io::Error,
-    },
+
+    #[error("open failed: {}: {}", .path.maybe_quote(), strip_errno(.error))]
+    OpenFailed { path: String, error: std::io::Error },
+
+    #[error("failed to parse key {}: {}", .key.quote(), .msg)]
+    ParseKeyError { key: String, msg: String },
+
+    #[error("cannot read: {}: {}", .path.maybe_quote(), strip_errno(.error))]
     ReadFailed {
         path: PathBuf,
         error: std::io::Error,
     },
-    ParseKeyError {
-        key: String,
-        msg: String,
-    },
-    OpenTmpFileFailed {
-        error: std::io::Error,
-    },
-    CompressProgExecutionFailed {
-        code: i32,
-    },
-    CompressProgTerminatedAbnormally {
-        prog: String,
-    },
-    TmpDirCreationFailed,
-    Uft8Error {
-        error: Utf8Error,
-    },
-}
 
-impl Error for SortError {}
+    #[error("failed to open temporary file: {}", strip_errno(.error))]
+    OpenTmpFileFailed { error: std::io::Error },
+
+    #[error("couldn't execute compress program: errno {code}")]
+    CompressProgExecutionFailed { code: i32 },
+
+    #[error("{} terminated abnormally", .prog.quote())]
+    CompressProgTerminatedAbnormally { prog: String },
+
+    #[error("cannot create temporary file in '{}':", .path.display())]
+    TmpFileCreationFailed { path: PathBuf },
+
+    #[error("{error}")]
+    Uft8Error { error: Utf8Error },
+
+    #[error("multiple output files specified")]
+    MultipleOutputFiles,
+}
 
 impl UError for SortError {
     fn code(&self) -> i32 {
@@ -162,58 +170,11 @@ impl UError for SortError {
     }
 }
 
-impl Display for SortError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Disorder {
-                file,
-                line_number,
-                line,
-                silent,
-            } => {
-                if *silent {
-                    Ok(())
-                } else {
-                    write!(
-                        f,
-                        "{}:{}: disorder: {}",
-                        file.maybe_quote(),
-                        line_number,
-                        line
-                    )
-                }
-            }
-            Self::OpenFailed { path, error } => {
-                write!(
-                    f,
-                    "open failed: {}: {}",
-                    path.maybe_quote(),
-                    strip_errno(error)
-                )
-            }
-            Self::ParseKeyError { key, msg } => {
-                write!(f, "failed to parse key {}: {}", key.quote(), msg)
-            }
-            Self::ReadFailed { path, error } => {
-                write!(
-                    f,
-                    "cannot read: {}: {}",
-                    path.maybe_quote(),
-                    strip_errno(error)
-                )
-            }
-            Self::OpenTmpFileFailed { error } => {
-                write!(f, "failed to open temporary file: {}", strip_errno(error))
-            }
-            Self::CompressProgExecutionFailed { code } => {
-                write!(f, "couldn't execute compress program: errno {code}")
-            }
-            Self::CompressProgTerminatedAbnormally { prog } => {
-                write!(f, "{} terminated abnormally", prog.quote())
-            }
-            Self::TmpDirCreationFailed => write!(f, "could not create temporary directory"),
-            Self::Uft8Error { error } => write!(f, "{error}"),
-        }
+fn format_disorder(file: &OsString, line_number: &usize, line: &String, silent: &bool) -> String {
+    if *silent {
+        String::new()
+    } else {
+        format!("{}:{}: disorder: {line}", file.maybe_quote(), line_number)
     }
 }
 
@@ -251,6 +212,7 @@ impl Output {
         let file = if let Some(name) = name {
             // This is different from `File::create()` because we don't truncate the output yet.
             // This allows using the output file as an input file.
+            #[allow(clippy::suspicious_open_options)]
             let file = OpenOptions::new()
                 .write(true)
                 .create(true)
@@ -330,7 +292,7 @@ impl GlobalSettings {
         // GNU sort (8.32) invalid:  b, B, 1B,                         p, e, z, y
         let size = Parser::default()
             .with_allow_list(&[
-                "b", "k", "K", "m", "M", "g", "G", "t", "T", "P", "E", "Z", "Y",
+                "b", "k", "K", "m", "M", "g", "G", "t", "T", "P", "E", "Z", "Y", "R", "Q", "%",
             ])
             .with_default_unit("K")
             .with_b_byte_count(true)
@@ -501,6 +463,13 @@ impl<'a> Line<'a> {
         if settings.precomputed.needs_tokens {
             tokenize(line, settings.separator, token_buffer);
         }
+        if settings.mode == SortMode::Numeric {
+            // exclude inf, nan, scientific notation
+            let line_num_float = (!line.contains(char::is_alphabetic))
+                .then(|| line.parse::<f64>().ok())
+                .flatten();
+            line_data.line_num_floats.push(line_num_float);
+        }
         for (selector, selection) in settings
             .selectors
             .iter()
@@ -522,13 +491,14 @@ impl<'a> Line<'a> {
         Self { line, index }
     }
 
-    fn print(&self, writer: &mut impl Write, settings: &GlobalSettings) {
+    fn print(&self, writer: &mut impl Write, settings: &GlobalSettings) -> std::io::Result<()> {
         if settings.debug {
-            self.print_debug(settings, writer).unwrap();
+            self.print_debug(settings, writer)?;
         } else {
-            writer.write_all(self.line.as_bytes()).unwrap();
-            writer.write_all(&[settings.line_ending.into()]).unwrap();
+            writer.write_all(self.line.as_bytes())?;
+            writer.write_all(&[settings.line_ending.into()])?;
         }
+        Ok(())
     }
 
     /// Writes indicators for the selections this line matched. The original line content is NOT expected
@@ -576,8 +546,9 @@ impl<'a> Line<'a> {
                     } else {
                         // include a trailing si unit
                         if selector.settings.mode == SortMode::HumanNumeric
-                            && self.line[selection.end..initial_selection.end]
-                                .starts_with(&['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'][..])
+                            && self.line[selection.end..initial_selection.end].starts_with(
+                                &['k', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y', 'R', 'Q'][..],
+                            )
                         {
                             selection.end += 1;
                         }
@@ -645,6 +616,7 @@ impl<'a> Line<'a> {
                 )?;
             }
         }
+
         if settings.mode != SortMode::Random
             && !settings.stable
             && !settings.unique
@@ -656,7 +628,7 @@ impl<'a> Line<'a> {
                 || settings
                     .selectors
                     .last()
-                    .map_or(true, |selector| selector != &FieldSelector::default()))
+                    .is_none_or(|selector| selector != &FieldSelector::default()))
         {
             // A last resort comparator is in use, underline the whole line.
             if self.line.is_empty() {
@@ -707,9 +679,9 @@ fn tokenize_default(line: &str, token_buffer: &mut Vec<Field>) {
 /// Split between separators. These separators are not included in fields.
 /// The result is stored into `token_buffer`.
 fn tokenize_with_separator(line: &str, separator: char, token_buffer: &mut Vec<Field>) {
-    let separator_indices =
-        line.char_indices()
-            .filter_map(|(i, c)| if c == separator { Some(i) } else { None });
+    let separator_indices = line
+        .char_indices()
+        .filter_map(|(i, c)| if c == separator { Some(i) } else { None });
     let mut start = 0;
     for sep_idx in separator_indices {
         token_buffer.push(start..sep_idx);
@@ -738,16 +710,20 @@ impl KeyPosition {
             .ok_or_else(|| format!("invalid key {}", key.quote()))?;
         let char = field_and_char.next();
 
-        let field = field
-            .parse()
-            .map_err(|e| format!("failed to parse field index {}: {}", field.quote(), e))?;
+        let field = match field.parse::<usize>() {
+            Ok(f) => f,
+            Err(e) if *e.kind() == IntErrorKind::PosOverflow => usize::MAX,
+            Err(e) => {
+                return Err(format!("failed to parse field index {} {e}", field.quote(),));
+            }
+        };
         if field == 0 {
             return Err("field index can not be 0".to_string());
         }
 
         let char = char.map_or(Ok(default_char_index), |char| {
             char.parse()
-                .map_err(|e| format!("failed to parse character index {}: {}", char.quote(), e))
+                .map_err(|e| format!("failed to parse character index {}: {e}", char.quote()))
         })?;
 
         Ok(Self {
@@ -985,7 +961,7 @@ impl FieldSelector {
                 let mut range = match to {
                     Some(Resolution::StartOfChar(mut to)) => {
                         // We need to include the character at `to`.
-                        to += line[to..].chars().next().map_or(1, |c| c.len_utf8());
+                        to += line[to..].chars().next().map_or(1, char::len_utf8);
                         from..to
                     }
                     Some(Resolution::EndOfChar(to)) => from..to,
@@ -1002,7 +978,9 @@ impl FieldSelector {
                 range
             }
             Resolution::TooLow | Resolution::EndOfChar(_) => {
-                unreachable!("This should only happen if the field start index is 0, but that should already have caused an error.")
+                unreachable!(
+                    "This should only happen if the field start index is 0, but that should already have caused an error."
+                )
             }
             // While for comparisons it's only important that this is an empty slice,
             // to produce accurate debug output we need to match an empty slice at the end of the line.
@@ -1026,10 +1004,21 @@ fn make_sort_mode_arg(mode: &'static str, short: char, help: &'static str) -> Ar
     arg
 }
 
+#[cfg(target_os = "linux")]
+fn get_rlimit() -> UResult<usize> {
+    let mut limit = rlimit {
+        rlim_cur: 0,
+        rlim_max: 0,
+    };
+    match unsafe { getrlimit(RLIMIT_NOFILE, &mut limit) } {
+        0 => Ok(limit.rlim_cur as usize),
+        _ => Err(UUsageError::new(2, "Failed to fetch rlimit")),
+    }
+}
+
 #[uucore::main]
 #[allow(clippy::cognitive_complexity)]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
     let mut settings = GlobalSettings::default();
 
     let matches = match uu_app().try_get_matches_from(args) {
@@ -1048,6 +1037,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
     };
 
+    // Prevent -o/--output to be specified multiple times
+    if matches
+        .get_occurrences::<String>(options::OUTPUT)
+        .is_some_and(|out| out.len() > 1)
+    {
+        return Err(SortError::MultipleOutputFiles.into());
+    }
+
     settings.debug = matches.get_flag(options::DEBUG);
 
     // check whether user specified a zero terminated list of files for input, otherwise read files from args
@@ -1131,7 +1128,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             .get_one::<String>(options::PARALLEL)
             .map(String::from)
             .unwrap_or_else(|| "0".to_string());
-        env::set_var("RAYON_NUM_THREADS", &settings.threads);
+        unsafe {
+            env::set_var("RAYON_NUM_THREADS", &settings.threads);
+        }
     }
 
     settings.buffer_size =
@@ -1155,12 +1154,36 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(String::from);
 
     if let Some(n_merge) = matches.get_one::<String>(options::BATCH_SIZE) {
-        settings.merge_batch_size = n_merge.parse().map_err(|_| {
-            UUsageError::new(
-                2,
-                format!("invalid --batch-size argument {}", n_merge.quote()),
-            )
-        })?;
+        match n_merge.parse::<usize>() {
+            Ok(parsed_value) => {
+                if parsed_value < 2 {
+                    show_error!("invalid --batch-size argument '{n_merge}'");
+                    return Err(UUsageError::new(2, "minimum --batch-size argument is '2'"));
+                }
+                settings.merge_batch_size = parsed_value;
+            }
+            Err(e) => {
+                let error_message = if *e.kind() == IntErrorKind::PosOverflow {
+                    #[cfg(target_os = "linux")]
+                    {
+                        show_error!("--batch-size argument {} too large", n_merge.quote());
+
+                        format!(
+                            "maximum --batch-size argument with current rlimit is {}",
+                            get_rlimit()?
+                        )
+                    }
+                    #[cfg(not(target_os = "linux"))]
+                    {
+                        format!("--batch-size argument {} too large", n_merge.quote())
+                    }
+                } else {
+                    format!("invalid --batch-size argument {}", n_merge.quote())
+                };
+
+                return Err(UUsageError::new(2, error_message));
+            }
+        }
     }
 
     settings.line_ending = LineEnding::from_zero_flag(matches.get_flag(options::ZERO_TERMINATED));
@@ -1274,13 +1297,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .disable_help_flag(true)
         .disable_version_flag(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::HELP)
                 .long(options::HELP)
@@ -1296,14 +1320,14 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::modes::SORT)
                 .long(options::modes::SORT)
-                .value_parser([
+                .value_parser(ShortcutValueParser::new([
                     "general-numeric",
                     "human-numeric",
                     "month",
                     "numeric",
                     "version",
                     "random",
-                ])
+                ]))
                 .conflicts_with_all(options::modes::ALL_SORT_MODES),
         )
         .arg(make_sort_mode_arg(
@@ -1362,19 +1386,19 @@ pub fn uu_app() -> Command {
                 .long(options::check::CHECK)
                 .require_equals(true)
                 .num_args(0..)
-                .value_parser([
+                .value_parser(ShortcutValueParser::new([
                     options::check::SILENT,
                     options::check::QUIET,
                     options::check::DIAGNOSE_FIRST,
-                ])
-                .conflicts_with(options::OUTPUT)
+                ]))
+                .conflicts_with_all([options::OUTPUT, options::check::CHECK_SILENT])
                 .help("check for sorted input; do not sort"),
         )
         .arg(
             Arg::new(options::check::CHECK_SILENT)
                 .short('C')
                 .long(options::check::CHECK_SILENT)
-                .conflicts_with(options::OUTPUT)
+                .conflicts_with_all([options::OUTPUT, options::check::CHECK])
                 .help(
                     "exit successfully if the given file is already sorted, \
                 and exit with status 1 otherwise.",
@@ -1414,7 +1438,9 @@ pub fn uu_app() -> Command {
                 .long(options::OUTPUT)
                 .help("write output to FILENAME instead of stdout")
                 .value_name("FILENAME")
-                .value_hint(clap::ValueHint::FilePath),
+                .value_hint(clap::ValueHint::FilePath)
+                // To detect multiple occurrences and raise an error
+                .action(ArgAction::Append),
         )
         .arg(
             Arg::new(options::REVERSE)
@@ -1523,8 +1549,7 @@ fn exec(
     tmp_dir: &mut TmpDirWrapper,
 ) -> UResult<()> {
     if settings.merge {
-        let file_merger = merge::merge(files, settings, output.as_output_name(), tmp_dir)?;
-        file_merger.write_all(settings, output)
+        merge::merge(files, settings, output, tmp_dir)
     } else if settings.check {
         if files.len() > 1 {
             Err(UUsageError::new(2, "only one file allowed with -c"))
@@ -1555,6 +1580,24 @@ fn compare_by<'a>(
     let mut selection_index = 0;
     let mut num_info_index = 0;
     let mut parsed_float_index = 0;
+
+    if let (Some(Some(a_f64)), Some(Some(b_f64))) = (
+        a_line_data.line_num_floats.get(a.index),
+        b_line_data.line_num_floats.get(b.index),
+    ) {
+        // we don't use total_cmp() because it always sorts -0 before 0
+        if let Some(cmp) = a_f64.partial_cmp(b_f64) {
+            // don't trust `Ordering::Equal` if lines are not fully equal
+            if cmp != Ordering::Equal || a.line == b.line {
+                return if global_settings.reverse {
+                    cmp.reverse()
+                } else {
+                    cmp
+                };
+            }
+        }
+    }
+
     for selector in &global_settings.selectors {
         let (a_str, b_str) = if selector.needs_selection {
             let selections = (
@@ -1667,7 +1710,7 @@ fn get_leading_gen(input: &str) -> Range<usize> {
 
     let first = char_indices.peek();
 
-    if matches!(first, Some((_, NEGATIVE) | (_, POSITIVE))) {
+    if matches!(first, Some((_, NEGATIVE | POSITIVE))) {
         char_indices.next();
     }
 
@@ -1724,8 +1767,8 @@ fn general_f64_parse(a: &str) -> GeneralF64ParseResult {
     // TODO: Once our minimum supported Rust version is 1.53 or above, we should add tests for those cases.
     match a.parse::<f64>() {
         Ok(a) if a.is_nan() => GeneralF64ParseResult::NaN,
-        Ok(a) if a == std::f64::NEG_INFINITY => GeneralF64ParseResult::NegInfinity,
-        Ok(a) if a == std::f64::INFINITY => GeneralF64ParseResult::Infinity,
+        Ok(a) if a == f64::NEG_INFINITY => GeneralF64ParseResult::NegInfinity,
+        Ok(a) if a == f64::INFINITY => GeneralF64ParseResult::Infinity,
         Ok(a) => GeneralF64ParseResult::Number(a),
         Err(_) => GeneralF64ParseResult::Invalid,
     }
@@ -1739,7 +1782,7 @@ fn general_numeric_compare(a: &GeneralF64ParseResult, b: &GeneralF64ParseResult)
 }
 
 fn get_rand_string() -> [u8; 16] {
-    thread_rng().sample(rand::distributions::Standard)
+    rng().sample(rand::distr::StandardUniform)
 }
 
 fn get_hash<T: Hash>(t: &T) -> u64 {
@@ -1819,11 +1862,19 @@ fn print_sorted<'a, T: Iterator<Item = &'a Line<'a>>>(
     iter: T,
     settings: &GlobalSettings,
     output: Output,
-) {
+) -> UResult<()> {
+    let output_name = output
+        .as_output_name()
+        .unwrap_or("standard output")
+        .to_owned();
+    let ctx = || format!("write failed: {}", output_name.maybe_quote());
+
     let mut writer = output.into_write();
     for line in iter {
-        line.print(&mut writer, settings);
+        line.print(&mut writer, settings).map_err_context(ctx)?;
     }
+    writer.flush().map_err_context(ctx)?;
+    Ok(())
 }
 
 fn open(path: impl AsRef<OsStr>) -> UResult<Box<dyn Read + Send>> {
@@ -1847,13 +1898,15 @@ fn open(path: impl AsRef<OsStr>) -> UResult<Box<dyn Read + Send>> {
 
 fn format_error_message(error: &ParseSizeError, s: &str, option: &str) -> String {
     // NOTE:
-    // GNU's sort echos affected flag, -S or --buffer-size, depending user's selection
+    // GNU's sort echos affected flag, -S or --buffer-size, depending on user's selection
     match error {
         ParseSizeError::InvalidSuffix(_) => {
-            format!("invalid suffix in --{} argument {}", option, s.quote())
+            format!("invalid suffix in --{option} argument {}", s.quote())
+        }
+        ParseSizeError::ParseFailure(_) | ParseSizeError::PhysicalMem(_) => {
+            format!("invalid --{option} argument {}", s.quote())
         }
-        ParseSizeError::ParseFailure(_) => format!("invalid --{} argument {}", option, s.quote()),
-        ParseSizeError::SizeTooBig(_) => format!("--{} argument {} too large", option, s.quote()),
+        ParseSizeError::SizeTooBig(_) => format!("--{option} argument {} too large", s.quote()),
     }
 }
 
@@ -1911,7 +1964,7 @@ mod tests {
     #[test]
     fn test_tokenize_fields() {
         let line = "foo bar b    x";
-        assert_eq!(tokenize_helper(line, None), vec![0..3, 3..7, 7..9, 9..14,],);
+        assert_eq!(tokenize_helper(line, None), vec![0..3, 3..7, 7..9, 9..14]);
     }
 
     #[test]
@@ -1919,7 +1972,7 @@ mod tests {
         let line = "    foo bar b    x";
         assert_eq!(
             tokenize_helper(line, None),
-            vec![0..7, 7..11, 11..13, 13..18,]
+            vec![0..7, 7..11, 11..13, 13..18]
         );
     }
 
@@ -1928,7 +1981,7 @@ mod tests {
         let line = "aaa foo bar b    x";
         assert_eq!(
             tokenize_helper(line, Some('a')),
-            vec![0..0, 1..1, 2..2, 3..9, 10..18,]
+            vec![0..0, 1..1, 2..2, 3..9, 10..18]
         );
     }
 
@@ -1947,7 +2000,7 @@ mod tests {
     fn test_line_size() {
         // We should make sure to not regress the size of the Line struct because
         // it is unconditional overhead for every line we sort.
-        assert_eq!(std::mem::size_of::<Line>(), 24);
+        assert_eq!(size_of::<Line>(), 24);
     }
 
     #[test]
@@ -1983,7 +2036,6 @@ mod tests {
         // SizeTooBig
         let invalid_input = ["500E", "1Y"];
         for input in &invalid_input {
-            #[cfg(not(target_pointer_width = "128"))]
             assert!(GlobalSettings::parse_byte_count(input).is_err());
         }
 
diff --git a/src/uu/sort/src/tmp_dir.rs b/src/uu/sort/src/tmp_dir.rs
index 14e17a0d64a..f97298ebd6c 100644
--- a/src/uu/sort/src/tmp_dir.rs
+++ b/src/uu/sort/src/tmp_dir.rs
@@ -46,7 +46,9 @@ impl TmpDirWrapper {
             tempfile::Builder::new()
                 .prefix("uutils_sort")
                 .tempdir_in(&self.parent_path)
-                .map_err(|_| SortError::TmpDirCreationFailed)?,
+                .map_err(|_| SortError::TmpFileCreationFailed {
+                    path: self.parent_path.clone(),
+                })?,
         );
 
         let path = self.temp_dir.as_ref().unwrap().path().to_owned();
@@ -56,7 +58,7 @@ impl TmpDirWrapper {
             // and the program doesn't terminate before the handler has finished
             let _lock = lock.lock().unwrap();
             if let Err(e) = remove_tmp_dir(&path) {
-                show_error!("failed to delete temporary directory: {}", e);
+                show_error!("failed to delete temporary directory: {e}");
             }
             std::process::exit(2)
         })
diff --git a/src/uu/split/Cargo.toml b/src/uu/split/Cargo.toml
index fb53914e291..f53412db340 100644
--- a/src/uu/split/Cargo.toml
+++ b/src/uu/split/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_split"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "split ~ (uutils) split input into output files"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/split"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/split.rs"
@@ -17,7 +20,8 @@ path = "src/split.rs"
 [dependencies]
 clap = { workspace = true }
 memchr = { workspace = true }
-uucore = { workspace = true, features = ["fs"] }
+uucore = { workspace = true, features = ["fs", "parser"] }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "split"
diff --git a/src/uu/split/split.md b/src/uu/split/split.md
index d3a481fd307..836e3a0c69a 100644
--- a/src/uu/split/split.md
+++ b/src/uu/split/split.md
@@ -11,3 +11,16 @@ 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.
+
+The SIZE argument is an integer and optional unit (example: 10K is 10*1024).
+Units are K,M,G,T,P,E,Z,Y,R,Q (powers of 1024) or KB,MB,... (powers of 1000).
+Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
+
+CHUNKS may be:
+
+- N       split into N files based on size of input
+- K/N     output Kth of N to stdout
+- l/N     split into N files without splitting lines/records
+- l/K/N   output Kth of N to stdout without splitting lines/records
+- r/N     like 'l' but use round robin distribution
+- r/K/N   likewise but only output Kth of N to stdout
diff --git a/src/uu/split/src/filenames.rs b/src/uu/split/src/filenames.rs
index 08f08e293f0..52b284a167f 100644
--- a/src/uu/split/src/filenames.rs
+++ b/src/uu/split/src/filenames.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 zaaa zaab
+// spell-checker:ignore zaaa zaab stype
 //! Compute filenames from a given index.
 //!
 //! The [`FilenameIterator`] yields filenames for use with ``split``.
@@ -16,18 +16,32 @@
 //! use crate::filenames::SuffixType;
 //!
 //! let prefix = "chunk_".to_string();
-//! let suffix = ".txt".to_string();
-//! let width = 2;
-//! let suffix_type = SuffixType::Alphabetic;
-//! let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+//! let suffix = Suffix {
+//!     stype: SuffixType::Alphabetic,
+//!     length: 2,
+//!     start: 0,
+//!     auto_widening: true,
+//!     additional: ".txt".to_string(),
+//! };
+//! let it = FilenameIterator::new(prefix, suffix);
 //!
 //! assert_eq!(it.next().unwrap(), "chunk_aa.txt");
 //! assert_eq!(it.next().unwrap(), "chunk_ab.txt");
 //! assert_eq!(it.next().unwrap(), "chunk_ac.txt");
 //! ```
+
 use crate::number::DynamicWidthNumber;
 use crate::number::FixedWidthNumber;
 use crate::number::Number;
+use crate::strategy::Strategy;
+use crate::{
+    OPT_ADDITIONAL_SUFFIX, OPT_HEX_SUFFIXES, OPT_HEX_SUFFIXES_SHORT, OPT_NUMERIC_SUFFIXES,
+    OPT_NUMERIC_SUFFIXES_SHORT, OPT_SUFFIX_LENGTH,
+};
+use clap::ArgMatches;
+use std::path::is_separator;
+use thiserror::Error;
+use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
 
 /// The format to use for suffixes in the filename for each output chunk.
@@ -54,21 +68,190 @@ impl SuffixType {
     }
 }
 
+/// Filename suffix parameters
+#[derive(Clone)]
+pub struct Suffix {
+    stype: SuffixType,
+    length: usize,
+    start: usize,
+    auto_widening: bool,
+    additional: String,
+}
+
+/// An error when parsing suffix parameters from command-line arguments.
+#[derive(Debug, Error)]
+pub enum SuffixError {
+    /// Invalid suffix length parameter.
+    #[error("invalid suffix length: {}", .0.quote())]
+    NotParsable(String),
+
+    /// Suffix contains a directory separator, which is not allowed.
+    #[error("invalid suffix {}, contains directory separator", .0.quote())]
+    ContainsSeparator(String),
+
+    /// Suffix is not large enough to split into specified chunks
+    #[error("the suffix length needs to be at least {0}")]
+    TooSmall(usize),
+}
+
+impl Suffix {
+    /// Parse the suffix type, start, length and additional suffix from the command-line arguments
+    /// as well process suffix length auto-widening and auto-width scenarios
+    ///
+    /// Suffix auto-widening: Determine if the output file names suffix is allowed to dynamically auto-widen,
+    /// i.e. change (increase) suffix length dynamically as more files need to be written into.
+    /// Suffix length auto-widening rules are (in the order they are applied):
+    /// - ON by default
+    /// - OFF when suffix start N is specified via long option with a value
+    ///   `--numeric-suffixes=N` or `--hex-suffixes=N`
+    /// - OFF when suffix length N is specified, except for N=0 (see edge cases below)
+    ///   `-a N` or `--suffix-length=N`
+    /// - OFF if suffix length is auto pre-calculated (auto-width)
+    ///
+    /// Suffix auto-width: Determine if the the output file names suffix length should be automatically pre-calculated
+    /// based on number of files that need to written into, having number of files known upfront
+    /// Suffix length auto pre-calculation rules:
+    /// - Pre-calculate new suffix length when `-n`/`--number` option (N, K/N, l/N, l/K/N, r/N, r/K/N)
+    ///   is used, where N is number of chunks = number of files to write into
+    ///   and suffix start < N number of files
+    ///   as in `split --numeric-suffixes=1 --number=r/100 file`
+    /// - Do NOT pre-calculate new suffix length otherwise, i.e. when
+    ///   suffix start >= N number of files
+    ///   as in `split --numeric-suffixes=100 --number=r/100 file`
+    ///   OR when suffix length N is specified, except for N=0 (see edge cases below)
+    ///   `-a N` or `--suffix-length=N`
+    ///
+    /// Edge case:
+    /// - If suffix length is specified as 0 in a command line,
+    ///   first apply auto-width calculations and if still 0
+    ///   set it to default value.
+    ///   Do NOT change auto-widening value
+    ///
+    pub fn from(matches: &ArgMatches, strategy: &Strategy) -> Result<Self, SuffixError> {
+        let stype: SuffixType;
+
+        // Defaults
+        let mut start = 0;
+        let mut auto_widening = true;
+        let default_length: usize = 2;
+
+        // Check if the user is specifying one or more than one suffix
+        // Any combination of suffixes is allowed
+        // Since all suffixes are setup with 'overrides_with_all()' against themselves and each other,
+        // last one wins, all others are ignored
+        match (
+            matches.contains_id(OPT_NUMERIC_SUFFIXES),
+            matches.contains_id(OPT_HEX_SUFFIXES),
+            matches.get_flag(OPT_NUMERIC_SUFFIXES_SHORT),
+            matches.get_flag(OPT_HEX_SUFFIXES_SHORT),
+        ) {
+            (true, _, _, _) => {
+                stype = SuffixType::Decimal;
+                // if option was specified, but without value - this will return None as there is no default value
+                if let Some(opt) = matches.get_one::<String>(OPT_NUMERIC_SUFFIXES) {
+                    start = opt
+                        .parse::<usize>()
+                        .map_err(|_| SuffixError::NotParsable(opt.to_string()))?;
+                    auto_widening = false;
+                }
+            }
+            (_, true, _, _) => {
+                stype = SuffixType::Hexadecimal;
+                // if option was specified, but without value - this will return None as there is no default value
+                if let Some(opt) = matches.get_one::<String>(OPT_HEX_SUFFIXES) {
+                    start = usize::from_str_radix(opt, 16)
+                        .map_err(|_| SuffixError::NotParsable(opt.to_string()))?;
+                    auto_widening = false;
+                }
+            }
+            (_, _, true, _) => stype = SuffixType::Decimal, // short numeric suffix '-d'
+            (_, _, _, true) => stype = SuffixType::Hexadecimal, // short hex suffix '-x'
+            _ => stype = SuffixType::Alphabetic, // no numeric/hex suffix, using default alphabetic
+        }
+
+        // Get suffix length and a flag to indicate if it was specified with command line option
+        let (mut length, is_length_cmd_opt) =
+            if let Some(v) = matches.get_one::<String>(OPT_SUFFIX_LENGTH) {
+                // suffix length was specified in command line
+                (
+                    v.parse::<usize>()
+                        .map_err(|_| SuffixError::NotParsable(v.to_string()))?,
+                    true,
+                )
+            } else {
+                // no suffix length option was specified in command line
+                // set to default value
+                (default_length, false)
+            };
+
+        // Disable dynamic auto-widening if suffix length was specified in command line with value > 0
+        if is_length_cmd_opt && length > 0 {
+            auto_widening = false;
+        }
+
+        // Auto pre-calculate new suffix length (auto-width) if necessary
+        if let Strategy::Number(number_type) = strategy {
+            let chunks = number_type.num_chunks();
+            let required_length = ((start as u64 + chunks) as f64)
+                .log(stype.radix() as f64)
+                .ceil() as usize;
+
+            if (start as u64) < chunks && !(is_length_cmd_opt && length > 0) {
+                // with auto-width ON the auto-widening is OFF
+                auto_widening = false;
+
+                // do not reduce suffix length with auto-width
+                if length < required_length {
+                    length = required_length;
+                }
+            }
+
+            if length < required_length {
+                return Err(SuffixError::TooSmall(required_length));
+            }
+        }
+
+        // Check edge case when suffix length == 0 was specified in command line
+        // Set it to default value
+        if is_length_cmd_opt && length == 0 {
+            length = default_length;
+        }
+
+        let additional = matches
+            .get_one::<String>(OPT_ADDITIONAL_SUFFIX)
+            .unwrap()
+            .to_string();
+        if additional.chars().any(is_separator) {
+            return Err(SuffixError::ContainsSeparator(additional));
+        }
+
+        let result = Self {
+            stype,
+            length,
+            start,
+            auto_widening,
+            additional,
+        };
+
+        Ok(result)
+    }
+}
+
 /// Compute filenames from a given index.
 ///
 /// This iterator yields filenames for use with ``split``.
 ///
 /// The `prefix` is prepended to each filename and the
-/// `additional_suffix1` is appended to each filename.
+/// `suffix.additional` is appended to each filename.
 ///
-/// If `suffix_length` is 0, then the variable portion of the filename
+/// If `suffix.auto_widening` is true, then the variable portion of the filename
 /// that identifies the current chunk will have a dynamically
-/// increasing width. If `suffix_length` is greater than zero, then
-/// the variable portion of the filename will always be exactly that
+/// increasing width. If `suffix.auto_widening` is false, then
+/// the variable portion of the filename will always be exactly `suffix.length`
 /// width in characters. In that case, after the iterator yields each
 /// string of that width, the iterator is exhausted.
 ///
-/// Finally, `suffix_type` controls which type of suffix to produce,
+/// Finally, `suffix.stype` controls which type of suffix to produce,
 /// alphabetic or numeric.
 ///
 /// # Examples
@@ -81,10 +264,14 @@ impl SuffixType {
 /// use crate::filenames::SuffixType;
 ///
 /// let prefix = "chunk_".to_string();
-/// let suffix = ".txt".to_string();
-/// let width = 2;
-/// let suffix_type = SuffixType::Alphabetic;
-/// let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+/// let suffix = Suffix {
+///     stype: SuffixType::Alphabetic,
+///     length: 2,
+///     start: 0,
+///     auto_widening: true,
+///     additional: ".txt".to_string(),
+/// };
+/// let it = FilenameIterator::new(prefix, suffix);
 ///
 /// assert_eq!(it.next().unwrap(), "chunk_aa.txt");
 /// assert_eq!(it.next().unwrap(), "chunk_ab.txt");
@@ -98,36 +285,34 @@ impl SuffixType {
 /// use crate::filenames::SuffixType;
 ///
 /// let prefix = "chunk_".to_string();
-/// let suffix = ".txt".to_string();
-/// let width = 2;
-/// let suffix_type = SuffixType::Decimal;
-/// let it = FilenameIterator::new(prefix, suffix, width, suffix_type);
+/// let suffix = Suffix {
+///     stype: SuffixType::Decimal,
+///     length: 2,
+///     start: 0,
+///     auto_widening: true,
+///     additional: ".txt".to_string(),
+/// };
+/// let it = FilenameIterator::new(prefix, suffix);
 ///
 /// assert_eq!(it.next().unwrap(), "chunk_00.txt");
 /// assert_eq!(it.next().unwrap(), "chunk_01.txt");
 /// assert_eq!(it.next().unwrap(), "chunk_02.txt");
 /// ```
 pub struct FilenameIterator<'a> {
-    additional_suffix: &'a str,
     prefix: &'a str,
+    additional_suffix: &'a str,
     number: Number,
     first_iteration: bool,
 }
 
 impl<'a> FilenameIterator<'a> {
-    pub fn new(
-        prefix: &'a str,
-        additional_suffix: &'a str,
-        suffix_length: usize,
-        suffix_type: SuffixType,
-        suffix_start: usize,
-    ) -> UResult<FilenameIterator<'a>> {
-        let radix = suffix_type.radix();
-        let number = if suffix_length == 0 {
-            Number::DynamicWidth(DynamicWidthNumber::new(radix, suffix_start))
+    pub fn new(prefix: &'a str, suffix: &'a Suffix) -> UResult<Self> {
+        let radix = suffix.stype.radix();
+        let number = if suffix.auto_widening {
+            Number::DynamicWidth(DynamicWidthNumber::new(radix, suffix.start))
         } else {
             Number::FixedWidth(
-                FixedWidthNumber::new(radix, suffix_length, suffix_start).map_err(|_| {
+                FixedWidthNumber::new(radix, suffix.length, suffix.start).map_err(|_| {
                     USimpleError::new(
                         1,
                         "numerical suffix start value is too large for the suffix length",
@@ -135,6 +320,7 @@ impl<'a> FilenameIterator<'a> {
                 })?,
             )
         };
+        let additional_suffix = suffix.additional.as_str();
 
         Ok(FilenameIterator {
             prefix,
@@ -145,7 +331,7 @@ impl<'a> FilenameIterator<'a> {
     }
 }
 
-impl<'a> Iterator for FilenameIterator<'a> {
+impl Iterator for FilenameIterator<'_> {
     type Item = String;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -167,40 +353,62 @@ impl<'a> Iterator for FilenameIterator<'a> {
 mod tests {
 
     use crate::filenames::FilenameIterator;
+    use crate::filenames::Suffix;
     use crate::filenames::SuffixType;
 
     #[test]
     fn test_filename_iterator_alphabetic_fixed_width() {
-        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Alphabetic, 0).unwrap();
+        let suffix = Suffix {
+            stype: SuffixType::Alphabetic,
+            length: 2,
+            start: 0,
+            auto_widening: false,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_aa.txt");
         assert_eq!(it.next().unwrap(), "chunk_ab.txt");
         assert_eq!(it.next().unwrap(), "chunk_ac.txt");
 
-        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Alphabetic, 0).unwrap();
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.nth(26 * 26 - 1).unwrap(), "chunk_zz.txt");
         assert_eq!(it.next(), None);
     }
 
     #[test]
     fn test_filename_iterator_numeric_fixed_width() {
-        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Decimal, 0).unwrap();
+        let suffix = Suffix {
+            stype: SuffixType::Decimal,
+            length: 2,
+            start: 0,
+            auto_widening: false,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_00.txt");
         assert_eq!(it.next().unwrap(), "chunk_01.txt");
         assert_eq!(it.next().unwrap(), "chunk_02.txt");
 
-        let mut it = FilenameIterator::new("chunk_", ".txt", 2, SuffixType::Decimal, 0).unwrap();
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.nth(10 * 10 - 1).unwrap(), "chunk_99.txt");
         assert_eq!(it.next(), None);
     }
 
     #[test]
     fn test_filename_iterator_alphabetic_dynamic_width() {
-        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Alphabetic, 0).unwrap();
+        let suffix = Suffix {
+            stype: SuffixType::Alphabetic,
+            length: 2,
+            start: 0,
+            auto_widening: true,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_aa.txt");
         assert_eq!(it.next().unwrap(), "chunk_ab.txt");
         assert_eq!(it.next().unwrap(), "chunk_ac.txt");
 
-        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Alphabetic, 0).unwrap();
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.nth(26 * 25 - 1).unwrap(), "chunk_yz.txt");
         assert_eq!(it.next().unwrap(), "chunk_zaaa.txt");
         assert_eq!(it.next().unwrap(), "chunk_zaab.txt");
@@ -208,49 +416,96 @@ mod tests {
 
     #[test]
     fn test_filename_iterator_numeric_dynamic_width() {
-        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal, 0).unwrap();
+        let suffix = Suffix {
+            stype: SuffixType::Decimal,
+            length: 2,
+            start: 0,
+            auto_widening: true,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_00.txt");
         assert_eq!(it.next().unwrap(), "chunk_01.txt");
         assert_eq!(it.next().unwrap(), "chunk_02.txt");
 
-        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal, 0).unwrap();
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.nth(10 * 9 - 1).unwrap(), "chunk_89.txt");
         assert_eq!(it.next().unwrap(), "chunk_9000.txt");
         assert_eq!(it.next().unwrap(), "chunk_9001.txt");
     }
 
     #[test]
-    fn test_filename_iterator_numeric_suffix_decimal() {
-        let mut it = FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Decimal, 5).unwrap();
+    fn test_filename_iterator_numeric_decimal() {
+        let suffix = Suffix {
+            stype: SuffixType::Decimal,
+            length: 2,
+            start: 5,
+            auto_widening: true,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_05.txt");
         assert_eq!(it.next().unwrap(), "chunk_06.txt");
         assert_eq!(it.next().unwrap(), "chunk_07.txt");
     }
 
     #[test]
-    fn test_filename_iterator_numeric_suffix_hex() {
-        let mut it =
-            FilenameIterator::new("chunk_", ".txt", 0, SuffixType::Hexadecimal, 9).unwrap();
+    fn test_filename_iterator_numeric_hex() {
+        let suffix = Suffix {
+            stype: SuffixType::Hexadecimal,
+            length: 2,
+            start: 9,
+            auto_widening: true,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_09.txt");
         assert_eq!(it.next().unwrap(), "chunk_0a.txt");
         assert_eq!(it.next().unwrap(), "chunk_0b.txt");
     }
 
     #[test]
-    fn test_filename_iterator_numeric_suffix_err() {
-        let mut it = FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Decimal, 999).unwrap();
+    fn test_filename_iterator_numeric_err() {
+        let suffix = Suffix {
+            stype: SuffixType::Decimal,
+            length: 3,
+            start: 999,
+            auto_widening: false,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_999.txt");
         assert!(it.next().is_none());
 
-        let it = FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Decimal, 1000);
+        let suffix = Suffix {
+            stype: SuffixType::Decimal,
+            length: 3,
+            start: 1000,
+            auto_widening: false,
+            additional: ".txt".to_string(),
+        };
+        let it = FilenameIterator::new("chunk_", &suffix);
         assert!(it.is_err());
 
-        let mut it =
-            FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Hexadecimal, 0xfff).unwrap();
+        let suffix = Suffix {
+            stype: SuffixType::Hexadecimal,
+            length: 3,
+            start: 0xfff,
+            auto_widening: false,
+            additional: ".txt".to_string(),
+        };
+        let mut it = FilenameIterator::new("chunk_", &suffix).unwrap();
         assert_eq!(it.next().unwrap(), "chunk_fff.txt");
         assert!(it.next().is_none());
 
-        let it = FilenameIterator::new("chunk_", ".txt", 3, SuffixType::Hexadecimal, 0x1000);
+        let suffix = Suffix {
+            stype: SuffixType::Hexadecimal,
+            length: 3,
+            start: 0x1000,
+            auto_widening: false,
+            additional: ".txt".to_string(),
+        };
+        let it = FilenameIterator::new("chunk_", &suffix);
         assert!(it.is_err());
     }
 }
diff --git a/src/uu/split/src/number.rs b/src/uu/split/src/number.rs
index 39d64f9272e..6de90cfe7d0 100644
--- a/src/uu/split/src/number.rs
+++ b/src/uu/split/src/number.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 zaaa zaab
+// spell-checker:ignore zaaa zaab feff
 //! A number in arbitrary radix expressed in a positional notation.
 //!
 //! Use the [`Number`] enum to represent an arbitrary number in an
@@ -21,8 +21,8 @@ use std::fmt::{self, Display, Formatter};
 #[derive(Debug)]
 pub struct Overflow;
 
-impl fmt::Display for Overflow {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl Display for Overflow {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         write!(f, "Overflow")
     }
 }
@@ -398,6 +398,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_dynamic_width_number_display_alphabetic() {
         fn num(n: usize) -> Number {
             let mut number = Number::DynamicWidth(DynamicWidthNumber::new(26, 0));
@@ -443,6 +444,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_dynamic_width_number_display_numeric_hexadecimal() {
         fn num(n: usize) -> Number {
             let mut number = Number::DynamicWidth(DynamicWidthNumber::new(16, 0));
@@ -467,6 +469,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_fixed_width_number_increment() {
         let mut n = Number::FixedWidth(FixedWidthNumber::new(3, 2, 0).unwrap());
         assert_eq!(n.digits(), vec![0, 0]);
@@ -490,6 +493,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_fixed_width_number_display_alphabetic() {
         fn num(n: usize) -> Result<Number, Overflow> {
             let mut number = Number::FixedWidth(FixedWidthNumber::new(26, 2, 0).unwrap());
diff --git a/src/uu/split/src/platform/unix.rs b/src/uu/split/src/platform/unix.rs
index f4adb818834..446d8d66763 100644
--- a/src/uu/split/src/platform/unix.rs
+++ b/src/uu/split/src/platform/unix.rs
@@ -4,12 +4,13 @@
 // file that was distributed with this source code.
 use std::env;
 use std::io::Write;
-use std::io::{BufWriter, Error, ErrorKind, Result};
+use std::io::{BufWriter, Error, Result};
 use std::path::Path;
 use std::process::{Child, Command, Stdio};
-use uucore::crash;
+use uucore::error::USimpleError;
 use uucore::fs;
 use uucore::fs::FileInformation;
+use uucore::show;
 
 /// A writer that writes to a shell_process' stdin
 ///
@@ -48,7 +49,9 @@ impl WithEnvVarSet {
     /// Save previous value assigned to key, set key=value
     fn new(key: &str, value: &str) -> Self {
         let previous_env_value = env::var(key);
-        env::set_var(key, value);
+        unsafe {
+            env::set_var(key, value);
+        }
         Self {
             _previous_var_key: String::from(key),
             _previous_var_value: previous_env_value,
@@ -60,9 +63,13 @@ impl Drop for WithEnvVarSet {
     /// Restore previous value now that this is being dropped by context
     fn drop(&mut self) {
         if let Ok(ref prev_value) = self._previous_var_value {
-            env::set_var(&self._previous_var_key, prev_value);
+            unsafe {
+                env::set_var(&self._previous_var_key, prev_value);
+            }
         } else {
-            env::remove_var(&self._previous_var_key);
+            unsafe {
+                env::remove_var(&self._previous_var_key);
+            }
         }
     }
 }
@@ -101,35 +108,45 @@ impl Drop for FilterWriter {
             .expect("Couldn't wait for child process");
         if let Some(return_code) = exit_status.code() {
             if return_code != 0 {
-                crash!(1, "Shell process returned {}", return_code);
+                show!(USimpleError::new(
+                    1,
+                    format!("Shell process returned {return_code}")
+                ));
             }
         } else {
-            crash!(1, "Shell process terminated by signal")
+            show!(USimpleError::new(1, "Shell process terminated by signal"));
         }
     }
 }
 
 /// Instantiate either a file writer or a "write to shell process's stdin" writer
 pub fn instantiate_current_writer(
-    filter: &Option<String>,
+    filter: Option<&str>,
     filename: &str,
+    is_new: bool,
 ) -> Result<BufWriter<Box<dyn Write>>> {
     match filter {
-        None => Ok(BufWriter::new(Box::new(
-            // write to the next file
-            std::fs::OpenOptions::new()
-                .write(true)
-                .create(true)
-                .truncate(true)
-                .open(std::path::Path::new(&filename))
-                .map_err(|_| {
-                    Error::new(
-                        ErrorKind::Other,
-                        format!("unable to open '{filename}'; aborting"),
-                    )
-                })?,
-        ) as Box<dyn Write>)),
-        Some(ref filter_command) => Ok(BufWriter::new(Box::new(
+        None => {
+            let file = if is_new {
+                // create new file
+                std::fs::OpenOptions::new()
+                    .write(true)
+                    .create(true)
+                    .truncate(true)
+                    .open(Path::new(&filename))
+                    .map_err(|_| Error::other(format!("unable to open '{filename}'; aborting")))?
+            } else {
+                // re-open file that we previously created to append to it
+                std::fs::OpenOptions::new()
+                    .append(true)
+                    .open(Path::new(&filename))
+                    .map_err(|_| {
+                        Error::other(format!("unable to re-open '{filename}'; aborting"))
+                    })?
+            };
+            Ok(BufWriter::new(Box::new(file) as Box<dyn Write>))
+        }
+        Some(filter_command) => Ok(BufWriter::new(Box::new(
             // spawn a shell command and write to it
             FilterWriter::new(filter_command, filename)?,
         ) as Box<dyn Write>)),
diff --git a/src/uu/split/src/platform/windows.rs b/src/uu/split/src/platform/windows.rs
index 8b90789896f..576fa43c4d8 100644
--- a/src/uu/split/src/platform/windows.rs
+++ b/src/uu/split/src/platform/windows.rs
@@ -3,7 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use std::io::Write;
-use std::io::{BufWriter, Error, ErrorKind, Result};
+use std::io::{BufWriter, Error, Result};
 use std::path::Path;
 use uucore::fs;
 
@@ -12,23 +12,26 @@ use uucore::fs;
 /// Unlike the unix version of this function, this _always_ returns
 /// a file writer
 pub fn instantiate_current_writer(
-    _filter: &Option<String>,
+    _filter: Option<&str>,
     filename: &str,
+    is_new: bool,
 ) -> Result<BufWriter<Box<dyn Write>>> {
-    Ok(BufWriter::new(Box::new(
-        // write to the next file
+    let file = if is_new {
+        // create new file
         std::fs::OpenOptions::new()
             .write(true)
             .create(true)
             .truncate(true)
-            .open(std::path::Path::new(&filename))
-            .map_err(|_| {
-                Error::new(
-                    ErrorKind::Other,
-                    format!("'{filename}' would overwrite input; aborting"),
-                )
-            })?,
-    ) as Box<dyn Write>))
+            .open(Path::new(&filename))
+            .map_err(|_| Error::other(format!("unable to open '{filename}'; aborting")))?
+    } else {
+        // re-open file that we previously created to append to it
+        std::fs::OpenOptions::new()
+            .append(true)
+            .open(Path::new(&filename))
+            .map_err(|_| Error::other(format!("unable to re-open '{filename}'; aborting")))?
+    };
+    Ok(BufWriter::new(Box::new(file) as Box<dyn Write>))
 }
 
 pub fn paths_refer_to_same_file(p1: &str, p2: &str) -> bool {
diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs
index 517031791bd..64548ea387d 100644
--- a/src/uu/split/src/split.rs
+++ b/src/uu/split/src/split.rs
@@ -3,24 +3,27 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore nbbbb ncccc hexdigit
+// spell-checker:ignore nbbbb ncccc hexdigit getmaxstdio
 
 mod filenames;
 mod number;
 mod platform;
+mod strategy;
 
-use crate::filenames::FilenameIterator;
-use crate::filenames::SuffixType;
-use clap::{crate_version, parser::ValueSource, Arg, ArgAction, ArgMatches, Command};
+use crate::filenames::{FilenameIterator, Suffix, SuffixError};
+use crate::strategy::{NumberType, Strategy, StrategyError};
+use clap::{Arg, ArgAction, ArgMatches, Command, ValueHint, parser::ValueSource};
 use std::env;
-use std::fmt;
-use std::fs::{metadata, File};
+use std::ffi::OsString;
+use std::fs::{File, metadata};
 use std::io;
-use std::io::{stdin, BufRead, BufReader, BufWriter, ErrorKind, Read, Write};
+use std::io::{BufRead, BufReader, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write, stdin};
 use std::path::Path;
+use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UIoError, UResult, USimpleError, UUsageError};
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parser::parse_size::parse_size_u64;
+
 use uucore::uio_error;
 use uucore::{format_usage, help_about, help_section, help_usage};
 
@@ -35,13 +38,10 @@ static OPT_NUMERIC_SUFFIXES_SHORT: &str = "-d";
 static OPT_HEX_SUFFIXES: &str = "hex-suffixes";
 static OPT_HEX_SUFFIXES_SHORT: &str = "-x";
 static OPT_SUFFIX_LENGTH: &str = "suffix-length";
-static OPT_DEFAULT_SUFFIX_LENGTH: &str = "0";
 static OPT_VERBOSE: &str = "verbose";
-//The ---io and ---io-blksize parameters are consumed and ignored.
-//The parameter is included to make GNU coreutils tests pass.
-static OPT_IO: &str = "-io";
-static OPT_IO_BLKSIZE: &str = "-io-blksize";
+static OPT_SEPARATOR: &str = "separator";
 static OPT_ELIDE_EMPTY_FILES: &str = "elide-empty-files";
+static OPT_IO_BLKSIZE: &str = "-io-blksize";
 
 static ARG_INPUT: &str = "input";
 static ARG_PREFIX: &str = "prefix";
@@ -52,17 +52,183 @@ const AFTER_HELP: &str = help_section!("after help", "split.md");
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let (args, obs_lines) = handle_obsolete(args);
     let matches = uu_app().try_get_matches_from(args)?;
-    match Settings::from(&matches) {
+
+    match Settings::from(&matches, obs_lines.as_deref()) {
         Ok(settings) => split(&settings),
         Err(e) if e.requires_usage() => Err(UUsageError::new(1, format!("{e}"))),
         Err(e) => Err(USimpleError::new(1, format!("{e}"))),
     }
 }
 
+/// Extract obsolete shorthand (if any) for specifying lines in following scenarios (and similar)
+/// `split -22 file` would mean `split -l 22 file`
+/// `split -2de file` would mean `split -l 2 -d -e file`
+/// `split -x300e file` would mean `split -x -l 300 -e file`
+/// `split -x300e -22 file` would mean `split -x -e -l 22 file` (last obsolete lines option wins)
+/// following GNU `split` behavior
+fn handle_obsolete(args: impl uucore::Args) -> (Vec<OsString>, Option<String>) {
+    let mut obs_lines = None;
+    let mut preceding_long_opt_req_value = false;
+    let mut preceding_short_opt_req_value = false;
+
+    let filtered_args = args
+        .filter_map(|os_slice| {
+            filter_args(
+                os_slice,
+                &mut obs_lines,
+                &mut preceding_long_opt_req_value,
+                &mut preceding_short_opt_req_value,
+            )
+        })
+        .collect();
+
+    (filtered_args, obs_lines)
+}
+
+/// Helper function to [`handle_obsolete`]
+/// Filters out obsolete lines option from args
+fn filter_args(
+    os_slice: OsString,
+    obs_lines: &mut Option<String>,
+    preceding_long_opt_req_value: &mut bool,
+    preceding_short_opt_req_value: &mut bool,
+) -> Option<OsString> {
+    let filter: Option<OsString>;
+    if let Some(slice) = os_slice.to_str() {
+        if should_extract_obs_lines(
+            slice,
+            preceding_long_opt_req_value,
+            preceding_short_opt_req_value,
+        ) {
+            // start of the short option string
+            // that can have obsolete lines option value in it
+            filter = handle_extract_obs_lines(slice, obs_lines);
+        } else {
+            // either not a short option
+            // or a short option that cannot have obsolete lines value in it
+            filter = Some(OsString::from(slice));
+        }
+        handle_preceding_options(
+            slice,
+            preceding_long_opt_req_value,
+            preceding_short_opt_req_value,
+        );
+    } else {
+        // Cannot cleanly convert os_slice to UTF-8
+        // Do not process and return as-is
+        // This will cause failure later on, but we should not handle it here
+        // and let clap panic on invalid UTF-8 argument
+        filter = Some(os_slice);
+    }
+    filter
+}
+
+/// Helper function to [`filter_args`]
+/// Checks if the slice is a true short option (and not hyphen prefixed value of an option)
+/// and if so, a short option that can contain obsolete lines value
+fn should_extract_obs_lines(
+    slice: &str,
+    preceding_long_opt_req_value: &bool,
+    preceding_short_opt_req_value: &bool,
+) -> bool {
+    slice.starts_with('-')
+        && !slice.starts_with("--")
+        && !preceding_long_opt_req_value
+        && !preceding_short_opt_req_value
+        && !slice.starts_with("-a")
+        && !slice.starts_with("-b")
+        && !slice.starts_with("-C")
+        && !slice.starts_with("-l")
+        && !slice.starts_with("-n")
+        && !slice.starts_with("-t")
+}
+
+/// Helper function to [`filter_args`]
+/// Extracts obsolete lines numeric part from argument slice
+/// and filters it out
+fn handle_extract_obs_lines(slice: &str, obs_lines: &mut Option<String>) -> Option<OsString> {
+    let mut obs_lines_extracted: Vec<char> = vec![];
+    let mut obs_lines_end_reached = false;
+    let filtered_slice: Vec<char> = slice
+        .chars()
+        .filter(|c| {
+            // To correctly process scenario like '-x200a4'
+            // we need to stop extracting digits once alphabetic character is encountered
+            // after we already have something in obs_lines_extracted
+            if c.is_ascii_digit() && !obs_lines_end_reached {
+                obs_lines_extracted.push(*c);
+                false
+            } else {
+                if !obs_lines_extracted.is_empty() {
+                    obs_lines_end_reached = true;
+                }
+                true
+            }
+        })
+        .collect();
+
+    if obs_lines_extracted.is_empty() {
+        // no obsolete lines value found/extracted
+        Some(OsString::from(slice))
+    } else {
+        // obsolete lines value was extracted
+        let extracted: String = obs_lines_extracted.iter().collect();
+        *obs_lines = Some(extracted);
+        if filtered_slice.get(1).is_some() {
+            // there were some short options in front of or after obsolete lines value
+            // i.e. '-xd100' or '-100de' or similar, which after extraction of obsolete lines value
+            // would look like '-xd' or '-de' or similar
+            let filtered_slice: String = filtered_slice.iter().collect();
+            Some(OsString::from(filtered_slice))
+        } else {
+            None
+        }
+    }
+}
+
+/// Helper function to [`handle_extract_obs_lines`]
+/// Captures if current slice is a preceding option
+/// that requires value
+fn handle_preceding_options(
+    slice: &str,
+    preceding_long_opt_req_value: &mut bool,
+    preceding_short_opt_req_value: &mut bool,
+) {
+    // capture if current slice is a preceding long option that requires value and does not use '=' to assign that value
+    // following slice should be treaded as value for this option
+    // even if it starts with '-' (which would be treated as hyphen prefixed value)
+    if slice.starts_with("--") {
+        *preceding_long_opt_req_value = &slice[2..] == OPT_BYTES
+            || &slice[2..] == OPT_LINE_BYTES
+            || &slice[2..] == OPT_LINES
+            || &slice[2..] == OPT_ADDITIONAL_SUFFIX
+            || &slice[2..] == OPT_FILTER
+            || &slice[2..] == OPT_NUMBER
+            || &slice[2..] == OPT_SUFFIX_LENGTH
+            || &slice[2..] == OPT_SEPARATOR;
+    }
+    // capture if current slice is a preceding short option that requires value and does not have value in the same slice (value separated by whitespace)
+    // following slice should be treaded as value for this option
+    // even if it starts with '-' (which would be treated as hyphen prefixed value)
+    *preceding_short_opt_req_value = slice == "-b"
+        || slice == "-C"
+        || slice == "-l"
+        || slice == "-n"
+        || slice == "-a"
+        || slice == "-t";
+    // slice is a value
+    // reset preceding option flags
+    if !slice.starts_with('-') {
+        *preceding_short_opt_req_value = false;
+        *preceding_long_opt_req_value = false;
+    }
+}
+
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(AFTER_HELP)
         .override_usage(format_usage(USAGE))
@@ -72,6 +238,7 @@ pub fn uu_app() -> Command {
             Arg::new(OPT_BYTES)
                 .short('b')
                 .long(OPT_BYTES)
+                .allow_hyphen_values(true)
                 .value_name("SIZE")
                 .help("put SIZE bytes per output file"),
         )
@@ -79,14 +246,15 @@ pub fn uu_app() -> Command {
             Arg::new(OPT_LINE_BYTES)
                 .short('C')
                 .long(OPT_LINE_BYTES)
+                .allow_hyphen_values(true)
                 .value_name("SIZE")
-                .default_value("2")
                 .help("put at most SIZE bytes of lines per output file"),
         )
         .arg(
             Arg::new(OPT_LINES)
                 .short('l')
                 .long(OPT_LINES)
+                .allow_hyphen_values(true)
                 .value_name("NUMBER")
                 .default_value("1000")
                 .help("put NUMBER lines/records per output file"),
@@ -95,6 +263,7 @@ pub fn uu_app() -> Command {
             Arg::new(OPT_NUMBER)
                 .short('n')
                 .long(OPT_NUMBER)
+                .allow_hyphen_values(true)
                 .value_name("CHUNKS")
                 .help("generate CHUNKS output files; see explanation below"),
         )
@@ -102,6 +271,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(OPT_ADDITIONAL_SUFFIX)
                 .long(OPT_ADDITIONAL_SUFFIX)
+                .allow_hyphen_values(true)
                 .value_name("SUFFIX")
                 .default_value("")
                 .help("additional SUFFIX to append to output file names"),
@@ -109,8 +279,9 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(OPT_FILTER)
                 .long(OPT_FILTER)
+                .allow_hyphen_values(true)
                 .value_name("COMMAND")
-                .value_hint(clap::ValueHint::CommandName)
+                .value_hint(ValueHint::CommandName)
                 .help(
                     "write to shell COMMAND; file name is $FILE (Currently not implemented for Windows)",
                 ),
@@ -125,7 +296,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(OPT_NUMERIC_SUFFIXES_SHORT)
                 .short('d')
-                .action(clap::ArgAction::SetTrue)
+                .action(ArgAction::SetTrue)
                 .overrides_with_all([
                     OPT_NUMERIC_SUFFIXES,
                     OPT_NUMERIC_SUFFIXES_SHORT,
@@ -138,7 +309,6 @@ pub fn uu_app() -> Command {
             Arg::new(OPT_NUMERIC_SUFFIXES)
                 .long(OPT_NUMERIC_SUFFIXES)
                 .require_equals(true)
-                .default_missing_value("0")
                 .num_args(0..=1)
                 .overrides_with_all([
                     OPT_NUMERIC_SUFFIXES,
@@ -146,12 +316,13 @@ pub fn uu_app() -> Command {
                     OPT_HEX_SUFFIXES,
                     OPT_HEX_SUFFIXES_SHORT
                 ])
+                .value_name("FROM")
                 .help("same as -d, but allow setting the start value"),
         )
         .arg(
             Arg::new(OPT_HEX_SUFFIXES_SHORT)
                 .short('x')
-                .action(clap::ArgAction::SetTrue)
+                .action(ArgAction::SetTrue)
                 .overrides_with_all([
                     OPT_NUMERIC_SUFFIXES,
                     OPT_NUMERIC_SUFFIXES_SHORT,
@@ -163,7 +334,6 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(OPT_HEX_SUFFIXES)
                 .long(OPT_HEX_SUFFIXES)
-                .default_missing_value("0")
                 .require_equals(true)
                 .num_args(0..=1)
                 .overrides_with_all([
@@ -172,15 +342,16 @@ pub fn uu_app() -> Command {
                     OPT_HEX_SUFFIXES,
                     OPT_HEX_SUFFIXES_SHORT
                 ])
+                .value_name("FROM")
                 .help("same as -x, but allow setting the start value"),
         )
         .arg(
             Arg::new(OPT_SUFFIX_LENGTH)
                 .short('a')
                 .long(OPT_SUFFIX_LENGTH)
+                .allow_hyphen_values(true)
                 .value_name("N")
-                .default_value(OPT_DEFAULT_SUFFIX_LENGTH)
-                .help("use suffixes of fixed length N. 0 implies dynamic length."),
+                .help("generate suffixes of length N (default 2)"),
         )
         .arg(
             Arg::new(OPT_VERBOSE)
@@ -189,10 +360,13 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new(OPT_IO)
-                .long("io")
-                .alias(OPT_IO)
-                .hide(true),
+            Arg::new(OPT_SEPARATOR)
+                .short('t')
+                .long(OPT_SEPARATOR)
+                .allow_hyphen_values(true)
+                .value_name("SEP")
+                .action(ArgAction::Append)
+                .help("use SEP instead of newline as the record separator; '\\0' (zero) specifies the NUL character"),
         )
         .arg(
             Arg::new(OPT_IO_BLKSIZE)
@@ -203,7 +377,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(ARG_INPUT)
                 .default_value("-")
-                .value_hint(clap::ValueHint::FilePath),
+                .value_hint(ValueHint::FilePath),
         )
         .arg(
             Arg::new(ARG_PREFIX)
@@ -211,285 +385,19 @@ pub fn uu_app() -> Command {
         )
 }
 
-/// Sub-strategy to use when splitting a file into a specific number of chunks.
-#[derive(Debug, PartialEq)]
-enum NumberType {
-    /// Split into a specific number of chunks by byte.
-    Bytes(u64),
-
-    /// Split into a specific number of chunks by line (approximately).
-    Lines(u64),
-
-    /// Split into a specific number of chunks by line
-    /// (approximately), but output only the *k*th chunk.
-    KthLines(u64, u64),
-
-    /// Assign lines via round-robin to the specified number of output chunks.
-    RoundRobin(u64),
-
-    /// Assign lines via round-robin to the specified number of output
-    /// chunks, but output only the *k*th chunk.
-    KthRoundRobin(u64, u64),
-}
-
-impl NumberType {
-    /// The number of chunks for this number type.
-    fn num_chunks(&self) -> u64 {
-        match self {
-            Self::Bytes(n) => *n,
-            Self::Lines(n) => *n,
-            Self::KthLines(_, n) => *n,
-            Self::RoundRobin(n) => *n,
-            Self::KthRoundRobin(_, n) => *n,
-        }
-    }
-}
-
-/// An error due to an invalid parameter to the `-n` command-line option.
-#[derive(Debug, PartialEq)]
-enum NumberTypeError {
-    /// The number of chunks was invalid.
-    ///
-    /// This can happen if the value of `N` in any of the following
-    /// command-line options is not a positive integer:
-    ///
-    /// ```ignore
-    /// -n N
-    /// -n l/N
-    /// -n l/K/N
-    /// -n r/N
-    /// -n r/K/N
-    /// ```
-    NumberOfChunks(String),
-
-    /// The chunk number was invalid.
-    ///
-    /// This can happen if the value of `K` in any of the following
-    /// command-line options is not a positive integer:
-    ///
-    /// ```ignore
-    /// -n l/K/N
-    /// -n r/K/N
-    /// ```
-    ChunkNumber(String),
-}
-
-impl NumberType {
-    /// Parse a `NumberType` from a string.
-    ///
-    /// The following strings are valid arguments:
-    ///
-    /// ```ignore
-    /// "N"
-    /// "l/N"
-    /// "l/K/N"
-    /// "r/N"
-    /// "r/K/N"
-    /// ```
-    ///
-    /// The `N` represents the number of chunks and the `K` represents
-    /// a chunk number.
-    ///
-    /// # Errors
-    ///
-    /// If the string is not one of the valid number types, if `K` is
-    /// not a nonnegative integer, or if `N` is not a positive
-    /// integer, then this function returns [`NumberTypeError`].
-    fn from(s: &str) -> Result<Self, NumberTypeError> {
-        let parts: Vec<&str> = s.split('/').collect();
-        match &parts[..] {
-            [n_str] => {
-                let num_chunks = n_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
-                if num_chunks > 0 {
-                    Ok(Self::Bytes(num_chunks))
-                } else {
-                    Err(NumberTypeError::NumberOfChunks(s.to_string()))
-                }
-            }
-            ["l", n_str] => {
-                let num_chunks = n_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
-                Ok(Self::Lines(num_chunks))
-            }
-            ["l", k_str, n_str] => {
-                let num_chunks = n_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
-                let chunk_number = k_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
-                Ok(Self::KthLines(chunk_number, num_chunks))
-            }
-            ["r", n_str] => {
-                let num_chunks = n_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
-                Ok(Self::RoundRobin(num_chunks))
-            }
-            ["r", k_str, n_str] => {
-                let num_chunks = n_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
-                let chunk_number = k_str
-                    .parse()
-                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
-                Ok(Self::KthRoundRobin(chunk_number, num_chunks))
-            }
-            _ => Err(NumberTypeError::NumberOfChunks(s.to_string())),
-        }
-    }
-}
-
-/// The strategy for breaking up the input file into chunks.
-enum Strategy {
-    /// Each chunk has the specified number of lines.
-    Lines(u64),
-
-    /// Each chunk has the specified number of bytes.
-    Bytes(u64),
-
-    /// Each chunk has as many lines as possible without exceeding the
-    /// specified number of bytes.
-    LineBytes(u64),
-
-    /// Split the file into this many chunks.
-    ///
-    /// There are several sub-strategies available, as defined by
-    /// [`NumberType`].
-    Number(NumberType),
-}
-
-/// An error when parsing a chunking strategy from command-line arguments.
-enum StrategyError {
-    /// Invalid number of lines.
-    Lines(ParseSizeError),
-
-    /// Invalid number of bytes.
-    Bytes(ParseSizeError),
-
-    /// Invalid number type.
-    NumberType(NumberTypeError),
-
-    /// Multiple chunking strategies were specified (but only one should be).
-    MultipleWays,
-}
-
-impl fmt::Display for StrategyError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::Lines(e) => write!(f, "invalid number of lines: {e}"),
-            Self::Bytes(e) => write!(f, "invalid number of bytes: {e}"),
-            Self::NumberType(NumberTypeError::NumberOfChunks(s)) => {
-                write!(f, "invalid number of chunks: {s}")
-            }
-            Self::NumberType(NumberTypeError::ChunkNumber(s)) => {
-                write!(f, "invalid chunk number: {s}")
-            }
-            Self::MultipleWays => write!(f, "cannot split in more than one way"),
-        }
-    }
-}
-
-impl Strategy {
-    /// Parse a strategy from the command-line arguments.
-    fn from(matches: &ArgMatches) -> Result<Self, StrategyError> {
-        fn get_and_parse(
-            matches: &ArgMatches,
-            option: &str,
-            strategy: fn(u64) -> Strategy,
-            error: fn(ParseSizeError) -> StrategyError,
-        ) -> Result<Strategy, StrategyError> {
-            let s = matches.get_one::<String>(option).unwrap();
-            let n = parse_size(s).map_err(error)?;
-            if n > 0 {
-                Ok(strategy(n))
-            } else {
-                Err(error(ParseSizeError::ParseFailure(s.to_string())))
-            }
-        }
-        // Check that the user is not specifying more than one strategy.
-        //
-        // Note: right now, this exact behavior cannot be handled by
-        // `ArgGroup` since `ArgGroup` considers a default value `Arg`
-        // as "defined".
-        match (
-            matches.value_source(OPT_LINES) == Some(ValueSource::CommandLine),
-            matches.value_source(OPT_BYTES) == Some(ValueSource::CommandLine),
-            matches.value_source(OPT_LINE_BYTES) == Some(ValueSource::CommandLine),
-            matches.value_source(OPT_NUMBER) == Some(ValueSource::CommandLine),
-        ) {
-            (false, false, false, false) => Ok(Self::Lines(1000)),
-            (true, false, false, false) => {
-                get_and_parse(matches, OPT_LINES, Self::Lines, StrategyError::Lines)
-            }
-            (false, true, false, false) => {
-                get_and_parse(matches, OPT_BYTES, Self::Bytes, StrategyError::Bytes)
-            }
-            (false, false, true, false) => get_and_parse(
-                matches,
-                OPT_LINE_BYTES,
-                Self::LineBytes,
-                StrategyError::Bytes,
-            ),
-            (false, false, false, true) => {
-                let s = matches.get_one::<String>(OPT_NUMBER).unwrap();
-                let number_type = NumberType::from(s).map_err(StrategyError::NumberType)?;
-                Ok(Self::Number(number_type))
-            }
-            _ => Err(StrategyError::MultipleWays),
-        }
-    }
-}
-
-/// Parse the suffix type from the command-line arguments.
-fn suffix_type_from(matches: &ArgMatches) -> Result<(SuffixType, usize), SettingsError> {
-    // Check if the user is specifying one or more than one suffix
-    // Any combination of suffixes is allowed
-    // Since all suffixes are setup with 'overrides_with_all()' against themselves and each other,
-    // last one wins, all others are ignored
-    match (
-        matches.get_one::<String>(OPT_NUMERIC_SUFFIXES),
-        matches.get_one::<String>(OPT_HEX_SUFFIXES),
-        matches.get_flag(OPT_NUMERIC_SUFFIXES_SHORT),
-        matches.get_flag(OPT_HEX_SUFFIXES_SHORT),
-    ) {
-        (Some(v), _, _, _) => {
-            let suffix_start = v;
-            let suffix_start = suffix_start
-                .parse::<usize>()
-                .map_err(|_| SettingsError::SuffixNotParsable(suffix_start.to_string()))?;
-            Ok((SuffixType::Decimal, suffix_start))
-        }
-        (_, Some(v), _, _) => {
-            let suffix_start = v;
-            let suffix_start = usize::from_str_radix(suffix_start, 16)
-                .map_err(|_| SettingsError::SuffixNotParsable(suffix_start.to_string()))?;
-            Ok((SuffixType::Hexadecimal, suffix_start))
-        }
-        (_, _, true, _) => Ok((SuffixType::Decimal, 0)), // short numeric suffix '-d', default start 0
-        (_, _, _, true) => Ok((SuffixType::Hexadecimal, 0)), // short hex suffix '-x', default start 0
-        _ => Ok((SuffixType::Alphabetic, 0)), // no numeric/hex suffix, using default alphabetic
-    }
-}
-
 /// Parameters that control how a file gets split.
 ///
 /// You can convert an [`ArgMatches`] instance into a [`Settings`]
 /// instance by calling [`Settings::from`].
 struct Settings {
     prefix: String,
-    suffix_type: SuffixType,
-    suffix_length: usize,
-    suffix_start: usize,
-    additional_suffix: String,
+    suffix: Suffix,
     input: String,
     /// When supplied, a shell command to output to instead of xaa, xab …
     filter: Option<String>,
     strategy: Strategy,
     verbose: bool,
+    separator: u8,
 
     /// Whether to *not* produce empty files when using `-n`.
     ///
@@ -500,24 +408,42 @@ struct Settings {
     /// chunks. If this is `false`, then empty files will not be
     /// created.
     elide_empty_files: bool,
+    io_blksize: Option<u64>,
 }
 
+#[derive(Debug, Error)]
 /// An error when parsing settings from command-line arguments.
 enum SettingsError {
     /// Invalid chunking strategy.
+    #[error("{0}")]
     Strategy(StrategyError),
 
     /// Invalid suffix length parameter.
-    SuffixNotParsable(String),
+    #[error("{0}")]
+    Suffix(SuffixError),
 
-    /// Suffix contains a directory separator, which is not allowed.
-    SuffixContainsSeparator(String),
+    /// Multi-character (Invalid) separator
+    #[error("multi-character separator {}", .0.quote())]
+    MultiCharacterSeparator(String),
 
-    /// Suffix is not large enough to split into specified chunks
-    SuffixTooSmall(usize),
+    /// Multiple different separator characters
+    #[error("multiple separator characters specified")]
+    MultipleSeparatorCharacters,
+
+    /// Using `--filter` with `--number` option sub-strategies that print Kth chunk out of N chunks to stdout
+    /// K/N
+    /// l/K/N
+    /// r/K/N
+    #[error("--filter does not process a chunk extracted to stdout")]
+    FilterWithKthChunkNumber,
+
+    /// Invalid IO block size
+    #[error("invalid IO block size: {}", .0.quote())]
+    InvalidIOBlockSize(String),
 
     /// The `--filter` option is not supported on Windows.
     #[cfg(windows)]
+    #[error("{OPT_FILTER} is currently not supported in this platform")]
     NotSupported,
 }
 
@@ -526,89 +452,221 @@ impl SettingsError {
     fn requires_usage(&self) -> bool {
         matches!(
             self,
-            Self::Strategy(StrategyError::MultipleWays) | Self::SuffixContainsSeparator(_)
+            Self::Strategy(StrategyError::MultipleWays)
+                | Self::Suffix(SuffixError::ContainsSeparator(_))
         )
     }
 }
 
-impl fmt::Display for SettingsError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::Strategy(e) => e.fmt(f),
-            Self::SuffixNotParsable(s) => write!(f, "invalid suffix length: {}", s.quote()),
-            Self::SuffixTooSmall(i) => write!(f, "the suffix length needs to be at least {i}"),
-            Self::SuffixContainsSeparator(s) => write!(
-                f,
-                "invalid suffix {}, contains directory separator",
-                s.quote()
-            ),
-            #[cfg(windows)]
-            Self::NotSupported => write!(
-                f,
-                "{OPT_FILTER} is currently not supported in this platform"
-            ),
-        }
-    }
-}
-
 impl Settings {
     /// Parse a strategy from the command-line arguments.
-    fn from(matches: &ArgMatches) -> Result<Self, SettingsError> {
-        let additional_suffix = matches
-            .get_one::<String>(OPT_ADDITIONAL_SUFFIX)
-            .unwrap()
-            .to_string();
-        if additional_suffix.contains('/') {
-            return Err(SettingsError::SuffixContainsSeparator(additional_suffix));
-        }
-        let strategy = Strategy::from(matches).map_err(SettingsError::Strategy)?;
-        let (suffix_type, suffix_start) = suffix_type_from(matches)?;
-        let suffix_length_str = matches.get_one::<String>(OPT_SUFFIX_LENGTH).unwrap();
-        let suffix_length: usize = suffix_length_str
-            .parse()
-            .map_err(|_| SettingsError::SuffixNotParsable(suffix_length_str.to_string()))?;
-        if let Strategy::Number(ref number_type) = strategy {
-            let chunks = number_type.num_chunks();
-            if suffix_length != 0 {
-                let required_suffix_length =
-                    (chunks as f64).log(suffix_type.radix() as f64).ceil() as usize;
-                if suffix_length < required_suffix_length {
-                    return Err(SettingsError::SuffixTooSmall(required_suffix_length));
+    fn from(matches: &ArgMatches, obs_lines: Option<&str>) -> Result<Self, SettingsError> {
+        let strategy = Strategy::from(matches, obs_lines).map_err(SettingsError::Strategy)?;
+        let suffix = Suffix::from(matches, &strategy).map_err(SettingsError::Suffix)?;
+
+        // Make sure that separator is only one UTF8 character (if specified)
+        // defaults to '\n' - newline character
+        // If the same separator (the same value) was used multiple times - `split` should NOT fail
+        // If the separator was used multiple times but with different values (not all values are the same) - `split` should fail
+        let separator = match matches.get_many::<String>(OPT_SEPARATOR) {
+            Some(mut sep_values) => {
+                let first = sep_values.next().unwrap(); // it is safe to just unwrap here since Clap should not return empty ValuesRef<'_,String> in the option from get_many() call
+                if !sep_values.all(|s| s == first) {
+                    return Err(SettingsError::MultipleSeparatorCharacters);
+                }
+                match first.as_str() {
+                    "\\0" => b'\0',
+                    s if s.len() == 1 => s.as_bytes()[0],
+                    s => return Err(SettingsError::MultiCharacterSeparator(s.to_string())),
                 }
             }
-        }
+            None => b'\n',
+        };
+
+        let io_blksize: Option<u64> = if let Some(s) = matches.get_one::<String>(OPT_IO_BLKSIZE) {
+            match parse_size_u64(s) {
+                Ok(0) => return Err(SettingsError::InvalidIOBlockSize(s.to_string())),
+                Ok(n) if n <= uucore::fs::sane_blksize::MAX => Some(n),
+                _ => return Err(SettingsError::InvalidIOBlockSize(s.to_string())),
+            }
+        } else {
+            None
+        };
+
         let result = Self {
-            suffix_length: suffix_length_str
-                .parse()
-                .map_err(|_| SettingsError::SuffixNotParsable(suffix_length_str.to_string()))?,
-            suffix_type,
-            suffix_start,
-            additional_suffix,
-            verbose: matches.value_source("verbose") == Some(ValueSource::CommandLine),
+            prefix: matches.get_one::<String>(ARG_PREFIX).unwrap().clone(),
+            suffix,
+            input: matches.get_one::<String>(ARG_INPUT).unwrap().clone(),
+            filter: matches.get_one::<String>(OPT_FILTER).cloned(),
             strategy,
-            input: matches.get_one::<String>(ARG_INPUT).unwrap().to_owned(),
-            prefix: matches.get_one::<String>(ARG_PREFIX).unwrap().to_owned(),
-            filter: matches.get_one::<String>(OPT_FILTER).map(|s| s.to_owned()),
+            verbose: matches.value_source(OPT_VERBOSE) == Some(ValueSource::CommandLine),
+            separator,
             elide_empty_files: matches.get_flag(OPT_ELIDE_EMPTY_FILES),
+            io_blksize,
         };
+
         #[cfg(windows)]
         if result.filter.is_some() {
             // see https://github.com/rust-lang/rust/issues/29494
             return Err(SettingsError::NotSupported);
         }
 
+        // Return an error if `--filter` option is used with any of the
+        // Kth chunk sub-strategies of `--number` option
+        // As those are writing to stdout of `split` and cannot write to filter command child process
+        let kth_chunk = matches!(
+            result.strategy,
+            Strategy::Number(
+                NumberType::KthBytes(_, _)
+                    | NumberType::KthLines(_, _)
+                    | NumberType::KthRoundRobin(_, _)
+            )
+        );
+        if kth_chunk && result.filter.is_some() {
+            return Err(SettingsError::FilterWithKthChunkNumber);
+        }
+
         Ok(result)
     }
 
-    fn instantiate_current_writer(&self, filename: &str) -> io::Result<BufWriter<Box<dyn Write>>> {
+    fn instantiate_current_writer(
+        &self,
+        filename: &str,
+        is_new: bool,
+    ) -> io::Result<BufWriter<Box<dyn Write>>> {
         if platform::paths_refer_to_same_file(&self.input, filename) {
-            return Err(io::Error::new(
-                ErrorKind::Other,
-                format!("'{filename}' would overwrite input; aborting"),
-            ));
+            return Err(io::Error::other(format!(
+                "'{filename}' would overwrite input; aborting"
+            )));
         }
 
-        platform::instantiate_current_writer(&self.filter, filename)
+        platform::instantiate_current_writer(self.filter.as_deref(), filename, is_new)
+    }
+}
+
+/// When using `--filter` option, writing to child command process stdin
+/// could fail with BrokenPipe error
+/// It can be safely ignored
+fn ignorable_io_error(error: &io::Error, settings: &Settings) -> bool {
+    error.kind() == ErrorKind::BrokenPipe && settings.filter.is_some()
+}
+
+/// Custom wrapper for `write()` method
+/// Follows similar approach to GNU implementation
+/// If ignorable io error occurs, return number of bytes as if all bytes written
+/// Should not be used for Kth chunk number sub-strategies
+/// as those do not work with `--filter` option
+fn custom_write<T: Write>(bytes: &[u8], writer: &mut T, settings: &Settings) -> io::Result<usize> {
+    match writer.write(bytes) {
+        Ok(n) => Ok(n),
+        Err(e) if ignorable_io_error(&e, settings) => Ok(bytes.len()),
+        Err(e) => Err(e),
+    }
+}
+
+/// Custom wrapper for `write_all()` method
+/// Similar to [`custom_write`], but returns true or false
+/// depending on if `--filter` stdin is still open (no BrokenPipe error)
+/// Should not be used for Kth chunk number sub-strategies
+/// as those do not work with `--filter` option
+fn custom_write_all<T: Write>(
+    bytes: &[u8],
+    writer: &mut T,
+    settings: &Settings,
+) -> io::Result<bool> {
+    match writer.write_all(bytes) {
+        Ok(()) => Ok(true),
+        Err(e) if ignorable_io_error(&e, settings) => Ok(false),
+        Err(e) => Err(e),
+    }
+}
+
+/// Get the size of the input file in bytes
+/// Used only for subset of `--number=CHUNKS` strategy, as there is a need
+/// to determine input file size upfront in order to estimate the chunk size
+/// to be written into each of N files/chunks:
+/// * N       split into N files based on size of input
+/// * K/N     output Kth of N to stdout
+/// * l/N     split into N files without splitting lines/records
+/// * l/K/N   output Kth of N to stdout without splitting lines/records
+///
+/// For most files the size will be determined by either reading entire file content into a buffer
+/// or by `len()` function of [`std::fs::metadata`].
+///
+/// However, for some files which report filesystem metadata size that does not match
+/// their actual content size, we will need to attempt to find the end of file
+/// with direct `seek()` on [`std::fs::File`].
+///
+/// For STDIN stream - read into a buffer up to a limit
+/// If input stream does not EOF before that - return an error
+/// (i.e. "infinite" input as in `cat /dev/zero | split ...`, `yes | split ...` etc.).
+///
+/// Note: The `buf` might end up with either partial or entire input content.
+fn get_input_size<R>(
+    input: &String,
+    reader: &mut R,
+    buf: &mut Vec<u8>,
+    io_blksize: Option<u64>,
+) -> io::Result<u64>
+where
+    R: BufRead,
+{
+    // Set read limit to io_blksize if specified
+    let read_limit: u64 = if let Some(custom_blksize) = io_blksize {
+        custom_blksize
+    } else {
+        // otherwise try to get it from filesystem, or use default
+        uucore::fs::sane_blksize::sane_blksize_from_path(Path::new(input))
+    };
+
+    // Try to read into buffer up to a limit
+    let num_bytes = reader
+        .by_ref()
+        .take(read_limit)
+        .read_to_end(buf)
+        .map(|n| n as u64)?;
+
+    if num_bytes < read_limit {
+        // Finite file or STDIN stream that fits entirely
+        // into a buffer within the limit
+        // Note: files like /dev/null or similar,
+        // empty STDIN stream,
+        // and files with true file size 0
+        // will also fit here
+        Ok(num_bytes)
+    } else if input == "-" {
+        // STDIN stream that did not fit all content into a buffer
+        // Most likely continuous/infinite input stream
+        return Err(io::Error::other(format!(
+            "{input}: cannot determine input size"
+        )));
+    } else {
+        // Could be that file size is larger than set read limit
+        // Get the file size from filesystem metadata
+        let metadata = metadata(input)?;
+        let metadata_size = metadata.len();
+        if num_bytes <= metadata_size {
+            Ok(metadata_size)
+        } else {
+            // Could be a file from locations like /dev, /sys, /proc or similar
+            // which report filesystem metadata size that does not match
+            // their actual content size
+            // Attempt direct `seek()` for the end of a file
+            let mut tmp_fd = File::open(Path::new(input))?;
+            let end = tmp_fd.seek(SeekFrom::End(0))?;
+            if end > 0 {
+                Ok(end)
+            } else {
+                // Edge case of either "infinite" file (i.e. /dev/zero)
+                // or some other "special" non-standard file type
+                // Give up and return an error
+                // TODO It might be possible to do more here
+                // to address all possible file types and edge cases
+                return Err(io::Error::other(format!(
+                    "{input}: cannot determine file size"
+                )));
+            }
+        }
     }
 }
 
@@ -649,21 +707,15 @@ struct ByteChunkWriter<'a> {
 }
 
 impl<'a> ByteChunkWriter<'a> {
-    fn new(chunk_size: u64, settings: &'a Settings) -> UResult<ByteChunkWriter<'a>> {
-        let mut filename_iterator = FilenameIterator::new(
-            &settings.prefix,
-            &settings.additional_suffix,
-            settings.suffix_length,
-            settings.suffix_type,
-            settings.suffix_start,
-        )?;
+    fn new(chunk_size: u64, settings: &'a Settings) -> UResult<Self> {
+        let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
         let filename = filename_iterator
             .next()
             .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
         if settings.verbose {
             println!("creating file {}", filename.quote());
         }
-        let inner = settings.instantiate_current_writer(&filename)?;
+        let inner = settings.instantiate_current_writer(&filename, true)?;
         Ok(ByteChunkWriter {
             settings,
             chunk_size,
@@ -675,8 +727,9 @@ impl<'a> ByteChunkWriter<'a> {
     }
 }
 
-impl<'a> Write for ByteChunkWriter<'a> {
-    fn write(&mut self, mut buf: &[u8]) -> std::io::Result<usize> {
+impl Write for ByteChunkWriter<'_> {
+    /// Implements `--bytes=SIZE`
+    fn write(&mut self, mut buf: &[u8]) -> io::Result<usize> {
         // If the length of `buf` exceeds the number of bytes remaining
         // in the current chunk, we will need to write to multiple
         // different underlying writers. In that case, each iteration of
@@ -694,22 +747,23 @@ impl<'a> Write for ByteChunkWriter<'a> {
                 self.num_bytes_remaining_in_current_chunk = self.chunk_size;
 
                 // Allocate the new file, since at this point we know there are bytes to be written to it.
-                let filename = self.filename_iterator.next().ok_or_else(|| {
-                    std::io::Error::new(ErrorKind::Other, "output file suffixes exhausted")
-                })?;
+                let filename = self
+                    .filename_iterator
+                    .next()
+                    .ok_or_else(|| io::Error::other("output file suffixes exhausted"))?;
                 if self.settings.verbose {
                     println!("creating file {}", filename.quote());
                 }
-                self.inner = self.settings.instantiate_current_writer(&filename)?;
+                self.inner = self.settings.instantiate_current_writer(&filename, true)?;
             }
 
             // If the capacity of this chunk is greater than the number of
             // bytes in `buf`, then write all the bytes in `buf`. Otherwise,
             // write enough bytes to fill the current chunk, then increment
             // the chunk number and repeat.
-            let n = buf.len();
-            if (n as u64) < self.num_bytes_remaining_in_current_chunk {
-                let num_bytes_written = self.inner.write(buf)?;
+            let buf_len = buf.len();
+            if (buf_len as u64) < self.num_bytes_remaining_in_current_chunk {
+                let num_bytes_written = custom_write(buf, &mut self.inner, self.settings)?;
                 self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64;
                 return Ok(carryover_bytes_written + num_bytes_written);
             } else {
@@ -719,7 +773,7 @@ impl<'a> Write for ByteChunkWriter<'a> {
                 // self.num_bytes_remaining_in_current_chunk is lower than
                 // n, which is already usize.
                 let i = self.num_bytes_remaining_in_current_chunk as usize;
-                let num_bytes_written = self.inner.write(&buf[..i])?;
+                let num_bytes_written = custom_write(&buf[..i], &mut self.inner, self.settings)?;
                 self.num_bytes_remaining_in_current_chunk -= num_bytes_written as u64;
 
                 // It's possible that the underlying writer did not
@@ -736,7 +790,7 @@ impl<'a> Write for ByteChunkWriter<'a> {
             }
         }
     }
-    fn flush(&mut self) -> std::io::Result<()> {
+    fn flush(&mut self) -> io::Result<()> {
         self.inner.flush()
     }
 }
@@ -778,21 +832,9 @@ struct LineChunkWriter<'a> {
 }
 
 impl<'a> LineChunkWriter<'a> {
-    fn new(chunk_size: u64, settings: &'a Settings) -> UResult<LineChunkWriter<'a>> {
-        let mut filename_iterator = FilenameIterator::new(
-            &settings.prefix,
-            &settings.additional_suffix,
-            settings.suffix_length,
-            settings.suffix_type,
-            settings.suffix_start,
-        )?;
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        if settings.verbose {
-            println!("creating file {}", filename.quote());
-        }
-        let inner = settings.instantiate_current_writer(&filename)?;
+    fn new(chunk_size: u64, settings: &'a Settings) -> UResult<Self> {
+        let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
+        let inner = Self::start_new_chunk(settings, &mut filename_iterator)?;
         Ok(LineChunkWriter {
             settings,
             chunk_size,
@@ -802,10 +844,24 @@ impl<'a> LineChunkWriter<'a> {
             filename_iterator,
         })
     }
+
+    fn start_new_chunk(
+        settings: &Settings,
+        filename_iterator: &mut FilenameIterator,
+    ) -> io::Result<BufWriter<Box<dyn Write>>> {
+        let filename = filename_iterator
+            .next()
+            .ok_or_else(|| io::Error::other("output file suffixes exhausted"))?;
+        if settings.verbose {
+            println!("creating file {}", filename.quote());
+        }
+        settings.instantiate_current_writer(&filename, true)
+    }
 }
 
-impl<'a> Write for LineChunkWriter<'a> {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+impl Write for LineChunkWriter<'_> {
+    /// Implements `--lines=NUMBER`
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         // If the number of lines in `buf` exceeds the number of lines
         // remaining in the current chunk, we will need to write to
         // multiple different underlying writers. In that case, each
@@ -813,277 +869,255 @@ impl<'a> Write for LineChunkWriter<'a> {
         // corresponds to the current chunk number.
         let mut prev = 0;
         let mut total_bytes_written = 0;
-        for i in memchr::memchr_iter(b'\n', buf) {
+        let sep = self.settings.separator;
+        for i in memchr::memchr_iter(sep, buf) {
             // If we have exceeded the number of lines to write in the
             // current chunk, then start a new chunk and its
             // corresponding writer.
             if self.num_lines_remaining_in_current_chunk == 0 {
                 self.num_chunks_written += 1;
-                let filename = self.filename_iterator.next().ok_or_else(|| {
-                    std::io::Error::new(ErrorKind::Other, "output file suffixes exhausted")
-                })?;
-                if self.settings.verbose {
-                    println!("creating file {}", filename.quote());
-                }
-                self.inner = self.settings.instantiate_current_writer(&filename)?;
+                self.inner = Self::start_new_chunk(self.settings, &mut self.filename_iterator)?;
                 self.num_lines_remaining_in_current_chunk = self.chunk_size;
             }
 
             // Write the line, starting from *after* the previous
-            // newline character and ending *after* the current
-            // newline character.
-            let n = self.inner.write(&buf[prev..i + 1])?;
-            total_bytes_written += n;
+            // separator character and ending *after* the current
+            // separator character.
+            let num_bytes_written = custom_write(&buf[prev..=i], &mut self.inner, self.settings)?;
+            total_bytes_written += num_bytes_written;
             prev = i + 1;
             self.num_lines_remaining_in_current_chunk -= 1;
         }
 
-        let n = self.inner.write(&buf[prev..buf.len()])?;
-        total_bytes_written += n;
+        // There might be bytes remaining in the buffer, and we write
+        // them to the current chunk. But first, we may need to rotate
+        // the current chunk in case it has already reached its line
+        // limit.
+        if prev < buf.len() {
+            if self.num_lines_remaining_in_current_chunk == 0 {
+                self.inner = Self::start_new_chunk(self.settings, &mut self.filename_iterator)?;
+                self.num_lines_remaining_in_current_chunk = self.chunk_size;
+            }
+            let num_bytes_written =
+                custom_write(&buf[prev..buf.len()], &mut self.inner, self.settings)?;
+            total_bytes_written += num_bytes_written;
+        }
         Ok(total_bytes_written)
     }
 
-    fn flush(&mut self) -> std::io::Result<()> {
+    fn flush(&mut self) -> io::Result<()> {
         self.inner.flush()
     }
 }
 
-/// Write lines to each sequential output files, limited by bytes.
-///
-/// This struct maintains an underlying writer representing the
-/// current chunk of the output. On each call to [`write`], it writes
-/// as many lines as possible to the current chunk without exceeding
-/// the specified byte limit. If a single line has more bytes than the
-/// limit, then fill an entire single chunk with those bytes and
-/// handle the remainder of the line as if it were its own distinct
-/// line. As many new underlying writers are created as needed to
-/// write all the data in the input buffer.
-struct LineBytesChunkWriter<'a> {
-    /// Parameters for creating the underlying writer for each new chunk.
-    settings: &'a Settings,
-
-    /// The maximum number of bytes allowed for a single chunk of output.
-    chunk_size: u64,
-
-    /// Running total of number of chunks that have been completed.
-    num_chunks_written: usize,
-
-    /// Remaining capacity in number of bytes in the current chunk.
-    ///
-    /// This number starts at `chunk_size` and decreases as lines are
-    /// written. Once it reaches zero, a writer for a new chunk is
-    /// initialized and this number gets reset to `chunk_size`.
-    num_bytes_remaining_in_current_chunk: usize,
-
-    /// The underlying writer for the current chunk.
-    ///
-    /// Once the number of bytes written to this writer exceeds
-    /// `chunk_size`, a new writer is initialized and assigned to this
-    /// field.
-    inner: BufWriter<Box<dyn Write>>,
+/// Output file parameters
+struct OutFile {
+    filename: String,
+    maybe_writer: Option<BufWriter<Box<dyn Write>>>,
+    is_new: bool,
+}
 
-    /// Iterator that yields filenames for each chunk.
-    filename_iterator: FilenameIterator<'a>,
+/// A set of output files
+/// Used in [`n_chunks_by_byte`], [`n_chunks_by_line`]
+/// and [`n_chunks_by_line_round_robin`] functions.
+type OutFiles = Vec<OutFile>;
+trait ManageOutFiles {
+    fn instantiate_writer(
+        &mut self,
+        idx: usize,
+        settings: &Settings,
+    ) -> UResult<&mut BufWriter<Box<dyn Write>>>;
+    /// Initialize a new set of output files
+    /// Each OutFile is generated with filename, while the writer for it could be
+    /// optional, to be instantiated later by the calling function as needed.
+    /// Optional writers could happen in the following situations:
+    /// * in [`n_chunks_by_line`] and [`n_chunks_by_line_round_robin`] if `elide_empty_files` parameter is set to `true`
+    /// * if the number of files is greater than system limit for open files
+    fn init(num_files: u64, settings: &Settings, is_writer_optional: bool) -> UResult<Self>
+    where
+        Self: Sized;
+    /// Get the writer for the output file by index.
+    /// If system limit of open files has been reached
+    /// it will try to close one of previously instantiated writers
+    /// to free up resources and re-try instantiating current writer,
+    /// except for `--filter` mode.
+    /// The writers that get closed to free up resources for the current writer
+    /// are flagged as `is_new=false`, so they can be re-opened for appending
+    /// instead of created anew if we need to keep writing into them later,
+    /// i.e. in case of round robin distribution as in [`n_chunks_by_line_round_robin`]
+    fn get_writer(
+        &mut self,
+        idx: usize,
+        settings: &Settings,
+    ) -> UResult<&mut BufWriter<Box<dyn Write>>>;
 }
 
-impl<'a> LineBytesChunkWriter<'a> {
-    fn new(chunk_size: u64, settings: &'a Settings) -> UResult<LineBytesChunkWriter<'a>> {
-        let mut filename_iterator = FilenameIterator::new(
-            &settings.prefix,
-            &settings.additional_suffix,
-            settings.suffix_length,
-            settings.suffix_type,
-            settings.suffix_start,
-        )?;
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        if settings.verbose {
-            println!("creating file {}", filename.quote());
+impl ManageOutFiles for OutFiles {
+    fn init(num_files: u64, settings: &Settings, is_writer_optional: bool) -> UResult<Self> {
+        // This object is responsible for creating the filename for each chunk
+        let mut filename_iterator: FilenameIterator<'_> =
+            FilenameIterator::new(&settings.prefix, &settings.suffix)
+                .map_err(|e| io::Error::other(format!("{e}")))?;
+        let mut out_files: Self = Self::new();
+        for _ in 0..num_files {
+            let filename = filename_iterator
+                .next()
+                .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+            let maybe_writer = if is_writer_optional {
+                None
+            } else {
+                let instantiated = settings.instantiate_current_writer(filename.as_str(), true);
+                // If there was an error instantiating the writer for a file,
+                // it could be due to hitting the system limit of open files,
+                // so record it as None and let [`get_writer`] function handle closing/re-opening
+                // of writers as needed within system limits.
+                // However, for `--filter` child process writers - propagate the error,
+                // as working around system limits of open files for child shell processes
+                // is currently not supported (same as in GNU)
+                match instantiated {
+                    Ok(writer) => Some(writer),
+                    Err(e) if settings.filter.is_some() => {
+                        return Err(e.into());
+                    }
+                    Err(_) => None,
+                }
+            };
+            out_files.push(OutFile {
+                filename,
+                maybe_writer,
+                is_new: true,
+            });
         }
-        let inner = settings.instantiate_current_writer(&filename)?;
-        Ok(LineBytesChunkWriter {
-            settings,
-            chunk_size,
-            num_bytes_remaining_in_current_chunk: usize::try_from(chunk_size).unwrap(),
-            num_chunks_written: 0,
-            inner,
-            filename_iterator,
-        })
+        Ok(out_files)
     }
-}
-
-impl<'a> Write for LineBytesChunkWriter<'a> {
-    /// Write as many lines to a chunk as possible without
-    /// exceeding the byte limit. If a single line has more bytes
-    /// than the limit, then fill an entire single chunk with those
-    /// bytes and handle the remainder of the line as if it were
-    /// its own distinct line.
-    ///
-    /// For example: if the `chunk_size` is 8 and the input is:
-    ///
-    /// ```text
-    /// aaaaaaaaa\nbbbb\ncccc\ndd\nee\n
-    /// ```
-    ///
-    /// then the output gets broken into chunks like this:
-    ///
-    /// ```text
-    /// chunk 0    chunk 1    chunk 2    chunk 3
-    ///
-    /// 0            1             2
-    /// 01234567  89 01234   56789 012   345 6
-    /// |------|  |-------|  |--------|  |---|
-    /// aaaaaaaa  a\nbbbb\n  cccc\ndd\n  ee\n
-    /// ```
-    fn write(&mut self, mut buf: &[u8]) -> std::io::Result<usize> {
-        // The total number of bytes written during the loop below.
-        //
-        // It is necessary to keep this running total because we may
-        // be making multiple calls to `write()` on multiple different
-        // underlying writers and we want the final reported number of
-        // bytes written to reflect the total number of bytes written
-        // to all of the underlying writers.
-        let mut total_bytes_written = 0;
 
-        // Loop until we have written all bytes in the input buffer
-        // (or an IO error occurs).
-        loop {
-            // If the buffer is empty, then we are done writing.
-            if buf.is_empty() {
-                return Ok(total_bytes_written);
+    fn instantiate_writer(
+        &mut self,
+        idx: usize,
+        settings: &Settings,
+    ) -> UResult<&mut BufWriter<Box<dyn Write>>> {
+        let mut count = 0;
+        // Use-case for doing multiple tries of closing fds:
+        // E.g. split running in parallel to other processes (e.g. another split) doing similar stuff,
+        // sharing the same limits. In this scenario, after closing one fd, the other process
+        // might "steel" the freed fd and open a file on its side. Then it would be beneficial
+        // if split would be able to close another fd before cancellation.
+        'loop1: loop {
+            let filename_to_open = self[idx].filename.as_str();
+            let file_to_open_is_new = self[idx].is_new;
+            let maybe_writer =
+                settings.instantiate_current_writer(filename_to_open, file_to_open_is_new);
+            if let Ok(writer) = maybe_writer {
+                self[idx].maybe_writer = Some(writer);
+                return Ok(self[idx].maybe_writer.as_mut().unwrap());
             }
 
-            // If we have filled the current chunk with bytes, then
-            // start a new chunk and initialize its corresponding
-            // writer.
-            if self.num_bytes_remaining_in_current_chunk == 0 {
-                self.num_chunks_written += 1;
-                let filename = self.filename_iterator.next().ok_or_else(|| {
-                    std::io::Error::new(ErrorKind::Other, "output file suffixes exhausted")
-                })?;
-                if self.settings.verbose {
-                    println!("creating file {}", filename.quote());
-                }
-                self.inner = self.settings.instantiate_current_writer(&filename)?;
-                self.num_bytes_remaining_in_current_chunk = self.chunk_size.try_into().unwrap();
+            if settings.filter.is_some() {
+                // Propagate error if in `--filter` mode
+                return Err(maybe_writer.err().unwrap().into());
             }
 
-            // Find the first newline character in the buffer.
-            match memchr::memchr(b'\n', buf) {
-                // If there is no newline character and the buffer is
-                // not empty, then write as many bytes as we can and
-                // then move on to the next chunk if necessary.
-                None => {
-                    let end = self.num_bytes_remaining_in_current_chunk;
-
-                    // This is ugly but here to match GNU behavior. If the input
-                    // doesn't end with a \n, pretend that it does for handling
-                    // the second to last segment chunk. See `line-bytes.sh`.
-                    if end == buf.len()
-                        && self.num_bytes_remaining_in_current_chunk
-                            < self.chunk_size.try_into().unwrap()
-                        && buf[buf.len() - 1] != b'\n'
-                    {
-                        self.num_bytes_remaining_in_current_chunk = 0;
-                    } else {
-                        let num_bytes_written = self.inner.write(&buf[..end.min(buf.len())])?;
-                        self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
-                        total_bytes_written += num_bytes_written;
-                        buf = &buf[num_bytes_written..];
-                    }
-                }
-
-                // If there is a newline character and the line
-                // (including the newline character) will fit in the
-                // current chunk, then write the entire line and
-                // continue to the next iteration. (See chunk 1 in the
-                // example comment above.)
-                Some(i) if i < self.num_bytes_remaining_in_current_chunk => {
-                    let num_bytes_written = self.inner.write(&buf[..i + 1])?;
-                    self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
-                    total_bytes_written += num_bytes_written;
-                    buf = &buf[num_bytes_written..];
-                }
-
-                // If there is a newline character, the line
-                // (including the newline character) will not fit in
-                // the current chunk, *and* no other lines have been
-                // written to the current chunk, then write as many
-                // bytes as we can and continue to the next
-                // iteration. (See chunk 0 in the example comment
-                // above.)
-                Some(_)
-                    if self.num_bytes_remaining_in_current_chunk
-                        == self.chunk_size.try_into().unwrap() =>
-                {
-                    let end = self.num_bytes_remaining_in_current_chunk;
-                    let num_bytes_written = self.inner.write(&buf[..end])?;
-                    self.num_bytes_remaining_in_current_chunk -= num_bytes_written;
-                    total_bytes_written += num_bytes_written;
-                    buf = &buf[num_bytes_written..];
-                }
-
-                // If there is a newline character, the line
-                // (including the newline character) will not fit in
-                // the current chunk, and at least one other line has
-                // been written to the current chunk, then signal to
-                // the next iteration that a new chunk needs to be
-                // created and continue to the next iteration of the
-                // loop to try writing the line there.
-                Some(_) => {
-                    self.num_bytes_remaining_in_current_chunk = 0;
+            // Could have hit system limit for open files.
+            // Try to close one previously instantiated writer first
+            for (i, out_file) in self.iter_mut().enumerate() {
+                if i != idx && out_file.maybe_writer.is_some() {
+                    out_file.maybe_writer.as_mut().unwrap().flush()?;
+                    out_file.maybe_writer = None;
+                    out_file.is_new = false;
+                    count += 1;
+
+                    // And then try to instantiate the writer again
+                    continue 'loop1;
                 }
             }
+
+            // If this fails - give up and propagate the error
+            uucore::show_error!(
+                "at file descriptor limit, but no file descriptor left to close. Closed {count} writers before."
+            );
+            return Err(maybe_writer.err().unwrap().into());
         }
     }
 
-    fn flush(&mut self) -> std::io::Result<()> {
-        self.inner.flush()
+    fn get_writer(
+        &mut self,
+        idx: usize,
+        settings: &Settings,
+    ) -> UResult<&mut BufWriter<Box<dyn Write>>> {
+        if self[idx].maybe_writer.is_some() {
+            Ok(self[idx].maybe_writer.as_mut().unwrap())
+        } else {
+            // Writer was not instantiated upfront or was temporarily closed due to system resources constraints.
+            // Instantiate it and record for future use.
+            self.instantiate_writer(idx, settings)
+        }
     }
 }
 
-/// Split a file into a specific number of chunks by byte.
+/// Split a file or STDIN into a specific number of chunks by byte.
 ///
-/// This function always creates one output file for each chunk, even
+/// When file size cannot be evenly divided into the number of chunks of the same size,
+/// the first X chunks are 1 byte longer than the rest,
+/// where X is a modulus reminder of (file size % number of chunks)
+///
+/// In Kth chunk of N mode - writes to STDOUT the contents of the chunk identified by `kth_chunk`
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
 /// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n 10 --filter='head -c1 > $FILE' in`
 ///
 /// # Errors
 ///
 /// This function returns an error if there is a problem reading from
-/// `reader` or writing to one of the output files.
-fn split_into_n_chunks_by_byte<R>(
+/// `reader` or writing to one of the output files or stdout.
+///
+/// # See also
+///
+/// * [`n_chunks_by_line`], which splits its input into a specific number of chunks by line.
+///
+/// Implements `--number=CHUNKS`
+/// Where CHUNKS
+/// * N
+/// * K/N
+fn n_chunks_by_byte<R>(
     settings: &Settings,
     reader: &mut R,
     num_chunks: u64,
+    kth_chunk: Option<u64>,
 ) -> UResult<()>
 where
-    R: Read,
+    R: BufRead,
 {
-    // Get the size of the input file in bytes and compute the number
-    // of bytes per chunk.
-    //
+    // Get the size of the input in bytes
+    let initial_buf = &mut Vec::new();
+    let mut num_bytes = get_input_size(&settings.input, reader, initial_buf, settings.io_blksize)?;
+    let mut reader = initial_buf.chain(reader);
+
+    // If input file is empty and we would not have determined the Kth chunk
+    // in the Kth chunk of N chunk mode, then terminate immediately.
+    // This happens on `split -n 3/10 /dev/null`, for example.
+    if kth_chunk.is_some() && num_bytes == 0 {
+        return Ok(());
+    }
+
     // If the requested number of chunks exceeds the number of bytes
-    // in the file *and* the `elide_empty_files` parameter is enabled,
-    // then behave as if the number of chunks was set to the number of
-    // bytes in the file. This ensures that we don't write empty
-    // files. Otherwise, just write the `num_chunks - num_bytes` empty
-    // files.
-    let metadata = metadata(&settings.input).map_err(|_| {
-        USimpleError::new(1, format!("{}: cannot determine file size", settings.input))
-    })?;
-
-    let num_bytes = metadata.len();
-    let will_have_empty_files = settings.elide_empty_files && num_chunks > num_bytes;
-    let (num_chunks, chunk_size) = if will_have_empty_files {
-        let num_chunks = num_bytes;
-        let chunk_size = 1;
-        (num_chunks, chunk_size)
+    // in the input:
+    // * in Kth chunk of N mode - just write empty byte string to stdout
+    //   NOTE: the `elide_empty_files` parameter is ignored here
+    //   as we do not generate any files
+    //   and instead writing to stdout
+    // * In N chunks mode - if the `elide_empty_files` parameter is enabled,
+    //   then behave as if the number of chunks was set to the number of
+    //   bytes in the file. This ensures that we don't write empty
+    //   files. Otherwise, just write the `num_chunks - num_bytes` empty files.
+    let num_chunks = if kth_chunk.is_none() && settings.elide_empty_files && num_chunks > num_bytes
+    {
+        num_bytes
     } else {
-        let chunk_size = (num_bytes / (num_chunks)).max(1);
-        (num_chunks, chunk_size)
+        num_chunks
     };
 
     // If we would have written zero chunks of output, then terminate
@@ -1093,63 +1127,92 @@ where
         return Ok(());
     }
 
-    let num_chunks: usize = num_chunks
-        .try_into()
-        .map_err(|_| USimpleError::new(1, "Number of chunks too big"))?;
-
-    // This object is responsible for creating the filename for each chunk.
-    let mut filename_iterator = FilenameIterator::new(
-        &settings.prefix,
-        &settings.additional_suffix,
-        settings.suffix_length,
-        settings.suffix_type,
-        settings.suffix_start,
-    )?;
-
-    // Create one writer for each chunk. This will create each
-    // of the underlying files (if not in `--filter` mode).
-    let mut writers = vec![];
-    for _ in 0..num_chunks {
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        let writer = settings.instantiate_current_writer(filename.as_str())?;
-        writers.push(writer);
+    // In Kth chunk of N mode - we will write to stdout instead of to a file.
+    let mut stdout_writer = io::stdout().lock();
+    // In N chunks mode - we will write to `num_chunks` files
+    let mut out_files: OutFiles = OutFiles::new();
+
+    // Calculate chunk size base and modulo reminder
+    // to be used in calculating chunk_size later on
+    let chunk_size_base = num_bytes / num_chunks;
+    let chunk_size_reminder = num_bytes % num_chunks;
+
+    // If in N chunks mode
+    // Create one writer for each chunk.
+    // This will create each of the underlying files
+    // or stdin pipes to child shell/command processes if in `--filter` mode
+    if kth_chunk.is_none() {
+        out_files = OutFiles::init(num_chunks, settings, false)?;
     }
 
-    // Capture the result of the `std::io::copy()` calls to check for
-    // `BrokenPipe`.
-    let result: std::io::Result<()> = {
-        // Write `chunk_size` bytes from the reader into each writer
-        // except the last.
-        //
-        // The last writer gets all remaining bytes so that if the number
-        // of bytes in the input file was not evenly divisible by
-        // `num_chunks`, we don't leave any bytes behind.
-        for writer in writers.iter_mut().take(num_chunks - 1) {
-            io::copy(&mut reader.by_ref().take(chunk_size), writer)?;
-        }
+    for i in 1_u64..=num_chunks {
+        let chunk_size = chunk_size_base + (chunk_size_reminder > i - 1) as u64;
+        let buf = &mut Vec::new();
+        if num_bytes > 0 {
+            // Read `chunk_size` bytes from the reader into `buf`
+            // except the last.
+            //
+            // The last chunk gets all remaining bytes so that if the number
+            // of bytes in the input file was not evenly divisible by
+            // `num_chunks`, we don't leave any bytes behind.
+            let limit = {
+                if i == num_chunks {
+                    num_bytes
+                } else {
+                    chunk_size
+                }
+            };
 
-        // Write all the remaining bytes to the last chunk.
-        let i = num_chunks - 1;
-        let last_chunk_size = num_bytes - (chunk_size * (num_chunks as u64 - 1));
-        io::copy(&mut reader.by_ref().take(last_chunk_size), &mut writers[i])?;
+            let n_bytes_read = reader.by_ref().take(limit).read_to_end(buf);
 
-        Ok(())
-    };
-    match result {
-        Ok(_) => Ok(()),
-        Err(e) if e.kind() == ErrorKind::BrokenPipe => Ok(()),
-        Err(e) => Err(uio_error!(e, "input/output error")),
+            match n_bytes_read {
+                Ok(n_bytes) => {
+                    num_bytes -= n_bytes as u64;
+                }
+                Err(error) => {
+                    return Err(USimpleError::new(
+                        1,
+                        format!("{}: cannot read from input : {error}", settings.input),
+                    ));
+                }
+            }
+
+            match kth_chunk {
+                Some(chunk_number) => {
+                    if i == chunk_number {
+                        stdout_writer.write_all(buf)?;
+                        break;
+                    }
+                }
+                None => {
+                    let idx = (i - 1) as usize;
+                    let writer = out_files.get_writer(idx, settings)?;
+                    writer.write_all(buf)?;
+                }
+            }
+        } else {
+            break;
+        }
     }
+    Ok(())
 }
 
-/// Split a file into a specific number of chunks by line.
+/// Split a file or STDIN into a specific number of chunks by line.
+///
+/// It is most likely that input cannot be evenly divided into the number of chunks
+/// of the same size in bytes or number of lines, since we cannot break lines.
+/// It is also likely that there could be empty files (having `elide_empty_files` is disabled)
+/// when a long line overlaps one or more chunks.
 ///
-/// This function always creates one output file for each chunk, even
+/// In Kth chunk of N mode - writes to STDOUT the contents of the chunk identified by `kth_chunk`
+/// Note: the `elide_empty_files` flag is ignored in this mode
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
 /// if there is an error reading or writing one of the chunks or if
-/// the input file is truncated. However, if the `filter` option is
-/// being used, then no files are created.
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n l/10 --filter='head -c1 > $FILE' in`
 ///
 /// # Errors
 ///
@@ -1158,70 +1221,135 @@ where
 ///
 /// # See also
 ///
-/// * [`kth_chunk_by_line`], which splits its input in the same way,
-///   but writes only one specified chunk to stdout.
-fn split_into_n_chunks_by_line<R>(
+/// * [`n_chunks_by_byte`], which splits its input into a specific number of chunks by byte.
+///
+/// Implements `--number=CHUNKS`
+/// Where CHUNKS
+/// * l/N
+/// * l/K/N
+fn n_chunks_by_line<R>(
     settings: &Settings,
     reader: &mut R,
     num_chunks: u64,
+    kth_chunk: Option<u64>,
 ) -> UResult<()>
 where
     R: BufRead,
 {
-    // Get the size of the input file in bytes and compute the number
+    // Get the size of the input in bytes and compute the number
     // of bytes per chunk.
-    let metadata = metadata(&settings.input).unwrap();
-    let num_bytes = metadata.len();
-    let chunk_size = (num_bytes / num_chunks) as usize;
-
-    // This object is responsible for creating the filename for each chunk.
-    let mut filename_iterator = FilenameIterator::new(
-        &settings.prefix,
-        &settings.additional_suffix,
-        settings.suffix_length,
-        settings.suffix_type,
-        settings.suffix_start,
-    )?;
-
-    // Create one writer for each chunk. This will create each
-    // of the underlying files (if not in `--filter` mode).
-    let mut writers = vec![];
-    for _ in 0..num_chunks {
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        let writer = settings.instantiate_current_writer(filename.as_str())?;
-        writers.push(writer);
+    let initial_buf = &mut Vec::new();
+    let num_bytes = get_input_size(&settings.input, reader, initial_buf, settings.io_blksize)?;
+    let reader = initial_buf.chain(reader);
+
+    // If input file is empty and we would not have determined the Kth chunk
+    // in the Kth chunk of N chunk mode, then terminate immediately.
+    // This happens on `split -n l/3/10 /dev/null`, for example.
+    // Similarly, if input file is empty and `elide_empty_files` parameter is enabled,
+    // then we would have written zero chunks of output,
+    // so terminate immediately as well.
+    // This happens on `split -e -n l/3 /dev/null`, for example.
+    if num_bytes == 0 && (kth_chunk.is_some() || settings.elide_empty_files) {
+        return Ok(());
     }
 
-    let mut num_bytes_remaining_in_current_chunk = chunk_size;
-    let mut i = 0;
-    for line_result in reader.lines() {
-        let line = line_result.unwrap();
-        let maybe_writer = writers.get_mut(i);
-        let writer = maybe_writer.unwrap();
-        let bytes = line.as_bytes();
-        writer.write_all(bytes)?;
-        writer.write_all(b"\n")?;
-
-        // Add one byte for the newline character.
-        let num_bytes = bytes.len() + 1;
-        if num_bytes > num_bytes_remaining_in_current_chunk {
-            num_bytes_remaining_in_current_chunk = chunk_size;
-            i += 1;
-        } else {
-            num_bytes_remaining_in_current_chunk -= num_bytes;
-        }
+    // In Kth chunk of N mode - we will write to stdout instead of to a file.
+    let mut stdout_writer = io::stdout().lock();
+    // In N chunks mode - we will write to `num_chunks` files
+    let mut out_files: OutFiles = OutFiles::new();
+
+    // Calculate chunk size base and modulo reminder
+    // to be used in calculating `num_bytes_should_be_written` later on
+    let chunk_size_base = num_bytes / num_chunks;
+    let chunk_size_reminder = num_bytes % num_chunks;
+
+    // If in N chunks mode
+    // Generate filenames for each file and
+    // if `elide_empty_files` parameter is NOT enabled - instantiate the writer
+    // which will create each of the underlying files or stdin pipes
+    // to child shell/command processes if in `--filter` mode.
+    // Otherwise keep writer optional, to be instantiated later if there is data
+    // to write for the associated chunk.
+    if kth_chunk.is_none() {
+        out_files = OutFiles::init(num_chunks, settings, settings.elide_empty_files)?;
     }
 
+    let mut chunk_number = 1;
+    let sep = settings.separator;
+    let mut num_bytes_should_be_written = chunk_size_base + (chunk_size_reminder > 0) as u64;
+    let mut num_bytes_written = 0;
+
+    for line_result in reader.split(sep) {
+        let mut line = line_result?;
+        // add separator back in at the end of the line,
+        // since `reader.split(sep)` removes it,
+        // except if the last line did not end with separator character
+        if (num_bytes_written + line.len() as u64) < num_bytes {
+            line.push(sep);
+        }
+        let bytes = line.as_slice();
+
+        match kth_chunk {
+            Some(kth) => {
+                if chunk_number == kth {
+                    stdout_writer.write_all(bytes)?;
+                }
+            }
+            None => {
+                // Should write into a file
+                let idx = (chunk_number - 1) as usize;
+                let writer = out_files.get_writer(idx, settings)?;
+                custom_write_all(bytes, writer, settings)?;
+            }
+        }
+
+        // Advance to the next chunk if the current one is filled.
+        // There could be a situation when a long line, which started in current chunk,
+        // would overlap the next chunk (or even several next chunks),
+        // and since we cannot break lines for this split strategy, we could end up with
+        // empty files in place(s) of skipped chunk(s)
+        let num_line_bytes = bytes.len() as u64;
+        num_bytes_written += num_line_bytes;
+        let mut skipped = -1;
+        while num_bytes_should_be_written <= num_bytes_written {
+            num_bytes_should_be_written +=
+                chunk_size_base + (chunk_size_reminder > chunk_number) as u64;
+            chunk_number += 1;
+            skipped += 1;
+        }
+
+        // If a chunk was skipped and `elide_empty_files` flag is set,
+        // roll chunk_number back to preserve sequential continuity
+        // of file names for files written to,
+        // except for Kth chunk of N mode
+        if settings.elide_empty_files && skipped > 0 && kth_chunk.is_none() {
+            chunk_number -= skipped as u64;
+        }
+
+        if let Some(kth) = kth_chunk {
+            if chunk_number > kth {
+                break;
+            }
+        }
+    }
     Ok(())
 }
 
-/// Print the k-th chunk of a file, splitting by line.
+/// Split a file or STDIN into a specific number of chunks by line, but
+/// assign lines via round-robin.
+/// Note: There is no need to know the size of the input upfront for this method,
+/// since the lines are assigned to chunks randomly and the size of each chunk
+/// does not need to be estimated. As a result, "infinite" inputs are supported
+/// for this method, i.e. `yes | split -n r/10` or `yes | split -n r/3/11`
 ///
-/// This function is like [`split_into_n_chunks_by_line`], but instead
-/// of writing each chunk to its own file, it only writes to stdout
-/// the contents of the chunk identified by `chunk_number`.
+/// In Kth chunk of N mode - writes to stdout the contents of the chunk identified by `kth_chunk`
+///
+/// In N chunks mode - this function always creates one output file for each chunk, even
+/// if there is an error reading or writing one of the chunks or if
+/// the input file is truncated. However, if the `--filter` option is
+/// being used, then files will only be created if `$FILE` variable was used
+/// in filter command,
+/// i.e. `split -n r/10 --filter='head -c1 > $FILE' in`
 ///
 /// # Errors
 ///
@@ -1230,132 +1358,219 @@ where
 ///
 /// # See also
 ///
-/// * [`split_into_n_chunks_by_line`], which splits its input in the
-///   same way, but writes each chunk to its own file.
-fn kth_chunk_by_line<R>(
+/// * [`n_chunks_by_line`], which splits its input into a specific number of chunks by line.
+///
+/// Implements `--number=CHUNKS`
+/// Where CHUNKS
+/// * r/N
+/// * r/K/N
+fn n_chunks_by_line_round_robin<R>(
     settings: &Settings,
     reader: &mut R,
-    chunk_number: u64,
     num_chunks: u64,
+    kth_chunk: Option<u64>,
 ) -> UResult<()>
 where
     R: BufRead,
 {
-    // Get the size of the input file in bytes and compute the number
-    // of bytes per chunk.
-    let metadata = metadata(&settings.input).unwrap();
-    let num_bytes = metadata.len();
-    let chunk_size = (num_bytes / num_chunks) as usize;
+    // In Kth chunk of N mode - we will write to stdout instead of to a file.
+    let mut stdout_writer = io::stdout().lock();
+    // In N chunks mode - we will write to `num_chunks` files
+    let mut out_files: OutFiles = OutFiles::new();
+
+    // If in N chunks mode
+    // Create one writer for each chunk.
+    // This will create each of the underlying files
+    // or stdin pipes to child shell/command processes if in `--filter` mode
+    if kth_chunk.is_none() {
+        out_files = OutFiles::init(num_chunks, settings, settings.elide_empty_files)?;
+    }
 
-    // Write to stdout instead of to a file.
-    let stdout = std::io::stdout();
-    let mut writer = stdout.lock();
+    let num_chunks: usize = num_chunks.try_into().unwrap();
+    let sep = settings.separator;
+    let mut closed_writers = 0;
 
-    let mut num_bytes_remaining_in_current_chunk = chunk_size;
     let mut i = 0;
-    for line_result in reader.lines() {
-        let line = line_result?;
-        let bytes = line.as_bytes();
-        if i == chunk_number {
-            writer.write_all(bytes)?;
-            writer.write_all(b"\n")?;
-        }
+    loop {
+        let line = &mut Vec::new();
+        let num_bytes_read = reader.by_ref().read_until(sep, line)?;
+
+        // if there is nothing else to read - exit the loop
+        if num_bytes_read == 0 {
+            break;
+        };
 
-        // Add one byte for the newline character.
-        let num_bytes = bytes.len() + 1;
-        if num_bytes >= num_bytes_remaining_in_current_chunk {
-            num_bytes_remaining_in_current_chunk = chunk_size;
-            i += 1;
+        let bytes = line.as_slice();
+        if let Some(chunk_number) = kth_chunk {
+            if (i % num_chunks) == (chunk_number - 1) as usize {
+                stdout_writer.write_all(bytes)?;
+            }
         } else {
-            num_bytes_remaining_in_current_chunk -= num_bytes;
+            let writer = out_files.get_writer(i % num_chunks, settings)?;
+            let writer_stdin_open = custom_write_all(bytes, writer, settings)?;
+            if !writer_stdin_open {
+                closed_writers += 1;
+            }
         }
-
-        if i > chunk_number {
+        i += 1;
+        if closed_writers == num_chunks {
+            // all writers are closed - stop reading
             break;
         }
     }
-
     Ok(())
 }
 
-fn split_into_n_chunks_by_line_round_robin<R>(
-    settings: &Settings,
-    reader: &mut R,
-    num_chunks: u64,
-) -> UResult<()>
+/// Like `io::Lines`, but includes the line ending character.
+///
+/// This struct is generally created by calling `lines_with_sep` on a
+/// reader.
+pub struct LinesWithSep<R> {
+    inner: R,
+    separator: u8,
+}
+
+impl<R> Iterator for LinesWithSep<R>
 where
     R: BufRead,
 {
-    // This object is responsible for creating the filename for each chunk.
-    let mut filename_iterator = FilenameIterator::new(
-        &settings.prefix,
-        &settings.additional_suffix,
-        settings.suffix_length,
-        settings.suffix_type,
-        settings.suffix_start,
-    )?;
-
-    // Create one writer for each chunk. This will create each
-    // of the underlying files (if not in `--filter` mode).
-    let mut writers = vec![];
-    for _ in 0..num_chunks {
-        let filename = filename_iterator
-            .next()
-            .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
-        let writer = settings.instantiate_current_writer(filename.as_str())?;
-        writers.push(writer);
+    type Item = io::Result<Vec<u8>>;
+
+    /// Read bytes from a buffer up to the requested number of lines.
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut buf = vec![];
+        match self.inner.read_until(self.separator, &mut buf) {
+            Ok(0) => None,
+            Ok(_) => Some(Ok(buf)),
+            Err(e) => Some(Err(e)),
+        }
     }
+}
 
-    let num_chunks: usize = num_chunks.try_into().unwrap();
-    for (i, line_result) in reader.lines().enumerate() {
-        let line = line_result.unwrap();
-        let maybe_writer = writers.get_mut(i % num_chunks);
-        let writer = maybe_writer.unwrap();
-        let bytes = line.as_bytes();
-        writer.write_all(bytes)?;
-        writer.write_all(b"\n")?;
+/// Like `std::str::lines` but includes the line ending character.
+///
+/// The `separator` defines the character to interpret as the line
+/// ending. For the usual notion of "line", set this to `b'\n'`.
+pub fn lines_with_sep<R>(reader: R, separator: u8) -> LinesWithSep<R>
+where
+    R: BufRead,
+{
+    LinesWithSep {
+        inner: reader,
+        separator,
     }
+}
+
+fn line_bytes<R>(settings: &Settings, reader: &mut R, chunk_size: usize) -> UResult<()>
+where
+    R: BufRead,
+{
+    let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?;
+
+    // Initialize the writer just to satisfy the compiler. It is going
+    // to be overwritten for sure at the beginning of the loop below
+    // because we start with `remaining == 0`, indicating that a new
+    // chunk should start.
+    let mut writer: BufWriter<Box<dyn Write>> = BufWriter::new(Box::new(io::Cursor::new(vec![])));
+
+    let mut remaining = 0;
+    for line in lines_with_sep(reader, settings.separator) {
+        let line = line?;
+        let mut line = &line[..];
+        loop {
+            if remaining == 0 {
+                let filename = filename_iterator
+                    .next()
+                    .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?;
+                if settings.verbose {
+                    println!("creating file {}", filename.quote());
+                }
+                writer = settings.instantiate_current_writer(&filename, true)?;
+                remaining = chunk_size;
+            }
+
+            // Special case: if this is the last line and it doesn't end
+            // with a newline character, then count its length as though
+            // it did end with a newline. If that puts it over the edge
+            // of this chunk, continue to the next chunk.
+            if line.len() == remaining
+                && remaining < chunk_size
+                && line[line.len() - 1] != settings.separator
+            {
+                remaining = 0;
+                continue;
+            }
 
+            // If the entire line fits in this chunk, write it and
+            // continue to the next line.
+            if line.len() <= remaining {
+                custom_write_all(line, &mut writer, settings)?;
+                remaining -= line.len();
+                break;
+            }
+
+            // If the line is too large to fit in *any* chunk and we are
+            // at the start of a new chunk, write as much as we can of
+            // it and pass the remainder along to the next chunk.
+            if line.len() > chunk_size && remaining == chunk_size {
+                custom_write_all(&line[..chunk_size], &mut writer, settings)?;
+                line = &line[chunk_size..];
+                remaining = 0;
+                continue;
+            }
+
+            // If the line is too large to fit in *this* chunk, but
+            // might otherwise fit in the next chunk, then just continue
+            // to the next chunk and let it be handled there.
+            remaining = 0;
+        }
+    }
     Ok(())
 }
 
+#[allow(clippy::cognitive_complexity)]
 fn split(settings: &Settings) -> UResult<()> {
-    let mut reader = BufReader::new(if settings.input == "-" {
+    let r_box = if settings.input == "-" {
         Box::new(stdin()) as Box<dyn Read>
     } else {
-        let r = File::open(Path::new(&settings.input)).map_err_context(|| {
-            format!(
-                "cannot open {} for reading: No such file or directory",
-                settings.input.quote()
-            )
-        })?;
+        let r = File::open(Path::new(&settings.input))
+            .map_err_context(|| format!("cannot open {} for reading", settings.input.quote()))?;
         Box::new(r) as Box<dyn Read>
-    });
+    };
+    let mut reader = if let Some(c) = settings.io_blksize {
+        BufReader::with_capacity(c.try_into().unwrap(), r_box)
+    } else {
+        BufReader::new(r_box)
+    };
 
     match settings.strategy {
         Strategy::Number(NumberType::Bytes(num_chunks)) => {
-            split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+            // split_into_n_chunks_by_byte(settings, &mut reader, num_chunks)
+            n_chunks_by_byte(settings, &mut reader, num_chunks, None)
+        }
+        Strategy::Number(NumberType::KthBytes(chunk_number, num_chunks)) => {
+            // kth_chunks_by_byte(settings, &mut reader, chunk_number, num_chunks)
+            n_chunks_by_byte(settings, &mut reader, num_chunks, Some(chunk_number))
         }
         Strategy::Number(NumberType::Lines(num_chunks)) => {
-            split_into_n_chunks_by_line(settings, &mut reader, num_chunks)
+            n_chunks_by_line(settings, &mut reader, num_chunks, None)
         }
         Strategy::Number(NumberType::KthLines(chunk_number, num_chunks)) => {
-            // The chunk number is given as a 1-indexed number, but it
-            // is a little easier to deal with a 0-indexed number.
-            let chunk_number = chunk_number - 1;
-            kth_chunk_by_line(settings, &mut reader, chunk_number, num_chunks)
+            n_chunks_by_line(settings, &mut reader, num_chunks, Some(chunk_number))
         }
         Strategy::Number(NumberType::RoundRobin(num_chunks)) => {
-            split_into_n_chunks_by_line_round_robin(settings, &mut reader, num_chunks)
+            n_chunks_by_line_round_robin(settings, &mut reader, num_chunks, None)
+        }
+        Strategy::Number(NumberType::KthRoundRobin(chunk_number, num_chunks)) => {
+            n_chunks_by_line_round_robin(settings, &mut reader, num_chunks, Some(chunk_number))
         }
-        Strategy::Number(_) => Err(USimpleError::new(1, "-n mode not yet fully implemented")),
         Strategy::Lines(chunk_size) => {
             let mut writer = LineChunkWriter::new(chunk_size, settings)?;
-            match std::io::copy(&mut reader, &mut writer) {
+            match io::copy(&mut reader, &mut writer) {
                 Ok(_) => Ok(()),
                 Err(e) => match e.kind() {
                     // TODO Since the writer object controls the creation of
-                    // new files, we need to rely on the `std::io::Result`
+                    // new files, we need to rely on the `io::Result`
                     // returned by its `write()` method to communicate any
                     // errors to this calling scope. If a new file cannot be
                     // created because we have exceeded the number of
@@ -1363,18 +1578,17 @@ fn split(settings: &Settings) -> UResult<()> {
                     // indicate that. A special error message needs to be
                     // printed in that case.
                     ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))),
-                    ErrorKind::BrokenPipe => Ok(()),
                     _ => Err(uio_error!(e, "input/output error")),
                 },
             }
         }
         Strategy::Bytes(chunk_size) => {
             let mut writer = ByteChunkWriter::new(chunk_size, settings)?;
-            match std::io::copy(&mut reader, &mut writer) {
+            match io::copy(&mut reader, &mut writer) {
                 Ok(_) => Ok(()),
                 Err(e) => match e.kind() {
                     // TODO Since the writer object controls the creation of
-                    // new files, we need to rely on the `std::io::Result`
+                    // new files, we need to rely on the `io::Result`
                     // returned by its `write()` method to communicate any
                     // errors to this calling scope. If a new file cannot be
                     // created because we have exceeded the number of
@@ -1382,113 +1596,10 @@ fn split(settings: &Settings) -> UResult<()> {
                     // indicate that. A special error message needs to be
                     // printed in that case.
                     ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))),
-                    ErrorKind::BrokenPipe => Ok(()),
                     _ => Err(uio_error!(e, "input/output error")),
                 },
             }
         }
-        Strategy::LineBytes(chunk_size) => {
-            let mut writer = LineBytesChunkWriter::new(chunk_size, settings)?;
-            match std::io::copy(&mut reader, &mut writer) {
-                Ok(_) => Ok(()),
-                Err(e) => match e.kind() {
-                    // TODO Since the writer object controls the creation of
-                    // new files, we need to rely on the `std::io::Result`
-                    // returned by its `write()` method to communicate any
-                    // errors to this calling scope. If a new file cannot be
-                    // created because we have exceeded the number of
-                    // allowable filenames, we use `ErrorKind::Other` to
-                    // indicate that. A special error message needs to be
-                    // printed in that case.
-                    ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))),
-                    ErrorKind::BrokenPipe => Ok(()),
-                    _ => Err(uio_error!(e, "input/output error")),
-                },
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::NumberType;
-    use crate::NumberTypeError;
-
-    #[test]
-    fn test_number_type_from() {
-        assert_eq!(NumberType::from("123").unwrap(), NumberType::Bytes(123));
-        assert_eq!(NumberType::from("l/123").unwrap(), NumberType::Lines(123));
-        assert_eq!(
-            NumberType::from("l/123/456").unwrap(),
-            NumberType::KthLines(123, 456)
-        );
-        assert_eq!(
-            NumberType::from("r/123").unwrap(),
-            NumberType::RoundRobin(123)
-        );
-        assert_eq!(
-            NumberType::from("r/123/456").unwrap(),
-            NumberType::KthRoundRobin(123, 456)
-        );
-    }
-
-    #[test]
-    fn test_number_type_from_error() {
-        assert_eq!(
-            NumberType::from("xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-        assert_eq!(
-            NumberType::from("l/xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-        assert_eq!(
-            NumberType::from("l/123/xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-        assert_eq!(
-            NumberType::from("l/abc/456").unwrap_err(),
-            NumberTypeError::ChunkNumber("abc".to_string())
-        );
-        // In GNU split, the number of chunks get precedence:
-        //
-        //     $ split -n l/abc/xyz
-        //     split: invalid number of chunks: ‘xyz’
-        //
-        assert_eq!(
-            NumberType::from("l/abc/xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-        assert_eq!(
-            NumberType::from("r/xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-        assert_eq!(
-            NumberType::from("r/123/xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-        assert_eq!(
-            NumberType::from("r/abc/456").unwrap_err(),
-            NumberTypeError::ChunkNumber("abc".to_string())
-        );
-        // In GNU split, the number of chunks get precedence:
-        //
-        //     $ split -n r/abc/xyz
-        //     split: invalid number of chunks: ‘xyz’
-        //
-        assert_eq!(
-            NumberType::from("r/abc/xyz").unwrap_err(),
-            NumberTypeError::NumberOfChunks("xyz".to_string())
-        );
-    }
-
-    #[test]
-    fn test_number_type_num_chunks() {
-        assert_eq!(NumberType::from("123").unwrap().num_chunks(), 123);
-        assert_eq!(NumberType::from("l/123").unwrap().num_chunks(), 123);
-        assert_eq!(NumberType::from("l/123/456").unwrap().num_chunks(), 456);
-        assert_eq!(NumberType::from("r/123").unwrap().num_chunks(), 123);
-        assert_eq!(NumberType::from("r/123/456").unwrap().num_chunks(), 456);
+        Strategy::LineBytes(chunk_size) => line_bytes(settings, &mut reader, chunk_size as usize),
     }
 }
diff --git a/src/uu/split/src/strategy.rs b/src/uu/split/src/strategy.rs
new file mode 100644
index 00000000000..a8526ada221
--- /dev/null
+++ b/src/uu/split/src/strategy.rs
@@ -0,0 +1,375 @@
+// 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.
+//! Determine the strategy for breaking up the input (file or stdin) into chunks
+//! based on the command line options
+
+use crate::{OPT_BYTES, OPT_LINE_BYTES, OPT_LINES, OPT_NUMBER};
+use clap::{ArgMatches, parser::ValueSource};
+use thiserror::Error;
+use uucore::{
+    display::Quotable,
+    parser::parse_size::{ParseSizeError, parse_size_u64, parse_size_u64_max},
+};
+
+/// Sub-strategy of the [`Strategy::Number`]
+/// Splitting a file into a specific number of chunks.
+#[derive(Debug, PartialEq)]
+pub enum NumberType {
+    /// Split into a specific number of chunks by byte.
+    Bytes(u64),
+
+    /// Split into a specific number of chunks by byte
+    /// but output only the *k*th chunk.
+    KthBytes(u64, u64),
+
+    /// Split into a specific number of chunks by line (approximately).
+    Lines(u64),
+
+    /// Split into a specific number of chunks by line
+    /// (approximately), but output only the *k*th chunk.
+    KthLines(u64, u64),
+
+    /// Assign lines via round-robin to the specified number of output chunks.
+    RoundRobin(u64),
+
+    /// Assign lines via round-robin to the specified number of output
+    /// chunks, but output only the *k*th chunk.
+    KthRoundRobin(u64, u64),
+}
+
+impl NumberType {
+    /// The number of chunks for this number type.
+    pub fn num_chunks(&self) -> u64 {
+        match self {
+            Self::Bytes(n) => *n,
+            Self::KthBytes(_, n) => *n,
+            Self::Lines(n) => *n,
+            Self::KthLines(_, n) => *n,
+            Self::RoundRobin(n) => *n,
+            Self::KthRoundRobin(_, n) => *n,
+        }
+    }
+}
+
+/// An error due to an invalid parameter to the `-n` command-line option.
+#[derive(Debug, PartialEq, Error)]
+pub enum NumberTypeError {
+    /// The number of chunks was invalid.
+    ///
+    /// This can happen if the value of `N` in any of the following
+    /// command-line options is not a positive integer:
+    ///
+    /// ```ignore
+    /// -n N
+    /// -n K/N
+    /// -n l/N
+    /// -n l/K/N
+    /// -n r/N
+    /// -n r/K/N
+    /// ```
+    #[error("invalid number of chunks: {}", .0.quote())]
+    NumberOfChunks(String),
+
+    /// The chunk number was invalid.
+    ///
+    /// This can happen if the value of `K` in any of the following
+    /// command-line options is not a positive integer
+    /// or if `K` is 0
+    /// or if `K` is greater than `N`:
+    ///
+    /// ```ignore
+    /// -n K/N
+    /// -n l/K/N
+    /// -n r/K/N
+    /// ```
+    #[error("invalid chunk number: {}", .0.quote())]
+    ChunkNumber(String),
+}
+
+impl NumberType {
+    /// Parse a `NumberType` from a string.
+    ///
+    /// The following strings are valid arguments:
+    ///
+    /// ```ignore
+    /// "N"
+    /// "K/N"
+    /// "l/N"
+    /// "l/K/N"
+    /// "r/N"
+    /// "r/K/N"
+    /// ```
+    ///
+    /// The `N` represents the number of chunks and the `K` represents
+    /// a chunk number.
+    ///
+    /// # Errors
+    ///
+    /// If the string is not one of the valid number types,
+    /// if `K` is not a non-negative integer,
+    /// or if `K` is 0,
+    /// or if `N` is not a positive integer,
+    /// or if `K` is greater than `N`
+    /// then this function returns [`NumberTypeError`].
+    fn from(s: &str) -> Result<Self, NumberTypeError> {
+        fn is_invalid_chunk(chunk_number: u64, num_chunks: u64) -> bool {
+            chunk_number > num_chunks || chunk_number == 0
+        }
+        let mut parts = s.splitn(4, '/');
+        match (parts.next(), parts.next(), parts.next(), parts.next()) {
+            (Some(n_str), None, None, None) => {
+                let num_chunks = parse_size_u64(n_str)
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                if num_chunks > 0 {
+                    Ok(Self::Bytes(num_chunks))
+                } else {
+                    Err(NumberTypeError::NumberOfChunks(s.to_string()))
+                }
+            }
+            (Some(k_str), Some(n_str), None, None)
+                if !k_str.starts_with('l') && !k_str.starts_with('r') =>
+            {
+                let num_chunks = parse_size_u64(n_str)
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                let chunk_number = parse_size_u64(k_str)
+                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+                if is_invalid_chunk(chunk_number, num_chunks) {
+                    return Err(NumberTypeError::ChunkNumber(k_str.to_string()));
+                }
+                Ok(Self::KthBytes(chunk_number, num_chunks))
+            }
+            (Some("l"), Some(n_str), None, None) => {
+                let num_chunks = parse_size_u64(n_str)
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                Ok(Self::Lines(num_chunks))
+            }
+            (Some("l"), Some(k_str), Some(n_str), None) => {
+                let num_chunks = parse_size_u64(n_str)
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                let chunk_number = parse_size_u64(k_str)
+                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+                if is_invalid_chunk(chunk_number, num_chunks) {
+                    return Err(NumberTypeError::ChunkNumber(k_str.to_string()));
+                }
+                Ok(Self::KthLines(chunk_number, num_chunks))
+            }
+            (Some("r"), Some(n_str), None, None) => {
+                let num_chunks = parse_size_u64(n_str)
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                Ok(Self::RoundRobin(num_chunks))
+            }
+            (Some("r"), Some(k_str), Some(n_str), None) => {
+                let num_chunks = parse_size_u64(n_str)
+                    .map_err(|_| NumberTypeError::NumberOfChunks(n_str.to_string()))?;
+                let chunk_number = parse_size_u64(k_str)
+                    .map_err(|_| NumberTypeError::ChunkNumber(k_str.to_string()))?;
+                if is_invalid_chunk(chunk_number, num_chunks) {
+                    return Err(NumberTypeError::ChunkNumber(k_str.to_string()));
+                }
+                Ok(Self::KthRoundRobin(chunk_number, num_chunks))
+            }
+            _ => Err(NumberTypeError::NumberOfChunks(s.to_string())),
+        }
+    }
+}
+
+/// The strategy for breaking up the input file into chunks.
+pub enum Strategy {
+    /// Each chunk has the specified number of lines.
+    Lines(u64),
+
+    /// Each chunk has the specified number of bytes.
+    Bytes(u64),
+
+    /// Each chunk has as many lines as possible without exceeding the
+    /// specified number of bytes.
+    LineBytes(u64),
+
+    /// Split the file into this many chunks.
+    ///
+    /// There are several sub-strategies available, as defined by
+    /// [`NumberType`].
+    Number(NumberType),
+}
+
+/// An error when parsing a chunking strategy from command-line arguments.
+#[derive(Debug, Error)]
+pub enum StrategyError {
+    /// Invalid number of lines.
+    #[error("invalid number of lines: {0}")]
+    Lines(ParseSizeError),
+
+    /// Invalid number of bytes.
+    #[error("invalid number of bytes: {0}")]
+    Bytes(ParseSizeError),
+
+    /// Invalid number type.
+    #[error("{0}")]
+    NumberType(NumberTypeError),
+
+    /// Multiple chunking strategies were specified (but only one should be).
+    #[error("cannot split in more than one way")]
+    MultipleWays,
+}
+
+impl Strategy {
+    /// Parse a strategy from the command-line arguments.
+    pub fn from(matches: &ArgMatches, obs_lines: Option<&str>) -> Result<Self, StrategyError> {
+        fn get_and_parse(
+            matches: &ArgMatches,
+            option: &str,
+            strategy: fn(u64) -> Strategy,
+            error: fn(ParseSizeError) -> StrategyError,
+        ) -> Result<Strategy, StrategyError> {
+            let s = matches.get_one::<String>(option).unwrap();
+            let n = parse_size_u64_max(s).map_err(error)?;
+            if n > 0 {
+                Ok(strategy(n))
+            } else {
+                Err(error(ParseSizeError::ParseFailure(s.to_string())))
+            }
+        }
+        // Check that the user is not specifying more than one strategy.
+        //
+        // Note: right now, this exact behavior cannot be handled by
+        // overrides_with_all() due to obsolete lines value option
+        match (
+            obs_lines,
+            matches.value_source(OPT_LINES) == Some(ValueSource::CommandLine),
+            matches.value_source(OPT_BYTES) == Some(ValueSource::CommandLine),
+            matches.value_source(OPT_LINE_BYTES) == Some(ValueSource::CommandLine),
+            matches.value_source(OPT_NUMBER) == Some(ValueSource::CommandLine),
+        ) {
+            (Some(v), false, false, false, false) => {
+                let v = parse_size_u64_max(v).map_err(|_| {
+                    StrategyError::Lines(ParseSizeError::ParseFailure(v.to_string()))
+                })?;
+                if v > 0 {
+                    Ok(Self::Lines(v))
+                } else {
+                    Err(StrategyError::Lines(ParseSizeError::ParseFailure(
+                        v.to_string(),
+                    )))
+                }
+            }
+            (None, false, false, false, false) => Ok(Self::Lines(1000)),
+            (None, true, false, false, false) => {
+                get_and_parse(matches, OPT_LINES, Self::Lines, StrategyError::Lines)
+            }
+            (None, false, true, false, false) => {
+                get_and_parse(matches, OPT_BYTES, Self::Bytes, StrategyError::Bytes)
+            }
+            (None, false, false, true, false) => get_and_parse(
+                matches,
+                OPT_LINE_BYTES,
+                Self::LineBytes,
+                StrategyError::Bytes,
+            ),
+            (None, false, false, false, true) => {
+                let s = matches.get_one::<String>(OPT_NUMBER).unwrap();
+                let number_type = NumberType::from(s).map_err(StrategyError::NumberType)?;
+                Ok(Self::Number(number_type))
+            }
+            _ => Err(StrategyError::MultipleWays),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::{strategy::NumberType, strategy::NumberTypeError};
+
+    #[test]
+    fn test_number_type_from() {
+        assert_eq!(NumberType::from("123").unwrap(), NumberType::Bytes(123));
+        assert_eq!(NumberType::from("l/123").unwrap(), NumberType::Lines(123));
+        assert_eq!(
+            NumberType::from("l/123/456").unwrap(),
+            NumberType::KthLines(123, 456)
+        );
+        assert_eq!(
+            NumberType::from("r/123").unwrap(),
+            NumberType::RoundRobin(123)
+        );
+        assert_eq!(
+            NumberType::from("r/123/456").unwrap(),
+            NumberType::KthRoundRobin(123, 456)
+        );
+    }
+
+    #[test]
+    #[allow(clippy::cognitive_complexity)]
+    fn test_number_type_from_error() {
+        assert_eq!(
+            NumberType::from("xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/123/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/abc/456").unwrap_err(),
+            NumberTypeError::ChunkNumber("abc".to_string())
+        );
+        assert_eq!(
+            NumberType::from("l/456/123").unwrap_err(),
+            NumberTypeError::ChunkNumber("456".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/456/123").unwrap_err(),
+            NumberTypeError::ChunkNumber("456".to_string())
+        );
+        assert_eq!(
+            NumberType::from("456/123").unwrap_err(),
+            NumberTypeError::ChunkNumber("456".to_string())
+        );
+        // In GNU split, the number of chunks get precedence:
+        //
+        //     $ split -n l/abc/xyz
+        //     split: invalid number of chunks: ‘xyz’
+        //
+        assert_eq!(
+            NumberType::from("l/abc/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/123/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+        assert_eq!(
+            NumberType::from("r/abc/456").unwrap_err(),
+            NumberTypeError::ChunkNumber("abc".to_string())
+        );
+        // In GNU split, the number of chunks get precedence:
+        //
+        //     $ split -n r/abc/xyz
+        //     split: invalid number of chunks: ‘xyz’
+        //
+        assert_eq!(
+            NumberType::from("r/abc/xyz").unwrap_err(),
+            NumberTypeError::NumberOfChunks("xyz".to_string())
+        );
+    }
+
+    #[test]
+    fn test_number_type_num_chunks() {
+        assert_eq!(NumberType::from("123").unwrap().num_chunks(), 123);
+        assert_eq!(NumberType::from("123/456").unwrap().num_chunks(), 456);
+        assert_eq!(NumberType::from("l/123").unwrap().num_chunks(), 123);
+        assert_eq!(NumberType::from("l/123/456").unwrap().num_chunks(), 456);
+        assert_eq!(NumberType::from("r/123").unwrap().num_chunks(), 123);
+        assert_eq!(NumberType::from("r/123/456").unwrap().num_chunks(), 456);
+    }
+}
diff --git a/src/uu/stat/Cargo.toml b/src/uu/stat/Cargo.toml
index f258aca1135..940a3ddbf86 100644
--- a/src/uu/stat/Cargo.toml
+++ b/src/uu/stat/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_stat"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "stat ~ (uutils) display FILE status"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stat"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/stat.rs"
@@ -17,6 +20,10 @@ path = "src/stat.rs"
 [dependencies]
 clap = { workspace = true }
 uucore = { workspace = true, features = ["entries", "libc", "fs", "fsext"] }
+chrono = { workspace = true }
+
+[features]
+selinux = ["uucore/selinux"]
 
 [[bin]]
 name = "stat"
diff --git a/src/uu/stat/src/stat.rs b/src/uu/stat/src/stat.rs
index c36b450067b..16a96c3807d 100644
--- a/src/uu/stat/src/stat.rs
+++ b/src/uu/stat/src/stat.rs
@@ -2,27 +2,31 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+// spell-checker:ignore datetime
+
+use uucore::error::{UResult, USimpleError};
 
 use clap::builder::ValueParser;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
 use uucore::fs::display_permissions;
 use uucore::fsext::{
-    pretty_filetype, pretty_fstype, pretty_time, read_fs_list, statfs, BirthTime, FsMeta,
+    BirthTime, FsMeta, StatFs, pretty_filetype, pretty_fstype, read_fs_list, statfs,
 };
 use uucore::libc::mode_t;
 use uucore::{
     entries, format_usage, help_about, help_section, help_usage, show_error, show_warning,
 };
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use chrono::{DateTime, Local};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use std::borrow::Cow;
-use std::convert::AsRef;
 use std::ffi::{OsStr, OsString};
-use std::fs;
+use std::fs::{FileType, Metadata};
+use std::io::Write;
 use std::os::unix::fs::{FileTypeExt, MetadataExt};
 use std::os::unix::prelude::OsStrExt;
 use std::path::Path;
+use std::{env, fs};
 
 const ABOUT: &str = help_about!("stat.md");
 const USAGE: &str = help_usage!("stat.md");
@@ -90,16 +94,48 @@ pub enum OutputType {
     Unsigned(u64),
     UnsignedHex(u64),
     UnsignedOct(u32),
+    Float(f64),
     Unknown,
 }
 
+#[derive(Default)]
+enum QuotingStyle {
+    Locale,
+    Shell,
+    #[default]
+    ShellEscapeAlways,
+    Quote,
+}
+
+impl std::str::FromStr for QuotingStyle {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "locale" => Ok(QuotingStyle::Locale),
+            "shell" => Ok(QuotingStyle::Shell),
+            "shell-escape-always" => Ok(QuotingStyle::ShellEscapeAlways),
+            // The others aren't exposed to the user
+            _ => Err(format!("Invalid quoting style: {s}")),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum Precision {
+    NotSpecified,
+    NoNumber,
+    Number(usize),
+}
+
 #[derive(Debug, PartialEq, Eq)]
 enum Token {
     Char(char),
+    Byte(u8),
     Directive {
         flag: Flags,
         width: usize,
-        precision: Option<usize>,
+        precision: Precision,
         format: char,
     },
 }
@@ -210,10 +246,10 @@ struct Stater {
 /// * `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.
+/// * `precision` - How many digits of precision, if any.
 ///
 /// 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>) {
+fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Precision) {
     // 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.
     // This gives the minimum number of digits to appear for d, i, o, u, x, and X conversions,
@@ -243,7 +279,7 @@ 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 = determine_padding_char(&flags, &precision);
+    let padding_char = determine_padding_char(&flags);
 
     match output {
         OutputType::Str(s) => print_str(s, &flags, width, precision),
@@ -255,6 +291,9 @@ fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<u
         OutputType::UnsignedHex(num) => {
             print_unsigned_hex(*num, &flags, width, precision, padding_char);
         }
+        OutputType::Float(num) => {
+            print_float(*num, &flags, width, precision, padding_char);
+        }
         OutputType::Unknown => print!("?"),
     }
 }
@@ -264,13 +303,12 @@ fn print_it(output: &OutputType, flags: Flags, width: usize, precision: Option<u
 /// # 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() {
+fn determine_padding_char(flags: &Flags) -> Padding {
+    if flags.zero && !flags.left {
         Padding::Zero
     } else {
         Padding::Space
@@ -284,15 +322,102 @@ fn determine_padding_char(flags: &Flags, precision: &Option<usize>) -> Padding {
 /// * `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>) {
+/// * `precision` - How many digits of precision, if any.
+fn print_str(s: &str, flags: &Flags, width: usize, precision: Precision) {
     let s = match precision {
-        Some(p) if p < s.len() => &s[..p],
+        Precision::Number(p) if p < s.len() => &s[..p],
         _ => s,
     };
     pad_and_print(s, flags.left, width, Padding::Space);
 }
 
+fn quote_file_name(file_name: &str, quoting_style: &QuotingStyle) -> String {
+    match quoting_style {
+        QuotingStyle::Locale | QuotingStyle::Shell => {
+            let escaped = file_name.replace('\'', r"\'");
+            format!("'{escaped}'")
+        }
+        QuotingStyle::ShellEscapeAlways => format!("\"{file_name}\""),
+        QuotingStyle::Quote => file_name.to_string(),
+    }
+}
+
+fn get_quoted_file_name(
+    display_name: &str,
+    file: &OsString,
+    file_type: &FileType,
+    from_user: bool,
+) -> Result<String, i32> {
+    let quoting_style = env::var("QUOTING_STYLE")
+        .ok()
+        .and_then(|style| style.parse().ok())
+        .unwrap_or_default();
+
+    if file_type.is_symlink() {
+        let quoted_display_name = quote_file_name(display_name, &quoting_style);
+        match fs::read_link(file) {
+            Ok(dst) => {
+                let quoted_dst = quote_file_name(&dst.to_string_lossy(), &quoting_style);
+                Ok(format!("{quoted_display_name} -> {quoted_dst}"))
+            }
+            Err(e) => {
+                show_error!("{e}");
+                Err(1)
+            }
+        }
+    } else {
+        let style = if from_user {
+            quoting_style
+        } else {
+            QuotingStyle::Quote
+        };
+        Ok(quote_file_name(display_name, &style))
+    }
+}
+
+fn process_token_filesystem(t: &Token, meta: &StatFs, display_name: &str) {
+    match *t {
+        Token::Byte(byte) => write_raw_byte(byte),
+        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);
+        }
+    }
+}
+
 /// Prints an integer value based on the provided flags, width, and precision.
 ///
 /// # Arguments
@@ -300,13 +425,13 @@ fn print_str(s: &str, flags: &Flags, width: usize, precision: Option<usize>) {
 /// * `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.
+/// * `precision` - How many digits of precision, if any.
 /// * `padding_char` - The padding character as determined by `determine_padding_char`.
 fn print_integer(
     num: i64,
     flags: &Flags,
     width: usize,
-    precision: Option<usize>,
+    precision: Precision,
     padding_char: Padding,
 ) {
     let num = num.to_string();
@@ -322,10 +447,63 @@ fn print_integer(
     } else {
         ""
     };
-    let extended = format!(
-        "{prefix}{arg:0>precision$}",
-        precision = precision.unwrap_or(0)
-    );
+    let extended = match precision {
+        Precision::NotSpecified => format!("{prefix}{arg}"),
+        Precision::NoNumber => format!("{prefix}{arg}"),
+        Precision::Number(p) => format!("{prefix}{arg:0>p$}"),
+    };
+    pad_and_print(&extended, flags.left, width, padding_char);
+}
+
+/// Truncate a float to the given number of digits after the decimal point.
+fn precision_trunc(num: f64, precision: Precision) -> String {
+    // GNU `stat` doesn't round, it just seems to truncate to the
+    // given precision:
+    //
+    //     $ stat -c "%.5Y" /dev/pts/ptmx
+    //     1736344012.76399
+    //     $ stat -c "%.4Y" /dev/pts/ptmx
+    //     1736344012.7639
+    //     $ stat -c "%.3Y" /dev/pts/ptmx
+    //     1736344012.763
+    //
+    // Contrast this with `printf`, which seems to round the
+    // numbers:
+    //
+    //     $ printf "%.5f\n" 1736344012.76399
+    //     1736344012.76399
+    //     $ printf "%.4f\n" 1736344012.76399
+    //     1736344012.7640
+    //     $ printf "%.3f\n" 1736344012.76399
+    //     1736344012.764
+    //
+    let num_str = num.to_string();
+    let n = num_str.len();
+    match (num_str.find('.'), precision) {
+        (None, Precision::NotSpecified) => num_str,
+        (None, Precision::NoNumber) => num_str,
+        (None, Precision::Number(0)) => num_str,
+        (None, Precision::Number(p)) => format!("{num_str}.{zeros}", zeros = "0".repeat(p)),
+        (Some(i), Precision::NotSpecified) => num_str[..i].to_string(),
+        (Some(_), Precision::NoNumber) => num_str,
+        (Some(i), Precision::Number(0)) => num_str[..i].to_string(),
+        (Some(i), Precision::Number(p)) if p < n - i => num_str[..i + 1 + p].to_string(),
+        (Some(i), Precision::Number(p)) => {
+            format!("{num_str}{zeros}", zeros = "0".repeat(p - (n - i - 1)))
+        }
+    }
+}
+
+fn print_float(num: f64, flags: &Flags, width: usize, precision: Precision, padding_char: Padding) {
+    let prefix = if flags.sign {
+        "+"
+    } else if flags.space {
+        " "
+    } else {
+        ""
+    };
+    let num_str = precision_trunc(num, precision);
+    let extended = format!("{prefix}{num_str}");
     pad_and_print(&extended, flags.left, width, padding_char);
 }
 
@@ -336,13 +514,13 @@ fn print_integer(
 /// * `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.
+/// * `precision` - How many digits of precision, if any.
 /// * `padding_char` - The padding character as determined by `determine_padding_char`.
 fn print_unsigned(
     num: u64,
     flags: &Flags,
     width: usize,
-    precision: Option<usize>,
+    precision: Precision,
     padding_char: Padding,
 ) {
     let num = num.to_string();
@@ -351,7 +529,11 @@ fn print_unsigned(
     } else {
         Cow::Borrowed(num.as_str())
     };
-    let s = format!("{s:0>precision$}", precision = precision.unwrap_or(0));
+    let s = match precision {
+        Precision::NotSpecified => s,
+        Precision::NoNumber => s,
+        Precision::Number(p) => format!("{s:0>p$}").into(),
+    };
     pad_and_print(&s, flags.left, width, padding_char);
 }
 
@@ -362,20 +544,21 @@ fn print_unsigned(
 /// * `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.
+/// * `precision` - How many digits of precision, if any.
 /// * `padding_char` - The padding character as determined by `determine_padding_char`.
 fn print_unsigned_oct(
     num: u32,
     flags: &Flags,
     width: usize,
-    precision: Option<usize>,
+    precision: Precision,
     padding_char: Padding,
 ) {
     let prefix = if flags.alter { "0" } else { "" };
-    let s = format!(
-        "{prefix}{num:0>precision$o}",
-        precision = precision.unwrap_or(0)
-    );
+    let s = match precision {
+        Precision::NotSpecified => format!("{prefix}{num:o}"),
+        Precision::NoNumber => format!("{prefix}{num:o}"),
+        Precision::Number(p) => format!("{prefix}{num:0>p$o}"),
+    };
     pad_and_print(&s, flags.left, width, padding_char);
 }
 
@@ -386,139 +569,209 @@ fn print_unsigned_oct(
 /// * `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.
+/// * `precision` - How many digits of precision, if any.
 /// * `padding_char` - The padding character as determined by `determine_padding_char`.
 fn print_unsigned_hex(
     num: u64,
     flags: &Flags,
     width: usize,
-    precision: Option<usize>,
+    precision: Precision,
     padding_char: Padding,
 ) {
     let prefix = if flags.alter { "0x" } else { "" };
-    let s = format!(
-        "{prefix}{num:0>precision$x}",
-        precision = precision.unwrap_or(0)
-    );
+    let s = match precision {
+        Precision::NotSpecified => format!("{prefix}{num:x}"),
+        Precision::NoNumber => format!("{prefix}{num:x}"),
+        Precision::Number(p) => format!("{prefix}{num:0>p$x}"),
+    };
     pad_and_print(&s, flags.left, width, padding_char);
 }
 
+fn write_raw_byte(byte: u8) {
+    std::io::stdout().write_all(&[byte]).unwrap();
+}
+
 impl Stater {
-    fn generate_tokens(format_str: &str, use_printf: bool) -> UResult<Vec<Token>> {
-        let mut tokens = Vec::new();
-        let bound = format_str.len();
-        let chars = format_str.chars().collect::<Vec<char>>();
-        let mut i = 0;
-        while i < bound {
-            match chars[i] {
-                '%' => {
-                    let old = i;
+    fn process_flags(chars: &[char], i: &mut usize, bound: usize, flag: &mut Flags) {
+        while *i < bound {
+            match chars[*i] {
+                '#' => flag.alter = true,
+                '0' => flag.zero = true,
+                '-' => flag.left = true,
+                ' ' => flag.space = true,
+                // This is not documented but the behavior seems to be
+                // the same as a space. For example `stat -c "%I5s" f`
+                // prints "    0".
+                'I' => flag.space = true,
+                '+' => flag.sign = true,
+                '\'' => flag.group = true,
+                _ => break,
+            }
+            *i += 1;
+        }
+    }
 
-                    i += 1;
-                    if i >= bound {
-                        tokens.push(Token::Char('%'));
-                        continue;
-                    }
-                    if chars[i] == '%' {
-                        tokens.push(Token::Char('%'));
-                        i += 1;
-                        continue;
-                    }
+    fn handle_percent_case(
+        chars: &[char],
+        i: &mut usize,
+        bound: usize,
+        format_str: &str,
+    ) -> UResult<Token> {
+        let old = *i;
+
+        *i += 1;
+        if *i >= bound {
+            return Ok(Token::Char('%'));
+        }
+        if chars[*i] == '%' {
+            *i += 1;
+            return Ok(Token::Char('%'));
+        }
 
-                    let mut flag = Flags::default();
-
-                    while i < bound {
-                        match chars[i] {
-                            '#' => flag.alter = true,
-                            '0' => flag.zero = true,
-                            '-' => flag.left = true,
-                            ' ' => flag.space = true,
-                            '+' => flag.sign = true,
-                            '\'' => flag.group = true,
-                            'I' => unimplemented!(),
-                            _ => break,
-                        }
-                        i += 1;
-                    }
-                    check_bound(format_str, bound, old, i)?;
+        let mut flag = Flags::default();
 
-                    let mut width = 0;
-                    let mut precision = None;
-                    let mut j = i;
+        Self::process_flags(chars, i, bound, &mut flag);
 
-                    if let Some((field_width, offset)) = format_str[j..].scan_num::<usize>() {
-                        width = field_width;
-                        j += offset;
-                    }
-                    check_bound(format_str, bound, old, j)?;
+        let mut width = 0;
+        let mut precision = Precision::NotSpecified;
+        let mut j = *i;
 
-                    if chars[j] == '.' {
-                        j += 1;
-                        check_bound(format_str, bound, old, j)?;
+        if let Some((field_width, offset)) = format_str[j..].scan_num::<usize>() {
+            width = field_width;
+            j += offset;
 
-                        match format_str[j..].scan_num::<i32>() {
-                            Some((value, offset)) => {
-                                if value >= 0 {
-                                    precision = Some(value as usize);
-                                }
-                                j += offset;
-                            }
-                            None => precision = Some(0),
-                        }
-                        check_bound(format_str, bound, old, j)?;
+            // Reject directives like `%<NUMBER>` by checking if width has been parsed.
+            if j >= bound || chars[j] == '%' {
+                let invalid_directive: String = chars[old..=j.min(bound - 1)].iter().collect();
+                return Err(USimpleError::new(
+                    1,
+                    format!("{}: invalid directive", invalid_directive.quote()),
+                ));
+            }
+        }
+        check_bound(format_str, bound, old, j)?;
+
+        if chars[j] == '.' {
+            j += 1;
+            check_bound(format_str, bound, old, j)?;
+
+            match format_str[j..].scan_num::<i32>() {
+                Some((value, offset)) => {
+                    if value >= 0 {
+                        precision = Precision::Number(value as usize);
                     }
+                    j += offset;
+                }
+                None => precision = Precision::NoNumber,
+            }
+            check_bound(format_str, bound, old, j)?;
+        }
 
-                    i = j;
-                    tokens.push(Token::Directive {
-                        width,
+        *i = j;
+
+        // Check for multi-character specifiers (e.g., `%Hd`, `%Lr`)
+        if *i + 1 < bound {
+            if let Some(&next_char) = chars.get(*i + 1) {
+                if (chars[*i] == 'H' || chars[*i] == 'L') && (next_char == 'd' || next_char == 'r')
+                {
+                    let specifier = format!("{}{next_char}", chars[*i]);
+                    *i += 1;
+                    return Ok(Token::Directive {
                         flag,
+                        width,
                         precision,
-                        format: chars[i],
+                        format: specifier.chars().next().unwrap(),
                     });
                 }
+            }
+        }
+
+        Ok(Token::Directive {
+            flag,
+            width,
+            precision,
+            format: chars[*i],
+        })
+    }
+
+    fn handle_escape_sequences(
+        chars: &[char],
+        i: &mut usize,
+        bound: usize,
+        format_str: &str,
+    ) -> Token {
+        *i += 1;
+        if *i >= bound {
+            show_warning!("backslash at end of format");
+            return Token::Char('\\');
+        }
+        match chars[*i] {
+            'a' => Token::Byte(0x07),   // BEL
+            'b' => Token::Byte(0x08),   // Backspace
+            'f' => Token::Byte(0x0C),   // Form feed
+            'n' => Token::Byte(0x0A),   // Line feed
+            'r' => Token::Byte(0x0D),   // Carriage return
+            't' => Token::Byte(0x09),   // Horizontal tab
+            '\\' => Token::Byte(b'\\'), // Backslash
+            '\'' => Token::Byte(b'\''), // Single quote
+            '"' => Token::Byte(b'"'),   // Double quote
+            '0'..='7' => {
+                // Parse octal escape sequence (up to 3 digits)
+                let mut value = 0u8;
+                let mut count = 0;
+                while *i < bound && count < 3 {
+                    if let Some(digit) = chars[*i].to_digit(8) {
+                        value = value * 8 + digit as u8;
+                        *i += 1;
+                        count += 1;
+                    } else {
+                        break;
+                    }
+                }
+                *i -= 1; // Adjust index to account for the outer loop increment
+                Token::Byte(value)
+            }
+            'x' => {
+                // Parse hexadecimal escape sequence
+                if *i + 1 < bound {
+                    if let Some((c, offset)) = format_str[*i + 1..].scan_char(16) {
+                        *i += offset;
+                        Token::Byte(c as u8)
+                    } else {
+                        show_warning!("unrecognized escape '\\x'");
+                        Token::Byte(b'x')
+                    }
+                } else {
+                    show_warning!("incomplete hex escape '\\x'");
+                    Token::Byte(b'x')
+                }
+            }
+            other => {
+                show_warning!("unrecognized escape '\\{other}'");
+                Token::Byte(other as u8)
+            }
+        }
+    }
+
+    fn generate_tokens(format_str: &str, use_printf: bool) -> UResult<Vec<Token>> {
+        let mut tokens = Vec::new();
+        let bound = format_str.len();
+        let chars = format_str.chars().collect::<Vec<char>>();
+        let mut i = 0;
+        while i < bound {
+            match chars[i] {
+                '%' => tokens.push(Self::handle_percent_case(
+                    &chars, &mut i, bound, format_str,
+                )?),
                 '\\' => {
                     if use_printf {
-                        i += 1;
-                        if i >= bound {
-                            show_warning!("backslash at end of format");
-                            tokens.push(Token::Char('\\'));
-                            continue;
-                        }
-                        match chars[i] {
-                            'x' if i + 1 < bound => {
-                                if let Some((c, offset)) = format_str[i + 1..].scan_char(16) {
-                                    tokens.push(Token::Char(c));
-                                    i += offset;
-                                } else {
-                                    show_warning!("unrecognized escape '\\x'");
-                                    tokens.push(Token::Char('x'));
-                                }
-                            }
-                            '0'..='7' => {
-                                let (c, offset) = format_str[i..].scan_char(8).unwrap();
-                                tokens.push(Token::Char(c));
-                                i += offset - 1;
-                            }
-                            '"' => tokens.push(Token::Char('"')),
-                            '\\' => tokens.push(Token::Char('\\')),
-                            'a' => tokens.push(Token::Char('\x07')),
-                            'b' => tokens.push(Token::Char('\x08')),
-                            'e' => tokens.push(Token::Char('\x1B')),
-                            'f' => tokens.push(Token::Char('\x0C')),
-                            'n' => tokens.push(Token::Char('\n')),
-                            'r' => tokens.push(Token::Char('\r')),
-                            't' => tokens.push(Token::Char('\t')),
-                            'v' => tokens.push(Token::Char('\x0B')),
-                            c => {
-                                show_warning!("unrecognized escape '\\{}'", c);
-                                tokens.push(Token::Char(c));
-                            }
-                        }
+                        tokens.push(Self::handle_escape_sequences(
+                            &chars, &mut i, bound, format_str,
+                        ));
                     } else {
                         tokens.push(Token::Char('\\'));
                     }
                 }
-
                 c => tokens.push(Token::Char(c)),
             }
             i += 1;
@@ -530,10 +783,16 @@ impl Stater {
     }
 
     fn new(matches: &ArgMatches) -> UResult<Self> {
-        let files = matches
+        let files: Vec<OsString> = matches
             .get_many::<OsString>(options::FILES)
             .map(|v| v.map(OsString::from).collect())
             .unwrap_or_default();
+        if files.is_empty() {
+            return Err(Box::new(USimpleError {
+                code: 1,
+                message: "missing operand\nTry 'stat --help' for more information.".to_string(),
+            }));
+        }
         let format_str = if matches.contains_id(options::PRINTF) {
             matches
                 .get_one::<String>(options::PRINTF)
@@ -562,7 +821,10 @@ impl Stater {
             None
         } else {
             let mut mount_list = read_fs_list()
-                .map_err_context(|| "cannot read table of mounted file systems".into())?
+                .map_err(|e| {
+                    let context = "cannot read table of mounted file systems";
+                    USimpleError::new(e.code(), format!("{context}: {e}"))
+                })?
                 .iter()
                 .map(|mi| mi.mount_dir.clone())
                 .collect::<Vec<String>>();
@@ -609,6 +871,162 @@ impl Stater {
         ret
     }
 
+    fn process_token_files(
+        &self,
+        t: &Token,
+        meta: &Metadata,
+        display_name: &str,
+        file: &OsString,
+        file_type: &FileType,
+        from_user: bool,
+    ) -> Result<(), i32> {
+        match *t {
+            Token::Byte(byte) => write_raw_byte(byte),
+            Token::Char(c) => print!("{c}"),
+
+            Token::Directive {
+                flag,
+                width,
+                precision,
+                format,
+            } => {
+                let output = match format {
+                    // access rights in octal
+                    'a' => OutputType::UnsignedOct(0o7777 & meta.mode()),
+                    // access rights in human readable form
+                    'A' => OutputType::Str(display_permissions(meta, true)),
+                    // number of blocks allocated (see %B)
+                    'b' => OutputType::Unsigned(meta.blocks()),
+
+                    // the size in bytes of each block reported by %b
+                    // FIXME: blocksize differs on various platform
+                    // See coreutils/gnulib/lib/stat-size.h ST_NBLOCKSIZE // spell-checker:disable-line
+                    'B' => OutputType::Unsigned(512),
+                    // SELinux security context string
+                    'C' => {
+                        #[cfg(feature = "selinux")]
+                        {
+                            if uucore::selinux::is_selinux_enabled() {
+                                match uucore::selinux::get_selinux_security_context(Path::new(file))
+                                {
+                                    Ok(ctx) => OutputType::Str(ctx),
+                                    Err(_) => OutputType::Str(
+                                        "failed to get security context".to_string(),
+                                    ),
+                                }
+                            } else {
+                                OutputType::Str("unsupported on this system".to_string())
+                            }
+                        }
+                        #[cfg(not(feature = "selinux"))]
+                        {
+                            OutputType::Str("unsupported for this operating system".to_string())
+                        }
+                    }
+                    // device number in decimal
+                    'd' => OutputType::Unsigned(meta.dev()),
+                    // device number in hex
+                    'D' => OutputType::UnsignedHex(meta.dev()),
+                    // raw mode in hex
+                    'f' => OutputType::UnsignedHex(meta.mode() as u64),
+                    // file type
+                    'F' => OutputType::Str(pretty_filetype(meta.mode() as mode_t, meta.len())),
+                    // group ID of owner
+                    'g' => OutputType::Unsigned(meta.gid() as u64),
+                    // group name of owner
+                    'G' => {
+                        let group_name =
+                            entries::gid2grp(meta.gid()).unwrap_or_else(|_| "UNKNOWN".to_owned());
+                        OutputType::Str(group_name)
+                    }
+                    // number of hard links
+                    'h' => OutputType::Unsigned(meta.nlink()),
+                    // inode number
+                    'i' => OutputType::Unsigned(meta.ino()),
+                    // mount point
+                    'm' => OutputType::Str(self.find_mount_point(file).unwrap()),
+                    // file name
+                    'n' => OutputType::Str(display_name.to_string()),
+                    // quoted file name with dereference if symbolic link
+                    'N' => {
+                        let file_name =
+                            get_quoted_file_name(display_name, file, file_type, from_user)?;
+                        OutputType::Str(file_name)
+                    }
+                    // optimal I/O transfer size hint
+                    'o' => OutputType::Unsigned(meta.blksize()),
+                    // total size, in bytes
+                    's' => OutputType::Integer(meta.len() as i64),
+                    // major device type in hex, for character/block device special
+                    // files
+                    't' => OutputType::UnsignedHex(meta.rdev() >> 8),
+                    // minor device type in hex, for character/block device special
+                    // files
+                    'T' => OutputType::UnsignedHex(meta.rdev() & 0xff),
+                    // user ID of owner
+                    'u' => OutputType::Unsigned(meta.uid() as u64),
+                    // user name of owner
+                    'U' => {
+                        let user_name =
+                            entries::uid2usr(meta.uid()).unwrap_or_else(|_| "UNKNOWN".to_owned());
+                        OutputType::Str(user_name)
+                    }
+
+                    // time of file birth, human-readable; - if unknown
+                    'w' => OutputType::Str(
+                        meta.birth()
+                            .map(|(sec, nsec)| pretty_time(sec as i64, nsec as i64))
+                            .unwrap_or(String::from("-")),
+                    ),
+
+                    // time of file birth, seconds since Epoch; 0 if unknown
+                    'W' => OutputType::Unsigned(meta.birth().unwrap_or_default().0),
+
+                    // time of last access, human-readable
+                    'x' => OutputType::Str(pretty_time(meta.atime(), meta.atime_nsec())),
+                    // time of last access, seconds since Epoch
+                    'X' => OutputType::Integer(meta.atime()),
+                    // time of last data modification, human-readable
+                    'y' => OutputType::Str(pretty_time(meta.mtime(), meta.mtime_nsec())),
+                    // time of last data modification, seconds since Epoch
+                    'Y' => {
+                        let sec = meta.mtime();
+                        let nsec = meta.mtime_nsec();
+                        let tm = DateTime::from_timestamp(sec, nsec as u32).unwrap_or_default();
+                        let tm: DateTime<Local> = tm.into();
+                        match tm.timestamp_nanos_opt() {
+                            None => {
+                                let micros = tm.timestamp_micros();
+                                let secs = micros as f64 / 1_000_000.0;
+                                OutputType::Float(secs)
+                            }
+                            Some(ns) => {
+                                let secs = ns as f64 / 1_000_000_000.0;
+                                OutputType::Float(secs)
+                            }
+                        }
+                    }
+                    // time of last status change, human-readable
+                    'z' => OutputType::Str(pretty_time(meta.ctime(), meta.ctime_nsec())),
+                    // time of last status change, seconds since Epoch
+                    'Z' => OutputType::Integer(meta.ctime()),
+                    'R' => {
+                        let major = meta.rdev() >> 8;
+                        let minor = meta.rdev() & 0xff;
+                        OutputType::Str(format!("{major},{minor}"))
+                    }
+                    'r' => OutputType::Unsigned(meta.rdev()),
+                    'H' => OutputType::Unsigned(meta.rdev() >> 8), // Major in decimal
+                    'L' => OutputType::Unsigned(meta.rdev() & 0xff), // Minor in decimal
+
+                    _ => OutputType::Unknown,
+                };
+                print_it(&output, flag, width, precision);
+            }
+        }
+        Ok(())
+    }
+
     fn do_stat(&self, file: &OsStr, stdin_is_fifo: bool) -> i32 {
         let display_name = file.to_string_lossy();
         let file = if cfg!(unix) && display_name == "-" {
@@ -633,53 +1051,15 @@ impl Stater {
                 Ok(meta) => {
                     let tokens = &self.default_tokens;
 
+                    // Usage
                     for t in tokens {
-                        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);
-                            }
-                        }
+                        process_token_filesystem(t, &meta, &display_name);
                     }
                 }
                 Err(e) => {
                     show_error!(
-                        "cannot read file system information for {}: {}",
+                        "cannot read file system information for {}: {e}",
                         display_name.quote(),
-                        e
                     );
                     return 1;
                 }
@@ -702,126 +1082,20 @@ impl Stater {
                     };
 
                     for t in tokens {
-                        match *t {
-                            Token::Char(c) => print!("{c}"),
-                            Token::Directive {
-                                flag,
-                                width,
-                                precision,
-                                format,
-                            } => {
-                                let output = match format {
-                                    // access rights in octal
-                                    'a' => OutputType::UnsignedOct(0o7777 & meta.mode()),
-                                    // access rights in human readable form
-                                    'A' => OutputType::Str(display_permissions(&meta, true)),
-                                    // number of blocks allocated (see %B)
-                                    'b' => OutputType::Unsigned(meta.blocks()),
-
-                                    // the size in bytes of each block reported by %b
-                                    // FIXME: blocksize differs on various platform
-                                    // See coreutils/gnulib/lib/stat-size.h ST_NBLOCKSIZE // spell-checker:disable-line
-                                    'B' => OutputType::Unsigned(512),
-
-                                    // device number in decimal
-                                    'd' => OutputType::Unsigned(meta.dev()),
-                                    // device number in hex
-                                    'D' => OutputType::UnsignedHex(meta.dev()),
-                                    // raw mode in hex
-                                    'f' => OutputType::UnsignedHex(meta.mode() as u64),
-                                    // file type
-                                    'F' => OutputType::Str(
-                                        pretty_filetype(meta.mode() as mode_t, meta.len())
-                                            .to_owned(),
-                                    ),
-                                    // group ID of owner
-                                    'g' => OutputType::Unsigned(meta.gid() as u64),
-                                    // group name of owner
-                                    'G' => {
-                                        let group_name = entries::gid2grp(meta.gid())
-                                            .unwrap_or_else(|_| "UNKNOWN".to_owned());
-                                        OutputType::Str(group_name)
-                                    }
-                                    // number of hard links
-                                    'h' => OutputType::Unsigned(meta.nlink()),
-                                    // inode number
-                                    'i' => OutputType::Unsigned(meta.ino()),
-                                    // mount point
-                                    'm' => OutputType::Str(self.find_mount_point(&file).unwrap()),
-                                    // file name
-                                    'n' => OutputType::Str(display_name.to_string()),
-                                    // quoted file name with dereference if symbolic link
-                                    'N' => {
-                                        let file_name = if file_type.is_symlink() {
-                                            let dst = match fs::read_link(&file) {
-                                                Ok(path) => path,
-                                                Err(e) => {
-                                                    println!("{e}");
-                                                    return 1;
-                                                }
-                                            };
-                                            format!("{} -> {}", display_name.quote(), dst.quote())
-                                        } else {
-                                            display_name.to_string()
-                                        };
-                                        OutputType::Str(file_name)
-                                    }
-                                    // optimal I/O transfer size hint
-                                    'o' => OutputType::Unsigned(meta.blksize()),
-                                    // total size, in bytes
-                                    's' => OutputType::Integer(meta.len() as i64),
-                                    // major device type in hex, for character/block device special
-                                    // files
-                                    't' => OutputType::UnsignedHex(meta.rdev() >> 8),
-                                    // minor device type in hex, for character/block device special
-                                    // files
-                                    'T' => OutputType::UnsignedHex(meta.rdev() & 0xff),
-                                    // user ID of owner
-                                    'u' => OutputType::Unsigned(meta.uid() as u64),
-                                    // user name of owner
-                                    'U' => {
-                                        let user_name = entries::uid2usr(meta.uid())
-                                            .unwrap_or_else(|_| "UNKNOWN".to_owned());
-                                        OutputType::Str(user_name)
-                                    }
-
-                                    // time of file birth, human-readable; - if unknown
-                                    'w' => OutputType::Str(meta.pretty_birth()),
-
-                                    // time of file birth, seconds since Epoch; 0 if unknown
-                                    'W' => OutputType::Unsigned(meta.birth()),
-
-                                    // time of last access, human-readable
-                                    'x' => OutputType::Str(pretty_time(
-                                        meta.atime(),
-                                        meta.atime_nsec(),
-                                    )),
-                                    // time of last access, seconds since Epoch
-                                    'X' => OutputType::Integer(meta.atime()),
-                                    // time of last data modification, human-readable
-                                    'y' => OutputType::Str(pretty_time(
-                                        meta.mtime(),
-                                        meta.mtime_nsec(),
-                                    )),
-                                    // time of last data modification, seconds since Epoch
-                                    'Y' => OutputType::Integer(meta.mtime()),
-                                    // time of last status change, human-readable
-                                    'z' => OutputType::Str(pretty_time(
-                                        meta.ctime(),
-                                        meta.ctime_nsec(),
-                                    )),
-                                    // time of last status change, seconds since Epoch
-                                    'Z' => OutputType::Integer(meta.ctime()),
-
-                                    _ => OutputType::Unknown,
-                                };
-                                print_it(&output, flag, width, precision);
-                            }
+                        if let Err(code) = self.process_token_files(
+                            t,
+                            &meta,
+                            &display_name,
+                            &file,
+                            &file_type,
+                            self.from_user,
+                        ) {
+                            return code;
                         }
                     }
                 }
                 Err(e) => {
-                    show_error!("cannot stat {}: {}", display_name.quote(), e);
+                    show_error!("cannot stat {}: {e}", display_name.quote());
                     return 1;
                 }
             }
@@ -874,7 +1148,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -927,9 +1201,19 @@ pub fn uu_app() -> Command {
         )
 }
 
+const PRETTY_DATETIME_FORMAT: &str = "%Y-%m-%d %H:%M:%S.%f %z";
+
+fn pretty_time(sec: i64, nsec: i64) -> String {
+    // Return the date in UTC
+    let tm = DateTime::from_timestamp(sec, nsec as u32).unwrap_or_default();
+    let tm: DateTime<Local> = tm.into();
+
+    tm.format(PRETTY_DATETIME_FORMAT).to_string()
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{group_num, Flags, ScanUtil, Stater, Token};
+    use super::{Flags, Precision, ScanUtil, Stater, Token, group_num, precision_trunc};
 
     #[test]
     fn test_scanners() {
@@ -945,6 +1229,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)]
     fn test_group_num() {
         assert_eq!("12,379,821,234", group_num("12379821234"));
         assert_eq!("21,234", group_num("21234"));
@@ -976,7 +1261,7 @@ mod tests {
                     ..Default::default()
                 },
                 width: 10,
-                precision: Some(2),
+                precision: Precision::Number(2),
                 format: 'a',
             },
             Token::Char('c'),
@@ -987,7 +1272,7 @@ mod tests {
                     ..Default::default()
                 },
                 width: 5,
-                precision: Some(0),
+                precision: Precision::NoNumber,
                 format: 'w',
             },
             Token::Char('\n'),
@@ -997,7 +1282,7 @@ mod tests {
 
     #[test]
     fn printf_format() {
-        let s = r#"%-# 15a\t\r\"\\\a\b\e\f\v%+020.-23w\x12\167\132\112\n"#;
+        let s = r#"%-# 15a\t\r\"\\\a\b\x1B\f\x0B%+020.-23w\x12\167\132\112\n"#;
         let expected = vec![
             Token::Directive {
                 flag: Flags {
@@ -1007,18 +1292,18 @@ mod tests {
                     ..Default::default()
                 },
                 width: 15,
-                precision: None,
+                precision: Precision::NotSpecified,
                 format: 'a',
             },
-            Token::Char('\t'),
-            Token::Char('\r'),
-            Token::Char('"'),
-            Token::Char('\\'),
-            Token::Char('\x07'),
-            Token::Char('\x08'),
-            Token::Char('\x1B'),
-            Token::Char('\x0C'),
-            Token::Char('\x0B'),
+            Token::Byte(b'\t'),
+            Token::Byte(b'\r'),
+            Token::Byte(b'"'),
+            Token::Byte(b'\\'),
+            Token::Byte(b'\x07'),
+            Token::Byte(b'\x08'),
+            Token::Byte(b'\x1B'),
+            Token::Byte(b'\x0C'),
+            Token::Byte(b'\x0B'),
             Token::Directive {
                 flag: Flags {
                     sign: true,
@@ -1026,15 +1311,27 @@ mod tests {
                     ..Default::default()
                 },
                 width: 20,
-                precision: None,
+                precision: Precision::NotSpecified,
                 format: 'w',
             },
-            Token::Char('\x12'),
-            Token::Char('w'),
-            Token::Char('Z'),
-            Token::Char('J'),
-            Token::Char('\n'),
+            Token::Byte(b'\x12'),
+            Token::Byte(b'w'),
+            Token::Byte(b'Z'),
+            Token::Byte(b'J'),
+            Token::Byte(b'\n'),
         ];
         assert_eq!(&expected, &Stater::generate_tokens(s, true).unwrap());
     }
+
+    #[test]
+    fn test_precision_trunc() {
+        assert_eq!(precision_trunc(123.456, Precision::NotSpecified), "123");
+        assert_eq!(precision_trunc(123.456, Precision::NoNumber), "123.456");
+        assert_eq!(precision_trunc(123.456, Precision::Number(0)), "123");
+        assert_eq!(precision_trunc(123.456, Precision::Number(1)), "123.4");
+        assert_eq!(precision_trunc(123.456, Precision::Number(2)), "123.45");
+        assert_eq!(precision_trunc(123.456, Precision::Number(3)), "123.456");
+        assert_eq!(precision_trunc(123.456, Precision::Number(4)), "123.4560");
+        assert_eq!(precision_trunc(123.456, Precision::Number(5)), "123.45600");
+    }
 }
diff --git a/src/uu/stdbuf/Cargo.toml b/src/uu/stdbuf/Cargo.toml
index f6101490715..5f9e8ffd772 100644
--- a/src/uu/stdbuf/Cargo.toml
+++ b/src/uu/stdbuf/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_stdbuf"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "stdbuf ~ (uutils) run COMMAND with modified standard stream buffering"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stdbuf"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/stdbuf.rs"
@@ -17,10 +20,10 @@ path = "src/stdbuf.rs"
 [dependencies]
 clap = { workspace = true }
 tempfile = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 
 [build-dependencies]
-libstdbuf = { version = "0.0.21", package = "uu_stdbuf_libstdbuf", path = "src/libstdbuf" }
+libstdbuf = { version = "0.1.0", 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 7483aeacfef..b31a32235a8 100644
--- a/src/uu/stdbuf/build.rs
+++ b/src/uu/stdbuf/build.rs
@@ -5,6 +5,7 @@
 // spell-checker:ignore (ToDO) dylib libstdbuf deps liblibstdbuf
 
 use std::env;
+use std::env::current_exe;
 use std::fs;
 use std::path::Path;
 
@@ -24,53 +25,25 @@ mod platform {
 }
 
 fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let mut target_dir = Path::new(&out_dir);
+    let current_exe = current_exe().unwrap();
 
-    // 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 out_dir_string = env::var("OUT_DIR").unwrap();
+    let out_dir = Path::new(&out_dir_string);
 
-    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(profile_name);
-    dir.push("deps");
-    let mut path = None;
+    let deps_dir = current_exe.ancestors().nth(3).unwrap().join("deps");
+    dbg!(&deps_dir);
 
-    // When running cargo publish, cargo appends hashes to the filenames of the compiled artifacts.
-    // Therefore, it won't work to just get liblibstdbuf.so. Instead, we look for files with the
-    // glob pattern "liblibstdbuf*.so" (i.e. starts with liblibstdbuf and ends with the extension).
-    for entry in fs::read_dir(dir).unwrap().flatten() {
-        let name = entry.file_name();
-        let name = name.to_string_lossy();
-        if name.starts_with("liblibstdbuf") && name.ends_with(platform::DYLIB_EXT) {
-            path = Some(entry.path());
-        }
-    }
-    fs::copy(
-        path.expect("liblibstdbuf was not found"),
-        Path::new(&out_dir).join("libstdbuf.so"),
-    )
-    .unwrap();
+    let libstdbuf = deps_dir
+        .read_dir()
+        .unwrap()
+        .flatten()
+        .find(|entry| {
+            let n = entry.file_name();
+            let name = n.to_string_lossy();
+
+            name.starts_with("liblibstdbuf") && name.ends_with(platform::DYLIB_EXT)
+        })
+        .expect("unable to find libstdbuf");
+
+    fs::copy(libstdbuf.path(), out_dir.join("libstdbuf.so")).unwrap();
 }
diff --git a/src/uu/stdbuf/src/libstdbuf/Cargo.toml b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
index 8061c61a642..3f8511ffaef 100644
--- a/src/uu/stdbuf/src/libstdbuf/Cargo.toml
+++ b/src/uu/stdbuf/src/libstdbuf/Cargo.toml
@@ -1,15 +1,14 @@
 [package]
 name = "uu_stdbuf_libstdbuf"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "stdbuf/libstdbuf ~ (uutils); dynamic library required for stdbuf"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stdbuf"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
 
 [lib]
 name = "libstdbuf"
@@ -20,9 +19,8 @@ crate-type = [
 ] # XXX: note: the rlib is just to prevent Cargo from spitting out a warning
 
 [dependencies]
-cpp = "0.5"
+cpp = "0.5.10"
 libc = { workspace = true }
-uucore = { version = ">=0.0.19", package = "uucore", path = "../../../../uucore" }
 
 [build-dependencies]
-cpp_build = "0.5"
+cpp_build = "0.5.10"
diff --git a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
index a29d01b78f3..b151ce68632 100644
--- a/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
+++ b/src/uu/stdbuf/src/libstdbuf/src/libstdbuf.rs
@@ -5,10 +5,9 @@
 // spell-checker:ignore (ToDO) IOFBF IOLBF IONBF cstdio setvbuf
 
 use cpp::cpp;
-use libc::{c_char, c_int, size_t, FILE, _IOFBF, _IOLBF, _IONBF};
+use libc::{_IOFBF, _IOLBF, _IONBF, FILE, c_char, c_int, fileno, size_t};
 use std::env;
 use std::ptr;
-use uucore::crash;
 
 cpp! {{
     #include <cstdio>
@@ -27,7 +26,7 @@ cpp! {{
     }
 }}
 
-extern "C" {
+unsafe extern "C" {
     fn __stdbuf_get_stdin() -> *mut FILE;
     fn __stdbuf_get_stdout() -> *mut FILE;
     fn __stdbuf_get_stderr() -> *mut FILE;
@@ -40,7 +39,10 @@ fn set_buffer(stream: *mut FILE, value: &str) {
         input => {
             let buff_size: usize = match input.parse() {
                 Ok(num) => num,
-                Err(e) => crash!(1, "incorrect size of buffer!: {}", e),
+                Err(_) => {
+                    eprintln!("failed to allocate a {value} byte stdio buffer");
+                    std::process::exit(1);
+                }
             };
             (_IOFBF, buff_size as size_t)
         }
@@ -52,21 +54,23 @@ fn set_buffer(stream: *mut FILE, value: &str) {
         res = libc::setvbuf(stream, buffer, mode, size);
     }
     if res != 0 {
-        crash!(res, "error while calling setvbuf!");
+        eprintln!("could not set buffering of {} to mode {mode}", unsafe {
+            fileno(stream)
+        },);
     }
 }
 
 /// # Safety
 /// ToDO ... (safety note)
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn __stdbuf() {
     if let Ok(val) = env::var("_STDBUF_E") {
-        set_buffer(__stdbuf_get_stderr(), &val);
+        set_buffer(unsafe { __stdbuf_get_stderr() }, &val);
     }
     if let Ok(val) = env::var("_STDBUF_I") {
-        set_buffer(__stdbuf_get_stdin(), &val);
+        set_buffer(unsafe { __stdbuf_get_stdin() }, &val);
     }
     if let Ok(val) = env::var("_STDBUF_O") {
-        set_buffer(__stdbuf_get_stdout(), &val);
+        set_buffer(unsafe { __stdbuf_get_stdout() }, &val);
     }
 }
diff --git a/src/uu/stdbuf/src/stdbuf.rs b/src/uu/stdbuf/src/stdbuf.rs
index 6e522aa3d7d..3b5c3fb9dbb 100644
--- a/src/uu/stdbuf/src/stdbuf.rs
+++ b/src/uu/stdbuf/src/stdbuf.rs
@@ -3,19 +3,19 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) tempdir dyld dylib dragonflybsd optgrps libstdbuf
+// spell-checker:ignore (ToDO) tempdir dyld dylib optgrps libstdbuf
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command};
 use std::fs::File;
-use std::io::{self, Write};
+use std::io::Write;
 use std::os::unix::process::ExitStatusExt;
 use std::path::PathBuf;
 use std::process;
-use tempfile::tempdir;
 use tempfile::TempDir;
-use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::parse_size::parse_size;
-use uucore::{crash, format_usage, help_about, help_section, help_usage};
+use tempfile::tempdir;
+use uucore::error::{FromIo, UClapError, UResult, USimpleError, UUsageError};
+use uucore::parser::parse_size::parse_size_u64;
+use uucore::{format_usage, help_about, help_section, help_usage};
 
 const ABOUT: &str = help_about!("stdbuf.md");
 const USAGE: &str = help_usage!("stdbuf.md");
@@ -64,15 +64,15 @@ struct ProgramOptionsError(String);
     target_os = "android",
     target_os = "freebsd",
     target_os = "netbsd",
-    target_os = "dragonflybsd"
+    target_os = "dragonfly"
 ))]
-fn preload_strings() -> (&'static str, &'static str) {
-    ("LD_PRELOAD", "so")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+    Ok(("LD_PRELOAD", "so"))
 }
 
 #[cfg(target_vendor = "apple")]
-fn preload_strings() -> (&'static str, &'static str) {
-    ("DYLD_LIBRARY_PATH", "dylib")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+    Ok(("DYLD_LIBRARY_PATH", "dylib"))
 }
 
 #[cfg(not(any(
@@ -80,13 +80,14 @@ fn preload_strings() -> (&'static str, &'static str) {
     target_os = "android",
     target_os = "freebsd",
     target_os = "netbsd",
-    target_os = "dragonflybsd",
+    target_os = "dragonfly",
     target_vendor = "apple"
 )))]
-fn preload_strings() -> (&'static str, &'static str) {
-    use uucore::crash;
-
-    crash!(1, "Command not supported for this operating system!")
+fn preload_strings() -> UResult<(&'static str, &'static str)> {
+    Err(USimpleError::new(
+        1,
+        "Command not supported for this operating system!",
+    ))
 }
 
 fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramOptionsError> {
@@ -101,8 +102,8 @@ fn check_option(matches: &ArgMatches, name: &str) -> Result<BufferType, ProgramO
                     Ok(BufferType::Line)
                 }
             }
-            x => parse_size(x).map_or_else(
-                |e| crash!(125, "invalid mode {}", e),
+            x => parse_size_u64(x).map_or_else(
+                |e| Err(ProgramOptionsError(format!("invalid mode {e}"))),
                 |m| {
                     Ok(BufferType::Size(m.try_into().map_err(|_| {
                         ProgramOptionsError(format!(
@@ -128,8 +129,8 @@ fn set_command_env(command: &mut process::Command, buffer_name: &str, buffer_typ
     }
 }
 
-fn get_preload_env(tmp_dir: &TempDir) -> io::Result<(String, PathBuf)> {
-    let (preload, extension) = preload_strings();
+fn get_preload_env(tmp_dir: &TempDir) -> UResult<(String, PathBuf)> {
+    let (preload, extension) = preload_strings()?;
     let inject_path = tmp_dir.path().join("libstdbuf").with_extension(extension);
 
     let mut file = File::create(&inject_path)?;
@@ -140,9 +141,7 @@ fn get_preload_env(tmp_dir: &TempDir) -> io::Result<(String, PathBuf)> {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app().try_get_matches_from(args)?;
+    let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     let options = ProgramOptions::try_from(&matches).map_err(|e| UUsageError::new(125, e.0))?;
 
@@ -151,16 +150,31 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let command_params: Vec<&str> = command_values.map(|s| s.as_ref()).collect();
 
     let tmp_dir = tempdir().unwrap();
-    let (preload_env, libstdbuf) = get_preload_env(&tmp_dir).map_err_context(String::new)?;
+    let (preload_env, libstdbuf) = get_preload_env(&tmp_dir)?;
     command.env(preload_env, libstdbuf);
     set_command_env(&mut command, "_STDBUF_I", &options.stdin);
     set_command_env(&mut command, "_STDBUF_O", &options.stdout);
     set_command_env(&mut command, "_STDBUF_E", &options.stderr);
     command.args(command_params);
 
-    let mut process = command
-        .spawn()
-        .map_err_context(|| "failed to execute process".to_string())?;
+    const EXEC_ERROR: &str = "failed to execute process:";
+    let mut process = match command.spawn() {
+        Ok(p) => p,
+        Err(e) => {
+            return match e.kind() {
+                std::io::ErrorKind::PermissionDenied => Err(USimpleError::new(
+                    126,
+                    format!("{EXEC_ERROR} Permission denied"),
+                )),
+                std::io::ErrorKind::NotFound => Err(USimpleError::new(
+                    127,
+                    format!("{EXEC_ERROR} No such file or directory"),
+                )),
+                _ => Err(USimpleError::new(1, format!("{EXEC_ERROR} {e}"))),
+            };
+        }
+    };
+
     let status = process.wait().map_err_context(String::new)?;
     match status.code() {
         Some(i) => {
@@ -179,7 +193,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .after_help(LONG_HELP)
         .override_usage(format_usage(USAGE))
diff --git a/src/uu/stty/Cargo.toml b/src/uu/stty/Cargo.toml
index eb86ae68102..380f0bcfeec 100644
--- a/src/uu/stty/Cargo.toml
+++ b/src/uu/stty/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_stty"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "stty ~ (uutils) print or change terminal characteristics"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/stty"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/stty.rs"
diff --git a/src/uu/stty/src/flags.rs b/src/uu/stty/src/flags.rs
index 2c8e154e8b1..79c85ceb257 100644
--- a/src/uu/stty/src/flags.rs
+++ b/src/uu/stty/src/flags.rs
@@ -5,7 +5,7 @@
 
 // spell-checker:ignore parenb parodd cmspar hupcl cstopb cread clocal crtscts CSIZE
 // spell-checker:ignore ignbrk brkint ignpar parmrk inpck istrip inlcr igncr icrnl ixoff ixon iuclc ixany imaxbel iutf
-// spell-checker:ignore opost olcuc ocrnl onlcr onocr onlret ofill ofdel nldly crdly tabdly bsdly vtdly ffdly
+// spell-checker:ignore opost olcuc ocrnl onlcr onocr onlret ofdel nldly crdly tabdly bsdly vtdly ffdly
 // spell-checker:ignore isig icanon iexten echoe crterase echok echonl noflsh xcase tostop echoprt prterase echoctl ctlecho echoke crtkill flusho extproc
 // spell-checker:ignore lnext rprnt susp swtch vdiscard veof veol verase vintr vkill vlnext vquit vreprint vstart vstop vsusp vswtc vwerase werase
 // spell-checker:ignore sigquit sigtstp
@@ -86,14 +86,6 @@ pub const OUTPUT_FLAGS: &[Flag<O>] = &[
         target_os = "linux",
         target_os = "macos"
     ))]
-    Flag::new("ofill", O::OFILL),
-    #[cfg(any(
-        target_os = "android",
-        target_os = "haiku",
-        target_os = "ios",
-        target_os = "linux",
-        target_os = "macos"
-    ))]
     Flag::new("ofdel", O::OFDEL),
     #[cfg(any(
         target_os = "android",
@@ -287,7 +279,7 @@ pub const BAUD_RATES: &[(&str, BaudRate)] = &[
     ("500000", BaudRate::B500000),
     #[cfg(any(target_os = "android", target_os = "linux"))]
     ("576000", BaudRate::B576000),
-    #[cfg(any(target_os = "android", target_os = "linux",))]
+    #[cfg(any(target_os = "android", target_os = "linux"))]
     ("921600", BaudRate::B921600),
     #[cfg(any(target_os = "android", target_os = "linux"))]
     ("1000000", BaudRate::B1000000),
diff --git a/src/uu/stty/src/stty.rs b/src/uu/stty/src/stty.rs
index d55870730aa..5cc24a5968e 100644
--- a/src/uu/stty/src/stty.rs
+++ b/src/uu/stty/src/stty.rs
@@ -7,17 +7,19 @@
 
 mod flags;
 
-use clap::{crate_version, Arg, ArgAction, ArgMatches, Command};
-use nix::libc::{c_ushort, O_NONBLOCK, TIOCGWINSZ, TIOCSWINSZ};
+use clap::{Arg, ArgAction, ArgMatches, Command};
+use nix::libc::{O_NONBLOCK, TIOCGWINSZ, TIOCSWINSZ, c_ushort};
 use nix::sys::termios::{
-    cfgetospeed, cfsetospeed, tcgetattr, tcsetattr, ControlFlags, InputFlags, LocalFlags,
-    OutputFlags, SpecialCharacterIndices, Termios,
+    ControlFlags, InputFlags, LocalFlags, OutputFlags, SpecialCharacterIndices, Termios,
+    cfgetospeed, cfsetospeed, tcgetattr, tcsetattr,
 };
 use nix::{ioctl_read_bad, ioctl_write_ptr_bad};
-use std::io::{self, stdout};
+use std::fs::File;
+use std::io::{self, Stdout, stdout};
 use std::ops::ControlFlow;
+use std::os::fd::{AsFd, BorrowedFd};
 use std::os::unix::fs::OpenOptionsExt;
-use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
+use std::os::unix::io::{AsRawFd, RawFd};
 use uucore::error::{UResult, USimpleError};
 use uucore::{format_usage, help_about, help_usage};
 
@@ -38,6 +40,7 @@ const SUMMARY: &str = help_about!("stty.md");
 #[derive(Clone, Copy, Debug)]
 pub struct Flag<T> {
     name: &'static str,
+    #[expect(clippy::struct_field_names)]
     flag: T,
     show: bool,
     sane: bool,
@@ -91,10 +94,33 @@ mod options {
 struct Options<'a> {
     all: bool,
     save: bool,
-    file: RawFd,
+    file: Device,
     settings: Option<Vec<&'a str>>,
 }
 
+enum Device {
+    File(File),
+    Stdout(Stdout),
+}
+
+impl AsFd for Device {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        match self {
+            Self::File(f) => f.as_fd(),
+            Self::Stdout(stdout) => stdout.as_fd(),
+        }
+    }
+}
+
+impl AsRawFd for Device {
+    fn as_raw_fd(&self) -> RawFd {
+        match self {
+            Self::File(f) => f.as_raw_fd(),
+            Self::Stdout(stdout) => stdout.as_raw_fd(),
+        }
+    }
+}
+
 impl<'a> Options<'a> {
     fn from(matches: &'a ArgMatches) -> io::Result<Self> {
         Ok(Self {
@@ -110,12 +136,13 @@ impl<'a> Options<'a> {
                 //    will clean up the FD for us on exit, so it doesn't
                 //    matter. The alternative would be to have an enum of
                 //    BorrowedFd/OwnedFd to handle both cases.
-                Some(f) => std::fs::OpenOptions::new()
-                    .read(true)
-                    .custom_flags(O_NONBLOCK)
-                    .open(f)?
-                    .into_raw_fd(),
-                None => stdout().as_raw_fd(),
+                Some(f) => Device::File(
+                    std::fs::OpenOptions::new()
+                        .read(true)
+                        .custom_flags(O_NONBLOCK)
+                        .open(f)?,
+                ),
+                None => Device::Stdout(stdout()),
             },
             settings: matches
                 .get_many::<String>(options::SETTINGS)
@@ -150,8 +177,6 @@ ioctl_write_ptr_bad!(
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let opts = Options::from(&matches)?;
@@ -175,7 +200,7 @@ fn stty(opts: &Options) -> UResult<()> {
     }
 
     // TODO: Figure out the right error message for when tcgetattr fails
-    let mut termios = tcgetattr(opts.file).expect("Could not get terminal attributes");
+    let mut termios = tcgetattr(opts.file.as_fd()).expect("Could not get terminal attributes");
 
     if let Some(settings) = &opts.settings {
         for setting in settings {
@@ -187,8 +212,12 @@ fn stty(opts: &Options) -> UResult<()> {
             }
         }
 
-        tcsetattr(opts.file, nix::sys::termios::SetArg::TCSANOW, &termios)
-            .expect("Could not write terminal attributes");
+        tcsetattr(
+            opts.file.as_fd(),
+            nix::sys::termios::SetArg::TCSANOW,
+            &termios,
+        )
+        .expect("Could not write terminal attributes");
     } else {
         print_settings(&termios, opts).expect("TODO: make proper error here from nix error");
     }
@@ -228,7 +257,7 @@ fn print_terminal_size(termios: &Termios, opts: &Options) -> nix::Result<()> {
 
     if opts.all {
         let mut size = TermSize::default();
-        unsafe { tiocgwinsz(opts.file, &mut size as *mut _)? };
+        unsafe { tiocgwinsz(opts.file.as_raw_fd(), &raw mut size)? };
         print!("rows {}; columns {}; ", size.rows, size.columns);
     }
 
@@ -435,7 +464,7 @@ fn apply_baud_rate_flag(termios: &mut Termios, input: &str) -> ControlFlow<bool>
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(SUMMARY)
         .infer_long_args(true)
@@ -471,7 +500,7 @@ pub fn uu_app() -> Command {
 impl TermiosFlag for ControlFlags {
     fn is_in(&self, termios: &Termios, group: Option<Self>) -> bool {
         termios.control_flags.contains(*self)
-            && group.map_or(true, |g| !termios.control_flags.intersects(g - *self))
+            && group.is_none_or(|g| !termios.control_flags.intersects(g - *self))
     }
 
     fn apply(&self, termios: &mut Termios, val: bool) {
@@ -482,7 +511,7 @@ impl TermiosFlag for ControlFlags {
 impl TermiosFlag for InputFlags {
     fn is_in(&self, termios: &Termios, group: Option<Self>) -> bool {
         termios.input_flags.contains(*self)
-            && group.map_or(true, |g| !termios.input_flags.intersects(g - *self))
+            && group.is_none_or(|g| !termios.input_flags.intersects(g - *self))
     }
 
     fn apply(&self, termios: &mut Termios, val: bool) {
@@ -493,7 +522,7 @@ impl TermiosFlag for InputFlags {
 impl TermiosFlag for OutputFlags {
     fn is_in(&self, termios: &Termios, group: Option<Self>) -> bool {
         termios.output_flags.contains(*self)
-            && group.map_or(true, |g| !termios.output_flags.intersects(g - *self))
+            && group.is_none_or(|g| !termios.output_flags.intersects(g - *self))
     }
 
     fn apply(&self, termios: &mut Termios, val: bool) {
@@ -504,7 +533,7 @@ impl TermiosFlag for OutputFlags {
 impl TermiosFlag for LocalFlags {
     fn is_in(&self, termios: &Termios, group: Option<Self>) -> bool {
         termios.local_flags.contains(*self)
-            && group.map_or(true, |g| !termios.local_flags.intersects(g - *self))
+            && group.is_none_or(|g| !termios.local_flags.intersects(g - *self))
     }
 
     fn apply(&self, termios: &mut Termios, val: bool) {
diff --git a/src/uu/sum/Cargo.toml b/src/uu/sum/Cargo.toml
index aa722c69433..9fdb07d84d9 100644
--- a/src/uu/sum/Cargo.toml
+++ b/src/uu/sum/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_sum"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "sum ~ (uutils) display checksum and block counts for input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sum"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/sum.rs"
diff --git a/src/uu/sum/src/sum.rs b/src/uu/sum/src/sum.rs
index 4616274d024..1aec0ef98c3 100644
--- a/src/uu/sum/src/sum.rs
+++ b/src/uu/sum/src/sum.rs
@@ -5,9 +5,9 @@
 
 // spell-checker:ignore (ToDO) sysv
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::fs::File;
-use std::io::{stdin, Read};
+use std::io::{ErrorKind, Read, Write, stdin, stdout};
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError};
@@ -16,49 +16,46 @@ use uucore::{format_usage, help_about, help_usage, show};
 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,
-// particularly a power of two.
-const fn div_ceil(a: usize, b: usize) -> usize {
-    (a + b - 1) / b
-}
-
-fn bsd_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
+fn bsd_sum(mut reader: impl Read) -> std::io::Result<(usize, u16)> {
     let mut buf = [0; 4096];
     let mut bytes_read = 0;
     let mut checksum: u16 = 0;
     loop {
         match reader.read(&mut buf) {
-            Ok(n) if n != 0 => {
+            Ok(0) => break,
+            Ok(n) => {
                 bytes_read += n;
-                for &byte in &buf[..n] {
-                    checksum = checksum.rotate_right(1);
-                    checksum = checksum.wrapping_add(u16::from(byte));
-                }
+                checksum = buf[..n].iter().fold(checksum, |acc, &byte| {
+                    let rotated = acc.rotate_right(1);
+                    rotated.wrapping_add(u16::from(byte))
+                });
             }
-            _ => break,
+            Err(e) if e.kind() == ErrorKind::Interrupted => continue,
+            Err(e) => return Err(e),
         }
     }
 
     // Report blocks read in terms of 1024-byte blocks.
-    let blocks_read = div_ceil(bytes_read, 1024);
-    (blocks_read, checksum)
+    let blocks_read = bytes_read.div_ceil(1024);
+    Ok((blocks_read, checksum))
 }
 
-fn sysv_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
+fn sysv_sum(mut reader: impl Read) -> std::io::Result<(usize, u16)> {
     let mut buf = [0; 4096];
     let mut bytes_read = 0;
     let mut ret = 0u32;
 
     loop {
         match reader.read(&mut buf) {
-            Ok(n) if n != 0 => {
+            Ok(0) => break,
+            Ok(n) => {
                 bytes_read += n;
-                for &byte in &buf[..n] {
-                    ret = ret.wrapping_add(u32::from(byte));
-                }
+                ret = buf[..n]
+                    .iter()
+                    .fold(ret, |acc, &byte| acc.wrapping_add(u32::from(byte)));
             }
-            _ => break,
+            Err(e) if e.kind() == ErrorKind::Interrupted => continue,
+            Err(e) => return Err(e),
         }
     }
 
@@ -66,8 +63,8 @@ fn sysv_sum(mut reader: Box<dyn Read>) -> (usize, u16) {
     ret = (ret & 0xffff) + (ret >> 16);
 
     // Report blocks read in terms of 512-byte blocks.
-    let blocks_read = div_ceil(bytes_read, 512);
-    (blocks_read, ret as u16)
+    let blocks_read = bytes_read.div_ceil(512);
+    Ok((blocks_read, ret as u16))
 }
 
 fn open(name: &str) -> UResult<Box<dyn Read>> {
@@ -102,12 +99,10 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let files: Vec<String> = match matches.get_many::<String>(options::FILE) {
-        Some(v) => v.clone().map(|v| v.to_owned()).collect(),
+        Some(v) => v.cloned().collect(),
         None => vec!["-".to_owned()],
     };
 
@@ -128,12 +123,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             sysv_sum(reader)
         } else {
             bsd_sum(reader)
-        };
+        }?;
 
+        let mut stdout = stdout().lock();
         if print_names {
-            println!("{sum:0width$} {blocks:width$} {file}");
+            writeln!(stdout, "{sum:0width$} {blocks:width$} {file}")?;
         } else {
-            println!("{sum:0width$} {blocks:width$}");
+            writeln!(stdout, "{sum:0width$} {blocks:width$}")?;
         }
     }
     Ok(())
@@ -141,7 +137,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
diff --git a/src/uu/sum/sum.md b/src/uu/sum/sum.md
index ca3adb81f36..93dbdbf62d0 100644
--- a/src/uu/sum/sum.md
+++ b/src/uu/sum/sum.md
@@ -1,7 +1,7 @@
 # sum
 
 ```
-sum [OPTION]... [FILE]..."
+sum [OPTION]... [FILE]...
 ```
 
 Checksum and count the blocks in a file.
diff --git a/src/uu/sync/Cargo.toml b/src/uu/sync/Cargo.toml
index b74e076e509..dc6d874348e 100644
--- a/src/uu/sync/Cargo.toml
+++ b/src/uu/sync/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_sync"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "sync ~ (uutils) synchronize cache writes to storage"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/sync"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/sync.rs"
@@ -19,7 +22,7 @@ clap = { workspace = true }
 libc = { workspace = true }
 uucore = { workspace = true, features = ["wide"] }
 
-[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
+[target.'cfg(unix)'.dependencies]
 nix = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
diff --git a/src/uu/sync/src/sync.rs b/src/uu/sync/src/sync.rs
index c0b8f3d00b5..b0221d3d764 100644
--- a/src/uu/sync/src/sync.rs
+++ b/src/uu/sync/src/sync.rs
@@ -5,11 +5,11 @@
 
 /* Last synced with: sync (GNU coreutils) 8.13 */
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use nix::errno::Errno;
 #[cfg(any(target_os = "linux", target_os = "android"))]
-use nix::fcntl::{open, OFlag};
+use nix::fcntl::{OFlag, open};
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use nix::sys::stat::Mode;
 use std::path::Path;
@@ -31,38 +31,34 @@ static ARG_FILES: &str = "files";
 
 #[cfg(unix)]
 mod platform {
+    use nix::unistd::sync;
     #[cfg(any(target_os = "linux", target_os = "android"))]
-    use std::fs::File;
+    use nix::unistd::{fdatasync, syncfs};
     #[cfg(any(target_os = "linux", target_os = "android"))]
-    use std::os::unix::io::AsRawFd;
-
-    pub unsafe fn do_sync() -> isize {
-        // see https://github.com/rust-lang/libc/pull/2161
-        #[cfg(target_os = "android")]
-        libc::syscall(libc::SYS_sync);
-        #[cfg(not(target_os = "android"))]
-        libc::sync();
-        0
+    use std::fs::File;
+    use uucore::error::UResult;
+
+    pub fn do_sync() -> UResult<()> {
+        sync();
+        Ok(())
     }
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
-    pub unsafe fn do_syncfs(files: Vec<String>) -> isize {
+    pub fn do_syncfs(files: Vec<String>) -> UResult<()> {
         for path in files {
             let f = File::open(path).unwrap();
-            let fd = f.as_raw_fd();
-            libc::syscall(libc::SYS_syncfs, fd);
+            syncfs(f)?;
         }
-        0
+        Ok(())
     }
 
     #[cfg(any(target_os = "linux", target_os = "android"))]
-    pub unsafe fn do_fdatasync(files: Vec<String>) -> isize {
+    pub fn do_fdatasync(files: Vec<String>) -> UResult<()> {
         for path in files {
             let f = File::open(path).unwrap();
-            let fd = f.as_raw_fd();
-            libc::syscall(libc::SYS_fdatasync, fd);
+            fdatasync(f)?;
         }
-        0
+        Ok(())
     }
 }
 
@@ -71,71 +67,94 @@ mod platform {
     use std::fs::OpenOptions;
     use std::os::windows::prelude::*;
     use std::path::Path;
-    use uucore::crash;
+    use uucore::error::{UResult, USimpleError};
     use uucore::wide::{FromWide, ToWide};
     use windows_sys::Win32::Foundation::{
-        GetLastError, ERROR_NO_MORE_FILES, HANDLE, INVALID_HANDLE_VALUE, MAX_PATH,
+        ERROR_NO_MORE_FILES, GetLastError, HANDLE, INVALID_HANDLE_VALUE, MAX_PATH,
     };
     use windows_sys::Win32::Storage::FileSystem::{
         FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, FlushFileBuffers, GetDriveTypeW,
     };
     use windows_sys::Win32::System::WindowsProgramming::DRIVE_FIXED;
 
-    unsafe fn flush_volume(name: &str) {
+    fn get_last_error() -> u32 {
+        // SAFETY: `GetLastError` has no safety preconditions
+        unsafe { GetLastError() as u32 }
+    }
+
+    fn flush_volume(name: &str) -> UResult<()> {
         let name_wide = name.to_wide_null();
-        if GetDriveTypeW(name_wide.as_ptr()) == DRIVE_FIXED {
+        // SAFETY: `name` is a valid `str`, so `name_wide` is valid null-terminated UTF-16
+        if unsafe { GetDriveTypeW(name_wide.as_ptr()) } == DRIVE_FIXED {
             let sliced_name = &name[..name.len() - 1]; // eliminate trailing backslash
             match OpenOptions::new().write(true).open(sliced_name) {
                 Ok(file) => {
-                    if FlushFileBuffers(file.as_raw_handle() as HANDLE) == 0 {
-                        crash!(GetLastError() as i32, "failed to flush file buffer");
+                    // SAFETY: `file` is a valid `File`
+                    if unsafe { FlushFileBuffers(file.as_raw_handle() as HANDLE) } == 0 {
+                        Err(USimpleError::new(
+                            get_last_error() as i32,
+                            "failed to flush file buffer",
+                        ))
+                    } else {
+                        Ok(())
                     }
                 }
-                Err(e) => crash!(
+                Err(e) => Err(USimpleError::new(
                     e.raw_os_error().unwrap_or(1),
-                    "failed to create volume handle"
-                ),
+                    "failed to create volume handle",
+                )),
             }
+        } else {
+            Ok(())
         }
     }
 
-    unsafe fn find_first_volume() -> (String, HANDLE) {
+    fn find_first_volume() -> UResult<(String, HANDLE)> {
         let mut name: [u16; MAX_PATH as usize] = [0; MAX_PATH as usize];
-        let handle = FindFirstVolumeW(name.as_mut_ptr(), name.len() as u32);
+        // SAFETY: `name` was just constructed and in scope, `len()` is its length by definition
+        let handle = unsafe { FindFirstVolumeW(name.as_mut_ptr(), name.len() as u32) };
         if handle == INVALID_HANDLE_VALUE {
-            crash!(GetLastError() as i32, "failed to find first volume");
+            return Err(USimpleError::new(
+                get_last_error() as i32,
+                "failed to find first volume",
+            ));
         }
-        (String::from_wide_null(&name), handle)
+        Ok((String::from_wide_null(&name), handle))
     }
 
-    unsafe fn find_all_volumes() -> Vec<String> {
-        let (first_volume, next_volume_handle) = find_first_volume();
+    fn find_all_volumes() -> UResult<Vec<String>> {
+        let (first_volume, next_volume_handle) = find_first_volume()?;
         let mut volumes = vec![first_volume];
         loop {
             let mut name: [u16; MAX_PATH as usize] = [0; MAX_PATH as usize];
-            if FindNextVolumeW(next_volume_handle, name.as_mut_ptr(), name.len() as u32) == 0 {
-                match GetLastError() {
+            // SAFETY: `next_volume_handle` was returned by `find_first_volume`,
+            // `name` was just constructed and in scope, `len()` is its length by definition
+            if unsafe { FindNextVolumeW(next_volume_handle, name.as_mut_ptr(), name.len() as u32) }
+                == 0
+            {
+                return match get_last_error() {
                     ERROR_NO_MORE_FILES => {
-                        FindVolumeClose(next_volume_handle);
-                        return volumes;
+                        // SAFETY: `next_volume_handle` was returned by `find_first_volume`
+                        unsafe { FindVolumeClose(next_volume_handle) };
+                        Ok(volumes)
                     }
-                    err => crash!(err as i32, "failed to find next volume"),
-                }
+                    err => Err(USimpleError::new(err as i32, "failed to find next volume")),
+                };
             } else {
                 volumes.push(String::from_wide_null(&name));
             }
         }
     }
 
-    pub unsafe fn do_sync() -> isize {
-        let volumes = find_all_volumes();
+    pub fn do_sync() -> UResult<()> {
+        let volumes = find_all_volumes()?;
         for vol in &volumes {
-            flush_volume(vol);
+            flush_volume(vol)?;
         }
-        0
+        Ok(())
     }
 
-    pub unsafe fn do_syncfs(files: Vec<String>) -> isize {
+    pub fn do_syncfs(files: Vec<String>) -> UResult<()> {
         for path in files {
             flush_volume(
                 Path::new(&path)
@@ -145,9 +164,9 @@ mod platform {
                     .as_os_str()
                     .to_str()
                     .unwrap(),
-            );
+            )?;
         }
-        0
+        Ok(())
     }
 }
 
@@ -190,19 +209,19 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     #[allow(clippy::if_same_then_else)]
     if matches.get_flag(options::FILE_SYSTEM) {
         #[cfg(any(target_os = "linux", target_os = "android", target_os = "windows"))]
-        syncfs(files);
+        syncfs(files)?;
     } else if matches.get_flag(options::DATA) {
         #[cfg(any(target_os = "linux", target_os = "android"))]
-        fdatasync(files);
+        fdatasync(files)?;
     } else {
-        sync();
+        sync()?;
     }
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -229,16 +248,16 @@ pub fn uu_app() -> Command {
         )
 }
 
-fn sync() -> isize {
-    unsafe { platform::do_sync() }
+fn sync() -> UResult<()> {
+    platform::do_sync()
 }
 
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "windows"))]
-fn syncfs(files: Vec<String>) -> isize {
-    unsafe { platform::do_syncfs(files) }
+fn syncfs(files: Vec<String>) -> UResult<()> {
+    platform::do_syncfs(files)
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
-fn fdatasync(files: Vec<String>) -> isize {
-    unsafe { platform::do_fdatasync(files) }
+fn fdatasync(files: Vec<String>) -> UResult<()> {
+    platform::do_fdatasync(files)
 }
diff --git a/src/uu/tac/Cargo.toml b/src/uu/tac/Cargo.toml
index 385ef37c89b..eb004c96b74 100644
--- a/src/uu/tac/Cargo.toml
+++ b/src/uu/tac/Cargo.toml
@@ -2,16 +2,19 @@
 
 [package]
 name = "uu_tac"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "tac ~ (uutils) concatenate and display input lines in reverse order"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tac"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/tac.rs"
@@ -22,6 +25,7 @@ memmap2 = { workspace = true }
 regex = { workspace = true }
 clap = { workspace = true }
 uucore = { workspace = true }
+thiserror = { workspace = true }
 
 [[bin]]
 name = "tac"
diff --git a/src/uu/tac/src/error.rs b/src/uu/tac/src/error.rs
index 7a737ad9b97..fc01bbffd2c 100644
--- a/src/uu/tac/src/error.rs
+++ b/src/uu/tac/src/error.rs
@@ -3,33 +3,37 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 //! Errors returned by tac during processing of a file.
-use std::error::Error;
-use std::fmt::Display;
+use thiserror::Error;
 
 use uucore::display::Quotable;
 use uucore::error::UError;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum TacError {
     /// A regular expression given by the user is invalid.
+    #[error("invalid regular expression: {0}")]
     InvalidRegex(regex::Error),
 
     /// An argument to tac is invalid.
+    #[error("{}: read error: Invalid argument", _0.maybe_quote())]
     InvalidArgument(String),
 
     /// The specified file is not found on the filesystem.
+    #[error("failed to open {} for reading: No such file or directory", _0.quote())]
     FileNotFound(String),
 
     /// An error reading the contents of a file or stdin.
     ///
     /// The parameters are the name of the file and the underlying
     /// [`std::io::Error`] that caused this error.
+    #[error("failed to read from {0}: {1}")]
     ReadError(String, std::io::Error),
 
     /// An error writing the (reversed) contents of a file or stdin.
     ///
     /// The parameter is the underlying [`std::io::Error`] that caused
     /// this error.
+    #[error("failed to write to stdout: {0}")]
     WriteError(std::io::Error),
 }
 
@@ -38,23 +42,3 @@ impl UError for TacError {
         1
     }
 }
-
-impl Error for TacError {}
-
-impl Display for TacError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::InvalidRegex(e) => write!(f, "invalid regular expression: {e}"),
-            Self::InvalidArgument(s) => {
-                write!(f, "{}: read error: Invalid argument", s.maybe_quote())
-            }
-            Self::FileNotFound(s) => write!(
-                f,
-                "failed to open {} for reading: No such file or directory",
-                s.quote()
-            ),
-            Self::ReadError(s, e) => write!(f, "failed to read from {s}: {e}"),
-            Self::WriteError(e) => write!(f, "failed to write to stdout: {e}"),
-        }
-    }
-}
diff --git a/src/uu/tac/src/tac.rs b/src/uu/tac/src/tac.rs
index b8cb61029da..4496c2ce120 100644
--- a/src/uu/tac/src/tac.rs
+++ b/src/uu/tac/src/tac.rs
@@ -6,12 +6,12 @@
 // spell-checker:ignore (ToDO) sbytes slen dlen memmem memmap Mmap mmap SIGBUS
 mod error;
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use memchr::memmem;
 use memmap2::Mmap;
-use std::io::{stdin, stdout, BufWriter, Read, Write};
+use std::io::{BufWriter, Read, Write, stdin, stdout};
 use std::{
-    fs::{read, File},
+    fs::{File, read},
     path::Path,
 };
 use uucore::display::Quotable;
@@ -33,8 +33,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let before = matches.get_flag(options::BEFORE);
@@ -59,7 +57,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
@@ -166,6 +164,7 @@ fn buffer_tac_regex(
     // After the loop terminates, write whatever bytes are remaining at
     // the beginning of the buffer.
     out.write_all(&data[0..following_line_start])?;
+    out.flush()?;
     Ok(())
 }
 
@@ -186,7 +185,7 @@ fn buffer_tac(data: &[u8], before: bool, separator: &str) -> std::io::Result<()>
     let mut out = BufWriter::new(out.lock());
 
     // The number of bytes in the line separator.
-    let slen = separator.as_bytes().len();
+    let slen = separator.len();
 
     // The index of the start of the next line in the `data`.
     //
@@ -217,6 +216,7 @@ fn buffer_tac(data: &[u8], before: bool, separator: &str) -> std::io::Result<()>
     // After the loop terminates, write whatever bytes are remaining at
     // the beginning of the buffer.
     out.write_all(&data[0..following_line_start])?;
+    out.flush()?;
     Ok(())
 }
 
diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml
index 792b7fcf178..264ae29aa87 100644
--- a/src/uu/tail/Cargo.toml
+++ b/src/uu/tail/Cargo.toml
@@ -1,16 +1,19 @@
-# spell-checker:ignore (libs) kqueue fundu
+# spell-checker:ignore (libs) kqueue
 [package]
 name = "uu_tail"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "tail ~ (uutils) display the last lines of input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tail"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/tail.rs"
@@ -20,10 +23,8 @@ clap = { workspace = true }
 libc = { workspace = true }
 memchr = { workspace = true }
 notify = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 same-file = { workspace = true }
-is-terminal = { workspace = true }
-fundu = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
 windows-sys = { workspace = true, features = [
diff --git a/src/uu/tail/README.md b/src/uu/tail/README.md
index ef7cfbd6c4d..16d37a7ea7e 100644
--- a/src/uu/tail/README.md
+++ b/src/uu/tail/README.md
@@ -36,7 +36,7 @@ flag name: `--use-polling`.
 * Improve resource management by adding more system calls to `inotify_rm_watch`
   when appropriate.
 
-# GNU test-suite results (9.1.8-e08752)
+## 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 <&-`
diff --git a/src/uu/tail/src/args.rs b/src/uu/tail/src/args.rs
index 795652f2650..61448388c29 100644
--- a/src/uu/tail/src/args.rs
+++ b/src/uu/tail/src/args.rs
@@ -3,19 +3,19 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) kqueue Signum fundu
+// spell-checker:ignore (ToDO) kqueue Signum
 
 use crate::paths::Input;
-use crate::{parse, platform, Quotable};
-use clap::{crate_version, value_parser};
-use clap::{Arg, ArgAction, ArgMatches, Command};
-use fundu::{DurationParser, SaturatingInto};
-use is_terminal::IsTerminal;
+use crate::{Quotable, parse, platform};
+use clap::{Arg, ArgAction, ArgMatches, Command, value_parser};
 use same_file::Handle;
 use std::ffi::OsString;
+use std::io::IsTerminal;
 use std::time::Duration;
 use uucore::error::{UResult, USimpleError, UUsageError};
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parser::parse_size::{ParseSizeError, parse_size_u64};
+use uucore::parser::parse_time;
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::{format_usage, help_about, help_usage, show_warning};
 
 const ABOUT: &str = help_about!("tail.md");
@@ -80,7 +80,7 @@ impl FilterMode {
                     return Err(USimpleError::new(
                         1,
                         format!("invalid number of bytes: '{e}'"),
-                    ))
+                    ));
                 }
             }
         } else if let Some(arg) = matches.get_one::<String>(options::LINES) {
@@ -93,7 +93,7 @@ impl FilterMode {
                     return Err(USimpleError::new(
                         1,
                         format!("invalid number of lines: {e}"),
-                    ))
+                    ));
                 }
             }
         } else if zero_term {
@@ -181,7 +181,7 @@ impl Settings {
         settings
     }
 
-    pub fn from(matches: &clap::ArgMatches) -> UResult<Self> {
+    pub fn from(matches: &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
@@ -228,22 +228,9 @@ impl Settings {
         };
 
         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.
-            // * no precision loss, rounding errors or other floating point problems.
-            // * evaluates to `Duration::MAX` if the parsed number would have exceeded
-            //   `DURATION::MAX` or `infinity` was given
-            // * not applied here but it supports customizable time units and provides better error
-            //   messages
-            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.sleep_sec = parse_time::from_str(source, false).map_err(|_| {
+                UUsageError::new(1, format!("invalid number of seconds: '{source}'"))
+            })?;
         }
 
         if let Some(s) = matches.get_one::<String>(options::MAX_UNCHANGED_STATS) {
@@ -279,7 +266,7 @@ impl Settings {
                 Err(e) => {
                     return Err(USimpleError::new(
                         1,
-                        format!("invalid PID: {}: {}", pid_str.quote(), e),
+                        format!("invalid PID: {}: {e}", pid_str.quote()),
                     ));
                 }
             }
@@ -290,8 +277,9 @@ impl Settings {
             .map(|v| v.map(Input::from).collect())
             .unwrap_or_else(|| vec![Input::default()]);
 
-        settings.verbose =
-            settings.inputs.len() > 1 && !matches.get_flag(options::verbosity::QUIET);
+        settings.verbose = (matches.get_flag(options::verbosity::VERBOSE)
+            || settings.inputs.len() > 1)
+            && !matches.get_flag(options::verbosity::QUIET);
 
         Ok(settings)
     }
@@ -335,11 +323,11 @@ impl Settings {
             let blocking_stdin = self.pid == 0
                 && self.follow == Some(FollowMode::Descriptor)
                 && self.num_inputs() == 1
-                && Handle::stdin().map_or(false, |handle| {
+                && Handle::stdin().is_ok_and(|handle| {
                     handle
                         .as_file()
                         .metadata()
-                        .map_or(false, |meta| !meta.is_file())
+                        .is_ok_and(|meta| !meta.is_file())
                 });
 
             if !blocking_stdin && std::io::stdin().is_terminal() {
@@ -414,7 +402,7 @@ fn parse_num(src: &str) -> Result<Signum, ParseSizeError> {
         }
     }
 
-    match parse_size(size_string) {
+    match parse_size_u64(size_string) {
         Ok(n) => match (n, starting_with) {
             (0, true) => Ok(Signum::PlusZero),
             (0, false) => Ok(Signum::MinusZero),
@@ -475,7 +463,7 @@ pub fn uu_app() -> Command {
     const POLLING_HELP: &str = "Disable 'ReadDirectoryChanges' support and use polling instead";
 
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -494,7 +482,7 @@ pub fn uu_app() -> Command {
                 .default_missing_value("descriptor")
                 .num_args(0..=1)
                 .require_equals(true)
-                .value_parser(["descriptor", "name"])
+                .value_parser(ShortcutValueParser::new(["descriptor", "name"]))
                 .overrides_with(options::FOLLOW)
                 .help("Print the file as it grows"),
         )
@@ -510,7 +498,8 @@ pub fn uu_app() -> Command {
             Arg::new(options::PID)
                 .long(options::PID)
                 .value_name("PID")
-                .help("With -f, terminate after process ID, PID dies"),
+                .help("With -f, terminate after process ID, PID dies")
+                .overrides_with(options::PID),
         )
         .arg(
             Arg::new(options::verbosity::QUIET)
diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs
index 6582bd25118..7d53b95d4d6 100644
--- a/src/uu/tail/src/chunks.rs
+++ b/src/uu/tail/src/chunks.rs
@@ -46,7 +46,7 @@ pub struct ReverseChunks<'a> {
 }
 
 impl<'a> ReverseChunks<'a> {
-    pub fn new(file: &'a mut File) -> ReverseChunks<'a> {
+    pub fn new(file: &'a mut File) -> Self {
         let current = if cfg!(unix) {
             file.stream_position().unwrap()
         } else {
@@ -64,7 +64,7 @@ impl<'a> ReverseChunks<'a> {
     }
 }
 
-impl<'a> Iterator for ReverseChunks<'a> {
+impl Iterator for ReverseChunks<'_> {
     type Item = Vec<u8>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -141,7 +141,7 @@ impl BytesChunk {
     ///
     /// * `chunk`: The chunk to create a new `BytesChunk` chunk from
     /// * `offset`: Start to copy the old chunk's buffer from this position. May not be larger
-    ///             than `chunk.bytes`.
+    ///   than `chunk.bytes`.
     ///
     /// # Examples
     ///
@@ -289,7 +289,7 @@ impl BytesChunkBuffer {
         let mut chunk = Box::new(BytesChunk::new());
 
         // fill chunks with all bytes from reader and reuse already instantiated chunks if possible
-        while (chunk.fill(reader)?).is_some() {
+        while chunk.fill(reader)?.is_some() {
             self.bytes += chunk.bytes as u64;
             self.chunks.push_back(chunk);
 
@@ -319,7 +319,7 @@ impl BytesChunkBuffer {
         Ok(())
     }
 
-    pub fn print(&self, mut writer: impl Write) -> UResult<()> {
+    pub fn print(&self, writer: &mut impl Write) -> UResult<()> {
         for chunk in &self.chunks {
             writer.write_all(chunk.get_buffer())?;
         }
@@ -477,7 +477,7 @@ impl LinesChunk {
     /// # Arguments
     ///
     /// * `offset`: the offset in number of lines. If offset is 0 then 0 is returned, if larger than
-    ///             the contained lines then self.bytes is returned.
+    ///   the contained lines then self.bytes is returned.
     ///
     /// # Examples
     ///
@@ -565,7 +565,7 @@ impl LinesChunkBuffer {
     pub fn fill(&mut self, reader: &mut impl BufRead) -> UResult<()> {
         let mut chunk = Box::new(LinesChunk::new(self.delimiter));
 
-        while (chunk.fill(reader)?).is_some() {
+        while chunk.fill(reader)?.is_some() {
             self.lines += chunk.lines as u64;
             self.chunks.push_back(chunk);
 
@@ -627,7 +627,7 @@ impl LinesChunkBuffer {
 
 #[cfg(test)]
 mod tests {
-    use crate::chunks::{BytesChunk, BUFFER_SIZE};
+    use crate::chunks::{BUFFER_SIZE, BytesChunk};
 
     #[test]
     fn test_bytes_chunk_from_when_offset_is_zero() {
diff --git a/src/uu/tail/src/follow/files.rs b/src/uu/tail/src/follow/files.rs
index e4f980267da..0fcf90e2ae3 100644
--- a/src/uu/tail/src/follow/files.rs
+++ b/src/uu/tail/src/follow/files.rs
@@ -9,10 +9,10 @@ use crate::args::Settings;
 use crate::chunks::BytesChunkBuffer;
 use crate::paths::{HeaderPrinter, PathExtTail};
 use crate::text;
-use std::collections::hash_map::Keys;
 use std::collections::HashMap;
+use std::collections::hash_map::Keys;
 use std::fs::{File, Metadata};
-use std::io::{stdout, BufRead, BufReader, BufWriter};
+use std::io::{BufRead, BufReader, BufWriter, Write, stdout};
 use std::path::{Path, PathBuf};
 use uucore::error::UResult;
 
@@ -40,7 +40,7 @@ impl FileHandling {
     pub fn insert(&mut self, k: &Path, v: PathData, update_last: bool) {
         let k = Self::canonicalize_path(k);
         if update_last {
-            self.last = Some(k.to_owned());
+            self.last = Some(k.clone());
         }
         let _ = self.map.insert(k, v);
     }
@@ -146,9 +146,9 @@ impl FileHandling {
                 self.header_printer.print(display_name.as_str());
             }
 
-            let stdout = stdout();
-            let writer = BufWriter::new(stdout.lock());
-            chunks.print(writer)?;
+            let mut writer = BufWriter::new(stdout().lock());
+            chunks.print(&mut writer)?;
+            writer.flush()?;
 
             self.last.replace(path.to_owned());
             self.update_metadata(path, None);
@@ -162,12 +162,13 @@ impl FileHandling {
     pub fn needs_header(&self, path: &Path, verbose: bool) -> bool {
         if verbose {
             if let Some(ref last) = self.last {
-                return !last.eq(&path);
+                !last.eq(&path)
             } else {
-                return true;
+                true
             }
+        } else {
+            false
         }
-        false
     }
 }
 
diff --git a/src/uu/tail/src/follow/mod.rs b/src/uu/tail/src/follow/mod.rs
index 52eef318f96..604602a4b01 100644
--- a/src/uu/tail/src/follow/mod.rs
+++ b/src/uu/tail/src/follow/mod.rs
@@ -6,4 +6,4 @@
 mod files;
 mod watch;
 
-pub use watch::{follow, Observer};
+pub use watch::{Observer, follow};
diff --git a/src/uu/tail/src/follow/watch.rs b/src/uu/tail/src/follow/watch.rs
index 3ecb47f6734..212ad63f969 100644
--- a/src/uu/tail/src/follow/watch.rs
+++ b/src/uu/tail/src/follow/watch.rs
@@ -12,9 +12,9 @@ use crate::{platform, text};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind};
 use std::io::BufRead;
 use std::path::{Path, PathBuf};
-use std::sync::mpsc::{self, channel, Receiver};
+use std::sync::mpsc::{self, Receiver, channel};
 use uucore::display::Quotable;
-use uucore::error::{set_exit_code, UResult, USimpleError};
+use uucore::error::{UResult, USimpleError, set_exit_code};
 use uucore::show_error;
 
 pub struct WatcherRx {
@@ -45,6 +45,9 @@ impl WatcherRx {
             Tested for notify::InotifyWatcher and for notify::PollWatcher.
             */
             if let Some(parent) = path.parent() {
+                // clippy::assigning_clones added with Rust 1.78
+                // Rust version = 1.76 on OpenBSD stable/7.5
+                #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
                 if parent.is_dir() {
                     path = parent.to_owned();
                 } else {
@@ -226,7 +229,7 @@ impl Observer {
             watcher = Box::new(notify::PollWatcher::new(tx, watcher_config).unwrap());
         } else {
             let tx_clone = tx.clone();
-            match notify::RecommendedWatcher::new(tx, notify::Config::default()) {
+            match RecommendedWatcher::new(tx, notify::Config::default()) {
                 Ok(w) => watcher = Box::new(w),
                 Err(e) if e.to_string().starts_with("Too many open files") => {
                     /*
@@ -279,7 +282,7 @@ impl Observer {
                         if !path.is_file() {
                             continue;
                         }
-                        let mut path = path.to_owned();
+                        let mut path = path.clone();
                         if path.is_relative() {
                             path = std::env::current_dir()?.join(path);
                         }
@@ -315,12 +318,10 @@ impl Observer {
         let display_name = self.files.get(event_path).display_name.clone();
 
         match event.kind {
-            EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any | MetadataKind::WriteTime))
-
-                // | EventKind::Access(AccessKind::Close(AccessMode::Write))
-                | EventKind::Create(CreateKind::File | CreateKind::Folder | CreateKind::Any)
-                | EventKind::Modify(ModifyKind::Data(DataChange::Any))
-                | EventKind::Modify(ModifyKind::Name(RenameMode::To)) => {
+            EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any |
+MetadataKind::WriteTime) | ModifyKind::Data(DataChange::Any) |
+ModifyKind::Name(RenameMode::To)) |
+EventKind::Create(CreateKind::File | CreateKind::Folder | CreateKind::Any) => {
                     if let Ok(new_md) = event_path.metadata() {
 
                         let is_tailable = new_md.is_tailable();
@@ -342,10 +343,10 @@ impl Observer {
                                     show_error!( "{} has been replaced;  following new file", display_name.quote());
                                     self.files.update_reader(event_path)?;
                                 } else if old_md.got_truncated(&new_md)? {
-                                    show_error!("{}: file truncated", display_name);
+                                    show_error!("{display_name}: file truncated");
                                     self.files.update_reader(event_path)?;
                                 }
-                                paths.push(event_path.to_owned());
+                                paths.push(event_path.clone());
                             } else if !is_tailable && old_md.is_tailable() {
                                 if pd.reader.is_some() {
                                     self.files.reset_reader(event_path);
@@ -359,7 +360,7 @@ impl Observer {
                         } else if is_tailable {
                                 show_error!( "{} has appeared;  following new file", display_name.quote());
                                 self.files.update_reader(event_path)?;
-                                paths.push(event_path.to_owned());
+                                paths.push(event_path.clone());
                             } else if settings.retry {
                                 if self.follow_descriptor() {
                                     show_error!(
@@ -403,11 +404,11 @@ impl Observer {
                                     "{} cannot be used, reverting to polling",
                                     text::BACKEND
                                 );
-                                self.orphans.push(event_path.to_owned());
+                                self.orphans.push(event_path.clone());
                                 let _ = self.watcher_rx.as_mut().unwrap().unwatch(event_path);
                             }
                         } else {
-                            show_error!("{}: {}", display_name, text::NO_SUCH_FILE);
+                            show_error!("{display_name}: {}", text::NO_SUCH_FILE);
                             if !self.files.files_remaining() && self.use_polling {
                                 // NOTE: GNU's tail exits here for `---disable-inotify`
                                 return Err(USimpleError::new(1, text::NO_FILES_REMAINING));
@@ -451,7 +452,7 @@ impl Observer {
 
                 if self.follow_descriptor() {
                     let new_path = event.paths.last().unwrap();
-                    paths.push(new_path.to_owned());
+                    paths.push(new_path.clone());
 
                     let new_data = PathData::from_other_with_path(self.files.remove(event_path), new_path);
                     self.files.insert(
@@ -479,8 +480,7 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
 
     let mut process = platform::ProcessChecker::new(observer.pid);
 
-    let mut _event_counter = 0;
-    let mut _timeout_counter = 0;
+    let mut timeout_counter = 0;
 
     // main follow loop
     loop {
@@ -529,8 +529,7 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
             .receiver
             .recv_timeout(settings.sleep_sec);
         if rx_result.is_ok() {
-            _event_counter += 1;
-            _timeout_counter = 0;
+            timeout_counter = 0;
         }
 
         let mut paths = vec![]; // Paths worth checking for new content to print
@@ -565,11 +564,11 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
                 return Err(USimpleError::new(
                     1,
                     format!("{} resources exhausted", text::BACKEND),
-                ))
+                ));
             }
             Ok(Err(e)) => return Err(USimpleError::new(1, format!("NotifyError: {e}"))),
             Err(mpsc::RecvTimeoutError::Timeout) => {
-                _timeout_counter += 1;
+                timeout_counter += 1;
             }
             Err(e) => return Err(USimpleError::new(1, format!("RecvTimeoutError: {e}"))),
         }
@@ -586,7 +585,7 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
             _read_some = observer.files.tail_file(path, settings.verbose)?;
         }
 
-        if _timeout_counter == settings.max_unchanged_stats {
+        if timeout_counter == settings.max_unchanged_stats {
             /*
             TODO: [2021-10; jhscheer] implement timeout_counter for each file.
             ‘--max-unchanged-stats=n’
diff --git a/src/uu/tail/src/parse.rs b/src/uu/tail/src/parse.rs
index 3d6b2697e36..2e768d1c913 100644
--- a/src/uu/tail/src/parse.rs
+++ b/src/uu/tail/src/parse.rs
@@ -32,11 +32,10 @@ pub enum ParseError {
     InvalidEncoding,
 }
 /// Parses obsolete syntax
-/// tail -\[NUM\]\[bcl\]\[f\] and tail +\[NUM\]\[bcl\]\[f\] // spell-checker:disable-line
+/// tail -\[NUM\]\[bcl\]\[f\] and tail +\[NUM\]\[bcl\]\[f\]
 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 Some(mut rest) = src.to_str() else {
+        return Some(Err(ParseError::InvalidEncoding));
     };
     let sign = if let Some(r) = rest.strip_prefix('-') {
         rest = r;
@@ -86,9 +85,8 @@ pub fn parse_obsolete(src: &OsString) -> Option<Result<ObsoleteArgs, ParseError>
     }
 
     let multiplier = if mode == 'b' { 512 } else { 1 };
-    let num = match num.checked_mul(multiplier) {
-        Some(n) => n,
-        None => return Some(Err(ParseError::Overflow)),
+    let Some(num) = num.checked_mul(multiplier) else {
+        return Some(Err(ParseError::Overflow));
     };
 
     Some(Ok(ObsoleteArgs {
diff --git a/src/uu/tail/src/paths.rs b/src/uu/tail/src/paths.rs
index 117cab8b0a0..5c56ff8441d 100644
--- a/src/uu/tail/src/paths.rs
+++ b/src/uu/tail/src/paths.rs
@@ -78,14 +78,18 @@ impl Input {
                 path.canonicalize().ok()
             }
             InputKind::File(_) | InputKind::Stdin => {
-                if cfg!(unix) {
-                    match PathBuf::from(text::DEV_STDIN).canonicalize().ok() {
-                        Some(path) if path != PathBuf::from(text::FD0) => Some(path),
-                        Some(_) | None => None,
-                    }
-                } else {
+                // on macOS, /dev/fd isn't backed by /proc and canonicalize()
+                // on dev/fd/0 (or /dev/stdin) will fail (NotFound),
+                // so we treat stdin as a pipe here
+                // https://github.com/rust-lang/rust/issues/95239
+                #[cfg(target_os = "macos")]
+                {
                     None
                 }
+                #[cfg(not(target_os = "macos"))]
+                {
+                    PathBuf::from(text::FD0).canonicalize().ok()
+                }
             }
         }
     }
@@ -93,7 +97,7 @@ impl Input {
     pub fn is_tailable(&self) -> bool {
         match &self.kind {
             InputKind::File(path) => path_is_tailable(path),
-            InputKind::Stdin => self.resolve().map_or(false, |path| path_is_tailable(&path)),
+            InputKind::Stdin => self.resolve().is_some_and(|path| path_is_tailable(&path)),
         }
     }
 }
@@ -128,9 +132,8 @@ impl HeaderPrinter {
     pub fn print(&mut self, string: &str) {
         if self.verbose {
             println!(
-                "{}==> {} <==",
+                "{}==> {string} <==",
                 if self.first_header { "" } else { "\n" },
-                string,
             );
             self.first_header = false;
         }
@@ -233,7 +236,7 @@ impl PathExtTail for Path {
 }
 
 pub fn path_is_tailable(path: &Path) -> bool {
-    path.is_file() || path.exists() && path.metadata().map_or(false, |meta| meta.is_tailable())
+    path.is_file() || path.exists() && path.metadata().is_ok_and(|meta| meta.is_tailable())
 }
 
 #[inline]
diff --git a/src/uu/tail/src/platform/mod.rs b/src/uu/tail/src/platform/mod.rs
index cd2953ffd31..d3220491f4a 100644
--- a/src/uu/tail/src/platform/mod.rs
+++ b/src/uu/tail/src/platform/mod.rs
@@ -5,14 +5,14 @@
 
 #[cfg(unix)]
 pub use self::unix::{
-    //stdin_is_bad_fd, stdin_is_pipe_or_fifo, supports_pid_checks, Pid, ProcessChecker,
-    supports_pid_checks,
     Pid,
     ProcessChecker,
+    //stdin_is_bad_fd, stdin_is_pipe_or_fifo, supports_pid_checks, Pid, ProcessChecker,
+    supports_pid_checks,
 };
 
 #[cfg(windows)]
-pub use self::windows::{supports_pid_checks, Pid, ProcessChecker};
+pub use self::windows::{Pid, ProcessChecker, supports_pid_checks};
 
 #[cfg(unix)]
 mod unix;
diff --git a/src/uu/tail/src/platform/unix.rs b/src/uu/tail/src/platform/unix.rs
index a04582a2c22..08e75bedf4f 100644
--- a/src/uu/tail/src/platform/unix.rs
+++ b/src/uu/tail/src/platform/unix.rs
@@ -11,11 +11,11 @@ use std::io::Error;
 pub type Pid = libc::pid_t;
 
 pub struct ProcessChecker {
-    pid: self::Pid,
+    pid: Pid,
 }
 
 impl ProcessChecker {
-    pub fn new(process_id: self::Pid) -> Self {
+    pub fn new(process_id: Pid) -> Self {
         Self { pid: process_id }
     }
 
@@ -30,7 +30,7 @@ impl Drop for ProcessChecker {
     fn drop(&mut self) {}
 }
 
-pub fn supports_pid_checks(pid: self::Pid) -> bool {
+pub fn supports_pid_checks(pid: Pid) -> bool {
     unsafe { !(libc::kill(pid, 0) != 0 && get_errno() == libc::ENOSYS) }
 }
 
diff --git a/src/uu/tail/src/platform/windows.rs b/src/uu/tail/src/platform/windows.rs
index 5925161621b..550f76bcc29 100644
--- a/src/uu/tail/src/platform/windows.rs
+++ b/src/uu/tail/src/platform/windows.rs
@@ -3,9 +3,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use windows_sys::Win32::Foundation::{CloseHandle, BOOL, HANDLE, WAIT_FAILED, WAIT_OBJECT_0};
+use windows_sys::Win32::Foundation::{BOOL, CloseHandle, HANDLE, WAIT_FAILED, WAIT_OBJECT_0};
 use windows_sys::Win32::System::Threading::{
-    OpenProcess, WaitForSingleObject, PROCESS_SYNCHRONIZE,
+    OpenProcess, PROCESS_SYNCHRONIZE, WaitForSingleObject,
 };
 
 pub type Pid = u32;
@@ -16,12 +16,12 @@ pub struct ProcessChecker {
 }
 
 impl ProcessChecker {
-    pub fn new(process_id: self::Pid) -> Self {
+    pub fn new(process_id: Pid) -> Self {
         #[allow(non_snake_case)]
         let FALSE: BOOL = 0;
         let h = unsafe { OpenProcess(PROCESS_SYNCHRONIZE, FALSE, process_id) };
         Self {
-            dead: h == 0,
+            dead: h.is_null(),
             handle: h,
         }
     }
@@ -47,6 +47,6 @@ impl Drop for ProcessChecker {
     }
 }
 
-pub fn supports_pid_checks(_pid: self::Pid) -> bool {
+pub fn supports_pid_checks(_pid: Pid) -> bool {
     true
 }
diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs
index 0488e0808ed..2a6f9eb23a4 100644
--- a/src/uu/tail/src/tail.rs
+++ b/src/uu/tail/src/tail.rs
@@ -3,7 +3,8 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) seekable seek'd tail'ing ringbuffer ringbuf unwatch Uncategorized filehandle Signum
+// spell-checker:ignore (ToDO) seekable seek'd tail'ing ringbuffer ringbuf unwatch
+// spell-checker:ignore (ToDO) Uncategorized filehandle Signum memrchr
 // spell-checker:ignore (libs) kqueue
 // spell-checker:ignore (acronyms)
 // spell-checker:ignore (env/flags)
@@ -21,17 +22,18 @@ mod platform;
 pub mod text;
 
 pub use args::uu_app;
-use args::{parse_args, FilterMode, Settings, Signum};
+use args::{FilterMode, Settings, Signum, parse_args};
 use chunks::ReverseChunks;
 use follow::Observer;
+use memchr::{memchr_iter, memrchr_iter};
 use paths::{FileExtTail, HeaderPrinter, Input, InputKind, MetadataExtTail};
 use same_file::Handle;
 use std::cmp::Ordering;
 use std::fs::File;
-use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write};
+use std::io::{self, BufReader, BufWriter, ErrorKind, Read, Seek, SeekFrom, Write, stdin, stdout};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::error::{get_exit_code, set_exit_code, FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError, get_exit_code, set_exit_code};
 use uucore::{show, show_error};
 
 #[uucore::main]
@@ -45,7 +47,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             return Err(USimpleError::new(
                 1,
                 format!("cannot follow {} by name", text::DASH.quote()),
-            ))
+            ));
         }
         // Exit early if we do not output anything. Note, that this may break a pipe
         // when tail is on the receiving side.
@@ -65,13 +67,15 @@ fn uu_tail(settings: &Settings) -> UResult<()> {
     // Add `path` and `reader` to `files` map if `--follow` is selected.
     for input in &settings.inputs.clone() {
         match input.kind() {
-            InputKind::File(path) if cfg!(not(unix)) || path != &PathBuf::from(text::DEV_STDIN) => {
-                tail_file(settings, &mut printer, input, path, &mut observer, 0)?;
+            InputKind::Stdin => {
+                tail_stdin(settings, &mut printer, input, &mut observer)?;
             }
-            // File points to /dev/stdin here
-            InputKind::File(_) | InputKind::Stdin => {
+            InputKind::File(path) if cfg!(unix) && path == &PathBuf::from(text::DEV_STDIN) => {
                 tail_stdin(settings, &mut printer, input, &mut observer)?;
             }
+            InputKind::File(path) => {
+                tail_file(settings, &mut printer, input, path, &mut observer, 0)?;
+            }
         }
     }
 
@@ -85,7 +89,7 @@ fn uu_tail(settings: &Settings) -> UResult<()> {
         the input file is not a FIFO, pipe, or regular file, it is unspecified whether or
         not the -f option shall be ignored.
         */
-        if !settings.has_only_stdin() {
+        if !settings.has_only_stdin() || settings.pid != 0 {
             follow::follow(observer, settings)?;
         }
     }
@@ -119,7 +123,7 @@ fn tail_file(
         header_printer.print_input(input);
         let err_msg = "Is a directory".to_string();
 
-        show_error!("error reading '{}': {}", input.display_name, err_msg);
+        show_error!("error reading '{}': {err_msg}", input.display_name);
         if settings.follow.is_some() {
             let msg = if settings.retry {
                 ""
@@ -127,12 +131,11 @@ fn tail_file(
                 "; giving up on this name"
             };
             show_error!(
-                "{}: cannot follow end of this type of file{}",
+                "{}: cannot follow end of this type of file{msg}",
                 input.display_name,
-                msg
             );
         }
-        if !(observer.follow_name_retry()) {
+        if !observer.follow_name_retry() {
             // skip directory if not retry
             return Ok(());
         }
@@ -160,7 +163,7 @@ fn tail_file(
                     true,
                 )?;
             }
-            Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+            Err(e) if e.kind() == ErrorKind::PermissionDenied => {
                 observer.add_bad_path(path, input.display_name.as_str(), false)?;
                 show!(e.map_err_context(|| {
                     format!("cannot open '{}' for reading", input.display_name)
@@ -186,6 +189,29 @@ fn tail_stdin(
     input: &Input,
     observer: &mut Observer,
 ) -> UResult<()> {
+    // on macOS, resolve() will always return None for stdin,
+    // we need to detect if stdin is a directory ourselves.
+    // fstat-ing certain descriptors under /dev/fd fails with
+    // bad file descriptor or might not catch directory cases
+    // e.g. see the differences between running ls -l /dev/stdin /dev/fd/0
+    // on macOS and Linux.
+    #[cfg(target_os = "macos")]
+    {
+        if let Ok(mut stdin_handle) = Handle::stdin() {
+            if let Ok(meta) = stdin_handle.as_file_mut().metadata() {
+                if meta.file_type().is_dir() {
+                    set_exit_code(1);
+                    show_error!(
+                        "cannot open '{}' for reading: {}",
+                        input.display_name,
+                        text::NO_SUCH_FILE
+                    );
+                    return Ok(());
+                }
+            }
+        }
+    }
+
     match input.resolve() {
         // fifo
         Some(path) => {
@@ -283,34 +309,42 @@ fn tail_stdin(
 /// let i = forwards_thru_file(&mut reader, 2, b'\n').unwrap();
 /// assert_eq!(i, 2);
 /// ```
-fn forwards_thru_file<R>(
-    reader: &mut R,
+fn forwards_thru_file(
+    reader: &mut impl Read,
     num_delimiters: u64,
     delimiter: u8,
-) -> std::io::Result<usize>
-where
-    R: Read,
-{
-    let mut reader = BufReader::new(reader);
-
-    let mut buf = vec![];
+) -> io::Result<usize> {
+    // If num_delimiters == 0, always return 0.
+    if num_delimiters == 0 {
+        return Ok(0);
+    }
+    // Use a 32K buffer.
+    let mut buf = [0; 32 * 1024];
     let mut total = 0;
-    for _ in 0..num_delimiters {
-        match reader.read_until(delimiter, &mut buf) {
-            Ok(0) => {
-                return Ok(total);
-            }
+    let mut count = 0;
+    // Iterate through the input, using `count` to record the number of times `delimiter`
+    // is seen. Once we find `num_delimiters` instances, return the offset of the byte
+    // immediately following that delimiter.
+    loop {
+        match reader.read(&mut buf) {
+            // Ok(0) => EoF before we found `num_delimiters` instance of `delimiter`.
+            // Return the total number of bytes read in that case.
+            Ok(0) => return Ok(total),
             Ok(n) => {
+                // Use memchr_iter since it greatly improves search performance.
+                for offset in memchr_iter(delimiter, &buf[..n]) {
+                    count += 1;
+                    if count == num_delimiters {
+                        // Return offset of the byte after the `delimiter` instance.
+                        return Ok(total + offset + 1);
+                    }
+                }
                 total += n;
-                buf.clear();
-                continue;
-            }
-            Err(e) => {
-                return Err(e);
             }
+            Err(e) if e.kind() == ErrorKind::Interrupted => continue,
+            Err(e) => return Err(e),
         }
     }
-    Ok(total)
 }
 
 /// Iterate over bytes in the file, in reverse, until we find the
@@ -320,35 +354,36 @@ fn backwards_thru_file(file: &mut File, num_delimiters: u64, delimiter: u8) {
     // This variable counts the number of delimiters found in the file
     // so far (reading from the end of the file toward the beginning).
     let mut counter = 0;
-
-    for (block_idx, slice) in ReverseChunks::new(file).enumerate() {
+    let mut first_slice = true;
+    for slice in ReverseChunks::new(file) {
         // Iterate over each byte in the slice in reverse order.
-        let mut iter = slice.iter().enumerate().rev();
+        let mut iter = memrchr_iter(delimiter, &slice);
 
         // Ignore a trailing newline in the last block, if there is one.
-        if block_idx == 0 {
+        if first_slice {
             if let Some(c) = slice.last() {
                 if *c == delimiter {
                     iter.next();
                 }
             }
+            first_slice = false;
         }
 
         // For each byte, increment the count of the number of
         // delimiters found. If we have found more than the specified
         // number of delimiters, terminate the search and seek to the
         // appropriate location in the file.
-        for (i, ch) in iter {
-            if *ch == delimiter {
-                counter += 1;
-                if counter >= num_delimiters {
-                    // After each iteration of the outer loop, the
-                    // cursor in the file is at the *beginning* of the
-                    // block, so seeking forward by `i + 1` bytes puts
-                    // us right after the found delimiter.
-                    file.seek(SeekFrom::Current((i + 1) as i64)).unwrap();
-                    return;
-                }
+        for i in iter {
+            counter += 1;
+            if counter >= num_delimiters {
+                // We should never over-count - assert that.
+                assert_eq!(counter, num_delimiters);
+                // After each iteration of the outer loop, the
+                // cursor in the file is at the *beginning* of the
+                // block, so seeking forward by `i + 1` bytes puts
+                // us right after the found delimiter.
+                file.seek(SeekFrom::Current((i + 1) as i64)).unwrap();
+                return;
             }
         }
     }
@@ -393,12 +428,11 @@ fn bounded_tail(file: &mut File, settings: &Settings) {
     // Print the target section of the file.
     let stdout = stdout();
     let mut stdout = stdout.lock();
-    std::io::copy(file, &mut stdout).unwrap();
+    io::copy(file, &mut stdout).unwrap();
 }
 
 fn unbounded_tail<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UResult<()> {
-    let stdout = stdout();
-    let mut writer = BufWriter::new(stdout.lock());
+    let mut writer = BufWriter::new(stdout().lock());
     match &settings.mode {
         FilterMode::Lines(Signum::Negative(count), sep) => {
             let mut chunks = chunks::LinesChunkBuffer::new(*sep, *count);
@@ -457,6 +491,7 @@ fn unbounded_tail<T: Read>(reader: &mut BufReader<T>, settings: &Settings) -> UR
         }
         _ => {}
     }
+    writer.flush()?;
     Ok(())
 }
 
diff --git a/src/uu/tee/Cargo.toml b/src/uu/tee/Cargo.toml
index 597299fc7d4..8b7ac44fe86 100644
--- a/src/uu/tee/Cargo.toml
+++ b/src/uu/tee/Cargo.toml
@@ -1,23 +1,26 @@
 [package]
 name = "uu_tee"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "tee ~ (uutils) display input and copy to FILE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tee"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/tee.rs"
 
 [dependencies]
 clap = { workspace = true }
-libc = { workspace = true }
-uucore = { workspace = true, features = ["libc", "signals"] }
+nix = { workspace = true, features = ["poll", "fs"] }
+uucore = { workspace = true, features = ["libc", "parser", "signals"] }
 
 [[bin]]
 name = "tee"
diff --git a/src/uu/tee/src/tee.rs b/src/uu/tee/src/tee.rs
index ca6e8a7c611..b16caeb9327 100644
--- a/src/uu/tee/src/tee.rs
+++ b/src/uu/tee/src/tee.rs
@@ -3,12 +3,15 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use clap::{builder::PossibleValue, crate_version, Arg, ArgAction, Command};
+// cSpell:ignore POLLERR POLLRDBAND pfds revents
+
+use clap::{Arg, ArgAction, Command, builder::PossibleValue};
 use std::fs::OpenOptions;
-use std::io::{copy, sink, stdin, stdout, Error, ErrorKind, Read, Result, Write};
+use std::io::{Error, ErrorKind, Read, Result, Write, copy, stdin, stdout};
 use std::path::PathBuf;
 use uucore::display::Quotable;
 use uucore::error::UResult;
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::{format_usage, help_about, help_section, help_usage, show_error};
 
 // spell-checker:ignore nopipe
@@ -32,15 +35,20 @@ mod options {
 struct Options {
     append: bool,
     ignore_interrupts: bool,
+    ignore_pipe_errors: bool,
     files: Vec<String>,
     output_error: Option<OutputErrorMode>,
 }
 
 #[derive(Clone, Debug)]
 enum OutputErrorMode {
+    /// Diagnose write error on any output
     Warn,
+    /// Diagnose write error on any output that is not a pipe
     WarnNoPipe,
+    /// Exit upon write error on any output
     Exit,
+    /// Exit upon write error on any output that is not a pipe
     ExitNoPipe,
 }
 
@@ -48,47 +56,61 @@ enum OutputErrorMode {
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
+    let append = matches.get_flag(options::APPEND);
+    let ignore_interrupts = matches.get_flag(options::IGNORE_INTERRUPTS);
+    let ignore_pipe_errors = matches.get_flag(options::IGNORE_PIPE_ERRORS);
+    let output_error = if matches.contains_id(options::OUTPUT_ERROR) {
+        match matches
+            .get_one::<String>(options::OUTPUT_ERROR)
+            .map(String::as_str)
+        {
+            Some("warn") => Some(OutputErrorMode::Warn),
+            // If no argument is specified for --output-error,
+            // defaults to warn-nopipe
+            None | Some("warn-nopipe") => Some(OutputErrorMode::WarnNoPipe),
+            Some("exit") => Some(OutputErrorMode::Exit),
+            Some("exit-nopipe") => Some(OutputErrorMode::ExitNoPipe),
+            _ => unreachable!(),
+        }
+    } else if ignore_pipe_errors {
+        Some(OutputErrorMode::WarnNoPipe)
+    } else {
+        None
+    };
+
+    let files = matches
+        .get_many::<String>(options::FILE)
+        .map(|v| v.map(ToString::to_string).collect())
+        .unwrap_or_default();
+
     let options = Options {
-        append: matches.get_flag(options::APPEND),
-        ignore_interrupts: matches.get_flag(options::IGNORE_INTERRUPTS),
-        files: matches
-            .get_many::<String>(options::FILE)
-            .map(|v| v.map(ToString::to_string).collect())
-            .unwrap_or_default(),
-        output_error: {
-            if matches.get_flag(options::IGNORE_PIPE_ERRORS) {
-                Some(OutputErrorMode::WarnNoPipe)
-            } else if matches.contains_id(options::OUTPUT_ERROR) {
-                if let Some(v) = matches.get_one::<String>(options::OUTPUT_ERROR) {
-                    match v.as_str() {
-                        "warn" => Some(OutputErrorMode::Warn),
-                        "warn-nopipe" => Some(OutputErrorMode::WarnNoPipe),
-                        "exit" => Some(OutputErrorMode::Exit),
-                        "exit-nopipe" => Some(OutputErrorMode::ExitNoPipe),
-                        _ => unreachable!(),
-                    }
-                } else {
-                    Some(OutputErrorMode::WarnNoPipe)
-                }
-            } else {
-                None
-            }
-        },
+        append,
+        ignore_interrupts,
+        ignore_pipe_errors,
+        files,
+        output_error,
     };
 
-    match tee(&options) {
-        Ok(_) => Ok(()),
-        Err(_) => Err(1.into()),
-    }
+    tee(&options).map_err(|_| 1.into())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
         .infer_long_args(true)
+        // Since we use value-specific help texts for "--output-error", clap's "short help" and "long help" differ.
+        // However, this is something that the GNU tests explicitly test for, so we *always* show the long help instead.
+        .disable_help_flag(true)
+        .arg(
+            Arg::new("--help")
+                .short('h')
+                .long("help")
+                .help("Print help")
+                .action(ArgAction::HelpLong)
+        )
         .arg(
             Arg::new(options::APPEND)
                 .long(options::APPEND)
@@ -119,7 +141,7 @@ pub fn uu_app() -> Command {
                 .long(options::OUTPUT_ERROR)
                 .require_equals(true)
                 .num_args(0..=1)
-                .value_parser([
+                .value_parser(ShortcutValueParser::new([
                     PossibleValue::new("warn")
                         .help("produce warnings for errors writing to any output"),
                     PossibleValue::new("warn-nopipe")
@@ -127,9 +149,8 @@ pub fn uu_app() -> Command {
                     PossibleValue::new("exit").help("exit on write errors to any output"),
                     PossibleValue::new("exit-nopipe")
                         .help("exit on write errors to any output that are not pipe errors (equivalent to exit on non-unix platforms)"),
-                ])
+                ]))
                 .help("set write error behavior")
-                .conflicts_with(options::IGNORE_PIPE_ERRORS),
         )
 }
 
@@ -148,15 +169,10 @@ fn tee(options: &Options) -> Result<()> {
     }
     let mut writers: Vec<NamedWriter> = options
         .files
-        .clone()
-        .into_iter()
-        .map(|file| {
-            Ok(NamedWriter {
-                name: file.clone(),
-                inner: open(file, options.append, options.output_error.as_ref())?,
-            })
-        })
+        .iter()
+        .filter_map(|file| open(file, options.append, options.output_error.as_ref()))
         .collect::<Result<Vec<NamedWriter>>>()?;
+    let had_open_errors = writers.len() != options.files.len();
 
     writers.insert(
         0,
@@ -171,6 +187,11 @@ fn tee(options: &Options) -> Result<()> {
         inner: Box::new(stdin()) as Box<dyn Read>,
     };
 
+    #[cfg(target_os = "linux")]
+    if options.ignore_pipe_errors && !ensure_stdout_not_broken()? && output.writers.len() == 1 {
+        return Ok(());
+    }
+
     let res = match copy(input, &mut output) {
         // ErrorKind::Other is raised by MultiWriter when all writers
         // have exited, so that copy will abort. It's equivalent to
@@ -181,38 +202,41 @@ fn tee(options: &Options) -> Result<()> {
         _ => Ok(()),
     };
 
-    if res.is_err() || output.flush().is_err() || output.error_occurred() {
+    if had_open_errors || res.is_err() || output.flush().is_err() || output.error_occurred() {
         Err(Error::from(ErrorKind::Other))
     } else {
         Ok(())
     }
 }
 
+/// Tries to open the indicated file and return it. Reports an error if that's not possible.
+/// If that error should lead to program termination, this function returns Some(Err()),
+/// otherwise it returns None.
 fn open(
-    name: String,
+    name: &str,
     append: bool,
     output_error: Option<&OutputErrorMode>,
-) -> Result<Box<dyn Write>> {
-    let path = PathBuf::from(name.clone());
-    let inner: Box<dyn Write> = {
-        let mut options = OpenOptions::new();
-        let mode = if append {
-            options.append(true)
-        } else {
-            options.truncate(true)
-        };
-        match mode.write(true).create(true).open(path.as_path()) {
-            Ok(file) => Box::new(file),
-            Err(f) => {
-                show_error!("{}: {}", name.maybe_quote(), f);
-                match output_error {
-                    Some(OutputErrorMode::Exit | OutputErrorMode::ExitNoPipe) => return Err(f),
-                    _ => Box::new(sink()),
-                }
+) -> Option<Result<NamedWriter>> {
+    let path = PathBuf::from(name);
+    let mut options = OpenOptions::new();
+    let mode = if append {
+        options.append(true)
+    } else {
+        options.truncate(true)
+    };
+    match mode.write(true).create(true).open(path.as_path()) {
+        Ok(file) => Some(Ok(NamedWriter {
+            inner: Box::new(file),
+            name: name.to_owned(),
+        })),
+        Err(f) => {
+            show_error!("{}: {f}", name.maybe_quote());
+            match output_error {
+                Some(OutputErrorMode::Exit | OutputErrorMode::ExitNoPipe) => Some(Err(f)),
+                _ => None,
             }
         }
-    };
-    Ok(Box::new(NamedWriter { inner, name }) as Box<dyn Write>)
+    }
 }
 
 struct MultiWriter {
@@ -243,26 +267,26 @@ fn process_error(
 ) -> Result<()> {
     match mode {
         Some(OutputErrorMode::Warn) => {
-            show_error!("{}: {}", writer.name.maybe_quote(), f);
+            show_error!("{}: {f}", writer.name.maybe_quote());
             *ignored_errors += 1;
             Ok(())
         }
         Some(OutputErrorMode::WarnNoPipe) | None => {
             if f.kind() != ErrorKind::BrokenPipe {
-                show_error!("{}: {}", writer.name.maybe_quote(), f);
+                show_error!("{}: {f}", writer.name.maybe_quote());
                 *ignored_errors += 1;
             }
             Ok(())
         }
         Some(OutputErrorMode::Exit) => {
-            show_error!("{}: {}", writer.name.maybe_quote(), f);
+            show_error!("{}: {f}", writer.name.maybe_quote());
             Err(f)
         }
         Some(OutputErrorMode::ExitNoPipe) => {
             if f.kind() == ErrorKind::BrokenPipe {
                 Ok(())
             } else {
-                show_error!("{}: {}", writer.name.maybe_quote(), f);
+                show_error!("{}: {f}", writer.name.maybe_quote());
                 Err(f)
             }
         }
@@ -351,10 +375,51 @@ impl Read for NamedReader {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         match self.inner.read(buf) {
             Err(f) => {
-                show_error!("stdin: {}", f);
+                show_error!("stdin: {f}");
                 Err(f)
             }
             okay => okay,
         }
     }
 }
+
+/// Check that if stdout is a pipe, it is not broken.
+#[cfg(target_os = "linux")]
+pub fn ensure_stdout_not_broken() -> Result<bool> {
+    use nix::{
+        poll::{PollFd, PollFlags, PollTimeout},
+        sys::stat::{SFlag, fstat},
+    };
+    use std::os::fd::AsFd;
+
+    let out = stdout();
+
+    // First, check that stdout is a fifo and return true if it's not the case
+    let stat = fstat(out.as_fd())?;
+    if !SFlag::from_bits_truncate(stat.st_mode).contains(SFlag::S_IFIFO) {
+        return Ok(true);
+    }
+
+    // POLLRDBAND is the flag used by GNU tee.
+    let mut pfds = [PollFd::new(out.as_fd(), PollFlags::POLLRDBAND)];
+
+    // Then, ensure that the pipe is not broken
+    let res = nix::poll::poll(&mut pfds, PollTimeout::NONE)?;
+
+    if res > 0 {
+        // poll succeeded;
+        let error = pfds.iter().any(|pfd| {
+            if let Some(revents) = pfd.revents() {
+                revents.contains(PollFlags::POLLERR)
+            } else {
+                true
+            }
+        });
+        return Ok(!error);
+    }
+
+    // if res == 0, it means that timeout was reached, which is impossible
+    // because we set infinite timeout.
+    // And if res < 0, the nix wrapper should have sent back an error.
+    unreachable!();
+}
diff --git a/src/uu/test/Cargo.toml b/src/uu/test/Cargo.toml
index fc70677a6c2..c59f9fcb422 100644
--- a/src/uu/test/Cargo.toml
+++ b/src/uu/test/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_test"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "test ~ (uutils) evaluate comparison and file type expressions"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/test"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/test.rs"
@@ -17,10 +20,7 @@ path = "src/test.rs"
 [dependencies]
 clap = { workspace = true }
 libc = { workspace = true }
-uucore = { workspace = true }
-
-[target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall = { workspace = true }
+uucore = { workspace = true, features = ["process"] }
 
 [[bin]]
 name = "test"
diff --git a/src/uu/test/src/error.rs b/src/uu/test/src/error.rs
index 48238fa1356..e392216e154 100644
--- a/src/uu/test/src/error.rs
+++ b/src/uu/test/src/error.rs
@@ -11,6 +11,7 @@ pub enum ParseError {
     MissingArgument(String),
     UnknownOperator(String),
     InvalidInteger(String),
+    UnaryOperatorExpected(String),
 }
 
 /// A Result type for parsing test expressions
@@ -26,6 +27,7 @@ impl std::fmt::Display for ParseError {
             Self::ExtraArgument(s) => write!(f, "extra argument {s}"),
             Self::UnknownOperator(s) => write!(f, "unknown operator {s}"),
             Self::InvalidInteger(s) => write!(f, "invalid integer {s}"),
+            Self::UnaryOperatorExpected(op) => write!(f, "{op}: unary operator expected"),
         }
     }
 }
diff --git a/src/uu/test/src/parser.rs b/src/uu/test/src/parser.rs
index 2b847fa1514..417de3380d0 100644
--- a/src/uu/test/src/parser.rs
+++ b/src/uu/test/src/parser.rs
@@ -50,7 +50,7 @@ impl Symbol {
                     "(" => Self::LParen,
                     "!" => Self::Bang,
                     "-a" | "-o" => Self::BoolOp(s),
-                    "=" | "==" | "!=" => Self::Op(Operator::String(s)),
+                    "=" | "==" | "!=" | "<" | ">" => Self::Op(Operator::String(s)),
                     "-eq" | "-ge" | "-gt" | "-le" | "-lt" | "-ne" => Self::Op(Operator::Int(s)),
                     "-ef" | "-nt" | "-ot" => Self::Op(Operator::File(s)),
                     "-n" | "-z" => Self::UnaryOp(UnaryOperator::StrlenOp(s)),
@@ -79,11 +79,8 @@ impl Symbol {
             Self::Bang => OsString::from("!"),
             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)) => s,
+            | Self::Op(Operator::String(s) | Operator::Int(s) | Operator::File(s))
+            | Self::UnaryOp(UnaryOperator::StrlenOp(s) | UnaryOperator::FiletestOp(s)) => s,
             Self::None => panic!(),
         })
     }
@@ -99,11 +96,10 @@ impl std::fmt::Display for Symbol {
             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::Op(Operator::String(s) | Operator::Int(s) | Operator::File(s))
+            | Self::UnaryOp(UnaryOperator::StrlenOp(s) | UnaryOperator::FiletestOp(s)) => {
+                OsStr::new(s)
+            }
             Self::None => OsStr::new("None"),
         };
         write!(f, "{}", s.quote())
@@ -164,7 +160,7 @@ impl Parser {
     /// The stream is unchanged and will return the same Symbol on subsequent
     /// calls to `next()` or `peek()`.
     fn peek(&mut self) -> Symbol {
-        Symbol::new(self.tokens.peek().map(|s| s.to_os_string()))
+        Symbol::new(self.tokens.peek().cloned())
     }
 
     /// Test if the next token in the stream is a BOOLOP (-a or -o), without
diff --git a/src/uu/test/src/test.rs b/src/uu/test/src/test.rs
index 7e778f9b5e0..e71e7b19166 100644
--- a/src/uu/test/src/test.rs
+++ b/src/uu/test/src/test.rs
@@ -8,15 +8,17 @@
 pub(crate) mod error;
 mod parser;
 
-use clap::{crate_version, Command};
+use clap::Command;
 use error::{ParseError, ParseResult};
-use parser::{parse, Operator, Symbol, UnaryOperator};
+use parser::{Operator, Symbol, UnaryOperator, parse};
 use std::ffi::{OsStr, OsString};
 use std::fs;
 #[cfg(unix)]
 use std::os::unix::fs::MetadataExt;
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError};
+#[cfg(not(windows))]
+use uucore::process::{getegid, geteuid};
 use uucore::{format_usage, help_about, help_section};
 
 const ABOUT: &str = help_about!("test.md");
@@ -27,10 +29,11 @@ const ABOUT: &str = help_about!("test.md");
 // So, we use test or [ instead of {} so that the usage string is correct.
 const USAGE: &str = "\
 test EXPRESSION
-test
+[
 [ EXPRESSION ]
 [ ]
-[ OPTION";
+[ 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 = help_section!("after help", "test.md");
@@ -39,7 +42,7 @@ 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!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .after_help(AFTER_HELP)
@@ -66,11 +69,7 @@ pub fn uumain(mut args: impl uucore::Args) -> UResult<()> {
 
     let result = parse(args).map(|mut stack| eval(&mut stack))??;
 
-    if result {
-        Ok(())
-    } else {
-        Err(1.into())
-    }
+    if result { Ok(()) } else { Err(1.into()) }
 }
 
 /// Evaluate a stack of Symbols, returning the result of the evaluation or
@@ -94,9 +93,14 @@ fn eval(stack: &mut Vec<Symbol>) -> ParseResult<bool> {
             Ok(!result)
         }
         Some(Symbol::Op(Operator::String(op))) => {
-            let b = stack.pop();
-            let a = stack.pop();
-            Ok(if op == "!=" { a != b } else { a == b })
+            let b = pop_literal!();
+            let a = pop_literal!();
+            match op.to_string_lossy().as_ref() {
+                "!=" => Ok(a != b),
+                "<" => Ok(a < b),
+                ">" => Ok(a > b),
+                _ => Ok(a == b),
+            }
         }
         Some(Symbol::Op(Operator::Int(op))) => {
             let b = pop_literal!();
@@ -159,6 +163,10 @@ fn eval(stack: &mut Vec<Symbol>) -> ParseResult<bool> {
         Some(Symbol::Literal(s)) => Ok(!s.is_empty()),
         Some(Symbol::None) | None => Ok(false),
         Some(Symbol::BoolOp(op)) => {
+            if (op == "-a" || op == "-o") && stack.len() < 2 {
+                return Err(ParseError::UnaryOperatorExpected(op.quote().to_string()));
+            }
+
             let b = eval(stack)?;
             let a = eval(stack)?;
 
@@ -203,13 +211,8 @@ fn integers(a: &OsStr, b: &OsStr, op: &OsStr) -> ParseResult<bool> {
 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) {
-        Ok(f) => f,
-        Err(_) => return Ok(false),
-    };
-    let f_b = match fs::metadata(b) {
-        Ok(f) => f,
-        Err(_) => return Ok(false),
+    let (Ok(f_a), Ok(f_b)) = (fs::metadata(a), fs::metadata(b)) else {
+        return Ok(false);
     };
 
     Ok(match op.to_str() {
@@ -218,7 +221,7 @@ fn files(a: &OsStr, b: &OsStr, op: &OsStr) -> ParseResult<bool> {
         #[cfg(not(unix))]
         Some("-ef") => unimplemented!(),
         Some("-nt") => f_a.modified().unwrap() > f_b.modified().unwrap(),
-        Some("-ot") => f_a.created().unwrap() > f_b.created().unwrap(),
+        Some("-ot") => f_a.modified().unwrap() < f_b.modified().unwrap(),
         _ => return Err(ParseError::UnknownOperator(op.quote().to_string())),
     })
 }
@@ -227,14 +230,7 @@ fn isatty(fd: &OsStr) -> ParseResult<bool> {
     fd.to_str()
         .and_then(|s| s.parse().ok())
         .ok_or_else(|| ParseError::InvalidInteger(fd.quote().to_string()))
-        .map(|i| {
-            #[cfg(not(target_os = "redox"))]
-            unsafe {
-                libc::isatty(i) == 1
-            }
-            #[cfg(target_os = "redox")]
-            syscall::dup(i, b"termios").map(syscall::close).is_ok()
-        })
+        .map(|i| unsafe { libc::isatty(i) == 1 })
 }
 
 #[derive(Eq, PartialEq)]
@@ -274,24 +270,6 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
         Execute = 0o1,
     }
 
-    let geteuid = || {
-        #[cfg(not(target_os = "redox"))]
-        let euid = unsafe { libc::geteuid() };
-        #[cfg(target_os = "redox")]
-        let euid = syscall::geteuid().unwrap() as u32;
-
-        euid
-    };
-
-    let getegid = || {
-        #[cfg(not(target_os = "redox"))]
-        let egid = unsafe { libc::getegid() };
-        #[cfg(target_os = "redox")]
-        let egid = syscall::getegid().unwrap() as u32;
-
-        egid
-    };
-
     let perm = |metadata: Metadata, p: Permission| {
         if geteuid() == metadata.uid() {
             metadata.mode() & ((p as u32) << 6) != 0
@@ -308,11 +286,8 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
         fs::metadata(path)
     };
 
-    let metadata = match metadata {
-        Ok(metadata) => metadata,
-        Err(_) => {
-            return false;
-        }
+    let Ok(metadata) = metadata else {
+        return false;
     };
 
     let file_type = metadata.file_type();
@@ -345,9 +320,8 @@ fn path(path: &OsStr, condition: &PathCondition) -> bool {
 fn path(path: &OsStr, condition: &PathCondition) -> bool {
     use std::fs::metadata;
 
-    let stat = match metadata(path) {
-        Ok(s) => s,
-        _ => return false,
+    let Ok(stat) = metadata(path) else {
+        return false;
     };
 
     match condition {
diff --git a/src/uu/timeout/Cargo.toml b/src/uu/timeout/Cargo.toml
index 949ac9da5f7..f2abe2ff45e 100644
--- a/src/uu/timeout/Cargo.toml
+++ b/src/uu/timeout/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_timeout"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "timeout ~ (uutils) run COMMAND with a DURATION time limit"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/timeout"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/timeout.rs"
@@ -18,7 +21,7 @@ path = "src/timeout.rs"
 clap = { workspace = true }
 libc = { workspace = true }
 nix = { workspace = true, features = ["signal"] }
-uucore = { workspace = true, features = ["process", "signals"] }
+uucore = { workspace = true, features = ["parser", "process", "signals"] }
 
 [[bin]]
 name = "timeout"
diff --git a/src/uu/timeout/src/status.rs b/src/uu/timeout/src/status.rs
index 10103ab9b29..7a94c7f9441 100644
--- a/src/uu/timeout/src/status.rs
+++ b/src/uu/timeout/src/status.rs
@@ -3,7 +3,6 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 //! Exit status codes produced by `timeout`.
-use std::convert::From;
 use uucore::error::UError;
 
 /// Enumerates the exit statuses produced by `timeout`.
diff --git a/src/uu/timeout/src/timeout.rs b/src/uu/timeout/src/timeout.rs
index 5e73fe2ab50..9de3358015c 100644
--- a/src/uu/timeout/src/timeout.rs
+++ b/src/uu/timeout/src/timeout.rs
@@ -7,13 +7,14 @@
 mod status;
 
 use crate::status::ExitStatus;
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use std::io::ErrorKind;
 use std::os::unix::process::ExitStatusExt;
 use std::process::{self, Child, Stdio};
 use std::time::Duration;
 use uucore::display::Quotable;
 use uucore::error::{UClapError, UResult, USimpleError, UUsageError};
+use uucore::parser::parse_time;
 use uucore::process::ChildExt;
 
 #[cfg(unix)]
@@ -60,28 +61,25 @@ impl Config {
                         return Err(UUsageError::new(
                             ExitStatus::TimeoutFailed.into(),
                             format!("{}: invalid signal", signal_.quote()),
-                        ))
+                        ));
                     }
                     Some(signal_value) => signal_value,
                 }
             }
-            _ => uucore::signals::signal_by_name_or_value("TERM").unwrap(),
+            _ => signal_by_name_or_value("TERM").unwrap(),
         };
 
         let kill_after = match options.get_one::<String>(options::KILL_AFTER) {
             None => None,
-            Some(kill_after) => match uucore::parse_time::from_str(kill_after) {
+            Some(kill_after) => match parse_time::from_str(kill_after, true) {
                 Ok(k) => Some(k),
                 Err(err) => return Err(UUsageError::new(ExitStatus::TimeoutFailed.into(), err)),
             },
         };
 
-        let duration = match uucore::parse_time::from_str(
-            options.get_one::<String>(options::DURATION).unwrap(),
-        ) {
-            Ok(duration) => duration,
-            Err(err) => return Err(UUsageError::new(ExitStatus::TimeoutFailed.into(), err)),
-        };
+        let duration =
+            parse_time::from_str(options.get_one::<String>(options::DURATION).unwrap(), true)
+                .map_err(|err| UUsageError::new(ExitStatus::TimeoutFailed.into(), err))?;
 
         let preserve_status: bool = options.get_flag(options::PRESERVE_STATUS);
         let foreground = options.get_flag(options::FOREGROUND);
@@ -107,8 +105,6 @@ impl Config {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args).with_exit_code(125)?;
 
     let config = Config::from(&matches)?;
@@ -125,12 +121,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new("timeout")
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .arg(
             Arg::new(options::FOREGROUND)
                 .long(options::FOREGROUND)
+                .short('f')
                 .help(
                     "when not running timeout directly from a shell prompt, allow \
                 COMMAND to read from the TTY and get TTY signals; in this mode, \
@@ -150,6 +147,7 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::PRESERVE_STATUS)
                 .long(options::PRESERVE_STATUS)
+                .short('p')
                 .help("exit with the same status as COMMAND, even when the command times out")
                 .action(ArgAction::SetTrue),
         )
@@ -196,7 +194,7 @@ fn unblock_sigchld() {
 fn report_if_verbose(signal: usize, cmd: &str, verbose: bool) {
     if verbose {
         let s = signal_name_by_value(signal).unwrap();
-        show_error!("sending signal {} to command {}", s, cmd.quote());
+        show_error!("sending signal {s} to command {}", cmd.quote());
     }
 }
 
@@ -204,13 +202,13 @@ 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);
+    if foreground {
+        let _ = process.send_signal(signal);
+    } else {
+        let _ = 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);
         }
     }
@@ -290,7 +288,6 @@ fn preserve_signal_info(signal: libc::c_int) -> libc::c_int {
 }
 
 /// TODO: Improve exit codes, and make them consistent with the GNU Coreutils exit codes.
-
 fn timeout(
     cmd: &[String],
     duration: Duration,
@@ -344,8 +341,15 @@ fn timeout(
             send_signal(process, signal, foreground);
             match kill_after {
                 None => {
+                    let status = process.wait()?;
                     if preserve_status {
-                        Err(ExitStatus::SignalSent(signal).into())
+                        if let Some(ec) = status.code() {
+                            Err(ec.into())
+                        } else if let Some(sc) = status.signal() {
+                            Err(ExitStatus::SignalSent(sc.try_into().unwrap()).into())
+                        } else {
+                            Err(ExitStatus::CommandTimedOut.into())
+                        }
                     } else {
                         Err(ExitStatus::CommandTimedOut.into())
                     }
diff --git a/src/uu/touch/Cargo.toml b/src/uu/touch/Cargo.toml
index 54682e1ddf4..182041c450d 100644
--- a/src/uu/touch/Cargo.toml
+++ b/src/uu/touch/Cargo.toml
@@ -1,16 +1,19 @@
 # spell-checker:ignore datetime
 [package]
 name = "uu_touch"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "touch ~ (uutils) change FILE timestamps"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/touch"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/touch.rs"
@@ -20,7 +23,8 @@ filetime = { workspace = true }
 clap = { workspace = true }
 chrono = { workspace = true }
 parse_datetime = { workspace = true }
-uucore = { workspace = true, features = ["libc"] }
+thiserror = { workspace = true }
+uucore = { workspace = true, features = ["libc", "parser"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-sys = { workspace = true, features = [
diff --git a/src/uu/touch/src/error.rs b/src/uu/touch/src/error.rs
new file mode 100644
index 00000000000..78cc8f33050
--- /dev/null
+++ b/src/uu/touch/src/error.rs
@@ -0,0 +1,48 @@
+// 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.
+
+// spell-checker:ignore (misc) uioerror
+use filetime::FileTime;
+use std::path::PathBuf;
+use thiserror::Error;
+use uucore::display::Quotable;
+use uucore::error::{UError, UIoError};
+
+#[derive(Debug, Error)]
+pub enum TouchError {
+    #[error("Unable to parse date: {0}")]
+    InvalidDateFormat(String),
+
+    /// The source time couldn't be converted to a [chrono::DateTime]
+    #[error("Source has invalid access or modification time: {0}")]
+    InvalidFiletime(FileTime),
+
+    /// The reference file's attributes could not be found or read
+    #[error("failed to get attributes of {}: {}", .0.quote(), to_uioerror(.1))]
+    ReferenceFileInaccessible(PathBuf, std::io::Error),
+
+    /// An error getting a path to stdout on Windows
+    #[error("GetFinalPathNameByHandleW failed with code {0}")]
+    WindowsStdoutPathError(String),
+
+    /// An error encountered on a specific file
+    #[error("{error}")]
+    TouchFileError {
+        path: PathBuf,
+        index: usize,
+        error: Box<dyn UError>,
+    },
+}
+
+fn to_uioerror(err: &std::io::Error) -> UIoError {
+    let copy = if let Some(code) = err.raw_os_error() {
+        std::io::Error::from_raw_os_error(code)
+    } else {
+        std::io::Error::from(err.kind())
+    };
+    UIoError::from(copy)
+}
+
+impl UError for TouchError {}
diff --git a/src/uu/touch/src/touch.rs b/src/uu/touch/src/touch.rs
index e9970cb2456..6749933f094 100644
--- a/src/uu/touch/src/touch.rs
+++ b/src/uu/touch/src/touch.rs
@@ -3,20 +3,86 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) filetime datetime lpszfilepath mktime DATETIME subsecond datelike timelike
+// spell-checker:ignore (ToDO) filetime datetime lpszfilepath mktime DATETIME datelike timelike
 // spell-checker:ignore (FORMATS) MMDDhhmm YYYYMMDDHHMM YYMMDDHHMM YYYYMMDDHHMMS
 
-use chrono::{DateTime, Datelike, Duration, Local, NaiveDate, NaiveTime, TimeZone, Timelike, Utc};
-use clap::builder::ValueParser;
-use clap::{crate_version, Arg, ArgAction, ArgGroup, Command};
-use filetime::{set_file_times, set_symlink_file_times, FileTime};
+pub mod error;
+
+use chrono::{
+    DateTime, Datelike, Duration, Local, LocalResult, NaiveDate, NaiveDateTime, NaiveTime,
+    TimeZone, Timelike,
+};
+use clap::builder::{PossibleValue, ValueParser};
+use clap::{Arg, ArgAction, ArgGroup, ArgMatches, Command};
+use filetime::{FileTime, set_file_times, set_symlink_file_times};
+use std::borrow::Cow;
 use std::ffi::OsString;
 use std::fs::{self, File};
+use std::io::{Error, ErrorKind};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::error::{FromIo, UResult, USimpleError};
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
 use uucore::{format_usage, help_about, help_usage, show};
 
+use crate::error::TouchError;
+
+/// Options contains all the possible behaviors and flags for touch.
+///
+/// All options are public so that the options can be programmatically
+/// constructed by other crates, such as nushell. That means that this struct is
+/// part of our public API. It should therefore not be changed without good reason.
+///
+/// The fields are documented with the arguments that determine their value.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Options {
+    /// Do not create any files. Set by `-c`/`--no-create`.
+    pub no_create: bool,
+
+    /// Affect each symbolic link instead of any referenced file. Set by `-h`/`--no-dereference`.
+    pub no_deref: bool,
+
+    /// Where to get access and modification times from
+    pub source: Source,
+
+    /// If given, uses time from `source` but on given date
+    pub date: Option<String>,
+
+    /// Whether to change access time only, modification time only, or both
+    pub change_times: ChangeTimes,
+
+    /// When true, error when file doesn't exist and either `--no-dereference`
+    /// was passed or the file couldn't be created
+    pub strict: bool,
+}
+
+pub enum InputFile {
+    /// A regular file
+    Path(PathBuf),
+    /// Touch stdout. `--no-dereference` will be ignored in this case.
+    Stdout,
+}
+
+/// Whether to set access time only, modification time only, or both
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum ChangeTimes {
+    /// Change only access time
+    AtimeOnly,
+    /// Change only modification time
+    MtimeOnly,
+    /// Change both access and modification times
+    Both,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Source {
+    /// Use access/modification times of given file
+    Reference(PathBuf),
+    Timestamp(FileTime),
+    /// Use current time
+    Now,
+}
+
 const ABOUT: &str = help_about!("touch.md");
 const USAGE: &str = help_usage!("touch.md");
 
@@ -65,164 +131,133 @@ fn datetime_to_filetime<T: TimeZone>(dt: &DateTime<T>) -> FileTime {
     FileTime::from_unix_time(dt.timestamp(), dt.timestamp_subsec_nanos())
 }
 
-#[uucore::main]
-#[allow(clippy::cognitive_complexity)]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
-
-    let files = matches.get_many::<OsString>(ARG_FILES).ok_or_else(|| {
-        USimpleError::new(
-            1,
-            format!(
-                "missing file operand\nTry '{} --help' for more information.",
-                uucore::execution_phrase()
-            ),
-        )
-    })?;
-    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) = parse_datetime::from_str(date) {
-                let seconds = offset.num_seconds();
-                let nanos = offset.num_nanoseconds().unwrap_or(0) % 1_000_000_000;
-
-                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,
-                );
+fn filetime_to_datetime(ft: &FileTime) -> Option<DateTime<Local>> {
+    Some(DateTime::from_timestamp(ft.unix_seconds(), ft.nanoseconds())?.into())
+}
 
-                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,
-                );
+/// Whether all characters in the string are digits.
+fn all_digits(s: &str) -> bool {
+    s.as_bytes().iter().all(u8::is_ascii_digit)
+}
 
-                (atime, mtime)
-            } else {
-                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(ts) = matches.get_one::<String>(options::sources::TIMESTAMP)
-            {
-                parse_timestamp(ts)?
-            } else {
-                datetime_to_filetime(&Local::now())
-            };
-            (timestamp, timestamp)
-        }
-    };
+/// Convert a two-digit year string to the corresponding number.
+///
+/// `s` must be of length two or more. The last two bytes of `s` are
+/// assumed to be the two digits of the year.
+fn get_year(s: &str) -> u8 {
+    let bytes = s.as_bytes();
+    let n = bytes.len();
+    let y1 = bytes[n - 2] - b'0';
+    let y2 = bytes[n - 1] - b'0';
+    10 * y1 + y2
+}
 
-    for filename in files {
-        // FIXME: find a way to avoid having to clone the path
-        let pathbuf = if filename == "-" {
-            pathbuf_from_stdout()?
-        } else {
-            PathBuf::from(filename)
-        };
+/// Whether the first filename should be interpreted as a timestamp.
+fn is_first_filename_timestamp(
+    reference: Option<&OsString>,
+    date: Option<&str>,
+    timestamp: Option<&str>,
+    files: &[&String],
+) -> bool {
+    if timestamp.is_none()
+        && reference.is_none()
+        && date.is_none()
+        && files.len() >= 2
+        // env check is last as the slowest op
+        && matches!(std::env::var("_POSIX2_VERSION").as_deref(), Ok("199209"))
+    {
+        let s = files[0];
+        all_digits(s) && (s.len() == 8 || (s.len() == 10 && (69..=99).contains(&get_year(s))))
+    } else {
+        false
+    }
+}
 
-        let path = pathbuf.as_path();
+/// Cycle the last two characters to the beginning of the string.
+///
+/// `s` must have length at least two.
+fn shr2(s: &str) -> String {
+    let n = s.len();
+    let (a, b) = s.split_at(n - 2);
+    let mut result = String::with_capacity(n);
+    result.push_str(b);
+    result.push_str(a);
+    result
+}
 
-        let metadata_result = if matches.get_flag(options::NO_DEREF) {
-            path.symlink_metadata()
-        } else {
-            path.metadata()
-        };
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
 
-        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())));
-            }
+    let mut filenames: Vec<&String> = matches
+        .get_many::<String>(ARG_FILES)
+        .ok_or_else(|| {
+            USimpleError::new(
+                1,
+                format!(
+                    "missing file operand\nTry '{} --help' for more information.",
+                    uucore::execution_phrase()
+                ),
+            )
+        })?
+        .collect();
 
-            if matches.get_flag(options::NO_CREATE) {
-                continue;
-            }
+    let no_deref = matches.get_flag(options::NO_DEREF);
 
-            if matches.get_flag(options::NO_DEREF) {
-                show!(USimpleError::new(
-                    1,
-                    format!(
-                        "setting times of {}: No such file or directory",
-                        filename.quote()
-                    )
-                ));
-                continue;
-            }
+    let reference = matches.get_one::<OsString>(options::sources::REFERENCE);
+    let date = matches
+        .get_one::<String>(options::sources::DATE)
+        .map(|date| date.to_owned());
 
-            if let Err(e) = File::create(path) {
-                show!(e.map_err_context(|| format!("cannot touch {}", path.quote())));
-                continue;
-            };
+    let mut timestamp = matches
+        .get_one::<String>(options::sources::TIMESTAMP)
+        .map(|t| t.to_owned());
 
-            // Minor optimization: if no reference time was specified, we're done.
-            if !matches.contains_id(options::SOURCES) {
-                continue;
-            }
-        }
+    if is_first_filename_timestamp(reference, date.as_deref(), timestamp.as_deref(), &filenames) {
+        timestamp = if filenames[0].len() == 10 {
+            Some(shr2(filenames[0]))
+        } else {
+            Some(filenames[0].to_string())
+        };
+        filenames = filenames[1..].to_vec();
+    }
 
-        // If changing "only" atime or mtime, grab the existing value of the other.
-        // Note that "-a" and "-m" may be passed together; this is not an xor.
-        if matches.get_flag(options::ACCESS)
-            || matches.get_flag(options::MODIFICATION)
-            || matches.contains_id(options::TIME)
-        {
-            let st = stat(path, !matches.get_flag(options::NO_DEREF))?;
-            let time = matches
-                .get_one::<String>(options::TIME)
-                .map(|s| s.as_str())
-                .unwrap_or("");
-
-            if !(matches.get_flag(options::ACCESS)
-                || time.contains(&"access".to_owned())
-                || time.contains(&"atime".to_owned())
-                || time.contains(&"use".to_owned()))
-            {
-                atime = st.0;
-            }
+    let source = if let Some(reference) = reference {
+        Source::Reference(PathBuf::from(reference))
+    } else if let Some(ts) = timestamp {
+        Source::Timestamp(parse_timestamp(&ts)?)
+    } else {
+        Source::Now
+    };
 
-            if !(matches.get_flag(options::MODIFICATION)
-                || time.contains(&"modify".to_owned())
-                || time.contains(&"mtime".to_owned()))
-            {
-                mtime = st.1;
+    let files: Vec<InputFile> = filenames
+        .into_iter()
+        .map(|filename| {
+            if filename == "-" {
+                InputFile::Stdout
+            } else {
+                InputFile::Path(PathBuf::from(filename))
             }
-        }
+        })
+        .collect();
+
+    let opts = Options {
+        no_create: matches.get_flag(options::NO_CREATE),
+        no_deref,
+        source,
+        date,
+        change_times: determine_atime_mtime_change(&matches),
+        strict: false,
+    };
 
-        // 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.
+    touch(&files, &opts)?;
 
-        // 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 {
-            set_file_times(path, atime, mtime)
-        }
-        .map_err_context(|| format!("setting times of {}", path.quote()))?;
-    }
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -296,13 +331,15 @@ pub fn uu_app() -> Command {
                      equivalent to -m",
                 )
                 .value_name("WORD")
-                .value_parser(["access", "atime", "use", "modify", "mtime"]),
+                .value_parser(ShortcutValueParser::new([
+                    PossibleValue::new("atime").alias("access").alias("use"),
+                    PossibleValue::new("mtime").alias("modify"),
+                ])),
         )
         .arg(
             Arg::new(ARG_FILES)
                 .action(ArgAction::Append)
                 .num_args(1..)
-                .value_parser(ValueParser::os_string())
                 .value_hint(clap::ValueHint::AnyPath),
         )
         .group(
@@ -316,24 +353,238 @@ pub fn uu_app() -> Command {
         )
 }
 
-// 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 = 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()),
+/// Execute the touch command.
+///
+/// # Errors
+///
+/// Possible causes:
+/// - The user doesn't have permission to access the file
+/// - One of the directory components of the file path doesn't exist.
+///
+/// It will return an `Err` on the first error. However, for any of the files,
+/// if all of the following are true, it will print the error and continue touching
+/// the rest of the files.
+/// - `opts.strict` is `false`
+/// - The file doesn't already exist
+/// - `-c`/`--no-create` was passed (`opts.no_create`)
+/// - Either `-h`/`--no-dereference` was passed (`opts.no_deref`) or the file couldn't be created
+pub fn touch(files: &[InputFile], opts: &Options) -> Result<(), TouchError> {
+    let (atime, mtime) = match &opts.source {
+        Source::Reference(reference) => {
+            let (atime, mtime) = stat(reference, !opts.no_deref)
+                .map_err(|e| TouchError::ReferenceFileInaccessible(reference.to_owned(), e))?;
+
+            (atime, mtime)
+        }
+        Source::Now => {
+            let now = datetime_to_filetime(&Local::now());
+            (now, now)
+        }
+        &Source::Timestamp(ts) => (ts, ts),
     };
 
+    let (atime, mtime) = if let Some(date) = &opts.date {
+        (
+            parse_date(
+                filetime_to_datetime(&atime).ok_or_else(|| TouchError::InvalidFiletime(atime))?,
+                date,
+            )?,
+            parse_date(
+                filetime_to_datetime(&mtime).ok_or_else(|| TouchError::InvalidFiletime(mtime))?,
+                date,
+            )?,
+        )
+    } else {
+        (atime, mtime)
+    };
+
+    for (ind, file) in files.iter().enumerate() {
+        let (path, is_stdout) = match file {
+            InputFile::Stdout => (Cow::Owned(pathbuf_from_stdout()?), true),
+            InputFile::Path(path) => (Cow::Borrowed(path), false),
+        };
+        touch_file(&path, is_stdout, opts, atime, mtime).map_err(|e| {
+            TouchError::TouchFileError {
+                path: path.into_owned(),
+                index: ind,
+                error: e,
+            }
+        })?;
+    }
+
+    Ok(())
+}
+
+/// Create or update the timestamp for a single file.
+///
+/// # Arguments
+///
+/// - `path` - The path to the file to create/update timestamp for
+/// - `is_stdout` - Stdout is handled specially, see [`update_times`] for more info
+/// - `atime` - Access time to set for the file
+/// - `mtime` - Modification time to set for the file
+fn touch_file(
+    path: &Path,
+    is_stdout: bool,
+    opts: &Options,
+    atime: FileTime,
+    mtime: FileTime,
+) -> UResult<()> {
+    let filename = if is_stdout {
+        String::from("-")
+    } else {
+        path.display().to_string()
+    };
+
+    let metadata_result = if opts.no_deref {
+        path.symlink_metadata()
+    } else {
+        path.metadata()
+    };
+
+    if let Err(e) = metadata_result {
+        if e.kind() != ErrorKind::NotFound {
+            return Err(e.map_err_context(|| format!("setting times of {}", filename.quote())));
+        }
+
+        if opts.no_create {
+            return Ok(());
+        }
+
+        if opts.no_deref {
+            let e = USimpleError::new(
+                1,
+                format!(
+                    "setting times of {}: No such file or directory",
+                    filename.quote()
+                ),
+            );
+            if opts.strict {
+                return Err(e);
+            }
+            show!(e);
+            return Ok(());
+        }
+
+        if let Err(e) = File::create(path) {
+            // we need to check if the path is the path to a directory (ends with a separator)
+            // we can't use File::create to create a directory
+            // we cannot use path.is_dir() because it calls fs::metadata which we already called
+            // when stable, we can change to use e.kind() == std::io::ErrorKind::IsADirectory
+            let is_directory = if let Some(last_char) = path.to_string_lossy().chars().last() {
+                last_char == std::path::MAIN_SEPARATOR
+            } else {
+                false
+            };
+            if is_directory {
+                let custom_err = Error::other("No such file or directory");
+                return Err(
+                    custom_err.map_err_context(|| format!("cannot touch {}", filename.quote()))
+                );
+            }
+            let e = e.map_err_context(|| format!("cannot touch {}", path.quote()));
+            if opts.strict {
+                return Err(e);
+            }
+            show!(e);
+            return Ok(());
+        };
+
+        // Minor optimization: if no reference time, timestamp, or date was specified, we're done.
+        if opts.source == Source::Now && opts.date.is_none() {
+            return Ok(());
+        }
+    }
+
+    update_times(path, is_stdout, opts, atime, mtime)
+}
+
+/// Returns which of the times (access, modification) are to be changed.
+///
+/// Note that "-a" and "-m" may be passed together; this is not an xor.
+/// - If `-a` is passed but not `-m`, only access time is changed
+/// - If `-m` is passed but not `-a`, only modification time is changed
+/// - If neither or both are passed, both times are changed
+fn determine_atime_mtime_change(matches: &ArgMatches) -> ChangeTimes {
+    // If `--time` is given, Some(true) if equivalent to `-a`, Some(false) if equivalent to `-m`
+    // If `--time` not given, None
+    let time_access_only = if matches.contains_id(options::TIME) {
+        matches
+            .get_one::<String>(options::TIME)
+            .map(|time| time.contains("access") || time.contains("atime") || time.contains("use"))
+    } else {
+        None
+    };
+
+    let atime_only = matches.get_flag(options::ACCESS) || time_access_only.unwrap_or_default();
+    let mtime_only = matches.get_flag(options::MODIFICATION) || !time_access_only.unwrap_or(true);
+
+    if atime_only && !mtime_only {
+        ChangeTimes::AtimeOnly
+    } else if mtime_only && !atime_only {
+        ChangeTimes::MtimeOnly
+    } else {
+        ChangeTimes::Both
+    }
+}
+
+/// Updating file access and modification times based on user-specified options
+///
+/// If the file is not stdout (`!is_stdout`) and `-h`/`--no-dereference` was
+/// passed, then, if the given file is a symlink, its own times will be updated,
+/// rather than the file it points to.
+fn update_times(
+    path: &Path,
+    is_stdout: bool,
+    opts: &Options,
+    atime: FileTime,
+    mtime: FileTime,
+) -> UResult<()> {
+    // If changing "only" atime or mtime, grab the existing value of the other.
+    let (atime, mtime) = match opts.change_times {
+        ChangeTimes::AtimeOnly => (
+            atime,
+            stat(path, !opts.no_deref)
+                .map_err_context(|| format!("failed to get attributes of {}", path.quote()))?
+                .1,
+        ),
+        ChangeTimes::MtimeOnly => (
+            stat(path, !opts.no_deref)
+                .map_err_context(|| format!("failed to get attributes of {}", path.quote()))?
+                .0,
+            mtime,
+        ),
+        ChangeTimes::Both => (atime, mtime),
+    };
+
+    // 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 opts.no_deref && !is_stdout {
+        set_symlink_file_times(path, atime, mtime)
+    } else {
+        set_file_times(path, atime, mtime)
+    }
+    .map_err_context(|| format!("setting times of {}", path.quote()))
+}
+
+/// 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) -> std::io::Result<(FileTime, FileTime)> {
+    let metadata = if follow {
+        fs::metadata(path).or_else(|_| fs::symlink_metadata(path))
+    } else {
+        fs::symlink_metadata(path)
+    }?;
+
     Ok((
         FileTime::from_last_access_time(&metadata),
         FileTime::from_last_modification_time(&metadata),
     ))
 }
 
-fn parse_date(s: &str) -> UResult<FileTime> {
+fn parse_date(ref_time: DateTime<Local>, s: &str) -> Result<FileTime, TouchError> {
     // This isn't actually compatible with GNU touch, but there doesn't seem to
     // be any simple specification for what format this parameter allows and I'm
     // not about to implement GNU parse_datetime.
@@ -348,8 +599,8 @@ fn parse_date(s: &str) -> UResult<FileTime> {
     // Tue Dec  3 ...
     // ("%c", POSIX_LOCALE_FORMAT),
     //
-    if let Ok(parsed) = Local.datetime_from_str(s, format::POSIX_LOCALE) {
-        return Ok(datetime_to_filetime(&parsed));
+    if let Ok(parsed) = NaiveDateTime::parse_from_str(s, format::POSIX_LOCALE) {
+        return Ok(datetime_to_filetime(&parsed.and_utc()));
     }
 
     // Also support other formats found in the GNU tests like
@@ -361,8 +612,8 @@ fn parse_date(s: &str) -> UResult<FileTime> {
         format::YYYY_MM_DD_HH_MM,
         format::YYYYMMDDHHMM_OFFSET,
     ] {
-        if let Ok(parsed) = Utc.datetime_from_str(s, fmt) {
-            return Ok(datetime_to_filetime(&parsed));
+        if let Ok(parsed) = NaiveDateTime::parse_from_str(s, fmt) {
+            return Ok(datetime_to_filetime(&parsed.and_utc()));
         }
     }
 
@@ -382,14 +633,37 @@ fn parse_date(s: &str) -> UResult<FileTime> {
         }
     }
 
-    if let Ok(duration) = parse_datetime::from_str(s) {
-        let dt = Local::now() + duration;
+    if let Ok(dt) = parse_datetime::parse_datetime_at_date(ref_time, s) {
         return Ok(datetime_to_filetime(&dt));
     }
 
-    Err(USimpleError::new(1, format!("Unable to parse date: {s}")))
+    Err(TouchError::InvalidDateFormat(s.to_owned()))
 }
 
+/// Prepends 19 or 20 to the year if it is a 2 digit year
+///
+/// GNU `touch` behavior:
+///
+/// - 68 and before is interpreted as 20xx
+/// - 69 and after is interpreted as 19xx
+fn prepend_century(s: &str) -> UResult<String> {
+    let first_two_digits = s[..2]
+        .parse::<u32>()
+        .map_err(|_| USimpleError::new(1, format!("invalid date ts format {}", s.quote())))?;
+    Ok(format!(
+        "{}{s}",
+        if first_two_digits > 68 { 19 } else { 20 }
+    ))
+}
+
+/// Parses a timestamp string into a FileTime.
+///
+/// This function attempts to parse a string into a FileTime
+/// As expected by gnu touch -t : `[[cc]yy]mmddhhmm[.ss]`
+///
+/// Note that  If the year is specified with only two digits,
+/// then cc is 20 for years in the range 0 … 68, and 19 for years in 69 … 99.
+/// in order to be compatible with GNU `touch`.
 fn parse_timestamp(s: &str) -> UResult<FileTime> {
     use format::*;
 
@@ -398,29 +672,34 @@ fn parse_timestamp(s: &str) -> UResult<FileTime> {
     let (format, ts) = match s.chars().count() {
         15 => (YYYYMMDDHHMM_DOT_SS, s.to_owned()),
         12 => (YYYYMMDDHHMM, s.to_owned()),
-        // If we don't add "20", we have insufficient information to parse
-        13 => (YYYYMMDDHHMM_DOT_SS, format!("20{}", s)),
-        10 => (YYYYMMDDHHMM, format!("20{}", s)),
-        11 => (YYYYMMDDHHMM_DOT_SS, format!("{}{}", current_year(), s)),
-        8 => (YYYYMMDDHHMM, format!("{}{}", current_year(), s)),
+        // If we don't add "19" or "20", we have insufficient information to parse
+        13 => (YYYYMMDDHHMM_DOT_SS, prepend_century(s)?),
+        10 => (YYYYMMDDHHMM, prepend_century(s)?),
+        11 => (YYYYMMDDHHMM_DOT_SS, format!("{}{s}", current_year())),
+        8 => (YYYYMMDDHHMM, format!("{}{s}", current_year())),
         _ => {
             return Err(USimpleError::new(
                 1,
                 format!("invalid date format {}", s.quote()),
-            ))
+            ));
         }
     };
 
-    let mut local = chrono::Local
-        .datetime_from_str(&ts, format)
+    let local = NaiveDateTime::parse_from_str(&ts, format)
         .map_err(|_| USimpleError::new(1, format!("invalid date ts format {}", ts.quote())))?;
+    let LocalResult::Single(mut local) = Local.from_local_datetime(&local) else {
+        return Err(USimpleError::new(
+            1,
+            format!("invalid date ts format {}", ts.quote()),
+        ));
+    };
 
     // Chrono caps seconds at 59, but 60 is valid. It might be a leap second
     // or wrap to the next minute. But that doesn't really matter, because we
     // only care about the timestamp anyway.
     // Tested in gnu/tests/touch/60-seconds
     if local.second() == 59 && ts.ends_with(".60") {
-        local += Duration::seconds(1);
+        local += Duration::try_seconds(1).unwrap();
     }
 
     // Due to daylight saving time switch, local time can jump from 1:59 AM to
@@ -428,7 +707,7 @@ fn parse_timestamp(s: &str) -> UResult<FileTime> {
     // valid. If we are within this jump, chrono takes the offset from before
     // the jump. If we then jump forward an hour, we get the new corrected
     // offset. Jumping back will then now correctly take the jump into account.
-    let local2 = local + Duration::hours(1) - Duration::hours(1);
+    let local2 = local + Duration::try_hours(1).unwrap() - Duration::try_hours(1).unwrap();
     if local.hour() != local2.hour() {
         return Err(USimpleError::new(
             1,
@@ -444,7 +723,7 @@ fn parse_timestamp(s: &str) -> UResult<FileTime> {
 ///
 /// On Windows, uses GetFinalPathNameByHandleW to attempt to get the path
 /// from the stdout handle.
-fn pathbuf_from_stdout() -> UResult<PathBuf> {
+fn pathbuf_from_stdout() -> Result<PathBuf, TouchError> {
     #[cfg(all(unix, not(target_os = "android")))]
     {
         Ok(PathBuf::from("/dev/stdout"))
@@ -457,11 +736,11 @@ fn pathbuf_from_stdout() -> UResult<PathBuf> {
     {
         use std::os::windows::prelude::AsRawHandle;
         use windows_sys::Win32::Foundation::{
-            GetLastError, ERROR_INVALID_PARAMETER, ERROR_NOT_ENOUGH_MEMORY, ERROR_PATH_NOT_FOUND,
+            ERROR_INVALID_PARAMETER, ERROR_NOT_ENOUGH_MEMORY, ERROR_PATH_NOT_FOUND, GetLastError,
             HANDLE, MAX_PATH,
         };
         use windows_sys::Win32::Storage::FileSystem::{
-            GetFinalPathNameByHandleW, FILE_NAME_OPENED,
+            FILE_NAME_OPENED, GetFinalPathNameByHandleW,
         };
 
         let handle = std::io::stdout().lock().as_raw_handle() as HANDLE;
@@ -486,41 +765,96 @@ fn pathbuf_from_stdout() -> UResult<PathBuf> {
 
         let buffer_size = match ret {
             ERROR_PATH_NOT_FOUND | ERROR_NOT_ENOUGH_MEMORY | ERROR_INVALID_PARAMETER => {
-                return Err(USimpleError::new(
-                    1,
-                    format!("GetFinalPathNameByHandleW failed with code {ret}"),
-                ))
+                return Err(TouchError::WindowsStdoutPathError(format!(
+                    "GetFinalPathNameByHandleW failed with code {ret}"
+                )));
             }
-            e if e == 0 => {
-                return Err(USimpleError::new(
-                    1,
-                    format!(
-                        "GetFinalPathNameByHandleW failed with code {}",
-                        // SAFETY: GetLastError is thread-safe and has no documented memory unsafety.
-                        unsafe { GetLastError() }
-                    ),
-                ));
+            0 => {
+                return Err(TouchError::WindowsStdoutPathError(format!(
+                    "GetFinalPathNameByHandleW failed with code {}",
+                    // SAFETY: GetLastError is thread-safe and has no documented memory unsafety.
+                    unsafe { GetLastError() },
+                )));
             }
             e => e as usize,
         };
 
         // Don't include the null terminator
         Ok(String::from_utf16(&file_path_buffer[0..buffer_size])
-            .map_err(|e| USimpleError::new(1, e.to_string()))?
+            .map_err(|e| TouchError::WindowsStdoutPathError(e.to_string()))?
             .into())
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use filetime::FileTime;
+
+    use crate::{
+        ChangeTimes, Options, Source, determine_atime_mtime_change, error::TouchError, touch,
+        uu_app,
+    };
+
     #[cfg(windows)]
     #[test]
     fn test_get_pathbuf_from_stdout_fails_if_stdout_is_not_a_file() {
         // We can trigger an error by not setting stdout to anything (will
         // fail with code 1)
-        assert!(super::pathbuf_from_stdout()
-            .expect_err("pathbuf_from_stdout should have failed")
-            .to_string()
-            .contains("GetFinalPathNameByHandleW failed with code 1"));
+        assert!(
+            super::pathbuf_from_stdout()
+                .expect_err("pathbuf_from_stdout should have failed")
+                .to_string()
+                .contains("GetFinalPathNameByHandleW failed with code 1")
+        );
+    }
+
+    #[test]
+    fn test_determine_atime_mtime_change() {
+        assert_eq!(
+            ChangeTimes::Both,
+            determine_atime_mtime_change(&uu_app().try_get_matches_from(vec!["touch"]).unwrap())
+        );
+        assert_eq!(
+            ChangeTimes::Both,
+            determine_atime_mtime_change(
+                &uu_app()
+                    .try_get_matches_from(vec!["touch", "-a", "-m", "--time", "modify"])
+                    .unwrap()
+            )
+        );
+        assert_eq!(
+            ChangeTimes::AtimeOnly,
+            determine_atime_mtime_change(
+                &uu_app()
+                    .try_get_matches_from(vec!["touch", "--time", "access"])
+                    .unwrap()
+            )
+        );
+        assert_eq!(
+            ChangeTimes::MtimeOnly,
+            determine_atime_mtime_change(
+                &uu_app().try_get_matches_from(vec!["touch", "-m"]).unwrap()
+            )
+        );
+    }
+
+    #[test]
+    fn test_invalid_filetime() {
+        let invalid_filetime = FileTime::from_unix_time(0, 1_111_111_111);
+        match touch(
+            &[],
+            &Options {
+                no_create: false,
+                no_deref: false,
+                source: Source::Timestamp(invalid_filetime),
+                date: Some("yesterday".to_owned()),
+                change_times: ChangeTimes::Both,
+                strict: false,
+            },
+        ) {
+            Err(TouchError::InvalidFiletime(filetime)) => assert_eq!(filetime, invalid_filetime),
+            Err(e) => panic!("Expected TouchError::InvalidFiletime, got {e}"),
+            Ok(_) => panic!("Expected to error with TouchError::InvalidFiletime but succeeded"),
+        };
     }
 }
diff --git a/src/uu/tr/Cargo.toml b/src/uu/tr/Cargo.toml
index 065fdab5274..a7253813567 100644
--- a/src/uu/tr/Cargo.toml
+++ b/src/uu/tr/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_tr"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "tr ~ (uutils) translate characters within input and display"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tr"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/tr.rs"
@@ -17,7 +20,7 @@ path = "src/tr.rs"
 [dependencies]
 nom = { workspace = true }
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
 name = "tr"
diff --git a/src/uu/tr/src/convert.rs b/src/uu/tr/src/convert.rs
deleted file mode 100644
index 28a80e9f52e..00000000000
--- a/src/uu/tr/src/convert.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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.
-
-// spell-checker:ignore (strings) anychar combinator
-
-use nom::{
-    branch::alt,
-    bytes::complete::tag,
-    character::complete::{anychar, one_of},
-    combinator::{map_opt, recognize},
-    multi::{many0, many_m_n},
-    sequence::preceded,
-    IResult,
-};
-
-fn parse_octal(input: &str) -> IResult<&str, char> {
-    map_opt(
-        preceded(tag("\\"), recognize(many_m_n(1, 3, one_of("01234567")))),
-        |out: &str| {
-            u32::from_str_radix(out, 8)
-                .map(std::char::from_u32)
-                .ok()
-                .flatten()
-        },
-    )(input)
-}
-
-pub fn reduce_octal_to_char(input: &str) -> String {
-    many0(alt((parse_octal, anychar)))(input)
-        .map(|(_, r)| r)
-        .unwrap()
-        .into_iter()
-        .collect()
-}
diff --git a/src/uu/tr/src/operation.rs b/src/uu/tr/src/operation.rs
index b7d74427a9e..8e24f8ce398 100644
--- a/src/uu/tr/src/operation.rs
+++ b/src/uu/tr/src/operation.rs
@@ -5,24 +5,26 @@
 
 // spell-checker:ignore (strings) anychar combinator Alnum Punct Xdigit alnum punct xdigit cntrl
 
+use crate::unicode_table;
 use nom::{
+    IResult, Parser,
     branch::alt,
-    bytes::complete::tag,
-    character::complete::{anychar, digit1},
-    combinator::{map, peek, value},
-    multi::many0,
-    sequence::{delimited, preceded, separated_pair},
-    IResult,
+    bytes::complete::{tag, take, take_till, take_until},
+    character::complete::one_of,
+    combinator::{map, map_opt, peek, recognize, value},
+    multi::{many_m_n, many0},
+    sequence::{delimited, preceded, separated_pair, terminated},
 };
 use std::{
+    char,
     collections::{HashMap, HashSet},
     error::Error,
     fmt::{Debug, Display},
     io::{BufRead, Write},
+    ops::Not,
 };
-use uucore::error::UError;
-
-use crate::unicode_table;
+use uucore::error::{FromIo, UError, UResult};
+use uucore::show_warning;
 
 #[derive(Debug, Clone)]
 pub enum BadSequence {
@@ -32,6 +34,12 @@ pub enum BadSequence {
     CharRepeatInSet1,
     InvalidRepeatCount(String),
     EmptySet2WhenNotTruncatingSet1,
+    ClassExceptLowerUpperInSet2,
+    ClassInSet2NotMatchedBySet1,
+    Set1LongerSet2EndsInClass,
+    ComplementMoreThanOneUniqueInSet2,
+    BackwardsRange { end: u32, start: u32 },
+    MultipleCharInEquivalence(String),
 }
 
 impl Display for BadSequence {
@@ -53,6 +61,51 @@ impl Display for BadSequence {
             Self::EmptySet2WhenNotTruncatingSet1 => {
                 write!(f, "when not truncating set1, string2 must be non-empty")
             }
+            Self::ClassExceptLowerUpperInSet2 => {
+                write!(
+                    f,
+                    "when translating, the only character classes that may appear in set2 are 'upper' and 'lower'"
+                )
+            }
+            Self::ClassInSet2NotMatchedBySet1 => {
+                write!(
+                    f,
+                    "when translating, every 'upper'/'lower' in set2 must be matched by a 'upper'/'lower' in the same position in set1"
+                )
+            }
+            Self::Set1LongerSet2EndsInClass => {
+                write!(
+                    f,
+                    "when translating with string1 longer than string2,\nthe latter string must not end with a character class"
+                )
+            }
+            Self::ComplementMoreThanOneUniqueInSet2 => {
+                write!(
+                    f,
+                    "when translating with complemented character classes,\nstring2 must map all characters in the domain to one"
+                )
+            }
+            Self::BackwardsRange { end, start } => {
+                fn end_or_start_to_string(ut: &u32) -> String {
+                    match char::from_u32(*ut) {
+                        Some(ch @ '\x20'..='\x7E') => ch.escape_default().to_string(),
+                        _ => {
+                            format!("\\{ut:03o}")
+                        }
+                    }
+                }
+
+                write!(
+                    f,
+                    "range-endpoints of '{}-{}' are in reverse collating sequence order",
+                    end_or_start_to_string(start),
+                    end_or_start_to_string(end)
+                )
+            }
+            Self::MultipleCharInEquivalence(s) => write!(
+                f,
+                "{s}: equivalence class operand must be a single character"
+            ),
         }
     }
 }
@@ -61,11 +114,7 @@ impl Error for BadSequence {}
 impl UError for BadSequence {}
 
 #[derive(Debug, Clone, Copy)]
-pub enum Sequence {
-    Char(char),
-    CharRange(u32, u32),
-    CharStar(char),
-    CharRepeat(char, usize),
+pub enum Class {
     Alnum,
     Alpha,
     Blank,
@@ -80,143 +129,182 @@ pub enum Sequence {
     Xdigit,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum Sequence {
+    Char(u8),
+    CharRange(u8, u8),
+    CharStar(u8),
+    CharRepeat(u8, usize),
+    Class(Class),
+}
+
 impl Sequence {
-    pub fn flatten(&self) -> Box<dyn Iterator<Item = char>> {
+    pub fn flatten(&self) -> Box<dyn Iterator<Item = u8>> {
         match self {
             Self::Char(c) => Box::new(std::iter::once(*c)),
-            Self::CharRange(l, r) => Box::new((*l..=*r).flat_map(std::char::from_u32)),
+            Self::CharRange(l, r) => Box::new(*l..=*r),
             Self::CharStar(c) => Box::new(std::iter::repeat(*c)),
-            Self::CharRepeat(c, n) => Box::new(std::iter::repeat(*c).take(*n)),
-            Self::Alnum => Box::new(('0'..='9').chain('A'..='Z').chain('a'..='z')),
-            Self::Alpha => Box::new(('A'..='Z').chain('a'..='z')),
-            Self::Blank => Box::new(unicode_table::BLANK.iter().cloned()),
-            Self::Control => Box::new(
-                (0..=31)
-                    .chain(std::iter::once(127))
-                    .flat_map(std::char::from_u32),
-            ),
-            Self::Digit => Box::new('0'..='9'),
-            Self::Graph => Box::new(
-                (48..=57) // digit
-                    .chain(65..=90) // uppercase
-                    .chain(97..=122) // lowercase
-                    // punctuations
-                    .chain(33..=47)
-                    .chain(58..=64)
-                    .chain(91..=96)
-                    .chain(123..=126)
-                    .chain(std::iter::once(32)) // space
-                    .flat_map(std::char::from_u32),
-            ),
-            Self::Lower => Box::new('a'..='z'),
-            Self::Print => Box::new(
-                (48..=57) // digit
-                    .chain(65..=90) // uppercase
-                    .chain(97..=122) // lowercase
-                    // punctuations
-                    .chain(33..=47)
-                    .chain(58..=64)
-                    .chain(91..=96)
-                    .chain(123..=126)
-                    .flat_map(std::char::from_u32),
-            ),
-            Self::Punct => Box::new(
-                (33..=47)
-                    .chain(58..=64)
-                    .chain(91..=96)
-                    .chain(123..=126)
-                    .flat_map(std::char::from_u32),
-            ),
-            Self::Space => Box::new(unicode_table::SPACES.iter().cloned()),
-            Self::Upper => Box::new('A'..='Z'),
-            Self::Xdigit => Box::new(('0'..='9').chain('A'..='F').chain('a'..='f')),
+            Self::CharRepeat(c, n) => Box::new(std::iter::repeat_n(*c, *n)),
+            Self::Class(class) => match class {
+                Class::Alnum => Box::new((b'0'..=b'9').chain(b'A'..=b'Z').chain(b'a'..=b'z')),
+                Class::Alpha => Box::new((b'A'..=b'Z').chain(b'a'..=b'z')),
+                Class::Blank => Box::new(unicode_table::BLANK.iter().copied()),
+                Class::Control => Box::new((0..=31).chain(std::iter::once(127))),
+                Class::Digit => Box::new(b'0'..=b'9'),
+                Class::Graph => Box::new(
+                    (48..=57) // digit
+                        .chain(65..=90) // uppercase
+                        .chain(97..=122) // lowercase
+                        // punctuations
+                        .chain(33..=47)
+                        .chain(58..=64)
+                        .chain(91..=96)
+                        .chain(123..=126)
+                        .chain(std::iter::once(32)), // space
+                ),
+                Class::Print => Box::new(
+                    (48..=57) // digit
+                        .chain(65..=90) // uppercase
+                        .chain(97..=122) // lowercase
+                        // punctuations
+                        .chain(33..=47)
+                        .chain(58..=64)
+                        .chain(91..=96)
+                        .chain(123..=126),
+                ),
+                Class::Punct => Box::new((33..=47).chain(58..=64).chain(91..=96).chain(123..=126)),
+                Class::Space => Box::new(unicode_table::SPACES.iter().copied()),
+                Class::Xdigit => Box::new((b'0'..=b'9').chain(b'A'..=b'F').chain(b'a'..=b'f')),
+                Class::Lower => Box::new(b'a'..=b'z'),
+                Class::Upper => Box::new(b'A'..=b'Z'),
+            },
         }
     }
 
     // Hide all the nasty sh*t in here
-    // TODO: Make the 2 set lazily generate the character mapping as necessary.
     pub fn solve_set_characters(
-        set1_str: &str,
-        set2_str: &str,
+        set1_str: &[u8],
+        set2_str: &[u8],
+        complement_flag: bool,
         truncate_set1_flag: bool,
-    ) -> Result<(Vec<char>, Vec<char>), BadSequence> {
+        translating: bool,
+    ) -> Result<(Vec<u8>, Vec<u8>), BadSequence> {
+        let is_char_star = |s: &&Self| -> bool { matches!(s, Self::CharStar(_)) };
+
         let set1 = Self::from_str(set1_str)?;
-        let set2 = Self::from_str(set2_str)?;
+        if set1.iter().filter(is_char_star).count() != 0 {
+            return Err(BadSequence::CharRepeatInSet1);
+        }
 
-        let is_char_star = |s: &&Self| -> bool { matches!(s, Self::CharStar(_)) };
-        let set1_star_count = set1.iter().filter(is_char_star).count();
-        if set1_star_count == 0 {
-            let set2_star_count = set2.iter().filter(is_char_star).count();
-            if set2_star_count < 2 {
-                let char_star = set2.iter().find_map(|s| match s {
-                    Self::CharStar(c) => Some(c),
-                    _ => None,
-                });
-                let mut partition = set2.as_slice().split(|s| matches!(s, Self::CharStar(_)));
-                let set1_len = set1.iter().flat_map(Self::flatten).count();
-                let set2_len = set2
-                    .iter()
-                    .filter_map(|s| match s {
-                        Self::CharStar(_) => None,
-                        r => Some(r),
-                    })
-                    .flat_map(Self::flatten)
-                    .count();
-                let star_compensate_len = set1_len.saturating_sub(set2_len);
-                let (left, right) = (partition.next(), partition.next());
-                let set2_solved: Vec<char> = match (left, right) {
-                    (None, None) => match char_star {
-                        Some(c) => std::iter::repeat(*c).take(star_compensate_len).collect(),
-                        None => std::iter::empty().collect(),
-                    },
-                    (None, Some(set2_b)) => {
-                        if let Some(c) = char_star {
-                            std::iter::repeat(*c)
-                                .take(star_compensate_len)
-                                .chain(set2_b.iter().flat_map(Self::flatten))
-                                .collect()
-                        } else {
-                            set2_b.iter().flat_map(Self::flatten).collect()
+        let mut set2 = Self::from_str(set2_str)?;
+        if set2.iter().filter(is_char_star).count() > 1 {
+            return Err(BadSequence::MultipleCharRepeatInSet2);
+        }
+
+        if translating
+            && set2.iter().any(|&x| {
+                matches!(x, Self::Class(_))
+                    && !matches!(x, Self::Class(Class::Upper | Class::Lower))
+            })
+        {
+            return Err(BadSequence::ClassExceptLowerUpperInSet2);
+        }
+
+        let mut set1_solved: Vec<u8> = set1.iter().flat_map(Self::flatten).collect();
+        if complement_flag {
+            set1_solved = (0..=u8::MAX).filter(|x| !set1_solved.contains(x)).collect();
+        }
+        let set1_len = set1_solved.len();
+
+        let set2_len = set2
+            .iter()
+            .filter_map(|s| match s {
+                Self::CharStar(_) => None,
+                r => Some(r),
+            })
+            .flat_map(Self::flatten)
+            .count();
+
+        let star_compensate_len = set1_len.saturating_sub(set2_len);
+        //Replace CharStar with CharRepeat
+        set2 = set2
+            .iter()
+            .filter_map(|s| match s {
+                Self::CharStar(0) => None,
+                Self::CharStar(c) => Some(Self::CharRepeat(*c, star_compensate_len)),
+                r => Some(*r),
+            })
+            .collect();
+
+        // For every upper/lower in set2, there must be an upper/lower in set1 at the same position. The position is calculated by expanding everything before the upper/lower in both sets
+        for (set2_pos, set2_item) in set2.iter().enumerate() {
+            if matches!(set2_item, Self::Class(_)) {
+                let mut set2_part_solved_len = 0;
+                if set2_pos >= 1 {
+                    set2_part_solved_len =
+                        set2.iter().take(set2_pos).flat_map(Self::flatten).count();
+                }
+
+                let mut class_matches = false;
+                for (set1_pos, set1_item) in set1.iter().enumerate() {
+                    if matches!(set1_item, Self::Class(_)) {
+                        let mut set1_part_solved_len = 0;
+                        if set1_pos >= 1 {
+                            set1_part_solved_len =
+                                set1.iter().take(set1_pos).flat_map(Self::flatten).count();
+                        }
+
+                        if set1_part_solved_len == set2_part_solved_len {
+                            class_matches = true;
+                            break;
                         }
                     }
-                    (Some(set2_a), None) => match char_star {
-                        Some(c) => set2_a
-                            .iter()
-                            .flat_map(Self::flatten)
-                            .chain(std::iter::repeat(*c).take(star_compensate_len))
-                            .collect(),
-                        None => set2_a.iter().flat_map(Self::flatten).collect(),
-                    },
-                    (Some(set2_a), Some(set2_b)) => match char_star {
-                        Some(c) => set2_a
-                            .iter()
-                            .flat_map(Self::flatten)
-                            .chain(std::iter::repeat(*c).take(star_compensate_len))
-                            .chain(set2_b.iter().flat_map(Self::flatten))
-                            .collect(),
-                        None => set2_a
-                            .iter()
-                            .chain(set2_b.iter())
-                            .flat_map(Self::flatten)
-                            .collect(),
-                    },
-                };
-                let mut set1_solved: Vec<char> = set1.iter().flat_map(Self::flatten).collect();
-                if truncate_set1_flag {
-                    set1_solved.truncate(set2_solved.len());
                 }
-                Ok((set1_solved, set2_solved))
-            } else {
-                Err(BadSequence::MultipleCharRepeatInSet2)
+
+                if !class_matches {
+                    return Err(BadSequence::ClassInSet2NotMatchedBySet1);
+                }
             }
-        } else {
-            Err(BadSequence::CharRepeatInSet1)
         }
+
+        let set2_solved: Vec<_> = set2.iter().flat_map(Self::flatten).collect();
+
+        // Calculate the set of unique characters in set2
+        let mut set2_uniques = set2_solved.clone();
+        set2_uniques.sort_unstable();
+        set2_uniques.dedup();
+
+        // If the complement flag is used in translate mode, only one unique
+        // character may appear in set2. Validate this with the set of uniques
+        // in set2 that we just generated.
+        // Also, set2 must not overgrow set1, otherwise the mapping can't be 1:1.
+        if set1.iter().any(|x| matches!(x, Self::Class(_)))
+            && translating
+            && complement_flag
+            && (set2_uniques.len() > 1 || set2_solved.len() > set1_len)
+        {
+            return Err(BadSequence::ComplementMoreThanOneUniqueInSet2);
+        }
+
+        if set2_solved.len() < set1_solved.len()
+            && !truncate_set1_flag
+            && matches!(
+                set2.last().copied(),
+                Some(Self::Class(Class::Upper | Class::Lower))
+            )
+        {
+            return Err(BadSequence::Set1LongerSet2EndsInClass);
+        }
+        //Truncation is done dead last. It has no influence on the other conversion steps
+        if truncate_set1_flag {
+            set1_solved.truncate(set2_solved.len());
+        }
+        Ok((set1_solved, set2_solved))
     }
 }
 
 impl Sequence {
-    pub fn from_str(input: &str) -> Result<Vec<Self>, BadSequence> {
+    pub fn from_str(input: &[u8]) -> Result<Vec<Self>, BadSequence> {
         many0(alt((
             Self::parse_char_range,
             Self::parse_char_star,
@@ -224,176 +312,283 @@ impl Sequence {
             Self::parse_class,
             Self::parse_char_equal,
             // NOTE: This must be the last one
-            map(Self::parse_backslash_or_char, |s| Ok(Self::Char(s))),
-        )))(input)
+            map(Self::parse_backslash_or_char_with_warning, |s| {
+                Ok(Self::Char(s))
+            }),
+        )))
+        .parse(input)
         .map(|(_, r)| r)
         .unwrap()
         .into_iter()
         .collect::<Result<Vec<_>, _>>()
     }
 
-    fn parse_backslash(input: &str) -> IResult<&str, char> {
-        preceded(tag("\\"), anychar)(input).map(|(l, a)| {
-            let c = match a {
-                'a' => unicode_table::BEL,
-                'b' => unicode_table::BS,
-                'f' => unicode_table::FF,
-                'n' => unicode_table::LF,
-                'r' => unicode_table::CR,
-                't' => unicode_table::HT,
-                'v' => unicode_table::VT,
-                x => x,
-            };
-            (l, c)
-        })
+    fn parse_octal(input: &[u8]) -> IResult<&[u8], u8> {
+        // For `parse_char_range`, `parse_char_star`, `parse_char_repeat`, `parse_char_equal`.
+        // Because in these patterns, there's no ambiguous cases.
+        preceded(tag("\\"), Self::parse_octal_up_to_three_digits).parse(input)
     }
 
-    fn parse_backslash_or_char(input: &str) -> IResult<&str, char> {
-        alt((Self::parse_backslash, anychar))(input)
+    fn parse_octal_with_warning(input: &[u8]) -> IResult<&[u8], u8> {
+        preceded(
+            tag("\\"),
+            alt((
+                Self::parse_octal_up_to_three_digits_with_warning,
+                // Fallback for if the three digit octal escape is greater than \377 (0xFF), and therefore can't be
+                // parsed as as a byte
+                // See test `test_multibyte_octal_sequence`
+                Self::parse_octal_two_digits,
+            )),
+        )
+        .parse(input)
+    }
+
+    fn parse_octal_up_to_three_digits(input: &[u8]) -> IResult<&[u8], u8> {
+        map_opt(
+            recognize(many_m_n(1, 3, one_of("01234567"))),
+            |out: &[u8]| {
+                let str_to_parse = std::str::from_utf8(out).unwrap();
+                u8::from_str_radix(str_to_parse, 8).ok()
+            },
+        )
+        .parse(input)
     }
 
-    fn parse_char_range(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_octal_up_to_three_digits_with_warning(input: &[u8]) -> IResult<&[u8], u8> {
+        map_opt(
+            recognize(many_m_n(1, 3, one_of("01234567"))),
+            |out: &[u8]| {
+                let str_to_parse = std::str::from_utf8(out).unwrap();
+                let result = u8::from_str_radix(str_to_parse, 8).ok();
+                if result.is_none() {
+                    let origin_octal: &str = std::str::from_utf8(input).unwrap();
+                    let actual_octal_tail: &str = std::str::from_utf8(&input[0..2]).unwrap();
+                    let outstand_char: char = char::from_u32(input[2] as u32).unwrap();
+                    show_warning!("the ambiguous octal escape \\{origin_octal} is being\n        interpreted as the 2-byte sequence \\0{actual_octal_tail}, {outstand_char}");
+                }
+                result
+            },
+        ).parse(input)
+    }
+
+    fn parse_octal_two_digits(input: &[u8]) -> IResult<&[u8], u8> {
+        map_opt(
+            recognize(many_m_n(2, 2, one_of("01234567"))),
+            |out: &[u8]| u8::from_str_radix(std::str::from_utf8(out).unwrap(), 8).ok(),
+        )
+        .parse(input)
+    }
+
+    fn parse_backslash(input: &[u8]) -> IResult<&[u8], u8> {
+        preceded(tag("\\"), Self::single_char)
+            .parse(input)
+            .map(|(l, a)| {
+                let c = match a {
+                    b'a' => unicode_table::BEL,
+                    b'b' => unicode_table::BS,
+                    b'f' => unicode_table::FF,
+                    b'n' => unicode_table::LF,
+                    b'r' => unicode_table::CR,
+                    b't' => unicode_table::HT,
+                    b'v' => unicode_table::VT,
+                    x => x,
+                };
+                (l, c)
+            })
+    }
+
+    fn parse_backslash_or_char(input: &[u8]) -> IResult<&[u8], u8> {
+        alt((Self::parse_octal, Self::parse_backslash, Self::single_char)).parse(input)
+    }
+
+    fn parse_backslash_or_char_with_warning(input: &[u8]) -> IResult<&[u8], u8> {
+        alt((
+            Self::parse_octal_with_warning,
+            Self::parse_backslash,
+            Self::single_char,
+        ))
+        .parse(input)
+    }
+
+    fn single_char(input: &[u8]) -> IResult<&[u8], u8> {
+        take(1usize)(input).map(|(l, a)| (l, a[0]))
+    }
+
+    fn parse_char_range(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         separated_pair(
             Self::parse_backslash_or_char,
             tag("-"),
             Self::parse_backslash_or_char,
-        )(input)
+        )
+        .parse(input)
         .map(|(l, (a, b))| {
             (l, {
                 let (start, end) = (u32::from(a), u32::from(b));
-                Ok(Self::CharRange(start, end))
+
+                let range = start..=end;
+
+                if range.is_empty() {
+                    Err(BadSequence::BackwardsRange { end, start })
+                } else {
+                    Ok(Self::CharRange(start as u8, end as u8))
+                }
             })
         })
     }
 
-    fn parse_char_star(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
-        delimited(tag("["), Self::parse_backslash_or_char, tag("*]"))(input)
+    fn parse_char_star(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
+        delimited(tag("["), Self::parse_backslash_or_char, tag("*]"))
+            .parse(input)
             .map(|(l, a)| (l, Ok(Self::CharStar(a))))
     }
 
-    fn parse_char_repeat(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_char_repeat(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         delimited(
             tag("["),
-            separated_pair(Self::parse_backslash_or_char, tag("*"), digit1),
+            separated_pair(
+                Self::parse_backslash_or_char,
+                tag("*"),
+                // TODO
+                // Why are the opening and closing tags not sufficient?
+                // Backslash check is a workaround for `check_against_gnu_tr_tests_repeat_bs_9`
+                take_till(|ue| matches!(ue, b']' | b'\\')),
+            ),
             tag("]"),
-        )(input)
+        )
+        .parse(input)
         .map(|(l, (c, cnt_str))| {
-            let result = if cnt_str.starts_with('0') {
-                match usize::from_str_radix(cnt_str, 8) {
+            let s = String::from_utf8_lossy(cnt_str);
+            let result = if cnt_str.starts_with(b"0") {
+                match usize::from_str_radix(&s, 8) {
                     Ok(0) => Ok(Self::CharStar(c)),
                     Ok(count) => Ok(Self::CharRepeat(c, count)),
-                    Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+                    Err(_) => Err(BadSequence::InvalidRepeatCount(s.to_string())),
                 }
             } else {
-                match cnt_str.parse::<usize>() {
+                match s.parse::<usize>() {
                     Ok(0) => Ok(Self::CharStar(c)),
                     Ok(count) => Ok(Self::CharRepeat(c, count)),
-                    Err(_) => Err(BadSequence::InvalidRepeatCount(cnt_str.to_string())),
+                    Err(_) => Err(BadSequence::InvalidRepeatCount(s.to_string())),
                 }
             };
             (l, result)
         })
     }
 
-    fn parse_class(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
+    fn parse_class(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
         delimited(
             tag("[:"),
             alt((
                 map(
                     alt((
-                        value(Self::Alnum, tag("alnum")),
-                        value(Self::Alpha, tag("alpha")),
-                        value(Self::Blank, tag("blank")),
-                        value(Self::Control, tag("cntrl")),
-                        value(Self::Digit, tag("digit")),
-                        value(Self::Graph, tag("graph")),
-                        value(Self::Lower, tag("lower")),
-                        value(Self::Print, tag("print")),
-                        value(Self::Punct, tag("punct")),
-                        value(Self::Space, tag("space")),
-                        value(Self::Upper, tag("upper")),
-                        value(Self::Xdigit, tag("xdigit")),
+                        value(Self::Class(Class::Alnum), tag("alnum")),
+                        value(Self::Class(Class::Alpha), tag("alpha")),
+                        value(Self::Class(Class::Blank), tag("blank")),
+                        value(Self::Class(Class::Control), tag("cntrl")),
+                        value(Self::Class(Class::Digit), tag("digit")),
+                        value(Self::Class(Class::Graph), tag("graph")),
+                        value(Self::Class(Class::Lower), tag("lower")),
+                        value(Self::Class(Class::Print), tag("print")),
+                        value(Self::Class(Class::Punct), tag("punct")),
+                        value(Self::Class(Class::Space), tag("space")),
+                        value(Self::Class(Class::Upper), tag("upper")),
+                        value(Self::Class(Class::Xdigit), tag("xdigit")),
                     )),
                     Ok,
                 ),
                 value(Err(BadSequence::MissingCharClassName), tag("")),
             )),
             tag(":]"),
-        )(input)
+        )
+        .parse(input)
     }
 
-    fn parse_char_equal(input: &str) -> IResult<&str, Result<Self, BadSequence>> {
-        delimited(
+    fn parse_char_equal(input: &[u8]) -> IResult<&[u8], Result<Self, BadSequence>> {
+        preceded(
             tag("[="),
-            alt((
-                value(
-                    Err(BadSequence::MissingEquivalentClassChar),
-                    peek(tag("=]")),
-                ),
-                map(Self::parse_backslash_or_char, |c| Ok(Self::Char(c))),
-            )),
-            tag("=]"),
-        )(input)
+            (
+                alt((
+                    value(Err(()), peek(tag("=]"))),
+                    map(Self::parse_backslash_or_char, Ok),
+                )),
+                map(terminated(take_until("=]"), tag("=]")), |v: &[u8]| {
+                    if v.is_empty() { Ok(()) } else { Err(v) }
+                }),
+            ),
+        )
+        .parse(input)
+        .map(|(l, (a, b))| {
+            (
+                l,
+                match (a, b) {
+                    (Err(()), _) => Err(BadSequence::MissingEquivalentClassChar),
+                    (Ok(c), Ok(())) => Ok(Self::Char(c)),
+                    (Ok(c), Err(v)) => Err(BadSequence::MultipleCharInEquivalence(format!(
+                        "{}{}",
+                        String::from_utf8_lossy(&[c]).into_owned(),
+                        String::from_utf8_lossy(v).into_owned()
+                    ))),
+                },
+            )
+        })
     }
 }
 
 pub trait SymbolTranslator {
-    fn translate(&mut self, current: char) -> Option<char>;
+    fn translate(&mut self, current: u8) -> Option<u8>;
+
+    /// Takes two SymbolTranslators and creates a new SymbolTranslator over both in sequence.
+    ///
+    /// This behaves pretty much identical to [`Iterator::chain`].
+    fn chain<T>(self, other: T) -> ChainedSymbolTranslator<Self, T>
+    where
+        Self: Sized,
+    {
+        ChainedSymbolTranslator::<Self, T> {
+            stage_a: self,
+            stage_b: other,
+        }
+    }
 }
 
-#[derive(Debug)]
-pub struct DeleteOperation {
-    set: Vec<char>,
-    complement_flag: bool,
+pub struct ChainedSymbolTranslator<A, B> {
+    stage_a: A,
+    stage_b: B,
 }
 
-impl DeleteOperation {
-    pub fn new(set: Vec<char>, complement_flag: bool) -> Self {
-        Self {
-            set,
-            complement_flag,
-        }
+impl<A: SymbolTranslator, B: SymbolTranslator> SymbolTranslator for ChainedSymbolTranslator<A, B> {
+    fn translate(&mut self, current: u8) -> Option<u8> {
+        self.stage_a
+            .translate(current)
+            .and_then(|c| self.stage_b.translate(c))
     }
 }
 
-impl SymbolTranslator for DeleteOperation {
-    fn translate(&mut self, current: char) -> Option<char> {
-        let found = self.set.iter().any(|sequence| sequence.eq(&current));
-        if self.complement_flag == found {
-            Some(current)
-        } else {
-            None
-        }
-    }
+#[derive(Debug)]
+pub struct DeleteOperation {
+    set: Vec<u8>,
 }
 
-pub struct TranslateOperationComplement {
-    iter: u32,
-    set2_iter: usize,
-    set1: Vec<char>,
-    set2: Vec<char>,
-    translation_map: HashMap<char, char>,
+impl DeleteOperation {
+    pub fn new(set: Vec<u8>) -> Self {
+        Self { set }
+    }
 }
 
-impl TranslateOperationComplement {
-    fn new(set1: Vec<char>, set2: Vec<char>) -> Self {
-        Self {
-            iter: 0,
-            set2_iter: 0,
-            set1,
-            set2,
-            translation_map: HashMap::new(),
-        }
+impl SymbolTranslator for DeleteOperation {
+    fn translate(&mut self, current: u8) -> Option<u8> {
+        // keep if not present in the set
+        self.set.contains(&current).not().then_some(current)
     }
 }
 
 #[derive(Debug)]
-pub struct TranslateOperationStandard {
-    translation_map: HashMap<char, char>,
+pub struct TranslateOperation {
+    translation_map: HashMap<u8, u8>,
 }
 
-impl TranslateOperationStandard {
-    fn new(set1: Vec<char>, set2: Vec<char>) -> Result<Self, BadSequence> {
+impl TranslateOperation {
+    pub fn new(set1: Vec<u8>, set2: Vec<u8>) -> Result<Self, BadSequence> {
         if let Some(fallback) = set2.last().copied() {
             Ok(Self {
                 translation_map: set1
@@ -411,143 +606,71 @@ impl TranslateOperationStandard {
     }
 }
 
-pub enum TranslateOperation {
-    Standard(TranslateOperationStandard),
-    Complement(TranslateOperationComplement),
-}
-
-impl TranslateOperation {
-    fn next_complement_char(iter: u32, ignore_list: &[char]) -> (u32, char) {
-        (iter..)
-            .filter_map(std::char::from_u32)
-            .filter(|c| !ignore_list.iter().any(|s| s.eq(c)))
-            .map(|c| (u32::from(c) + 1, c))
-            .next()
-            .expect("exhausted all possible characters")
-    }
-}
-
-impl TranslateOperation {
-    pub fn new(set1: Vec<char>, set2: Vec<char>, complement: bool) -> Result<Self, BadSequence> {
-        if complement {
-            Ok(Self::Complement(TranslateOperationComplement::new(
-                set1, set2,
-            )))
-        } else {
-            Ok(Self::Standard(TranslateOperationStandard::new(set1, set2)?))
-        }
-    }
-}
-
 impl SymbolTranslator for TranslateOperation {
-    fn translate(&mut self, current: char) -> Option<char> {
-        match self {
-            Self::Standard(TranslateOperationStandard { translation_map }) => Some(
-                translation_map
-                    .iter()
-                    .find_map(|(l, r)| if l.eq(&current) { Some(*r) } else { None })
-                    .unwrap_or(current),
-            ),
-            Self::Complement(TranslateOperationComplement {
-                iter,
-                set2_iter,
-                set1,
-                set2,
-                translation_map,
-            }) => {
-                // First, try to see if current char is already mapped
-                // If so, return the mapped char
-                // Else, pop from set2
-                // If we popped something, map the next complement character to this value
-                // If set2 is empty, we just map the current char directly to fallback --- to avoid looping unnecessarily
-                if let Some(c) = set1.iter().find(|c| c.eq(&&current)) {
-                    Some(*c)
-                } else {
-                    while translation_map.get(&current).is_none() {
-                        if let Some(value) = set2.get(*set2_iter) {
-                            let (next_iter, next_key) = Self::next_complement_char(*iter, &*set1);
-                            *iter = next_iter;
-                            *set2_iter = set2_iter.saturating_add(1);
-                            translation_map.insert(next_key, *value);
-                        } else {
-                            translation_map.insert(current, *set2.last().unwrap());
-                        }
-                    }
-                    Some(*translation_map.get(&current).unwrap())
-                }
-            }
-        }
+    fn translate(&mut self, current: u8) -> Option<u8> {
+        Some(
+            self.translation_map
+                .get(&current)
+                .copied()
+                .unwrap_or(current),
+        )
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct SqueezeOperation {
-    set1: HashSet<char>,
-    complement: bool,
-    previous: Option<char>,
+    set1: HashSet<u8>,
+    previous: Option<u8>,
 }
 
 impl SqueezeOperation {
-    pub fn new(set1: Vec<char>, complement: bool) -> Self {
+    pub fn new(set1: Vec<u8>) -> Self {
         Self {
             set1: set1.into_iter().collect(),
-            complement,
             previous: None,
         }
     }
 }
 
 impl SymbolTranslator for SqueezeOperation {
-    fn translate(&mut self, current: char) -> Option<char> {
-        if self.complement {
-            let next = if self.set1.contains(&current) {
-                Some(current)
-            } else {
-                match self.previous {
-                    Some(v) => {
-                        if v.eq(&current) {
-                            None
-                        } else {
-                            Some(current)
-                        }
-                    }
-                    None => Some(current),
-                }
-            };
-            self.previous = Some(current);
-            next
+    fn translate(&mut self, current: u8) -> Option<u8> {
+        let next = if self.set1.contains(&current) {
+            match self.previous {
+                Some(v) if v == current => None,
+                _ => Some(current),
+            }
         } else {
-            let next = if self.set1.contains(&current) {
-                match self.previous {
-                    Some(v) if v == current => None,
-                    _ => Some(current),
-                }
-            } else {
-                Some(current)
-            };
-            self.previous = Some(current);
-            next
-        }
+            Some(current)
+        };
+        self.previous = Some(current);
+        next
     }
 }
 
-pub fn translate_input<T, R, W>(input: &mut R, output: &mut W, mut translator: T)
+pub fn translate_input<T, R, W>(input: &mut R, output: &mut W, mut translator: T) -> UResult<()>
 where
     T: SymbolTranslator,
     R: BufRead,
     W: Write,
 {
-    let mut buf = String::new();
-    let mut output_buf = String::new();
-    while let Ok(length) = input.read_line(&mut buf) {
+    let mut buf = Vec::new();
+    let mut output_buf = Vec::new();
+
+    while let Ok(length) = input.read_until(b'\n', &mut buf) {
         if length == 0 {
-            break;
-        } else {
-            let filtered = buf.chars().filter_map(|c| translator.translate(c));
-            output_buf.extend(filtered);
-            output.write_all(output_buf.as_bytes()).unwrap();
+            break; // EOF reached
         }
+
+        let filtered = buf.iter().filter_map(|&c| translator.translate(c));
+        output_buf.extend(filtered);
+
+        output
+            .write_all(&output_buf)
+            .map_err_context(|| "write error".into())?;
+
         buf.clear();
         output_buf.clear();
     }
+
+    Ok(())
 }
diff --git a/src/uu/tr/src/tr.rs b/src/uu/tr/src/tr.rs
index 9c6e7a7da58..10a636fd7b6 100644
--- a/src/uu/tr/src/tr.rs
+++ b/src/uu/tr/src/tr.rs
@@ -5,19 +5,20 @@
 
 // spell-checker:ignore (ToDO) allocs bset dflag cflag sflag tflag
 
-mod convert;
 mod operation;
 mod unicode_table;
 
-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, help_about, help_section, help_usage, show};
-
 use crate::operation::DeleteOperation;
+use clap::{Arg, ArgAction, Command, value_parser};
+use operation::{
+    Sequence, SqueezeOperation, SymbolTranslator, TranslateOperation, translate_input,
+};
+use std::ffi::OsString;
+use std::io::{BufWriter, Write, stdin, stdout};
 use uucore::display::Quotable;
-use uucore::error::{UResult, USimpleError, UUsageError};
+use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::fs::is_stdin_directory;
+use uucore::{format_usage, help_about, help_section, help_usage, os_str_as_bytes, show};
 
 const ABOUT: &str = help_about!("tr.md");
 const AFTER_HELP: &str = help_section!("after help", "tr.md");
@@ -33,8 +34,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
 
     let delete_flag = matches.get_flag(options::DELETE);
@@ -42,14 +41,15 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let squeeze_flag = matches.get_flag(options::SQUEEZE);
     let truncate_set1_flag = matches.get_flag(options::TRUNCATE_SET1);
 
-    let sets = matches
-        .get_many::<String>(options::SETS)
-        .map(|v| {
-            v.map(ToString::to_string)
-                .map(|input| convert::reduce_octal_to_char(&input))
-                .collect::<Vec<_>>()
-        })
-        .unwrap_or_default();
+    // Ultimately this should be OsString, but we might want to wait for the
+    // pattern API on OsStr
+    let sets: Vec<_> = matches
+        .get_many::<OsString>(options::SETS)
+        .into_iter()
+        .flatten()
+        .map(ToOwned::to_owned)
+        .collect();
+
     let sets_len = sets.len();
 
     if sets.is_empty() {
@@ -59,12 +59,48 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     if !(delete_flag || squeeze_flag) && sets_len < 2 {
         return Err(UUsageError::new(
             1,
-            format!("missing operand after {}", sets[0].quote()),
+            format!(
+                "missing operand after {}\nTwo strings must be given when translating.",
+                sets[0].quote()
+            ),
+        ));
+    }
+
+    if delete_flag & squeeze_flag && sets_len < 2 {
+        return Err(UUsageError::new(
+            1,
+            format!(
+                "missing operand after {}\nTwo strings must be given when deleting and squeezing.",
+                sets[0].quote()
+            ),
         ));
     }
 
-    if let Some(first) = sets.get(0) {
-        if first.ends_with('\\') {
+    if sets_len > 1 {
+        let start = "extra operand";
+        if delete_flag && !squeeze_flag {
+            let op = sets[1].quote();
+            let msg = if sets_len == 2 {
+                format!(
+                    "{start} {op}\nOnly one string may be given when deleting without squeezing repeats.",
+                )
+            } else {
+                format!("{start} {op}")
+            };
+            return Err(UUsageError::new(1, msg));
+        }
+        if sets_len > 2 {
+            let op = sets[2].quote();
+            let msg = format!("{start} {op}");
+            return Err(UUsageError::new(1, msg));
+        }
+    }
+
+    if let Some(first) = sets.first() {
+        let slice = os_str_as_bytes(first)?;
+        let trailing_backslashes = slice.iter().rev().take_while(|&&c| c == b'\\').count();
+        if trailing_backslashes % 2 == 1 {
+            // The trailing backslash has a non-backslash character before it.
             show!(USimpleError::new(
                 0,
                 "warning: an unescaped backslash at end of string is not portable"
@@ -74,78 +110,80 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let stdin = stdin();
     let mut locked_stdin = stdin.lock();
-    let stdout = stdout();
-    let locked_stdout = stdout.lock();
-    let mut buffered_stdout = BufWriter::new(locked_stdout);
+    let mut buffered_stdout = BufWriter::new(stdout().lock());
 
-    let mut sets_iter = sets.iter().map(|c| c.as_str());
+    // According to the man page: translating only happens if deleting or if a second set is given
+    let translating = !delete_flag && sets.len() > 1;
+    let mut sets_iter = sets.iter().map(|c| c.as_os_str());
     let (set1, set2) = Sequence::solve_set_characters(
-        sets_iter.next().unwrap_or_default(),
-        sets_iter.next().unwrap_or_default(),
-        truncate_set1_flag,
+        os_str_as_bytes(sets_iter.next().unwrap_or_default())?,
+        os_str_as_bytes(sets_iter.next().unwrap_or_default())?,
+        complement_flag,
+        // if we are not translating then we don't truncate set1
+        truncate_set1_flag && translating,
+        translating,
     )?;
 
+    if is_stdin_directory(&stdin) {
+        return Err(USimpleError::new(1, "read error: Is a directory"));
+    }
+
+    // '*_op' are the operations that need to be applied, in order.
     if delete_flag {
         if squeeze_flag {
-            let mut delete_buffer = vec![];
-            {
-                let mut delete_writer = BufWriter::new(&mut delete_buffer);
-                let delete_op = DeleteOperation::new(set1, complement_flag);
-                translate_input(&mut locked_stdin, &mut delete_writer, delete_op);
-            }
-            {
-                let mut squeeze_reader = BufReader::new(delete_buffer.as_bytes());
-                let op = SqueezeOperation::new(set2, complement_flag);
-                translate_input(&mut squeeze_reader, &mut buffered_stdout, op);
-            }
+            let delete_op = DeleteOperation::new(set1);
+            let squeeze_op = SqueezeOperation::new(set2);
+            let op = delete_op.chain(squeeze_op);
+            translate_input(&mut locked_stdin, &mut buffered_stdout, op)?;
         } else {
-            let op = DeleteOperation::new(set1, complement_flag);
-            translate_input(&mut locked_stdin, &mut buffered_stdout, op);
+            let op = DeleteOperation::new(set1);
+            translate_input(&mut locked_stdin, &mut buffered_stdout, op)?;
         }
     } else if squeeze_flag {
         if sets_len < 2 {
-            let op = SqueezeOperation::new(set1, complement_flag);
-            translate_input(&mut locked_stdin, &mut buffered_stdout, op);
+            let op = SqueezeOperation::new(set1);
+            translate_input(&mut locked_stdin, &mut buffered_stdout, op)?;
         } else {
-            let mut translate_buffer = vec![];
-            {
-                let mut writer = BufWriter::new(&mut translate_buffer);
-                let op = TranslateOperation::new(set1, set2.clone(), complement_flag)?;
-                translate_input(&mut locked_stdin, &mut writer, op);
-            }
-            {
-                let mut reader = BufReader::new(translate_buffer.as_bytes());
-                let squeeze_op = SqueezeOperation::new(set2, false);
-                translate_input(&mut reader, &mut buffered_stdout, squeeze_op);
-            }
+            let translate_op = TranslateOperation::new(set1, set2.clone())?;
+            let squeeze_op = SqueezeOperation::new(set2);
+            let op = translate_op.chain(squeeze_op);
+            translate_input(&mut locked_stdin, &mut buffered_stdout, op)?;
         }
     } else {
-        let op = TranslateOperation::new(set1, set2, complement_flag)?;
-        translate_input(&mut locked_stdin, &mut buffered_stdout, op);
+        let op = TranslateOperation::new(set1, set2)?;
+        translate_input(&mut locked_stdin, &mut buffered_stdout, op)?;
     }
+
+    buffered_stdout
+        .flush()
+        .map_err_context(|| "write error".into())?;
+
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .trailing_var_arg(true)
         .arg(
             Arg::new(options::COMPLEMENT)
                 .visible_short_alias('C')
                 .short('c')
                 .long(options::COMPLEMENT)
                 .help("use the complement of SET1")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::COMPLEMENT),
         )
         .arg(
             Arg::new(options::DELETE)
                 .short('d')
                 .long(options::DELETE)
                 .help("delete characters in SET1, do not translate")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::DELETE),
         )
         .arg(
             Arg::new(options::SQUEEZE)
@@ -156,14 +194,20 @@ pub fn uu_app() -> Command {
                      listed in the last specified SET, with a single occurrence \
                      of that character",
                 )
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::SQUEEZE),
         )
         .arg(
             Arg::new(options::TRUNCATE_SET1)
                 .long(options::TRUNCATE_SET1)
                 .short('t')
                 .help("first truncate SET1 to length of SET2")
-                .action(ArgAction::SetTrue),
+                .action(ArgAction::SetTrue)
+                .overrides_with(options::TRUNCATE_SET1),
+        )
+        .arg(
+            Arg::new(options::SETS)
+                .num_args(1..)
+                .value_parser(value_parser!(OsString)),
         )
-        .arg(Arg::new(options::SETS).num_args(1..=2))
 }
diff --git a/src/uu/tr/src/unicode_table.rs b/src/uu/tr/src/unicode_table.rs
index a00a30b8bee..06687c3926e 100644
--- a/src/uu/tr/src/unicode_table.rs
+++ b/src/uu/tr/src/unicode_table.rs
@@ -3,13 +3,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-pub static BEL: char = '\u{0007}';
-pub static BS: char = '\u{0008}';
-pub static HT: char = '\u{0009}';
-pub static LF: char = '\u{000A}';
-pub static VT: char = '\u{000B}';
-pub static FF: char = '\u{000C}';
-pub static CR: char = '\u{000D}';
-pub static SPACE: char = '\u{0020}';
-pub static SPACES: &[char] = &[HT, LF, VT, FF, CR, SPACE];
-pub static BLANK: &[char] = &[SPACE, HT];
+pub static BEL: u8 = 0x7;
+pub static BS: u8 = 0x8;
+pub static HT: u8 = 0x9;
+pub static LF: u8 = 0xA;
+pub static VT: u8 = 0xB;
+pub static FF: u8 = 0xC;
+pub static CR: u8 = 0xD;
+pub static SPACE: u8 = 0x20;
+pub static SPACES: &[u8] = &[HT, LF, VT, FF, CR, SPACE];
+pub static BLANK: &[u8] = &[HT, SPACE];
diff --git a/src/uu/true/Cargo.toml b/src/uu/true/Cargo.toml
index 432dfa54e91..41925a20812 100644
--- a/src/uu/true/Cargo.toml
+++ b/src/uu/true/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_true"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "true ~ (uutils) do nothing and succeed"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/true"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/true.rs"
diff --git a/src/uu/true/src/true.rs b/src/uu/true/src/true.rs
index 637758625d3..29dae0ba61c 100644
--- a/src/uu/true/src/true.rs
+++ b/src/uu/true/src/true.rs
@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 use clap::{Arg, ArgAction, Command};
 use std::{ffi::OsString, io::Write};
-use uucore::error::{set_exit_code, UResult};
+use uucore::error::{UResult, set_exit_code};
 use uucore::help_about;
 
 const ABOUT: &str = help_about!("true.md");
@@ -22,14 +22,14 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         let error = match e.kind() {
             clap::error::ErrorKind::DisplayHelp => command.print_help(),
             clap::error::ErrorKind::DisplayVersion => {
-                writeln!(std::io::stdout(), "{}", command.render_version())
+                write!(std::io::stdout(), "{}", command.render_version())
             }
             _ => Ok(()),
         };
 
         if let Err(print_fail) = error {
             // Try to display this error.
-            let _ = writeln!(std::io::stderr(), "{}: {}", uucore::util_name(), print_fail);
+            let _ = writeln!(std::io::stderr(), "{}: {print_fail}", uucore::util_name());
             // Mirror GNU options. When failing to print warnings or version flags, then we exit
             // with FAIL. This avoids allocation some error information which may result in yet
             // other types of failure.
@@ -42,7 +42,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(clap::crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         // We provide our own help and version options, to ensure maximum compatibility with GNU.
         .disable_help_flag(true)
diff --git a/src/uu/truncate/Cargo.toml b/src/uu/truncate/Cargo.toml
index fbabe1fcd4f..3d651f20250 100644
--- a/src/uu/truncate/Cargo.toml
+++ b/src/uu/truncate/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_truncate"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "truncate ~ (uutils) truncate (or extend) FILE to SIZE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/truncate"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/truncate.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 
 [[bin]]
 name = "truncate"
diff --git a/src/uu/truncate/src/truncate.rs b/src/uu/truncate/src/truncate.rs
index 3b1e9bd0910..056163fa3ad 100644
--- a/src/uu/truncate/src/truncate.rs
+++ b/src/uu/truncate/src/truncate.rs
@@ -4,15 +4,15 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) RFILE refsize rfilename fsize tsize
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::fs::{metadata, OpenOptions};
+use clap::{Arg, ArgAction, Command};
+use std::fs::{OpenOptions, metadata};
 use std::io::ErrorKind;
 #[cfg(unix)]
 use std::os::unix::fs::FileTypeExt;
 use std::path::Path;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
-use uucore::parse_size::{parse_size, ParseSizeError};
+use uucore::parser::parse_size::{ParseSizeError, parse_size_u64};
 use uucore::{format_usage, help_about, help_section, help_usage};
 
 #[derive(Debug, Eq, PartialEq)]
@@ -102,7 +102,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .unwrap_or_default();
 
     if files.is_empty() {
-        return Err(UUsageError::new(1, "missing file operand"));
+        Err(UUsageError::new(1, "missing file operand"))
     } else {
         let io_blocks = matches.get_flag(options::IO_BLOCKS);
         let no_create = matches.get_flag(options::NO_CREATE);
@@ -116,7 +116,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -178,10 +178,26 @@ pub fn uu_app() -> Command {
 ///
 /// If the file could not be opened, or there was a problem setting the
 /// size of the file.
-fn file_truncate(filename: &str, create: bool, size: u64) -> std::io::Result<()> {
+fn file_truncate(filename: &str, create: bool, size: u64) -> UResult<()> {
+    #[cfg(unix)]
+    if let Ok(metadata) = metadata(filename) {
+        if metadata.file_type().is_fifo() {
+            return Err(USimpleError::new(
+                1,
+                format!(
+                    "cannot open {} for writing: No such device or address",
+                    filename.quote()
+                ),
+            ));
+        }
+    }
     let path = Path::new(filename);
-    let f = OpenOptions::new().write(true).create(create).open(path)?;
-    f.set_len(size)
+    match OpenOptions::new().write(true).create(create).open(path) {
+        Ok(file) => file.set_len(size),
+        Err(e) if e.kind() == ErrorKind::NotFound && !create => Ok(()),
+        Err(e) => Err(e),
+    }
+    .map_err_context(|| format!("cannot open {} for writing", filename.quote()))
 }
 
 /// Truncate files to a size relative to a given file.
@@ -213,7 +229,7 @@ fn truncate_reference_and_size(
             return Err(USimpleError::new(
                 1,
                 String::from("you must specify a relative '--size' with '--reference'"),
-            ))
+            ));
         }
         Ok(m) => m,
     };
@@ -233,19 +249,7 @@ fn truncate_reference_and_size(
     let fsize = metadata.len();
     let tsize = mode.to_size(fsize);
     for filename in filenames {
-        #[cfg(unix)]
-        if std::fs::metadata(filename)?.file_type().is_fifo() {
-            return Err(USimpleError::new(
-                1,
-                format!(
-                    "cannot open {} for writing: No such device or address",
-                    filename.quote()
-                ),
-            ));
-        }
-
-        file_truncate(filename, create, tsize)
-            .map_err_context(|| format!("cannot open {} for writing", filename.quote()))?;
+        file_truncate(filename, create, tsize)?;
     }
     Ok(())
 }
@@ -280,18 +284,7 @@ fn truncate_reference_file_only(
     })?;
     let tsize = metadata.len();
     for filename in filenames {
-        #[cfg(unix)]
-        if std::fs::metadata(filename)?.file_type().is_fifo() {
-            return Err(USimpleError::new(
-                1,
-                format!(
-                    "cannot open {} for writing: No such device or address",
-                    filename.quote()
-                ),
-            ));
-        }
-        file_truncate(filename, create, tsize)
-            .map_err_context(|| format!("cannot open {} for writing", filename.quote()))?;
+        file_truncate(filename, create, tsize)?;
     }
     Ok(())
 }
@@ -337,15 +330,8 @@ fn truncate_size_only(size_string: &str, filenames: &[String], create: bool) ->
             Err(_) => 0,
         };
         let tsize = mode.to_size(fsize);
-        match file_truncate(filename, create, tsize) {
-            Ok(_) => continue,
-            Err(e) if e.kind() == ErrorKind::NotFound && !create => continue,
-            Err(e) => {
-                return Err(
-                    e.map_err_context(|| format!("cannot open {} for writing", filename.quote()))
-                )
-            }
-        }
+        // TODO: Fix duplicate call to stat
+        file_truncate(filename, create, tsize)?;
     }
     Ok(())
 }
@@ -380,7 +366,7 @@ fn is_modifier(c: char) -> bool {
 
 /// Parse a size string with optional modifier symbol as its first character.
 ///
-/// A size string is as described in [`parse_size`]. The first character
+/// A size string is as described in [`parse_size_u64`]. The first character
 /// of `size_string` might be a modifier symbol, like `'+'` or
 /// `'<'`. The first element of the pair returned by this function
 /// indicates which modifier symbol was present, or
@@ -406,7 +392,7 @@ fn parse_mode_and_size(size_string: &str) -> Result<TruncateMode, ParseSizeError
         if is_modifier(c) {
             size_string = &size_string[1..];
         }
-        parse_size(size_string).map(match c {
+        parse_size_u64(size_string).map(match c {
             '+' => TruncateMode::Extend,
             '-' => TruncateMode::Reduce,
             '<' => TruncateMode::AtMost,
@@ -422,8 +408,8 @@ fn parse_mode_and_size(size_string: &str) -> Result<TruncateMode, ParseSizeError
 
 #[cfg(test)]
 mod tests {
-    use crate::parse_mode_and_size;
     use crate::TruncateMode;
+    use crate::parse_mode_and_size;
 
     #[test]
     fn test_parse_mode_and_size() {
diff --git a/src/uu/tsort/BENCHMARKING.md b/src/uu/tsort/BENCHMARKING.md
new file mode 100644
index 00000000000..52b9dfc57ef
--- /dev/null
+++ b/src/uu/tsort/BENCHMARKING.md
@@ -0,0 +1,64 @@
+# Benchmarking `tsort`
+<!-- spell-checker:ignore (words) randint tsort DAG uu_tsort GNU  -->
+Much of what makes `tsort` fast is the efficiency of its algorithm and implementation for topological sorting. 
+Our implementation of `tsort` also outputs a cycle whenever such ordering does not exist, just like GNU  `tsort`. 
+
+## Strategies
+
+To test `tsort`'s performance for its nominal use case, we need to test it with a DAG. One of the worst cases is when all nodes are just representing a succession of independent steps. 
+We should also test cycle detection for good measure. 
+
+### Random acyclic graph (DAG)
+
+This will output a DAG composed of 1 million pairs of edges between nodes numbered from 0 to 10,000, ensuring that the graph is acyclic by always assigning the edge with the smallest id to the node with the highest one.
+
+```python
+import random
+
+N = 10000
+
+for i in range(100*N):
+    a = random.randint(0, N)
+    b = random.randint(0, N)
+    print(f"{min(a, b)} {max(a, b)}")
+```
+
+### Random graph with cycles
+
+The following will output a graph with multiples edges, it also allows some degree of tuning to test different cases. 
+
+```python
+import random
+
+# Parameters for the graph
+num_nodes = 100  
+num_edges = 150  
+cycle_percentage = 0.10  
+max_cycle_size = 6  
+
+num_cycles = int(num_edges * cycle_percentage)
+
+for _ in range(num_edges - num_cycles):
+    a = random.randint(0, num_nodes)
+    b = random.randint(0, num_nodes)
+    print(f"{a} {b}")
+
+
+for _ in range(num_cycles):
+    cycle_size = random.randint(3, max_cycle_size)
+    cycle_nodes = random.sample(range(num_nodes), cycle_size)
+    for i in range(cycle_size):
+        print(f"{cycle_nodes[i]} {cycle_nodes[(i + 1) % cycle_size]}")
+```
+
+## Running Benchmarks
+The above scripts will output the generated graphs to the standard output. They can therefore be used directly as tests. In order to run a Benchmark, the output should be redirected to a file. 
+Use [`hyperfine`](https://github.com/sharkdp/hyperfine) to compare the performance of different `tsort` versions. For example, you can compare the performance of GNU `tsort` and another implementation with the following command:
+
+```sh
+hyperfine 'tsort random_graph.txt' 'uu_tsort random_graph.txt'
+```
+
+## Note
+
+Benchmark results from the above scripts are fuzzy and change from run to run unless a seed is set.
diff --git a/src/uu/tsort/Cargo.toml b/src/uu/tsort/Cargo.toml
index 2f276f98eea..a94591db8df 100644
--- a/src/uu/tsort/Cargo.toml
+++ b/src/uu/tsort/Cargo.toml
@@ -1,21 +1,25 @@
 [package]
 name = "uu_tsort"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "tsort ~ (uutils) topologically sort input (partially ordered) pairs"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tsort"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/tsort.rs"
 
 [dependencies]
 clap = { workspace = true }
+thiserror = { workspace = true }
 uucore = { workspace = true }
 
 [[bin]]
diff --git a/src/uu/tsort/src/tsort.rs b/src/uu/tsort/src/tsort.rs
index e71710847ea..3f7e89e99ef 100644
--- a/src/uu/tsort/src/tsort.rs
+++ b/src/uu/tsort/src/tsort.rs
@@ -2,14 +2,14 @@
 //
 // 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::{BTreeMap, BTreeSet};
-use std::fs::File;
-use std::io::{stdin, BufRead, BufReader, Read};
+//spell-checker:ignore TAOCP indegree
+use clap::{Arg, Command};
+use std::collections::{HashMap, HashSet, VecDeque};
 use std::path::Path;
+use thiserror::Error;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError};
-use uucore::{format_usage, help_about, help_usage};
+use uucore::error::{UError, UResult};
+use uucore::{format_usage, help_about, help_usage, show};
 
 const ABOUT: &str = help_about!("tsort.md");
 const USAGE: &str = help_usage!("tsort.md");
@@ -18,73 +18,64 @@ mod options {
     pub const FILE: &str = "file";
 }
 
+#[derive(Debug, Error)]
+enum TsortError {
+    /// The input file is actually a directory.
+    #[error("{0}: read error: Is a directory")]
+    IsDir(String),
+
+    /// The number of tokens in the input data is odd.
+    ///
+    /// The list of edges must be even because each edge has two
+    /// components: a source node and a target node.
+    #[error("{input}: input contains an odd number of tokens", input = .0.maybe_quote())]
+    NumTokensOdd(String),
+
+    /// The graph contains a cycle.
+    #[error("{0}: input contains a loop:")]
+    Loop(String),
+
+    /// A particular node in a cycle. (This is mainly used for printing.)
+    #[error("{0}")]
+    LoopNode(String),
+}
+
+impl UError for TsortError {}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_lossy();
-
     let matches = uu_app().try_get_matches_from(args)?;
 
     let input = matches
         .get_one::<String>(options::FILE)
         .expect("Value is required by clap");
 
-    let mut stdin_buf;
-    let mut file_buf;
-    let mut reader = BufReader::new(if input == "-" {
-        stdin_buf = stdin();
-        &mut stdin_buf as &mut dyn Read
+    let data = if input == "-" {
+        let stdin = std::io::stdin();
+        std::io::read_to_string(stdin)?
     } else {
-        file_buf = File::open(Path::new(&input)).map_err_context(|| input.to_string())?;
-        &mut file_buf as &mut dyn Read
-    });
-
-    let mut g = Graph::new();
-    loop {
-        let mut line = String::new();
-        match reader.read_line(&mut line) {
-            Ok(_) => {
-                let tokens: Vec<String> = line.split_whitespace().map(|s| s.to_owned()).collect();
-                if tokens.is_empty() {
-                    break;
-                }
-                for ab in tokens.chunks(2) {
-                    match ab.len() {
-                        2 => g.add_edge(&ab[0], &ab[1]),
-                        _ => {
-                            return Err(USimpleError::new(
-                                1,
-                                format!(
-                                    "{}: input contains an odd number of tokens",
-                                    input.maybe_quote()
-                                ),
-                            ))
-                        }
-                    }
-                }
-            }
-            _ => break,
+        let path = Path::new(&input);
+        if path.is_dir() {
+            return Err(TsortError::IsDir(input.to_string()).into());
         }
-    }
-
-    g.run_tsort();
-
-    if !g.is_acyclic() {
-        return Err(USimpleError::new(
-            1,
-            format!("{input}, input contains a loop:"),
-        ));
-    }
+        std::fs::read_to_string(path)?
+    };
 
-    for x in &g.result {
-        println!("{x}");
+    // Create the directed graph from pairs of tokens in the input data.
+    let mut g = Graph::new(input.clone());
+    for ab in data.split_whitespace().collect::<Vec<&str>>().chunks(2) {
+        match ab {
+            [a, b] => g.add_edge(a, b),
+            _ => return Err(TsortError::NumTokensOdd(input.to_string()).into()),
+        }
     }
 
+    g.run_tsort();
     Ok(())
 }
-
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
@@ -96,79 +87,190 @@ pub fn uu_app() -> Command {
         )
 }
 
+/// Find the element `x` in `vec` and remove it, returning its index.
+fn remove<T>(vec: &mut Vec<T>, x: T) -> Option<usize>
+where
+    T: PartialEq,
+{
+    vec.iter().position(|item| *item == x).inspect(|i| {
+        vec.remove(*i);
+    })
+}
+
 // We use String as a representation of node here
 // but using integer may improve performance.
 #[derive(Default)]
-struct Graph {
-    in_edges: BTreeMap<String, BTreeSet<String>>,
-    out_edges: BTreeMap<String, Vec<String>>,
-    result: Vec<String>,
+struct Node<'input> {
+    successor_names: Vec<&'input str>,
+    predecessor_count: usize,
 }
 
-impl Graph {
-    fn new() -> Self {
-        Self::default()
+impl<'input> Node<'input> {
+    fn add_successor(&mut self, successor_name: &'input str) {
+        self.successor_names.push(successor_name);
     }
+}
+
+struct Graph<'input> {
+    name: String,
+    nodes: HashMap<&'input str, Node<'input>>,
+}
 
-    fn has_node(&self, n: &str) -> bool {
-        self.in_edges.contains_key(n)
+impl<'input> Graph<'input> {
+    fn new(name: String) -> Graph<'input> {
+        Self {
+            name,
+            nodes: HashMap::default(),
+        }
     }
 
-    fn has_edge(&self, from: &str, to: &str) -> bool {
-        self.in_edges[to].contains(from)
+    fn add_node(&mut self, name: &'input str) {
+        self.nodes.entry(name).or_default();
     }
 
-    fn init_node(&mut self, n: &str) {
-        self.in_edges.insert(n.to_string(), BTreeSet::new());
-        self.out_edges.insert(n.to_string(), vec![]);
+    fn add_edge(&mut self, from: &'input str, to: &'input str) {
+        self.add_node(from);
+        if from != to {
+            self.add_node(to);
+
+            let from_node = self.nodes.get_mut(from).unwrap();
+            from_node.add_successor(to);
+
+            let to_node = self.nodes.get_mut(to).unwrap();
+            to_node.predecessor_count += 1;
+        }
+    }
+
+    fn remove_edge(&mut self, u: &'input str, v: &'input str) {
+        remove(&mut self.nodes.get_mut(u).unwrap().successor_names, v);
+        self.nodes.get_mut(v).unwrap().predecessor_count -= 1;
     }
 
-    fn add_edge(&mut self, from: &str, to: &str) {
-        if !self.has_node(to) {
-            self.init_node(to);
+    /// Implementation of algorithm T from TAOCP (Don. Knuth), vol. 1.
+    fn run_tsort(&mut self) {
+        // First, we find a node that have no prerequisites (independent nodes)
+        // If no such node exists, then there is a cycle.
+        let mut independent_nodes_queue: VecDeque<&'input str> = self
+            .nodes
+            .iter()
+            .filter_map(|(&name, node)| {
+                if node.predecessor_count == 0 {
+                    Some(name)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        // To make sure the resulting ordering is deterministic we
+        // need to order independent nodes.
+        //
+        // FIXME: this doesn't comply entirely with the GNU coreutils
+        // implementation.
+        independent_nodes_queue.make_contiguous().sort_unstable();
+
+        while !self.nodes.is_empty() {
+            // Get the next node (breaking any cycles necessary to do so).
+            let v = self.find_next_node(&mut independent_nodes_queue);
+            println!("{v}");
+            if let Some(node_to_process) = self.nodes.remove(v) {
+                for successor_name in node_to_process.successor_names {
+                    let successor_node = self.nodes.get_mut(successor_name).unwrap();
+                    successor_node.predecessor_count -= 1;
+                    if successor_node.predecessor_count == 0 {
+                        // if we find nodes without any other prerequisites, we add them to the queue.
+                        independent_nodes_queue.push_back(successor_name);
+                    }
+                }
+            }
         }
+    }
 
-        if !self.has_node(from) {
-            self.init_node(from);
+    /// Get the in-degree of the node with the given name.
+    fn indegree(&self, name: &str) -> Option<usize> {
+        self.nodes.get(name).map(|data| data.predecessor_count)
+    }
+
+    // Pre-condition: self.nodes is non-empty.
+    fn find_next_node(&mut self, frontier: &mut VecDeque<&'input str>) -> &'input str {
+        // If there are no nodes of in-degree zero but there are still
+        // un-visited nodes in the graph, then there must be a cycle.
+        // We need to find the cycle, display it, and then break the
+        // cycle.
+        //
+        // A cycle is guaranteed to be of length at least two. We break
+        // the cycle by deleting an arbitrary edge (the first). That is
+        // not necessarily the optimal thing, but it should be enough to
+        // continue making progress in the graph traversal.
+        //
+        // It is possible that deleting the edge does not actually
+        // result in the target node having in-degree zero, so we repeat
+        // the process until such a node appears.
+        loop {
+            match frontier.pop_front() {
+                None => self.find_and_break_cycle(frontier),
+                Some(v) => return v,
+            }
         }
+    }
 
-        if from != to && !self.has_edge(from, to) {
-            self.in_edges.get_mut(to).unwrap().insert(from.to_string());
-            self.out_edges.get_mut(from).unwrap().push(to.to_string());
+    fn find_and_break_cycle(&mut self, frontier: &mut VecDeque<&'input str>) {
+        let cycle = self.detect_cycle();
+        show!(TsortError::Loop(self.name.clone()));
+        for node in &cycle {
+            show!(TsortError::LoopNode(node.to_string()));
+        }
+        let u = cycle[0];
+        let v = cycle[1];
+        self.remove_edge(u, v);
+        if self.indegree(v).unwrap() == 0 {
+            frontier.push_back(v);
         }
     }
 
-    // Kahn's algorithm
-    // O(|V|+|E|)
-    fn run_tsort(&mut self) {
-        let mut start_nodes = vec![];
-        for (n, edges) in &self.in_edges {
-            if edges.is_empty() {
-                start_nodes.push(n.clone());
-            }
+    fn detect_cycle(&self) -> Vec<&'input str> {
+        // Sort the nodes just to make this function deterministic.
+        let mut nodes = Vec::new();
+        for node in self.nodes.keys() {
+            nodes.push(node);
         }
+        nodes.sort_unstable();
 
-        while !start_nodes.is_empty() {
-            let n = start_nodes.remove(0);
+        let mut visited = HashSet::new();
+        let mut stack = Vec::with_capacity(self.nodes.len());
+        for node in nodes {
+            if !visited.contains(node) && self.dfs(node, &mut visited, &mut stack) {
+                return stack;
+            }
+        }
+        unreachable!();
+    }
 
-            self.result.push(n.clone());
+    fn dfs(
+        &self,
+        node: &'input str,
+        visited: &mut HashSet<&'input str>,
+        stack: &mut Vec<&'input str>,
+    ) -> bool {
+        if stack.contains(&node) {
+            return true;
+        }
+        if visited.contains(&node) {
+            return false;
+        }
 
-            let n_out_edges = self.out_edges.get_mut(&n).unwrap();
-            #[allow(clippy::explicit_iter_loop)]
-            for m in n_out_edges.iter() {
-                let m_in_edges = self.in_edges.get_mut(m).unwrap();
-                m_in_edges.remove(&n);
+        visited.insert(node);
+        stack.push(node);
 
-                // If m doesn't have other in-coming edges add it to start_nodes
-                if m_in_edges.is_empty() {
-                    start_nodes.push(m.clone());
+        if let Some(successor_names) = self.nodes.get(node).map(|n| &n.successor_names) {
+            for &successor in successor_names {
+                if self.dfs(successor, visited, stack) {
+                    return true;
                 }
             }
-            n_out_edges.clear();
         }
-    }
 
-    fn is_acyclic(&self) -> bool {
-        self.out_edges.values().all(|edge| edge.is_empty())
+        stack.pop();
+        false
     }
 }
diff --git a/src/uu/tty/Cargo.toml b/src/uu/tty/Cargo.toml
index fde233250ac..0f0c09f5ab2 100644
--- a/src/uu/tty/Cargo.toml
+++ b/src/uu/tty/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_tty"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "tty ~ (uutils) display the name of the terminal connected to standard input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/tty"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/tty.rs"
@@ -17,7 +20,6 @@ path = "src/tty.rs"
 [dependencies]
 clap = { workspace = true }
 nix = { workspace = true, features = ["term"] }
-is-terminal = { workspace = true }
 uucore = { workspace = true, features = ["fs"] }
 
 [[bin]]
diff --git a/src/uu/tty/src/tty.rs b/src/uu/tty/src/tty.rs
index 96d851d3738..35dc1f08678 100644
--- a/src/uu/tty/src/tty.rs
+++ b/src/uu/tty/src/tty.rs
@@ -7,11 +7,9 @@
 
 // spell-checker:ignore (ToDO) ttyname filedesc
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use is_terminal::IsTerminal;
-use std::io::Write;
-use std::os::unix::io::AsRawFd;
-use uucore::error::{set_exit_code, UResult};
+use clap::{Arg, ArgAction, Command};
+use std::io::{IsTerminal, Write};
+use uucore::error::{UResult, set_exit_code};
 use uucore::{format_usage, help_about, help_usage};
 
 const ABOUT: &str = help_about!("tty.md");
@@ -38,8 +36,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let mut stdout = std::io::stdout();
 
-    // Get the ttyname via nix
-    let name = nix::unistd::ttyname(std::io::stdin().as_raw_fd());
+    let name = nix::unistd::ttyname(std::io::stdin());
 
     let write_result = match name {
         Ok(name) => writeln!(stdout, "{}", name.display()),
@@ -60,7 +57,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/uname/Cargo.toml b/src/uu/uname/Cargo.toml
index ccb3651ec63..0bf8c0ffe99 100644
--- a/src/uu/uname/Cargo.toml
+++ b/src/uu/uname/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_uname"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "uname ~ (uutils) display system information"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/uname"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/uname.rs"
diff --git a/src/uu/uname/src/uname.rs b/src/uu/uname/src/uname.rs
index 73ab07a6341..2e2b5f42fd2 100644
--- a/src/uu/uname/src/uname.rs
+++ b/src/uu/uname/src/uname.rs
@@ -3,11 +3,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// last synced with: uname (GNU coreutils) 8.21
-
 // spell-checker:ignore (API) nodename osname sysname (options) mnrsv mnrsvo
 
-use clap::{crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command};
 use platform_info::*;
 use uucore::{
     error::{UResult, USimpleError},
@@ -29,86 +27,125 @@ pub mod options {
     pub static OS: &str = "operating-system";
 }
 
-#[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().try_get_matches_from(args)?;
-
-    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);
-    let kernel_name = matches.get_flag(options::KERNEL_NAME);
-    let nodename = matches.get_flag(options::NODENAME);
-    let kernel_release = matches.get_flag(options::KERNEL_RELEASE);
-    let kernel_version = matches.get_flag(options::KERNEL_VERSION);
-    let machine = matches.get_flag(options::MACHINE);
-    let processor = matches.get_flag(options::PROCESSOR);
-    let hardware_platform = matches.get_flag(options::HARDWARE_PLATFORM);
-    let os = matches.get_flag(options::OS);
-
-    let none = !(all
-        || kernel_name
-        || nodename
-        || kernel_release
-        || kernel_version
-        || machine
-        || os
-        || processor
-        || hardware_platform);
-
-    if kernel_name || all || none {
-        output.push_str(&uname.sysname().to_string_lossy());
-        output.push(' ');
-    }
-
-    if nodename || all {
-        output.push_str(&uname.nodename().to_string_lossy());
-        output.push(' ');
-    }
-
-    if kernel_release || all {
-        output.push_str(&uname.release().to_string_lossy());
-        output.push(' ');
-    }
-
-    if kernel_version || all {
-        output.push_str(&uname.version().to_string_lossy());
-        output.push(' ');
-    }
-
-    if machine || all {
-        output.push_str(&uname.machine().to_string_lossy());
-        output.push(' ');
-    }
+pub struct UNameOutput {
+    pub kernel_name: Option<String>,
+    pub nodename: Option<String>,
+    pub kernel_release: Option<String>,
+    pub kernel_version: Option<String>,
+    pub machine: Option<String>,
+    pub os: Option<String>,
+    pub processor: Option<String>,
+    pub hardware_platform: Option<String>,
+}
 
-    if os || all {
-        output.push_str(&uname.osname().to_string_lossy());
-        output.push(' ');
+impl UNameOutput {
+    fn display(&self) -> String {
+        let mut output = String::new();
+        for name in [
+            self.kernel_name.as_ref(),
+            self.nodename.as_ref(),
+            self.kernel_release.as_ref(),
+            self.kernel_version.as_ref(),
+            self.machine.as_ref(),
+            self.os.as_ref(),
+            self.processor.as_ref(),
+            self.hardware_platform.as_ref(),
+        ]
+        .into_iter()
+        .flatten()
+        {
+            output.push_str(name);
+            output.push(' ');
+        }
+        output
     }
 
-    // This option is unsupported on modern Linux systems
-    // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
-    if processor {
-        output.push_str("unknown");
-        output.push(' ');
+    pub fn new(opts: &Options) -> UResult<Self> {
+        let uname =
+            PlatformInfo::new().map_err(|_e| USimpleError::new(1, "cannot get system name"))?;
+        let none = !(opts.all
+            || opts.kernel_name
+            || opts.nodename
+            || opts.kernel_release
+            || opts.kernel_version
+            || opts.machine
+            || opts.os
+            || opts.processor
+            || opts.hardware_platform);
+
+        let kernel_name = (opts.kernel_name || opts.all || none)
+            .then(|| uname.sysname().to_string_lossy().to_string());
+
+        let nodename =
+            (opts.nodename || opts.all).then(|| uname.nodename().to_string_lossy().to_string());
+
+        let kernel_release = (opts.kernel_release || opts.all)
+            .then(|| uname.release().to_string_lossy().to_string());
+
+        let kernel_version = (opts.kernel_version || opts.all)
+            .then(|| uname.version().to_string_lossy().to_string());
+
+        let machine =
+            (opts.machine || opts.all).then(|| uname.machine().to_string_lossy().to_string());
+
+        let os = (opts.os || opts.all).then(|| uname.osname().to_string_lossy().to_string());
+
+        // This option is unsupported on modern Linux systems
+        // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
+        let processor = opts.processor.then(|| "unknown".to_string());
+
+        // This option is unsupported on modern Linux systems
+        // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
+        let hardware_platform = opts.hardware_platform.then(|| "unknown".to_string());
+
+        Ok(Self {
+            kernel_name,
+            nodename,
+            kernel_release,
+            kernel_version,
+            machine,
+            os,
+            processor,
+            hardware_platform,
+        })
     }
+}
 
-    // This option is unsupported on modern Linux systems
-    // See: https://lists.gnu.org/archive/html/bug-coreutils/2005-09/msg00063.html
-    if hardware_platform {
-        output.push_str("unknown");
-        output.push(' ');
-    }
+pub struct Options {
+    pub all: bool,
+    pub kernel_name: bool,
+    pub nodename: bool,
+    pub kernel_version: bool,
+    pub kernel_release: bool,
+    pub machine: bool,
+    pub processor: bool,
+    pub hardware_platform: bool,
+    pub os: bool,
+}
 
-    println!("{}", output.trim_end());
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
 
+    let options = Options {
+        all: matches.get_flag(options::ALL),
+        kernel_name: matches.get_flag(options::KERNEL_NAME),
+        nodename: matches.get_flag(options::NODENAME),
+        kernel_release: matches.get_flag(options::KERNEL_RELEASE),
+        kernel_version: matches.get_flag(options::KERNEL_VERSION),
+        machine: matches.get_flag(options::MACHINE),
+        processor: matches.get_flag(options::PROCESSOR),
+        hardware_platform: matches.get_flag(options::HARDWARE_PLATFORM),
+        os: matches.get_flag(options::OS),
+    };
+    let output = UNameOutput::new(&options)?;
+    println!("{}", output.display().trim_end());
     Ok(())
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/unexpand/Cargo.toml b/src/uu/unexpand/Cargo.toml
index 6a12d48ab6b..41c3d8f85f7 100644
--- a/src/uu/unexpand/Cargo.toml
+++ b/src/uu/unexpand/Cargo.toml
@@ -1,20 +1,24 @@
 [package]
 name = "uu_unexpand"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "unexpand ~ (uutils) convert input spaces to tabs"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/unexpand"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/unexpand.rs"
 
 [dependencies]
+thiserror = { workspace = true }
 clap = { workspace = true }
 unicode-width = { workspace = true }
 uucore = { workspace = true }
diff --git a/src/uu/unexpand/src/unexpand.rs b/src/uu/unexpand/src/unexpand.rs
index 11ad43060a6..fb17b971d57 100644
--- a/src/uu/unexpand/src/unexpand.rs
+++ b/src/uu/unexpand/src/unexpand.rs
@@ -5,47 +5,37 @@
 
 // spell-checker:ignore (ToDO) nums aflag uflag scol prevtab amode ctype cwidth nbytes lastcol pctype Preprocess
 
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::error::Error;
-use std::fmt;
+use clap::{Arg, ArgAction, Command};
 use std::fs::File;
-use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Stdout, Write};
+use std::io::{BufRead, BufReader, BufWriter, Read, Stdout, Write, stdin, stdout};
 use std::num::IntErrorKind;
+use std::path::Path;
 use std::str::from_utf8;
+use thiserror::Error;
 use unicode_width::UnicodeWidthChar;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UError, UResult};
-use uucore::{crash, crash_if_err, format_usage, help_about, help_usage};
+use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::{format_usage, help_about, help_usage, show};
 
 const USAGE: &str = help_usage!("unexpand.md");
 const ABOUT: &str = help_about!("unexpand.md");
 
 const DEFAULT_TABSTOP: usize = 8;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum ParseError {
+    #[error("tab size contains invalid character(s): {}", _0.quote())]
     InvalidCharacter(String),
+    #[error("tab size cannot be 0")]
     TabSizeCannotBeZero,
+    #[error("tab stop value is too large")]
     TabSizeTooLarge,
+    #[error("tab sizes must be ascending")]
     TabSizesMustBeAscending,
 }
 
-impl Error for ParseError {}
 impl UError for ParseError {}
 
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::InvalidCharacter(s) => {
-                write!(f, "tab size contains invalid character(s): {}", s.quote())
-            }
-            Self::TabSizeCannotBeZero => write!(f, "tab size cannot be 0"),
-            Self::TabSizeTooLarge => write!(f, "tab stop value is too large"),
-            Self::TabSizesMustBeAscending => write!(f, "tab sizes must be ascending"),
-        }
-    }
-}
-
 fn tabstops_parse(s: &str) -> Result<Vec<usize>, ParseError> {
     let words = s.split(',');
 
@@ -54,18 +44,18 @@ fn tabstops_parse(s: &str) -> Result<Vec<usize>, ParseError> {
     for word in words {
         match word.parse::<usize>() {
             Ok(num) => nums.push(num),
-            Err(e) => match e.kind() {
-                IntErrorKind::PosOverflow => return Err(ParseError::TabSizeTooLarge),
-                _ => {
-                    return Err(ParseError::InvalidCharacter(
+            Err(e) => {
+                return match e.kind() {
+                    IntErrorKind::PosOverflow => Err(ParseError::TabSizeTooLarge),
+                    _ => Err(ParseError::InvalidCharacter(
                         word.trim_start_matches(char::is_numeric).to_string(),
-                    ))
-                }
-            },
+                    )),
+                };
+            }
         }
     }
 
-    if nums.iter().any(|&n| n == 0) {
+    if nums.contains(&0) {
         return Err(ParseError::TabSizeCannotBeZero);
     }
 
@@ -105,8 +95,8 @@ impl Options {
             && !matches.get_flag(options::FIRST_ONLY);
         let uflag = !matches.get_flag(options::NO_UTF8);
 
-        let files = match matches.get_one::<String>(options::FILE) {
-            Some(v) => vec![v.to_string()],
+        let files = match matches.get_many::<String>(options::FILE) {
+            Some(v) => v.cloned().collect(),
             None => vec!["-".to_owned()],
         };
 
@@ -161,12 +151,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
     let matches = uu_app().try_get_matches_from(expand_shortcuts(&args))?;
 
-    unexpand(&Options::new(&matches)?).map_err_context(String::new)
+    unexpand(&Options::new(&matches)?)
 }
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .override_usage(format_usage(USAGE))
         .about(ABOUT)
         .infer_long_args(true)
@@ -209,16 +199,19 @@ pub fn uu_app() -> Command {
         )
 }
 
-fn open(path: &str) -> BufReader<Box<dyn Read + 'static>> {
+fn open(path: &str) -> UResult<BufReader<Box<dyn Read + 'static>>> {
     let file_buf;
-    if path == "-" {
-        BufReader::new(Box::new(stdin()) as Box<dyn Read>)
+    let filename = Path::new(path);
+    if filename.is_dir() {
+        Err(Box::new(USimpleError {
+            code: 1,
+            message: format!("{}: Is a directory", filename.display()),
+        }))
+    } else if path == "-" {
+        Ok(BufReader::new(Box::new(stdin()) as Box<dyn Read>))
     } else {
-        file_buf = match File::open(path) {
-            Ok(a) => a,
-            Err(e) => crash!(1, "{}: {}", path.maybe_quote(), e),
-        };
-        BufReader::new(Box::new(file_buf) as Box<dyn Read>)
+        file_buf = File::open(path).map_err_context(|| path.to_string())?;
+        Ok(BufReader::new(Box::new(file_buf) as Box<dyn Read>))
     }
 }
 
@@ -240,7 +233,7 @@ fn write_tabs(
     prevtab: bool,
     init: bool,
     amode: bool,
-) {
+) -> UResult<()> {
     // This conditional establishes the following:
     // We never turn a single space before a non-blank into
     // a tab, unless it's at the start of the line.
@@ -251,15 +244,16 @@ fn write_tabs(
                 break;
             }
 
-            crash_if_err!(1, output.write_all(b"\t"));
+            output.write_all(b"\t")?;
             scol += nts;
         }
     }
 
     while col > scol {
-        crash_if_err!(1, output.write_all(b" "));
+        output.write_all(b" ")?;
         scol += 1;
     }
+    Ok(())
 }
 
 #[derive(PartialEq, Eq, Debug)]
@@ -315,106 +309,108 @@ fn next_char_info(uflag: bool, buf: &[u8], byte: usize) -> (CharType, usize, usi
 }
 
 #[allow(clippy::cognitive_complexity)]
-fn unexpand(options: &Options) -> std::io::Result<()> {
+fn unexpand_line(
+    buf: &mut Vec<u8>,
+    output: &mut BufWriter<Stdout>,
+    options: &Options,
+    lastcol: usize,
+    ts: &[usize],
+) -> UResult<()> {
+    let mut byte = 0; // offset into the buffer
+    let mut col = 0; // the current column
+    let mut scol = 0; // the start col for the current span, i.e., the already-printed width
+    let mut init = true; // are we at the start of the line?
+    let mut pctype = CharType::Other;
+
+    while byte < buf.len() {
+        // when we have a finite number of columns, never convert past the last column
+        if lastcol > 0 && col >= lastcol {
+            write_tabs(output, ts, scol, col, pctype == CharType::Tab, init, true)?;
+            output.write_all(&buf[byte..])?;
+            scol = col;
+            break;
+        }
+
+        // figure out how big the next char is, if it's UTF-8
+        let (ctype, cwidth, nbytes) = next_char_info(options.uflag, buf, byte);
+
+        // now figure out how many columns this char takes up, and maybe print it
+        let tabs_buffered = init || options.aflag;
+        match ctype {
+            CharType::Space | CharType::Tab => {
+                // compute next col, but only write space or tab chars if not buffering
+                col += if ctype == CharType::Space {
+                    1
+                } else {
+                    next_tabstop(ts, col).unwrap_or(1)
+                };
+
+                if !tabs_buffered {
+                    output.write_all(&buf[byte..byte + nbytes])?;
+                    scol = col; // now printed up to this column
+                }
+            }
+            CharType::Other | CharType::Backspace => {
+                // always
+                write_tabs(
+                    output,
+                    ts,
+                    scol,
+                    col,
+                    pctype == CharType::Tab,
+                    init,
+                    options.aflag,
+                )?;
+                init = false; // no longer at the start of a line
+                col = if ctype == CharType::Other {
+                    // use computed width
+                    col + cwidth
+                } else if col > 0 {
+                    // Backspace case, but only if col > 0
+                    col - 1
+                } else {
+                    0
+                };
+                output.write_all(&buf[byte..byte + nbytes])?;
+                scol = col; // we've now printed up to this column
+            }
+        }
+
+        byte += nbytes; // move on to next char
+        pctype = ctype; // save the previous type
+    }
+
+    // write out anything remaining
+    write_tabs(output, ts, scol, col, pctype == CharType::Tab, init, true)?;
+    output.flush()?;
+    buf.truncate(0); // clear out the buffer
+
+    Ok(())
+}
+
+fn unexpand(options: &Options) -> UResult<()> {
     let mut output = BufWriter::new(stdout());
     let ts = &options.tabstops[..];
     let mut buf = Vec::new();
     let lastcol = if ts.len() > 1 { *ts.last().unwrap() } else { 0 };
 
     for file in &options.files {
-        let mut fh = open(file);
+        let mut fh = match open(file) {
+            Ok(reader) => reader,
+            Err(err) => {
+                show!(err);
+                continue;
+            }
+        };
 
         while match fh.read_until(b'\n', &mut buf) {
             Ok(s) => s > 0,
             Err(_) => !buf.is_empty(),
         } {
-            let mut byte = 0; // offset into the buffer
-            let mut col = 0; // the current column
-            let mut scol = 0; // the start col for the current span, i.e., the already-printed width
-            let mut init = true; // are we at the start of the line?
-            let mut pctype = CharType::Other;
-
-            while byte < buf.len() {
-                // when we have a finite number of columns, never convert past the last column
-                if lastcol > 0 && col >= lastcol {
-                    write_tabs(
-                        &mut output,
-                        ts,
-                        scol,
-                        col,
-                        pctype == CharType::Tab,
-                        init,
-                        true,
-                    );
-                    output.write_all(&buf[byte..])?;
-                    scol = col;
-                    break;
-                }
-
-                // figure out how big the next char is, if it's UTF-8
-                let (ctype, cwidth, nbytes) = next_char_info(options.uflag, &buf, byte);
-
-                // now figure out how many columns this char takes up, and maybe print it
-                let tabs_buffered = init || options.aflag;
-                match ctype {
-                    CharType::Space | CharType::Tab => {
-                        // compute next col, but only write space or tab chars if not buffering
-                        col += if ctype == CharType::Space {
-                            1
-                        } else {
-                            next_tabstop(ts, col).unwrap_or(1)
-                        };
-
-                        if !tabs_buffered {
-                            output.write_all(&buf[byte..byte + nbytes])?;
-                            scol = col; // now printed up to this column
-                        }
-                    }
-                    CharType::Other | CharType::Backspace => {
-                        // always
-                        write_tabs(
-                            &mut output,
-                            ts,
-                            scol,
-                            col,
-                            pctype == CharType::Tab,
-                            init,
-                            options.aflag,
-                        );
-                        init = false; // no longer at the start of a line
-                        col = if ctype == CharType::Other {
-                            // use computed width
-                            col + cwidth
-                        } else if col > 0 {
-                            // Backspace case, but only if col > 0
-                            col - 1
-                        } else {
-                            0
-                        };
-                        output.write_all(&buf[byte..byte + nbytes])?;
-                        scol = col; // we've now printed up to this column
-                    }
-                }
-
-                byte += nbytes; // move on to next char
-                pctype = ctype; // save the previous type
-            }
-
-            // write out anything remaining
-            write_tabs(
-                &mut output,
-                ts,
-                scol,
-                col,
-                pctype == CharType::Tab,
-                init,
-                true,
-            );
-            output.flush()?;
-            buf.truncate(0); // clear out the buffer
+            unexpand_line(&mut buf, &mut output, options, lastcol, ts)?;
         }
     }
-    output.flush()
+    Ok(())
 }
 
 #[cfg(test)]
diff --git a/src/uu/uniq/Cargo.toml b/src/uu/uniq/Cargo.toml
index 0afcffc118b..6dbcc5d89f2 100644
--- a/src/uu/uniq/Cargo.toml
+++ b/src/uu/uniq/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_uniq"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "uniq ~ (uutils) filter identical adjacent lines from input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/uniq"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/uniq.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true }
+uucore = { workspace = true, features = ["parser"] }
 
 [[bin]]
 name = "uniq"
diff --git a/src/uu/uniq/src/uniq.rs b/src/uu/uniq/src/uniq.rs
index 3aac7b83467..2d54a508226 100644
--- a/src/uu/uniq/src/uniq.rs
+++ b/src/uu/uniq/src/uniq.rs
@@ -2,14 +2,19 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-
-use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+// spell-checker:ignore badoption
+use clap::{
+    Arg, ArgAction, ArgMatches, Command, builder::ValueParser, error::ContextKind, error::Error,
+    error::ErrorKind,
+};
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
-use std::io::{self, stdin, stdout, BufRead, BufReader, BufWriter, Write};
-use std::str::FromStr;
+use std::io::{BufRead, BufReader, BufWriter, Write, stdin, stdout};
+use std::num::IntErrorKind;
 use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult, USimpleError, UUsageError};
+use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::parser::shortcut_value_parser::ShortcutValueParser;
+use uucore::posix::{OBSOLETE, posix_version};
 use uucore::{format_usage, help_about, help_section, help_usage};
 
 const ABOUT: &str = help_about!("uniq.md");
@@ -66,7 +71,7 @@ impl Uniq {
         let mut first_line_printed = false;
         let mut group_count = 1;
         let line_terminator = self.get_line_terminator();
-        let mut lines = reader.split(line_terminator).map(get_line_string);
+        let mut lines = reader.split(line_terminator);
         let mut line = match lines.next() {
             Some(l) => l?,
             None => return Ok(()),
@@ -105,75 +110,82 @@ impl Uniq {
         {
             write_line_terminator!(writer, line_terminator)?;
         }
+        writer.flush().map_err_context(|| "write error".into())?;
         Ok(())
     }
 
-    fn skip_fields<'a>(&self, line: &'a str) -> &'a str {
+    fn skip_fields(&self, line: &[u8]) -> Vec<u8> {
         if let Some(skip_fields) = self.skip_fields {
-            let mut i = 0;
-            let mut char_indices = line.char_indices();
+            let mut line = line.iter();
+            let mut line_after_skipped_field: Vec<u8>;
             for _ in 0..skip_fields {
-                if char_indices.all(|(_, c)| c.is_whitespace()) {
-                    return "";
+                if line.all(|u| u.is_ascii_whitespace()) {
+                    return Vec::new();
                 }
-                match char_indices.find(|(_, c)| c.is_whitespace()) {
-                    None => return "",
-                    Some((next_field_i, _)) => i = next_field_i,
+                line_after_skipped_field = line
+                    .by_ref()
+                    .skip_while(|u| !u.is_ascii_whitespace())
+                    .copied()
+                    .collect::<Vec<u8>>();
+
+                if line_after_skipped_field.is_empty() {
+                    return Vec::new();
                 }
+                line = line_after_skipped_field.iter();
             }
-            &line[i..]
+            line.copied().collect::<Vec<u8>>()
         } else {
-            line
+            line.to_vec()
         }
     }
 
     fn get_line_terminator(&self) -> u8 {
-        if self.zero_terminated {
-            0
-        } else {
-            b'\n'
-        }
+        if self.zero_terminated { 0 } else { b'\n' }
     }
 
-    fn cmp_keys(&self, first: &str, second: &str) -> bool {
+    fn cmp_keys(&self, first: &[u8], second: &[u8]) -> bool {
         self.cmp_key(first, |first_iter| {
             self.cmp_key(second, |second_iter| first_iter.ne(second_iter))
         })
     }
 
-    fn cmp_key<F>(&self, line: &str, mut closure: F) -> bool
+    fn cmp_key<F>(&self, line: &[u8], mut closure: F) -> bool
     where
         F: FnMut(&mut dyn Iterator<Item = char>) -> bool,
     {
         let fields_to_check = self.skip_fields(line);
-        let len = fields_to_check.len();
-        let slice_start = self.slice_start.unwrap_or(0);
-        let slice_stop = self.slice_stop.unwrap_or(len);
-        if len > 0 {
-            // fast path: avoid doing any work if there is no need to skip or map to lower-case
-            if !self.ignore_case && slice_start == 0 && slice_stop == len {
-                return closure(&mut fields_to_check.chars());
-            }
 
-            // fast path: avoid skipping
-            if self.ignore_case && slice_start == 0 && slice_stop == len {
-                return closure(&mut fields_to_check.chars().flat_map(|c| c.to_uppercase()));
-            }
+        // Skip self.slice_start bytes (if -s was used).
+        // self.slice_start is how many characters to skip, but historically
+        // uniq’s `-s N` means “skip N *bytes*,� so do that literally:
+        let skip_bytes = self.slice_start.unwrap_or(0);
+        let fields_to_check = if skip_bytes < fields_to_check.len() {
+            &fields_to_check[skip_bytes..]
+        } else {
+            // If skipping beyond end-of-line, leftover is empty => effectively ""
+            &[]
+        };
 
-            // fast path: we can avoid mapping chars to upper-case, if we don't want to ignore the case
-            if !self.ignore_case {
-                return closure(&mut fields_to_check.chars().skip(slice_start).take(slice_stop));
-            }
+        // Convert the leftover bytes to UTF-8 for character-based -w
+        // If invalid UTF-8, just compare them as individual bytes (fallback).
+        let Ok(string_after_skip) = std::str::from_utf8(fields_to_check) else {
+            // Fallback: if invalid UTF-8, treat them as single-byte “chars�
+            return closure(&mut fields_to_check.iter().map(|&b| b as char));
+        };
 
-            closure(
-                &mut fields_to_check
-                    .chars()
-                    .skip(slice_start)
-                    .take(slice_stop)
-                    .flat_map(|c| c.to_uppercase()),
-            )
+        let total_chars = string_after_skip.chars().count();
+
+        // `-w N` => Compare no more than N characters
+        let slice_stop = self.slice_stop.unwrap_or(total_chars);
+        let slice_start = slice_stop.min(total_chars);
+
+        let mut iter = string_after_skip.chars().take(slice_start);
+
+        if self.ignore_case {
+            // We can do ASCII-lowercase or full Unicode-lowercase. For minimal changes, do ASCII:
+            closure(&mut iter.map(|c| c.to_ascii_lowercase()))
         } else {
-            closure(&mut fields_to_check.chars())
+            closure(&mut iter)
         }
     }
 
@@ -193,7 +205,7 @@ impl Uniq {
     fn print_line(
         &self,
         writer: &mut impl Write,
-        line: &str,
+        line: &[u8],
         count: usize,
         first_line_printed: bool,
     ) -> UResult<()> {
@@ -204,41 +216,341 @@ impl Uniq {
         }
 
         if self.show_counts {
-            write!(writer, "{count:7} {line}")
+            let prefix = format!("{count:7} ");
+            let out = prefix
+                .as_bytes()
+                .iter()
+                .chain(line.iter())
+                .copied()
+                .collect::<Vec<u8>>();
+            writer.write_all(out.as_slice())
         } else {
-            writer.write_all(line.as_bytes())
+            writer.write_all(line)
         }
-        .map_err_context(|| "Failed to write line".to_string())?;
+        .map_err_context(|| "write error".to_string())?;
 
         write_line_terminator!(writer, line_terminator)
     }
 }
 
-fn get_line_string(io_line: io::Result<Vec<u8>>) -> UResult<String> {
-    let line_bytes = io_line.map_err_context(|| "failed to split lines".to_string())?;
-    String::from_utf8(line_bytes)
-        .map_err(|e| USimpleError::new(1, format!("failed to convert line to utf8: {e}")))
+fn opt_parsed(opt_name: &str, matches: &ArgMatches) -> UResult<Option<usize>> {
+    match matches.get_one::<String>(opt_name) {
+        Some(arg_str) => match arg_str.parse::<usize>() {
+            Ok(v) => Ok(Some(v)),
+            Err(e) => match e.kind() {
+                IntErrorKind::PosOverflow => Ok(Some(usize::MAX)),
+                _ => Err(USimpleError::new(
+                    1,
+                    format!("Invalid argument for {opt_name}: {}", arg_str.maybe_quote()),
+                )),
+            },
+        },
+        None => Ok(None),
+    }
 }
 
-fn opt_parsed<T: FromStr>(opt_name: &str, matches: &ArgMatches) -> UResult<Option<T>> {
-    Ok(match matches.get_one::<String>(opt_name) {
-        Some(arg_str) => Some(arg_str.parse().map_err(|_| {
-            USimpleError::new(
-                1,
-                format!(
-                    "Invalid argument for {}: {}",
-                    opt_name,
-                    arg_str.maybe_quote()
-                ),
+/// Extract obsolete shorthands (if any) for skip fields and skip chars options
+/// following GNU `uniq` behavior
+///
+/// Examples for obsolete skip fields option
+/// `uniq -1 file` would equal `uniq -f1 file`
+/// `uniq -1 -2 -3 file` would equal `uniq -f123 file`
+/// `uniq -1 -2 -f5 file` would equal `uniq -f5 file`
+/// `uniq -u20s4 file` would equal `uniq -u -f20 -s4 file`
+/// `uniq -D1w3 -3 file` would equal `uniq -D -f3 -w3 file`
+///
+/// Examples for obsolete skip chars option
+/// `uniq +1 file` would equal `uniq -s1 file`
+/// `uniq +1 -s2 file` would equal `uniq -s2 file`
+/// `uniq -s2 +3 file` would equal `uniq -s3 file`
+///
+fn handle_obsolete(args: impl uucore::Args) -> (Vec<OsString>, Option<usize>, Option<usize>) {
+    let mut skip_fields_old = None;
+    let mut skip_chars_old = None;
+    let mut preceding_long_opt_req_value = false;
+    let mut preceding_short_opt_req_value = false;
+
+    let filtered_args = args
+        .filter_map(|os_slice| {
+            filter_args(
+                os_slice,
+                &mut skip_fields_old,
+                &mut skip_chars_old,
+                &mut preceding_long_opt_req_value,
+                &mut preceding_short_opt_req_value,
             )
-        })?),
-        None => None,
-    })
+        })
+        .collect();
+
+    // exacted String values (if any) for skip_fields_old and skip_chars_old
+    // are guaranteed to consist of ascii digit chars only at this point
+    // so, it is safe to parse into usize and collapse Result into Option
+    let skip_fields_old: Option<usize> = skip_fields_old.and_then(|v| v.parse::<usize>().ok());
+    let skip_chars_old: Option<usize> = skip_chars_old.and_then(|v| v.parse::<usize>().ok());
+
+    (filtered_args, skip_fields_old, skip_chars_old)
+}
+
+fn filter_args(
+    os_slice: OsString,
+    skip_fields_old: &mut Option<String>,
+    skip_chars_old: &mut Option<String>,
+    preceding_long_opt_req_value: &mut bool,
+    preceding_short_opt_req_value: &mut bool,
+) -> Option<OsString> {
+    let filter: Option<OsString>;
+    if let Some(slice) = os_slice.to_str() {
+        if should_extract_obs_skip_fields(
+            slice,
+            preceding_long_opt_req_value,
+            preceding_short_opt_req_value,
+        ) {
+            // start of the short option string
+            // that can have obsolete skip fields option value in it
+            filter = handle_extract_obs_skip_fields(slice, skip_fields_old);
+        } else if should_extract_obs_skip_chars(
+            slice,
+            preceding_long_opt_req_value,
+            preceding_short_opt_req_value,
+        ) {
+            // the obsolete skip chars option
+            filter = handle_extract_obs_skip_chars(slice, skip_chars_old);
+        } else {
+            // either not a short option
+            // or a short option that cannot have obsolete lines value in it
+            filter = Some(OsString::from(slice));
+            // Check and reset to None obsolete values extracted so far
+            // if corresponding new/documented options are encountered next.
+            // NOTE: For skip fields - occurrences of corresponding new/documented options
+            // inside combined short options ike '-u20s4' or '-D1w3', etc
+            // are also covered in `handle_extract_obs_skip_fields()` function
+            if slice.starts_with("-f") {
+                *skip_fields_old = None;
+            }
+            if slice.starts_with("-s") {
+                *skip_chars_old = None;
+            }
+        }
+        handle_preceding_options(
+            slice,
+            preceding_long_opt_req_value,
+            preceding_short_opt_req_value,
+        );
+    } else {
+        // Cannot cleanly convert os_slice to UTF-8
+        // Do not process and return as-is
+        // This will cause failure later on, but we should not handle it here
+        // and let clap panic on invalid UTF-8 argument
+        filter = Some(os_slice);
+    }
+    filter
+}
+
+/// Helper function to [`filter_args`]
+/// Checks if the slice is a true short option (and not hyphen prefixed value of an option)
+/// and if so, a short option that can contain obsolete skip fields value
+fn should_extract_obs_skip_fields(
+    slice: &str,
+    preceding_long_opt_req_value: &bool,
+    preceding_short_opt_req_value: &bool,
+) -> bool {
+    slice.starts_with('-')
+        && !slice.starts_with("--")
+        && !preceding_long_opt_req_value
+        && !preceding_short_opt_req_value
+        && !slice.starts_with("-s")
+        && !slice.starts_with("-f")
+        && !slice.starts_with("-w")
+}
+
+/// Helper function to [`filter_args`]
+/// Checks if the slice is a true obsolete skip chars short option
+fn should_extract_obs_skip_chars(
+    slice: &str,
+    preceding_long_opt_req_value: &bool,
+    preceding_short_opt_req_value: &bool,
+) -> bool {
+    slice.starts_with('+')
+        && posix_version().is_some_and(|v| v <= OBSOLETE)
+        && !preceding_long_opt_req_value
+        && !preceding_short_opt_req_value
+        && slice.chars().nth(1).is_some_and(|c| c.is_ascii_digit())
+}
+
+/// Helper function to [`filter_args`]
+/// Captures if current slice is a preceding option
+/// that requires value
+fn handle_preceding_options(
+    slice: &str,
+    preceding_long_opt_req_value: &mut bool,
+    preceding_short_opt_req_value: &mut bool,
+) {
+    // capture if current slice is a preceding long option that requires value and does not use '=' to assign that value
+    // following slice should be treaded as value for this option
+    // even if it starts with '-' (which would be treated as hyphen prefixed value)
+    if slice.starts_with("--") {
+        use options as O;
+        *preceding_long_opt_req_value = &slice[2..] == O::SKIP_CHARS
+            || &slice[2..] == O::SKIP_FIELDS
+            || &slice[2..] == O::CHECK_CHARS
+            || &slice[2..] == O::GROUP
+            || &slice[2..] == O::ALL_REPEATED;
+    }
+    // capture if current slice is a preceding short option that requires value and does not have value in the same slice (value separated by whitespace)
+    // following slice should be treaded as value for this option
+    // even if it starts with '-' (which would be treated as hyphen prefixed value)
+    *preceding_short_opt_req_value = slice == "-s" || slice == "-f" || slice == "-w";
+    // slice is a value
+    // reset preceding option flags
+    if !slice.starts_with('-') {
+        *preceding_short_opt_req_value = false;
+        *preceding_long_opt_req_value = false;
+    }
+}
+
+/// Helper function to [`filter_args`]
+/// Extracts obsolete skip fields numeric part from argument slice
+/// and filters it out
+fn handle_extract_obs_skip_fields(
+    slice: &str,
+    skip_fields_old: &mut Option<String>,
+) -> Option<OsString> {
+    let mut obs_extracted: Vec<char> = vec![];
+    let mut obs_end_reached = false;
+    let mut obs_overwritten_by_new = false;
+    let filtered_slice: Vec<char> = slice
+        .chars()
+        .filter(|c| {
+            if c.eq(&'f') {
+                // any extracted obsolete skip fields value up to this point should be discarded
+                // as the new/documented option for skip fields was used after it
+                // i.e. in situation like `-u12f3`
+                // The obsolete skip fields value should still be extracted, filtered out
+                // but the skip_fields_old should be set to None instead of Some(String) later on
+                obs_overwritten_by_new = true;
+            }
+            // To correctly process scenario like '-u20s4' or '-D1w3', etc
+            // we need to stop extracting digits once alphabetic character is encountered
+            // after we already have something in obs_extracted
+            if c.is_ascii_digit() && !obs_end_reached {
+                obs_extracted.push(*c);
+                false
+            } else {
+                if !obs_extracted.is_empty() {
+                    obs_end_reached = true;
+                }
+                true
+            }
+        })
+        .collect();
+
+    if obs_extracted.is_empty() {
+        // no obsolete value found/extracted
+        Some(OsString::from(slice))
+    } else {
+        // obsolete value was extracted
+        // unless there was new/documented option for skip fields used after it
+        // set the skip_fields_old value (concatenate to it if there was a value there already)
+        if obs_overwritten_by_new {
+            *skip_fields_old = None;
+        } else {
+            let mut extracted: String = obs_extracted.iter().collect();
+            if let Some(val) = skip_fields_old {
+                extracted.push_str(val);
+            }
+            *skip_fields_old = Some(extracted);
+        }
+        if filtered_slice.get(1).is_some() {
+            // there were some short options in front of or after obsolete lines value
+            // i.e. '-u20s4' or '-D1w3' or similar, which after extraction of obsolete lines value
+            // would look like '-us4' or '-Dw3' or similar
+            let filtered_slice: String = filtered_slice.iter().collect();
+            Some(OsString::from(filtered_slice))
+        } else {
+            None
+        }
+    }
+}
+
+/// Helper function to [`filter_args`]
+/// Extracts obsolete skip chars numeric part from argument slice
+fn handle_extract_obs_skip_chars(
+    slice: &str,
+    skip_chars_old: &mut Option<String>,
+) -> Option<OsString> {
+    let mut obs_extracted: Vec<char> = vec![];
+    let mut slice_chars = slice.chars();
+    slice_chars.next(); // drop leading '+' character
+    for c in slice_chars {
+        if c.is_ascii_digit() {
+            obs_extracted.push(c);
+        } else {
+            // for obsolete skip chars option the whole value after '+' should be numeric
+            // so, if any non-digit characters are encountered in the slice (i.e. `+1q`, etc)
+            // set skip_chars_old to None and return whole slice back.
+            // It will be parsed by clap and panic with appropriate error message
+            *skip_chars_old = None;
+            return Some(OsString::from(slice));
+        }
+    }
+    if obs_extracted.is_empty() {
+        // no obsolete value found/extracted
+        // i.e. it was just '+' character alone
+        Some(OsString::from(slice))
+    } else {
+        // successfully extracted numeric value
+        // capture it and return None to filter out the whole slice
+        *skip_chars_old = Some(obs_extracted.iter().collect());
+        None
+    }
+}
+
+/// Maps Clap errors to USimpleError and overrides 3 specific ones
+/// to meet requirements of GNU tests for `uniq`.
+/// Unfortunately these overrides are necessary, since several GNU tests
+/// for `uniq` hardcode and require the exact wording of the error message
+/// and it is not compatible with how Clap formats and displays those error messages.
+fn map_clap_errors(clap_error: Error) -> Box<dyn UError> {
+    let footer = "Try 'uniq --help' for more information.";
+    let override_arg_conflict =
+        "--group is mutually exclusive with -c/-d/-D/-u\n".to_string() + footer;
+    let override_group_badoption = "invalid argument 'badoption' for '--group'\nValid arguments are:\n  - 'prepend'\n  - 'append'\n  - 'separate'\n  - 'both'\n".to_string() + footer;
+    let override_all_repeated_badoption = "invalid argument 'badoption' for '--all-repeated'\nValid arguments are:\n  - 'none'\n  - 'prepend'\n  - 'separate'\n".to_string() + footer;
+
+    let error_message = match clap_error.kind() {
+        ErrorKind::ArgumentConflict => override_arg_conflict,
+        ErrorKind::InvalidValue
+            if clap_error
+                .get(ContextKind::InvalidValue)
+                .is_some_and(|v| v.to_string() == "badoption")
+                && clap_error
+                    .get(ContextKind::InvalidArg)
+                    .is_some_and(|v| v.to_string().starts_with("--group")) =>
+        {
+            override_group_badoption
+        }
+        ErrorKind::InvalidValue
+            if clap_error
+                .get(ContextKind::InvalidValue)
+                .is_some_and(|v| v.to_string() == "badoption")
+                && clap_error
+                    .get(ContextKind::InvalidArg)
+                    .is_some_and(|v| v.to_string().starts_with("--all-repeated")) =>
+        {
+            override_all_repeated_badoption
+        }
+        _ => return clap_error.into(),
+    };
+    USimpleError::new(1, error_message)
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let matches = uu_app().after_help(AFTER_HELP).try_get_matches_from(args)?;
+    let (args, skip_fields_old, skip_chars_old) = handle_obsolete(args);
+
+    let matches = uu_app()
+        .try_get_matches_from(args)
+        .map_err(map_clap_errors)?;
 
     let files = matches.get_many::<OsString>(ARG_FILES);
 
@@ -247,6 +559,9 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .map(|mut fi| (fi.next(), fi.next()))
         .unwrap_or_default();
 
+    let skip_fields_modern: Option<usize> = opt_parsed(options::SKIP_FIELDS, &matches)?;
+    let skip_chars_modern: Option<usize> = opt_parsed(options::SKIP_CHARS, &matches)?;
+
     let uniq = Uniq {
         repeats_only: matches.get_flag(options::REPEATED)
             || matches.contains_id(options::ALL_REPEATED),
@@ -255,17 +570,17 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             || matches.contains_id(options::GROUP),
         delimiters: get_delimiter(&matches),
         show_counts: matches.get_flag(options::COUNT),
-        skip_fields: opt_parsed(options::SKIP_FIELDS, &matches)?,
-        slice_start: opt_parsed(options::SKIP_CHARS, &matches)?,
+        skip_fields: skip_fields_modern.or(skip_fields_old),
+        slice_start: skip_chars_modern.or(skip_chars_old),
         slice_stop: opt_parsed(options::CHECK_CHARS, &matches)?,
         ignore_case: matches.get_flag(options::IGNORE_CASE),
         zero_terminated: matches.get_flag(options::ZERO_TERMINATED),
     };
 
     if uniq.show_counts && uniq.all_repeated {
-        return Err(UUsageError::new(
+        return Err(USimpleError::new(
             1,
-            "printing all duplicated lines and repeat counts is meaningless",
+            "printing all duplicated lines and repeat counts is meaningless\nTry 'uniq --help' for more information.",
         ));
     }
 
@@ -277,19 +592,20 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .after_help(AFTER_HELP)
         .arg(
             Arg::new(options::ALL_REPEATED)
                 .short('D')
                 .long(options::ALL_REPEATED)
-                .value_parser([
+                .value_parser(ShortcutValueParser::new([
                     "none",
                     "prepend",
                     "separate"
-                ])
+                ]))
                 .help("print all duplicate lines. Delimiting is done with blank lines. [default: none]")
                 .value_name("delimit-method")
                 .num_args(0..=1)
@@ -299,12 +615,12 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::GROUP)
                 .long(options::GROUP)
-                .value_parser([
+                .value_parser(ShortcutValueParser::new([
                     "separate",
                     "prepend",
                     "append",
                     "both",
-                ])
+                ]))
                 .help("show all items, separating groups with an empty line. [default: separate]")
                 .value_name("group-method")
                 .num_args(0..=1)
@@ -314,6 +630,7 @@ pub fn uu_app() -> Command {
                     options::REPEATED,
                     options::ALL_REPEATED,
                     options::UNIQUE,
+                    options::COUNT
                 ]),
         )
         .arg(
@@ -377,6 +694,7 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::Append)
                 .value_parser(ValueParser::os_string())
                 .num_args(0..=2)
+                .hide(true)
                 .value_hint(clap::ValueHint::FilePath),
         )
 }
diff --git a/src/uu/uniq/uniq.md b/src/uu/uniq/uniq.md
index dea57081b77..20de52395ba 100644
--- a/src/uu/uniq/uniq.md
+++ b/src/uu/uniq/uniq.md
@@ -1,7 +1,7 @@
 # uniq
 
 ```
-uniq [OPTION]... [INPUT [OUTPUT]]...
+uniq [OPTION]... [INPUT [OUTPUT]]
 ```
 
 Report or omit repeated lines.
diff --git a/src/uu/unlink/Cargo.toml b/src/uu/unlink/Cargo.toml
index ce86b81d8d1..88efad1e52a 100644
--- a/src/uu/unlink/Cargo.toml
+++ b/src/uu/unlink/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_unlink"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "unlink ~ (uutils) remove a (file system) link to FILE"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/unlink"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/unlink.rs"
diff --git a/src/uu/unlink/src/unlink.rs b/src/uu/unlink/src/unlink.rs
index 85e1ab4f594..09a1b0f1233 100644
--- a/src/uu/unlink/src/unlink.rs
+++ b/src/uu/unlink/src/unlink.rs
@@ -3,14 +3,12 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-/* last synced with: unlink (GNU coreutils) 8.21 */
-
 use std::ffi::OsString;
 use std::fs::remove_file;
 use std::path::Path;
 
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, Command};
+use clap::{Arg, Command};
 
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UResult};
@@ -31,7 +29,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/unlink/unlink.md b/src/uu/unlink/unlink.md
index 4468fb20450..14b023b8b66 100644
--- a/src/uu/unlink/unlink.md
+++ b/src/uu/unlink/unlink.md
@@ -1,7 +1,8 @@
 # unlink
 
 ```
-unlink [FILE]
+unlink FILE
+unlink OPTION
 ```
 
 Unlink the file at `FILE`.
diff --git a/src/uu/uptime/Cargo.toml b/src/uu/uptime/Cargo.toml
index 7bef7cc051d..4029cdf6d15 100644
--- a/src/uu/uptime/Cargo.toml
+++ b/src/uu/uptime/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_uptime"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "uptime ~ (uutils) display dynamic system information"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/uptime"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/uptime.rs"
@@ -17,7 +20,11 @@ path = "src/uptime.rs"
 [dependencies]
 chrono = { workspace = true }
 clap = { workspace = true }
-uucore = { workspace = true, features = ["libc", "utmpx"] }
+thiserror = { workspace = true }
+uucore = { workspace = true, features = ["libc", "utmpx", "uptime"] }
+
+[target.'cfg(target_os = "openbsd")'.dependencies]
+utmp-classic = { workspace = true }
 
 [[bin]]
 name = "uptime"
diff --git a/src/uu/uptime/src/uptime.rs b/src/uu/uptime/src/uptime.rs
index 778fbc92047..e001a64a8ef 100644
--- a/src/uu/uptime/src/uptime.rs
+++ b/src/uu/uptime/src/uptime.rs
@@ -3,60 +3,81 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (ToDO) getloadavg upsecs updays nusers loadavg boottime uphours upmins
+// spell-checker:ignore getloadavg behaviour loadavg uptime upsecs updays upmins uphours boottime nusers utmpxname gettime clockid
 
 use chrono::{Local, TimeZone, Utc};
-use clap::{crate_version, Arg, ArgAction, Command};
-
+#[cfg(unix)]
+use std::ffi::OsString;
+use std::io;
+use thiserror::Error;
+use uucore::error::{UError, UResult};
 use uucore::libc::time_t;
+use uucore::uptime::*;
+
+use clap::{Arg, ArgAction, Command, ValueHint, builder::ValueParser};
+
 use uucore::{format_usage, help_about, help_usage};
 
-use uucore::error::{UResult, USimpleError};
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
+use uucore::utmpx::*;
 
+#[cfg(target_env = "musl")]
+const ABOUT: &str = concat!(
+    help_about!("uptime.md"),
+    "\n\nWarning: When built with musl libc, the `uptime` utility may show '0 users' \n",
+    "due to musl's stub implementation of utmpx functions. Boot time and load averages \n",
+    "are still calculated using alternative mechanisms."
+);
+
+#[cfg(not(target_env = "musl"))]
 const ABOUT: &str = help_about!("uptime.md");
+
 const USAGE: &str = help_usage!("uptime.md");
+
 pub mod options {
     pub static SINCE: &str = "since";
+    pub static PATH: &str = "path";
 }
 
-#[cfg(unix)]
-use uucore::libc::getloadavg;
+#[derive(Debug, Error)]
+pub enum UptimeError {
+    // io::Error wrapper
+    #[error("couldn't get boot time: {0}")]
+    IoErr(#[from] io::Error),
+    #[error("couldn't get boot time: Is a directory")]
+    TargetIsDir,
+    #[error("couldn't get boot time: Illegal seek")]
+    TargetIsFifo,
+}
 
-#[cfg(windows)]
-extern "C" {
-    fn GetTickCount() -> uucore::libc::uint32_t;
+impl UError for UptimeError {
+    fn code(&self) -> i32 {
+        1
+    }
 }
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
 
-    let (boot_time, user_count) = process_utmpx();
-    let uptime = get_uptime(boot_time);
-    if uptime < 0 {
-        Err(USimpleError::new(1, "could not retrieve system uptime"))
-    } else {
-        if matches.get_flag(options::SINCE) {
-            let initial_date = Local
-                .timestamp_opt(Utc::now().timestamp() - uptime, 0)
-                .unwrap();
-            println!("{}", initial_date.format("%Y-%m-%d %H:%M:%S"));
-            return Ok(());
-        }
-
-        print_time();
-        let upsecs = uptime;
-        print_uptime(upsecs);
-        print_nusers(user_count);
-        print_loadavg();
+    #[cfg(unix)]
+    let file_path = matches.get_one::<OsString>(options::PATH);
+    #[cfg(windows)]
+    let file_path = None;
 
-        Ok(())
+    if matches.get_flag(options::SINCE) {
+        uptime_since()
+    } else if let Some(path) = file_path {
+        uptime_with_file(path)
+    } else {
+        default_uptime()
     }
 }
 
 pub fn uu_app() -> Command {
-    Command::new(uucore::util_name())
-        .version(crate_version!())
+    let cmd = Command::new(uucore::util_name())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -66,44 +87,162 @@ pub fn uu_app() -> Command {
                 .long(options::SINCE)
                 .help("system up since")
                 .action(ArgAction::SetTrue),
-        )
+        );
+    #[cfg(unix)]
+    cmd.arg(
+        Arg::new(options::PATH)
+            .help("file to search boot time from")
+            .action(ArgAction::Set)
+            .num_args(0..=1)
+            .value_parser(ValueParser::os_string())
+            .value_hint(ValueHint::AnyPath),
+    )
 }
 
 #[cfg(unix)]
-fn print_loadavg() {
-    use uucore::libc::c_double;
+fn uptime_with_file(file_path: &OsString) -> UResult<()> {
+    use std::fs;
+    use std::os::unix::fs::FileTypeExt;
+    use uucore::error::set_exit_code;
+    use uucore::show_error;
 
-    let mut avg: [c_double; 3] = [0.0; 3];
-    let loads: i32 = unsafe { getloadavg(avg.as_mut_ptr(), 3) };
+    // Uptime will print loadavg and time to stderr unless we encounter an extra operand.
+    let mut non_fatal_error = false;
 
-    if loads == -1 {
-        println!();
-    } else {
-        print!("load average: ");
-        for n in 0..loads {
-            print!(
-                "{:.2}{}",
-                avg[n as usize],
-                if n == loads - 1 { "\n" } else { ", " }
-            );
+    // process_utmpx_from_file() doesn't detect or report failures, we check if the path is valid
+    // before proceeding with more operations.
+    let md_res = fs::metadata(file_path);
+    if let Ok(md) = md_res {
+        if md.is_dir() {
+            show_error!("{}", UptimeError::TargetIsDir);
+            non_fatal_error = true;
+            set_exit_code(1);
+        }
+        if md.file_type().is_fifo() {
+            show_error!("{}", UptimeError::TargetIsFifo);
+            non_fatal_error = true;
+            set_exit_code(1);
+        }
+    } else if let Err(e) = md_res {
+        non_fatal_error = true;
+        set_exit_code(1);
+        show_error!("{}", UptimeError::IoErr(e));
+    }
+    // utmpxname() returns an -1 , when filename doesn't end with 'x' or its too long.
+    // Reference: `<https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/utmpxname.3.html>`
+
+    #[cfg(target_os = "macos")]
+    {
+        use std::os::unix::ffi::OsStrExt;
+        let bytes = file_path.as_os_str().as_bytes();
+
+        if bytes[bytes.len() - 1] != b'x' {
+            show_error!("couldn't get boot time");
+            print_time();
+            print!("up ???? days ??:??,");
+            print_nusers(Some(0));
+            print_loadavg();
+            set_exit_code(1);
+            return Ok(());
+        }
+    }
+
+    if non_fatal_error {
+        print_time();
+        print!("up ???? days ??:??,");
+        print_nusers(Some(0));
+        print_loadavg();
+        return Ok(());
+    }
+
+    print_time();
+    let user_count;
+
+    #[cfg(not(target_os = "openbsd"))]
+    {
+        let (boot_time, count) = process_utmpx(Some(file_path));
+        if let Some(time) = boot_time {
+            print_uptime(Some(time))?;
+        } else {
+            show_error!("couldn't get boot time");
+            set_exit_code(1);
+
+            print!("up ???? days ??:??,");
+        }
+        user_count = count;
+    }
+
+    #[cfg(target_os = "openbsd")]
+    {
+        let upsecs = get_uptime(None);
+        if upsecs >= 0 {
+            print_uptime(Some(upsecs))?;
+        } else {
+            show_error!("couldn't get boot time");
+            set_exit_code(1);
+
+            print!("up ???? days ??:??,");
         }
+        user_count = get_nusers(file_path.to_str().expect("invalid utmp path file"));
     }
+
+    print_nusers(Some(user_count));
+    print_loadavg();
+
+    Ok(())
 }
 
-#[cfg(windows)]
+fn uptime_since() -> UResult<()> {
+    #[cfg(unix)]
+    #[cfg(not(target_os = "openbsd"))]
+    let (boot_time, _) = process_utmpx(None);
+
+    #[cfg(target_os = "openbsd")]
+    let uptime = get_uptime(None)?;
+    #[cfg(unix)]
+    #[cfg(not(target_os = "openbsd"))]
+    let uptime = get_uptime(boot_time)?;
+    #[cfg(target_os = "windows")]
+    let uptime = get_uptime(None)?;
+
+    let initial_date = Local
+        .timestamp_opt(Utc::now().timestamp() - uptime, 0)
+        .unwrap();
+    println!("{}", initial_date.format("%Y-%m-%d %H:%M:%S"));
+
+    Ok(())
+}
+
+/// Default uptime behaviour i.e. when no file argument is given.
+fn default_uptime() -> UResult<()> {
+    print_time();
+    print_uptime(None)?;
+    print_nusers(None);
+    print_loadavg();
+
+    Ok(())
+}
+
+#[inline]
 fn print_loadavg() {
-    // XXX: currently this is a noop as Windows does not seem to have anything comparable to
-    //      getloadavg()
+    match get_formatted_loadavg() {
+        Err(_) => {}
+        Ok(s) => println!("{s}"),
+    }
 }
 
 #[cfg(unix)]
-fn process_utmpx() -> (Option<time_t>, usize) {
-    use uucore::utmpx::*;
-
+#[cfg(not(target_os = "openbsd"))]
+fn process_utmpx(file: Option<&OsString>) -> (Option<time_t>, usize) {
     let mut nusers = 0;
     let mut boot_time = None;
 
-    for line in Utmpx::iter_all_records() {
+    let records = match file {
+        Some(f) => Utmpx::iter_all_records_from(f),
+        None => Utmpx::iter_all_records(),
+    };
+
+    for line in records {
         match line.record_type() {
             USER_PROCESS => nusers += 1,
             BOOT_TIME => {
@@ -118,65 +257,25 @@ fn process_utmpx() -> (Option<time_t>, usize) {
     (boot_time, nusers)
 }
 
-#[cfg(windows)]
-fn process_utmpx() -> (Option<time_t>, usize) {
-    (None, 0) // TODO: change 0 to number of users
-}
-
-fn print_nusers(nusers: usize) {
-    match nusers.cmp(&1) {
-        std::cmp::Ordering::Equal => print!("1 user,  "),
-        std::cmp::Ordering::Greater => print!("{nusers} users,  "),
-        _ => {}
-    };
-}
-
-fn print_time() {
-    let local_time = Local::now().time();
-
-    print!(" {} ", local_time.format("%H:%M:%S"));
-}
-
-#[cfg(unix)]
-fn get_uptime(boot_time: Option<time_t>) -> i64 {
-    use std::fs::File;
-    use std::io::Read;
-
-    let mut proc_uptime_s = String::new();
-
-    let proc_uptime = File::open("/proc/uptime")
-        .ok()
-        .and_then(|mut f| f.read_to_string(&mut proc_uptime_s).ok())
-        .and_then(|_| proc_uptime_s.split_whitespace().next())
-        .and_then(|s| s.split('.').next().unwrap_or("0").parse().ok());
-
-    proc_uptime.unwrap_or_else(|| match boot_time {
-        Some(t) => {
-            let now = Local::now().timestamp();
-            #[cfg(target_pointer_width = "64")]
-            let boottime: i64 = t;
-            #[cfg(not(target_pointer_width = "64"))]
-            let boottime: i64 = t.into();
-            now - boottime
+fn print_nusers(nusers: Option<usize>) {
+    print!(
+        "{},  ",
+        match nusers {
+            None => {
+                get_formatted_nusers()
+            }
+            Some(nusers) => {
+                format_nusers(nusers)
+            }
         }
-        None => -1,
-    })
+    );
 }
 
-#[cfg(windows)]
-fn get_uptime(_boot_time: Option<time_t>) -> i64 {
-    unsafe { GetTickCount() as i64 }
+fn print_time() {
+    print!(" {}  ", get_formatted_time());
 }
 
-fn print_uptime(upsecs: i64) {
-    let updays = upsecs / 86400;
-    let uphours = (upsecs - (updays * 86400)) / 3600;
-    let upmins = (upsecs - (updays * 86400) - (uphours * 3600)) / 60;
-    match updays.cmp(&1) {
-        std::cmp::Ordering::Equal => print!("up {updays:1} day, {uphours:2}:{upmins:02},  "),
-        std::cmp::Ordering::Greater => {
-            print!("up {updays:1} days, {uphours:2}:{upmins:02},  ");
-        }
-        _ => print!("up  {uphours:2}:{upmins:02}, "),
-    };
+fn print_uptime(boot_time: Option<time_t>) -> UResult<()> {
+    print!("up  {},  ", get_formatted_uptime(boot_time)?);
+    Ok(())
 }
diff --git a/src/uu/users/Cargo.toml b/src/uu/users/Cargo.toml
index 4701c694f46..e45d8a040c4 100644
--- a/src/uu/users/Cargo.toml
+++ b/src/uu/users/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_users"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "users ~ (uutils) display names of currently logged-in users"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/users"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/users.rs"
@@ -18,6 +21,9 @@ path = "src/users.rs"
 clap = { workspace = true }
 uucore = { workspace = true, features = ["utmpx"] }
 
+[target.'cfg(target_os = "openbsd")'.dependencies]
+utmp-classic = { workspace = true }
+
 [[bin]]
 name = "users"
 path = "src/main.rs"
diff --git a/src/uu/users/src/users.rs b/src/uu/users/src/users.rs
index 199882b7eab..192ed0b579d 100644
--- a/src/uu/users/src/users.rs
+++ b/src/uu/users/src/users.rs
@@ -9,21 +9,40 @@ use std::ffi::OsString;
 use std::path::Path;
 
 use clap::builder::ValueParser;
-use clap::{crate_version, Arg, Command};
+use clap::{Arg, Command};
 use uucore::error::UResult;
-use uucore::utmpx::{self, Utmpx};
 use uucore::{format_usage, help_about, help_usage};
 
+#[cfg(target_os = "openbsd")]
+use utmp_classic::{UtmpEntry, parse_from_path};
+#[cfg(not(target_os = "openbsd"))]
+use uucore::utmpx::{self, Utmpx};
+
+#[cfg(target_env = "musl")]
+const ABOUT: &str = concat!(
+    help_about!("users.md"),
+    "\n\nWarning: When built with musl libc, the `users` utility may show '0 users' \n",
+    "due to musl's stub implementation of utmpx functions."
+);
+
+#[cfg(not(target_env = "musl"))]
 const ABOUT: &str = help_about!("users.md");
+
 const USAGE: &str = help_usage!("users.md");
 
-static ARG_FILES: &str = "files";
+#[cfg(target_os = "openbsd")]
+const OPENBSD_UTMP_FILE: &str = "/var/run/utmp";
+
+static ARG_FILE: &str = "file";
 
 fn get_long_usage() -> String {
+    #[cfg(not(target_os = "openbsd"))]
+    let default_path: &str = utmpx::DEFAULT_FILE;
+    #[cfg(target_os = "openbsd")]
+    let default_path: &str = OPENBSD_UTMP_FILE;
     format!(
         "Output who is currently logged in according to FILE.
-If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.",
-        utmpx::DEFAULT_FILE
+If FILE is not specified, use {default_path}.  /var/log/wtmp as FILE is common."
     )
 }
 
@@ -33,21 +52,39 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         .after_help(get_long_usage())
         .try_get_matches_from(args)?;
 
-    let files: Vec<&Path> = matches
-        .get_many::<OsString>(ARG_FILES)
-        .map(|v| v.map(AsRef::as_ref).collect())
-        .unwrap_or_default();
+    let maybe_file: Option<&Path> = matches.get_one::<OsString>(ARG_FILE).map(AsRef::as_ref);
 
-    let filename = if files.is_empty() {
-        utmpx::DEFAULT_FILE.as_ref()
-    } else {
-        files[0]
+    let mut users: Vec<String>;
+
+    // OpenBSD uses the Unix version 1 UTMP, all other Unixes use the newer UTMPX
+    #[cfg(target_os = "openbsd")]
+    {
+        let filename = maybe_file.unwrap_or(Path::new(OPENBSD_UTMP_FILE));
+        let entries = parse_from_path(filename).unwrap_or_default();
+        users = Vec::new();
+        for entry in entries {
+            if let UtmpEntry::UTMP {
+                line: _,
+                user,
+                host: _,
+                time: _,
+            } = entry
+            {
+                if !user.is_empty() {
+                    users.push(user);
+                }
+            }
+        }
     };
+    #[cfg(not(target_os = "openbsd"))]
+    {
+        let filename = maybe_file.unwrap_or(utmpx::DEFAULT_FILE.as_ref());
 
-    let mut users = Utmpx::iter_all_records_from(filename)
-        .filter(Utmpx::is_user_process)
-        .map(|ut| ut.user())
-        .collect::<Vec<_>>();
+        users = Utmpx::iter_all_records_from(filename)
+            .filter(Utmpx::is_user_process)
+            .map(|ut| ut.user())
+            .collect::<Vec<_>>();
+    };
 
     if !users.is_empty() {
         users.sort();
@@ -59,12 +96,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
         .arg(
-            Arg::new(ARG_FILES)
+            Arg::new(ARG_FILE)
                 .num_args(1)
                 .value_hint(clap::ValueHint::FilePath)
                 .value_parser(ValueParser::os_string()),
diff --git a/src/uu/vdir/Cargo.toml b/src/uu/vdir/Cargo.toml
index dc57512b1b6..63097cdec07 100644
--- a/src/uu/vdir/Cargo.toml
+++ b/src/uu/vdir/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_vdir"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "shortcut to ls -l -b"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/ls"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/vdir.rs"
 
 [dependencies]
 clap = { workspace = true, features = ["env"] }
-uucore = { workspace = true, features = ["entries", "fs"] }
+uucore = { workspace = true, features = ["entries", "fs", "quoting-style"] }
 uu_ls = { workspace = true }
 
 [[bin]]
diff --git a/src/uu/vdir/src/vdir.rs b/src/uu/vdir/src/vdir.rs
index b9d80c401d6..fbb8943cadc 100644
--- a/src/uu/vdir/src/vdir.rs
+++ b/src/uu/vdir/src/vdir.rs
@@ -6,7 +6,7 @@
 use clap::Command;
 use std::ffi::OsString;
 use std::path::Path;
-use uu_ls::{options, Config, Format};
+use uu_ls::{Config, Format, options};
 use uucore::error::UResult;
 use uucore::quoting_style::{Quotes, QuotingStyle};
 
diff --git a/src/uu/vdir/vdir.md b/src/uu/vdir/vdir.md
new file mode 100644
index 00000000000..c7a0cae3643
--- /dev/null
+++ b/src/uu/vdir/vdir.md
@@ -0,0 +1,10 @@
+# vdir
+
+```
+vdir [OPTION]... [FILE]...
+```
+
+List directory contents.
+Ignore files and directories starting with a '.' by default.
+
+Mandatory arguments to long options are mandatory for short options too.
diff --git a/src/uu/wc/BENCHMARKING.md b/src/uu/wc/BENCHMARKING.md
index 0a34c8cfad2..6c938a60279 100644
--- a/src/uu/wc/BENCHMARKING.md
+++ b/src/uu/wc/BENCHMARKING.md
@@ -26,10 +26,11 @@ 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
+### Counting lines and UTF-8 characters
 
-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.
+If the flags set are a subset of `-clm` then the input doesn't have to be decoded. The
+input is read in chunks and the `bytecount` crate is used to count the newlines (`-l` flag) 
+and/or UTF-8 characters (`-m` flag).
 
 It's useful to vary the line length in the input. GNU wc seems particularly
 bad at short lines.
@@ -86,8 +87,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 |
+| `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 |
 | `wc -m <FILE>`         |       2.7272 |           2.1704 |          7.3371 |            3.4347 |
diff --git a/src/uu/wc/Cargo.toml b/src/uu/wc/Cargo.toml
index 199cc4e0a29..9d43a2a229e 100644
--- a/src/uu/wc/Cargo.toml
+++ b/src/uu/wc/Cargo.toml
@@ -1,23 +1,26 @@
 [package]
 name = "uu_wc"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "wc ~ (uutils) display newline, word, and byte counts for input"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/wc"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/wc.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["pipes"] }
-bytecount = { workspace = true }
+uucore = { workspace = true, features = ["parser", "pipes", "quoting-style"] }
+bytecount = { workspace = true, features = ["runtime-dispatch-simd"] }
 thiserror = { workspace = true }
 unicode-width = { workspace = true }
 
diff --git a/src/uu/wc/src/count_fast.rs b/src/uu/wc/src/count_fast.rs
index 863625921bf..a8f5dd4326b 100644
--- a/src/uu/wc/src/count_fast.rs
+++ b/src/uu/wc/src/count_fast.rs
@@ -2,6 +2,8 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+
+// cSpell:ignore sysconf
 use crate::word_count::WordCount;
 
 use super::WordCountable;
@@ -11,18 +13,26 @@ use std::fs::OpenOptions;
 use std::io::{self, ErrorKind, Read};
 
 #[cfg(unix)]
-use libc::S_IFREG;
+use libc::{_SC_PAGESIZE, S_IFREG, sysconf};
 #[cfg(unix)]
 use nix::sys::stat;
-#[cfg(any(target_os = "linux", target_os = "android"))]
-use std::os::unix::io::AsRawFd;
+#[cfg(unix)]
+use std::io::{Seek, SeekFrom};
+#[cfg(unix)]
+use std::os::fd::{AsFd, AsRawFd};
+#[cfg(windows)]
+use std::os::windows::fs::MetadataExt;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_ARCHIVE: u32 = 32;
+#[cfg(windows)]
+const FILE_ATTRIBUTE_NORMAL: u32 = 128;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use libc::S_IFIFO;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use uucore::pipes::{pipe, splice, splice_exact};
 
-const BUF_SIZE: usize = 16 * 1024;
+const BUF_SIZE: usize = 256 * 1024;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const SPLICE_SIZE: usize = 128 * 1024;
 
@@ -33,15 +43,13 @@ const SPLICE_SIZE: usize = 128 * 1024;
 /// caller will fall back to a simpler method.
 #[inline]
 #[cfg(any(target_os = "linux", target_os = "android"))]
-fn count_bytes_using_splice(fd: &impl AsRawFd) -> Result<usize, usize> {
+fn count_bytes_using_splice(fd: &impl AsFd) -> Result<usize, usize> {
     let null_file = OpenOptions::new()
         .write(true)
         .open("/dev/null")
         .map_err(|_| 0_usize)?;
-    let null_rdev = stat::fstat(null_file.as_raw_fd())
-        .map_err(|_| 0_usize)?
-        .st_rdev as libc::dev_t;
-    if unsafe { (libc::major(null_rdev), libc::minor(null_rdev)) } != (1, 3) {
+    let null_rdev = stat::fstat(null_file.as_fd()).map_err(|_| 0_usize)?.st_rdev as libc::dev_t;
+    if (libc::major(null_rdev), libc::minor(null_rdev)) != (1, 3) {
         // This is not a proper /dev/null, writing to it is probably bad
         // Bit of an edge case, but it has been known to happen
         return Err(0);
@@ -72,6 +80,8 @@ fn count_bytes_using_splice(fd: &impl AsRawFd) -> Result<usize, usize> {
 ///   1. On Unix,  we can simply `stat` the file if it is regular.
 ///   2. On Linux -- if the above did not work -- we can use splice to count
 ///      the number of bytes if the file is a FIFO.
+///   3. On Windows we can use `std::os::windows::fs::MetadataExt` to get file size
+///      for regular files
 ///   3. Otherwise, we just read normally, but without the overhead of counting
 ///      other things such as lines and words.
 #[inline]
@@ -80,18 +90,70 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
 
     #[cfg(unix)]
     {
-        let fd = handle.as_raw_fd();
+        let fd = handle.as_fd();
         if let Ok(stat) = stat::fstat(fd) {
             // If the file is regular, then the `st_size` should hold
             // the file's size in bytes.
             // If stat.st_size = 0 then
             //  - either the size is 0
             //  - or the size is unknown.
-            // The second case happens for files in pseudo-filesystems. For
-            // example with /proc/version and /sys/kernel/profiling. So,
-            // if it is 0 we don't report that and instead do a full read.
-            if (stat.st_mode as libc::mode_t & S_IFREG) != 0 && stat.st_size > 0 {
-                return (stat.st_size as usize, None);
+            // The second case happens for files in pseudo-filesystems.
+            // For example with /proc/version.
+            // So, if it is 0 we don't report that and instead do a full read.
+            //
+            // Another thing to consider for files in pseudo-filesystems like /proc, /sys
+            // and similar is that they could report `st_size` greater than actual content.
+            // For example /sys/kernel/profiling could report `st_size` equal to
+            // system page size (typically 4096 on 64bit system), while it's file content
+            // would count up only to a couple of bytes.
+            // This condition usually occurs for files in pseudo-filesystems like /proc, /sys
+            // that report `st_size` in the multiples of system page size.
+            // In such cases - attempt `seek()` almost to the end of the file
+            // and then fall back on read to count the rest.
+            //
+            // And finally a special case of input redirection in *nix shell:
+            // `( wc -c ; wc -c ) < file` should return
+            // ```
+            // size_of_file
+            // 0
+            // ```
+            // Similarly
+            // `( head -c1 ; wc -c ) < file` should return
+            // ```
+            // first_byte_of_file
+            // size_of_file - 1
+            // ```
+            // Since the input stream from file is treated as continuous across both commands inside ().
+            // In cases like this, due to `<` redirect, the `stat.st_mode` would report input as a regular file
+            // and `stat.st_size` would report the size of file on disk
+            // and NOT the remaining number of bytes in the input stream.
+            // However, the raw file descriptor in this situation would be equal to `0`
+            // for STDIN in both invocations.
+            // Therefore we cannot rely of `st_size` here and should fall back on full read.
+            if fd.as_raw_fd() > 0
+                && (stat.st_mode as libc::mode_t & S_IFREG) != 0
+                && stat.st_size > 0
+            {
+                let sys_page_size = unsafe { sysconf(_SC_PAGESIZE) as usize };
+                if stat.st_size as usize % sys_page_size > 0 {
+                    // regular file or file from /proc, /sys and similar pseudo-filesystems
+                    // with size that is NOT a multiple of system page size
+                    return (stat.st_size as usize, None);
+                } else if let Some(file) = handle.inner_file() {
+                    // On some platforms `stat.st_blksize` and `stat.st_size`
+                    // are of different types: i64 vs i32
+                    // i.e. MacOS on Apple Silicon (aarch64-apple-darwin),
+                    // Debian Linux on ARM (aarch64-unknown-linux-gnu),
+                    // 32bit i686 targets, etc.
+                    // While on the others they are of the same type.
+                    #[allow(clippy::unnecessary_cast)]
+                    let offset =
+                        stat.st_size as i64 - stat.st_size as i64 % (stat.st_blksize as i64 + 1);
+
+                    if let Ok(n) = file.seek(SeekFrom::Start(offset as u64)) {
+                        byte_count = n as usize;
+                    }
+                }
             }
             #[cfg(any(target_os = "linux", target_os = "android"))]
             {
@@ -107,6 +169,21 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
         }
     }
 
+    #[cfg(windows)]
+    {
+        if let Some(file) = handle.inner_file() {
+            if let Ok(metadata) = file.metadata() {
+                let attributes = metadata.file_attributes();
+
+                if (attributes & FILE_ATTRIBUTE_ARCHIVE) != 0
+                    || (attributes & FILE_ATTRIBUTE_NORMAL) != 0
+                {
+                    return (metadata.file_size() as usize, None);
+                }
+            }
+        }
+    }
+
     // Fall back on `read`, but without the overhead of counting words and lines.
     let mut buf = [0_u8; BUF_SIZE];
     loop {
@@ -121,6 +198,23 @@ pub(crate) fn count_bytes_fast<T: WordCountable>(handle: &mut T) -> (usize, Opti
     }
 }
 
+/// A simple structure used to align a BUF_SIZE buffer to 32-byte boundary.
+///
+/// This is useful as bytecount uses 256-bit wide vector operations that run much
+/// faster on aligned data (at least on x86 with AVX2 support).
+#[repr(align(32))]
+struct AlignedBuffer {
+    data: [u8; BUF_SIZE],
+}
+
+impl Default for AlignedBuffer {
+    fn default() -> Self {
+        Self {
+            data: [0; BUF_SIZE],
+        }
+    }
+}
+
 /// Returns a WordCount that counts the number of bytes, lines, and/or the number of Unicode characters encoded in UTF-8 read via a Reader.
 ///
 /// This corresponds to the `-c`, `-l` and `-m` command line flags to wc.
@@ -136,25 +230,17 @@ pub(crate) fn count_bytes_chars_and_lines_fast<
 >(
     handle: &mut R,
 ) -> (WordCount, Option<io::Error>) {
-    /// Mask of the value bits of a continuation byte
-    const CONT_MASK: u8 = 0b0011_1111u8;
-    /// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte
-    const TAG_CONT_U8: u8 = 0b1000_0000u8;
-
     let mut total = WordCount::default();
-    let mut buf = [0; BUF_SIZE];
+    let buf: &mut [u8] = &mut AlignedBuffer::default().data;
     loop {
-        match handle.read(&mut buf) {
+        match handle.read(buf) {
             Ok(0) => return (total, None),
             Ok(n) => {
                 if COUNT_BYTES {
                     total.bytes += n;
                 }
                 if COUNT_CHARS {
-                    total.chars += buf[..n]
-                        .iter()
-                        .filter(|&&byte| (byte & !CONT_MASK) != TAG_CONT_U8)
-                        .count();
+                    total.chars += bytecount::num_chars(&buf[..n]);
                 }
                 if COUNT_LINES {
                     total.lines += bytecount::count(&buf[..n], b'\n');
diff --git a/src/uu/wc/src/countable.rs b/src/uu/wc/src/countable.rs
index 64397446491..5b2ad7a9965 100644
--- a/src/uu/wc/src/countable.rs
+++ b/src/uu/wc/src/countable.rs
@@ -11,18 +11,20 @@ use std::fs::File;
 use std::io::{BufRead, BufReader, Read, StdinLock};
 
 #[cfg(unix)]
-use std::os::unix::io::AsRawFd;
+use std::os::fd::{AsFd, AsRawFd};
 
 #[cfg(unix)]
-pub trait WordCountable: AsRawFd + Read {
+pub trait WordCountable: AsFd + AsRawFd + Read {
     type Buffered: BufRead;
     fn buffered(self) -> Self::Buffered;
+    fn inner_file(&mut self) -> Option<&mut File>;
 }
 
 #[cfg(not(unix))]
 pub trait WordCountable: Read {
     type Buffered: BufRead;
     fn buffered(self) -> Self::Buffered;
+    fn inner_file(&mut self) -> Option<&mut File>;
 }
 
 impl WordCountable for StdinLock<'_> {
@@ -31,6 +33,9 @@ impl WordCountable for StdinLock<'_> {
     fn buffered(self) -> Self::Buffered {
         self
     }
+    fn inner_file(&mut self) -> Option<&mut File> {
+        None
+    }
 }
 
 impl WordCountable for File {
@@ -39,4 +44,8 @@ impl WordCountable for File {
     fn buffered(self) -> Self::Buffered {
         BufReader::new(self)
     }
+
+    fn inner_file(&mut self) -> Option<&mut File> {
+        Some(self)
+    }
 }
diff --git a/src/uu/wc/src/utf8/read.rs b/src/uu/wc/src/utf8/read.rs
index 4a92d85e688..af10cbb5366 100644
--- a/src/uu/wc/src/utf8/read.rs
+++ b/src/uu/wc/src/utf8/read.rs
@@ -4,10 +4,8 @@
 // file that was distributed with this source code.
 // spell-checker:ignore bytestream
 use super::*;
-use std::error::Error;
-use std::fmt;
 use std::io::{self, BufRead};
-use std::str;
+use thiserror::Error;
 
 /// Wraps a `std::io::BufRead` buffered byte stream and decode it as UTF-8.
 pub struct BufReadDecoder<B: BufRead> {
@@ -16,36 +14,18 @@ pub struct BufReadDecoder<B: BufRead> {
     incomplete: Incomplete,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 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`.)
+    #[error("invalid byte sequence: {0:02x?}")]
     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),
-        }
-    }
+    #[error("underlying bytestream error: {0}")]
+    Io(#[source] io::Error),
 }
 
 impl<B: BufRead> BufReadDecoder<B> {
@@ -100,7 +80,7 @@ impl<B: BufRead> BufReadDecoder<B> {
                         }
                         match error.error_len() {
                             Some(invalid_sequence_length) => {
-                                break (BytesSource::BufRead(invalid_sequence_length), Err(()))
+                                break (BytesSource::BufRead(invalid_sequence_length), Err(()));
                             }
                             None => {
                                 self.bytes_consumed = buf.len();
diff --git a/src/uu/wc/src/wc.rs b/src/uu/wc/src/wc.rs
index 6d5894db058..47abfe2102f 100644
--- a/src/uu/wc/src/wc.rs
+++ b/src/uu/wc/src/wc.rs
@@ -13,14 +13,14 @@ mod word_count;
 use std::{
     borrow::{Borrow, Cow},
     cmp::max,
-    ffi::OsString,
+    ffi::{OsStr, OsString},
     fs::{self, File},
     io::{self, Write},
     iter,
     path::{Path, PathBuf},
 };
 
-use clap::{builder::ValueParser, crate_version, Arg, ArgAction, ArgMatches, Command};
+use clap::{Arg, ArgAction, ArgMatches, Command, builder::ValueParser};
 use thiserror::Error;
 use unicode_width::UnicodeWidthChar;
 use utf8::{BufReadDecoder, BufReadDecoderError};
@@ -28,7 +28,8 @@ use utf8::{BufReadDecoder, BufReadDecoderError};
 use uucore::{
     error::{FromIo, UError, UResult},
     format_usage, help_about, help_usage,
-    quoting_style::{escape_name, QuotingStyle},
+    parser::shortcut_value_parser::ShortcutValueParser,
+    quoting_style::{self, QuotingStyle},
     show,
 };
 
@@ -167,7 +168,9 @@ impl<'a> Inputs<'a> {
                     None => Ok(Self::Files0From(input)),
                 }
             }
-            (Some(_), Some(_)) => Err(WcError::FilesDisabled.into()),
+            (Some(mut files), Some(_)) => {
+                Err(WcError::files_disabled(files.next().unwrap()).into())
+            }
         }
     }
 
@@ -188,7 +191,7 @@ impl<'a> Inputs<'a> {
 
         // 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 files0_from_path = settings.files0_from.as_ref().map(Input::as_borrowed);
 
         let iter = iter::from_fn(move || {
             let (idx, next) = with_idx.next()?;
@@ -252,13 +255,17 @@ impl<'a> Input<'a> {
     }
 
     /// Converts input to title that appears in stats.
-    fn to_title(&self) -> Option<Cow<str>> {
+    fn to_title(&self) -> Option<Cow<OsStr>> {
         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::Path(path) => {
+                let path = path.as_os_str();
+                if path.to_string_lossy().contains('\n') {
+                    Some(Cow::Owned(quoting_style::escape_name(path, QS_ESCAPE)))
+                } else {
+                    Some(Cow::Borrowed(path))
+                }
+            }
+            Self::Stdin(StdinKind::Explicit) => Some(Cow::Borrowed(OsStr::new(STDIN_REPR))),
             Self::Stdin(StdinKind::Implicit) => None,
         }
     }
@@ -266,7 +273,7 @@ impl<'a> Input<'a> {
     /// Converts input into the form that appears in errors.
     fn path_display(&self) -> String {
         match self {
-            Self::Path(path) => escape_name(path.as_os_str(), QS_ESCAPE),
+            Self::Path(path) => escape_name_wrapper(path.as_os_str()),
             Self::Stdin(_) => String::from("standard input"),
         }
     }
@@ -342,8 +349,8 @@ impl TotalWhen {
 
 #[derive(Debug, Error)]
 enum WcError {
-    #[error("file operands cannot be combined with --files0-from")]
-    FilesDisabled,
+    #[error("extra operand '{extra}'\nfile operands cannot be combined with --files0-from")]
+    FilesDisabled { extra: Cow<'static, str> },
     #[error("when reading file names from stdin, no file name of '-' allowed")]
     StdinReprNotAllowed,
     #[error("invalid zero-length file name")]
@@ -358,18 +365,22 @@ impl WcError {
             Some((input, idx)) => {
                 let path = match input {
                     Input::Stdin(_) => STDIN_REPR.into(),
-                    Input::Path(path) => escape_name(path.as_os_str(), QS_ESCAPE).into(),
+                    Input::Path(path) => escape_name_wrapper(path.as_os_str()).into(),
                 };
                 Self::ZeroLengthFileNameCtx { path, idx }
             }
             None => Self::ZeroLengthFileName,
         }
     }
+    fn files_disabled(first_extra: &OsString) -> Self {
+        let extra = first_extra.to_string_lossy().into_owned().into();
+        Self::FilesDisabled { extra }
+    }
 }
 
 impl UError for WcError {
     fn usage(&self) -> bool {
-        matches!(self, Self::FilesDisabled)
+        matches!(self, Self::FilesDisabled { .. })
     }
 }
 
@@ -385,10 +396,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
+        .args_override_self(true)
         .arg(
             Arg::new(options::BYTES)
                 .short('c')
@@ -432,7 +444,9 @@ pub fn uu_app() -> Command {
         .arg(
             Arg::new(options::TOTAL)
                 .long(options::TOTAL)
-                .value_parser(["auto", "always", "only", "never"])
+                .value_parser(ShortcutValueParser::new([
+                    "auto", "always", "only", "never",
+                ]))
                 .value_name("WHEN")
                 .hide_possible_values(true)
                 .help(concat!(
@@ -519,11 +533,11 @@ fn word_count_from_reader<T: WordCountable>(
         (_, false, false, true, true) => {
             word_count_from_reader_specialized::<_, false, false, true, true>(reader)
         }
-        // show_chars, show_words
+        // show_lines, show_words
         (_, false, true, false, true) => {
             word_count_from_reader_specialized::<_, false, true, false, true>(reader)
         }
-        // show_chars, show_lines
+        // show_lines, show_max_line_length
         (_, false, true, true, false) => {
             word_count_from_reader_specialized::<_, false, true, true, false>(reader)
         }
@@ -558,7 +572,64 @@ fn word_count_from_reader<T: WordCountable>(
     }
 }
 
-#[allow(clippy::cognitive_complexity)]
+fn process_chunk<
+    const SHOW_CHARS: bool,
+    const SHOW_LINES: bool,
+    const SHOW_MAX_LINE_LENGTH: bool,
+    const SHOW_WORDS: bool,
+>(
+    total: &mut WordCount,
+    text: &str,
+    current_len: &mut usize,
+    in_word: &mut bool,
+) {
+    for ch in text.chars() {
+        if SHOW_WORDS {
+            if ch.is_whitespace() {
+                *in_word = false;
+            } else if !(*in_word) {
+                // This also counts control characters! (As of GNU coreutils 9.5)
+                *in_word = true;
+                total.words += 1;
+            }
+        }
+        if SHOW_MAX_LINE_LENGTH {
+            match ch {
+                '\n' | '\r' | '\x0c' => {
+                    total.max_line_length = max(*current_len, total.max_line_length);
+                    *current_len = 0;
+                }
+                '\t' => {
+                    *current_len -= *current_len % 8;
+                    *current_len += 8;
+                }
+                _ => {
+                    *current_len += ch.width().unwrap_or(0);
+                }
+            }
+        }
+        if SHOW_LINES && ch == '\n' {
+            total.lines += 1;
+        }
+        if SHOW_CHARS {
+            total.chars += 1;
+        }
+    }
+    total.bytes += text.len();
+
+    total.max_line_length = max(*current_len, total.max_line_length);
+}
+
+fn handle_error(error: BufReadDecoderError<'_>, total: &mut WordCount) -> Option<io::Error> {
+    match error {
+        BufReadDecoderError::InvalidByteSequence(bytes) => {
+            total.bytes += bytes.len();
+        }
+        BufReadDecoderError::Io(e) => return Some(e),
+    }
+    None
+}
+
 fn word_count_from_reader_specialized<
     T: WordCountable,
     const SHOW_CHARS: bool,
@@ -572,58 +643,24 @@ fn word_count_from_reader_specialized<
     let mut reader = BufReadDecoder::new(reader.buffered());
     let mut in_word = false;
     let mut current_len = 0;
-
     while let Some(chunk) = reader.next_strict() {
         match chunk {
             Ok(text) => {
-                for ch in text.chars() {
-                    if SHOW_WORDS {
-                        if ch.is_whitespace() {
-                            in_word = false;
-                        } else if ch.is_ascii_control() {
-                            // These count as characters but do not affect the word state
-                        } else if !in_word {
-                            in_word = true;
-                            total.words += 1;
-                        }
-                    }
-                    if SHOW_MAX_LINE_LENGTH {
-                        match ch {
-                            '\n' | '\r' | '\x0c' => {
-                                total.max_line_length = max(current_len, total.max_line_length);
-                                current_len = 0;
-                            }
-                            '\t' => {
-                                current_len -= current_len % 8;
-                                current_len += 8;
-                            }
-                            _ => {
-                                current_len += ch.width().unwrap_or(0);
-                            }
-                        }
-                    }
-                    if SHOW_LINES && ch == '\n' {
-                        total.lines += 1;
-                    }
-                    if SHOW_CHARS {
-                        total.chars += 1;
-                    }
-                }
-                total.bytes += text.len();
-            }
-            Err(BufReadDecoderError::InvalidByteSequence(bytes)) => {
-                // GNU wc treats invalid data as neither word nor char nor whitespace,
-                // so no other counters are affected
-                total.bytes += bytes.len();
+                process_chunk::<SHOW_CHARS, SHOW_LINES, SHOW_MAX_LINE_LENGTH, SHOW_WORDS>(
+                    &mut total,
+                    text,
+                    &mut current_len,
+                    &mut in_word,
+                );
             }
-            Err(BufReadDecoderError::Io(e)) => {
-                return (total, Some(e));
+            Err(e) => {
+                if let Some(e) = handle_error(e, &mut total) {
+                    return (total, Some(e));
+                }
             }
         }
     }
 
-    total.max_line_length = max(current_len, total.max_line_length);
-
     (total, None)
 }
 
@@ -702,7 +739,7 @@ fn compute_number_width(inputs: &Inputs, settings: &Settings) -> usize {
             if total == 0 {
                 minimum_width
             } else {
-                let total_width = (1 + ilog10_u64(total))
+                let total_width = (1 + total.ilog10())
                     .try_into()
                     .expect("ilog of a u64 should fit into a usize");
                 max(total_width, minimum_width)
@@ -728,7 +765,9 @@ fn files0_iter_file<'a>(path: &Path) -> UResult<impl Iterator<Item = InputIterIt
         Err(e) => Err(e.map_err_context(|| {
             format!(
                 "cannot open {} for reading",
-                escape_name(path.as_os_str(), QS_QUOTE_ESCAPE)
+                quoting_style::escape_name(path.as_os_str(), QS_QUOTE_ESCAPE)
+                    .into_string()
+                    .expect("All escaped names with the escaping option return valid strings.")
             )
         })),
     }
@@ -755,18 +794,17 @@ fn files0_iter<'a>(
                     // ...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))?;
+                        let s = String::from_utf8(p).map_err(io::Error::other)?;
                         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>),
+                Err(e) => Err(e
+                    .map_err_context(|| format!("{}: read error", escape_name_wrapper(&err_path)))
+                    as Box<dyn UError>),
             }),
     );
     // Loop until there is an error; yield that error and then nothing else.
-    std::iter::from_fn(move || {
+    iter::from_fn(move || {
         let next = i.as_mut().and_then(Iterator::next);
         if matches!(next, Some(Err(_)) | None) {
             i = None;
@@ -775,6 +813,12 @@ fn files0_iter<'a>(
     })
 }
 
+fn escape_name_wrapper(name: &OsStr) -> String {
+    quoting_style::escape_name(name, QS_ESCAPE)
+        .into_string()
+        .expect("All escaped names with the escaping option return valid strings.")
+}
+
 fn wc(inputs: &Inputs, settings: &Settings) -> UResult<()> {
     let mut total_word_count = WordCount::default();
     let mut num_inputs: usize = 0;
@@ -811,14 +855,17 @@ fn wc(inputs: &Inputs, settings: &Settings) -> UResult<()> {
             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}")));
+                let title = maybe_title_str.unwrap_or(OsStr::new("<stdin>"));
+                show!(err.map_err_context(|| format!(
+                    "failed to print result for {}",
+                    title.to_string_lossy()
+                )));
             }
         }
     }
 
     if settings.total_when.is_total_row_visible(num_inputs) {
-        let title = are_stats_visible.then_some("total");
+        let title = are_stats_visible.then_some(OsStr::new("total"));
         if let Err(err) = print_stats(settings, &total_word_count, title, number_width) {
             show!(err.map_err_context(|| "failed to print total".into()));
         }
@@ -832,7 +879,7 @@ fn wc(inputs: &Inputs, settings: &Settings) -> UResult<()> {
 fn print_stats(
     settings: &Settings,
     result: &WordCount,
-    title: Option<&str>,
+    title: Option<&OsStr>,
     number_width: usize,
 ) -> io::Result<()> {
     let mut stdout = io::stdout().lock();
@@ -852,34 +899,8 @@ fn print_stats(
     }
 
     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!(),
+        write!(stdout, "{space}")?;
+        stdout.write_all(&uucore::os_str_as_bytes_lossy(title))?;
     }
+    writeln!(stdout)
 }
diff --git a/src/uu/who/Cargo.toml b/src/uu/who/Cargo.toml
index b8b90b2ef31..b4578021387 100644
--- a/src/uu/who/Cargo.toml
+++ b/src/uu/who/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_who"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "who ~ (uutils) display information about currently logged-in users"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/who"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/who.rs"
diff --git a/src/uu/who/src/platform/mod.rs b/src/uu/who/src/platform/mod.rs
new file mode 100644
index 00000000000..e0e87dca1bf
--- /dev/null
+++ b/src/uu/who/src/platform/mod.rs
@@ -0,0 +1,14 @@
+// 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.
+
+#[cfg(not(target_os = "openbsd"))]
+mod unix;
+#[cfg(not(target_os = "openbsd"))]
+pub use self::unix::*;
+
+#[cfg(target_os = "openbsd")]
+mod openbsd;
+#[cfg(target_os = "openbsd")]
+pub use self::openbsd::*;
diff --git a/src/uu/who/src/platform/openbsd.rs b/src/uu/who/src/platform/openbsd.rs
new file mode 100644
index 00000000000..7e6970c1f09
--- /dev/null
+++ b/src/uu/who/src/platform/openbsd.rs
@@ -0,0 +1,17 @@
+// 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.
+
+// Specific implementation for OpenBSD: tool unsupported (utmpx not supported)
+
+use crate::uu_app;
+
+use uucore::error::UResult;
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+
+    println!("unsupported command on OpenBSD");
+    Ok(())
+}
diff --git a/src/uu/who/src/platform/unix.rs b/src/uu/who/src/platform/unix.rs
new file mode 100644
index 00000000000..93681cb57e1
--- /dev/null
+++ b/src/uu/who/src/platform/unix.rs
@@ -0,0 +1,430 @@
+// 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.
+
+// spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
+
+use crate::options;
+use crate::uu_app;
+
+use uucore::display::Quotable;
+use uucore::error::{FromIo, UResult};
+use uucore::libc::{S_IWGRP, STDIN_FILENO, ttyname};
+use uucore::utmpx::{self, Utmpx, time};
+
+use std::borrow::Cow;
+use std::ffi::CStr;
+use std::fmt::Write;
+use std::os::unix::fs::MetadataExt;
+use std::path::PathBuf;
+
+fn get_long_usage() -> String {
+    format!(
+        "If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.\n\
+         If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.",
+        utmpx::DEFAULT_FILE,
+    )
+}
+
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app()
+        .after_help(get_long_usage())
+        .try_get_matches_from(args)?;
+
+    let files: Vec<String> = matches
+        .get_many::<String>(options::FILE)
+        .map(|v| v.map(ToString::to_string).collect())
+        .unwrap_or_default();
+
+    // If true, attempt to canonicalize hostnames via a DNS lookup.
+    let do_lookup = matches.get_flag(options::LOOKUP);
+
+    // If true, display only a list of usernames and count of
+    // the users logged on.
+    // Ignored for 'who am i'.
+    let short_list = matches.get_flag(options::COUNT);
+
+    let all = matches.get_flag(options::ALL);
+
+    // If true, display a line at the top describing each field.
+    let include_heading = matches.get_flag(options::HEADING);
+
+    // If true, display a '+' for each user if mesg y, a '-' if mesg n,
+    // or a '?' if their tty cannot be statted.
+    let include_mesg = all || matches.get_flag(options::MESG);
+
+    // If true, display the last boot time.
+    let need_boottime = all || matches.get_flag(options::BOOT);
+
+    // If true, display dead processes.
+    let need_deadprocs = all || matches.get_flag(options::DEAD);
+
+    // If true, display processes waiting for user login.
+    let need_login = all || matches.get_flag(options::LOGIN);
+
+    // If true, display processes started by init.
+    let need_initspawn = all || matches.get_flag(options::PROCESS);
+
+    // If true, display the last clock change.
+    let need_clockchange = all || matches.get_flag(options::TIME);
+
+    // If true, display the current runlevel.
+    let need_runlevel = all || matches.get_flag(options::RUNLEVEL);
+
+    let use_defaults = !(all
+        || need_boottime
+        || need_deadprocs
+        || need_login
+        || need_initspawn
+        || need_runlevel
+        || need_clockchange
+        || matches.get_flag(options::USERS));
+
+    // If true, display user processes.
+    let need_users = all || matches.get_flag(options::USERS) || use_defaults;
+
+    // If true, display the hours:minutes since each user has touched
+    // the keyboard, or "." if within the last minute, or "old" if
+    // not within the last day.
+    let include_idle = need_deadprocs || need_login || need_runlevel || need_users;
+
+    // If true, display process termination & exit status.
+    let include_exit = need_deadprocs;
+
+    // If true, display only name, line, and time fields.
+    let short_output = !include_exit && use_defaults;
+
+    // If true, display info only for the controlling tty.
+    let my_line_only = matches.get_flag(options::ONLY_HOSTNAME_USER) || files.len() == 2;
+
+    let mut who = Who {
+        do_lookup,
+        short_list,
+        short_output,
+        include_idle,
+        include_heading,
+        include_mesg,
+        include_exit,
+        need_boottime,
+        need_deadprocs,
+        need_login,
+        need_initspawn,
+        need_clockchange,
+        need_runlevel,
+        need_users,
+        my_line_only,
+        args: files,
+    };
+
+    who.exec()
+}
+
+struct Who {
+    do_lookup: bool,
+    short_list: bool,
+    short_output: bool,
+    include_idle: bool,
+    include_heading: bool,
+    include_mesg: bool,
+    include_exit: bool,
+    need_boottime: bool,
+    need_deadprocs: bool,
+    need_login: bool,
+    need_initspawn: bool,
+    need_clockchange: bool,
+    need_runlevel: bool,
+    need_users: bool,
+    my_line_only: bool,
+    args: Vec<String>,
+}
+
+fn idle_string<'a>(when: i64, boottime: i64) -> Cow<'a, str> {
+    thread_local! {
+        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
+    }
+    NOW.with(|n| {
+        let now = n.unix_timestamp();
+        if boottime < when && now - 24 * 3600 < when && when <= now {
+            let seconds_idle = now - when;
+            if seconds_idle < 60 {
+                "  .  ".into()
+            } else {
+                format!(
+                    "{:02}:{:02}",
+                    seconds_idle / 3600,
+                    (seconds_idle % 3600) / 60
+                )
+                .into()
+            }
+        } else {
+            " old ".into()
+        }
+    })
+}
+
+fn time_string(ut: &Utmpx) -> String {
+    // "%b %e %H:%M"
+    let time_format: Vec<time::format_description::FormatItem> =
+        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
+            .unwrap();
+    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
+}
+
+#[inline]
+fn current_tty() -> String {
+    unsafe {
+        let res = ttyname(STDIN_FILENO);
+        if res.is_null() {
+            String::new()
+        } else {
+            CStr::from_ptr(res.cast_const())
+                .to_string_lossy()
+                .trim_start_matches("/dev/")
+                .to_owned()
+        }
+    }
+}
+
+impl Who {
+    #[allow(clippy::cognitive_complexity)]
+    fn exec(&mut self) -> UResult<()> {
+        let run_level_chk = |_record: i16| {
+            #[cfg(not(target_os = "linux"))]
+            return false;
+
+            #[cfg(target_os = "linux")]
+            return _record == utmpx::RUN_LVL;
+        };
+
+        let f = if self.args.len() == 1 {
+            self.args[0].as_ref()
+        } else {
+            utmpx::DEFAULT_FILE
+        };
+        if self.short_list {
+            let users = Utmpx::iter_all_records_from(f)
+                .filter(Utmpx::is_user_process)
+                .map(|ut| ut.user())
+                .collect::<Vec<_>>();
+            println!("{}", users.join(" "));
+            println!("# users={}", users.len());
+        } else {
+            let records = Utmpx::iter_all_records_from(f);
+
+            if self.include_heading {
+                self.print_heading();
+            }
+            let cur_tty = if self.my_line_only {
+                current_tty()
+            } else {
+                String::new()
+            };
+
+            for ut in records {
+                if !self.my_line_only || cur_tty == ut.tty_device() {
+                    if self.need_users && ut.is_user_process() {
+                        self.print_user(&ut)?;
+                    } else if self.need_runlevel && run_level_chk(ut.record_type()) {
+                        if cfg!(target_os = "linux") {
+                            self.print_runlevel(&ut);
+                        }
+                    } else if self.need_boottime && ut.record_type() == utmpx::BOOT_TIME {
+                        self.print_boottime(&ut);
+                    } else if self.need_clockchange && ut.record_type() == utmpx::NEW_TIME {
+                        self.print_clockchange(&ut);
+                    } else if self.need_initspawn && ut.record_type() == utmpx::INIT_PROCESS {
+                        self.print_initspawn(&ut);
+                    } else if self.need_login && ut.record_type() == utmpx::LOGIN_PROCESS {
+                        self.print_login(&ut);
+                    } else if self.need_deadprocs && ut.record_type() == utmpx::DEAD_PROCESS {
+                        self.print_deadprocs(&ut);
+                    }
+                }
+
+                if ut.record_type() == utmpx::BOOT_TIME {}
+            }
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn print_runlevel(&self, ut: &Utmpx) {
+        let last = (ut.pid() / 256) as u8 as char;
+        let curr = (ut.pid() % 256) as u8 as char;
+        let runlvline = format!("run-level {curr}");
+        let comment = format!("last={}", if last == 'N' { 'S' } else { 'N' });
+
+        self.print_line(
+            "",
+            ' ',
+            &runlvline,
+            &time_string(ut),
+            "",
+            "",
+            if last.is_control() { "" } else { &comment },
+            "",
+        );
+    }
+
+    #[inline]
+    fn print_clockchange(&self, ut: &Utmpx) {
+        self.print_line("", ' ', "clock change", &time_string(ut), "", "", "", "");
+    }
+
+    #[inline]
+    fn print_login(&self, ut: &Utmpx) {
+        let comment = format!("id={}", ut.terminal_suffix());
+        let pidstr = format!("{}", ut.pid());
+        self.print_line(
+            "LOGIN",
+            ' ',
+            &ut.tty_device(),
+            &time_string(ut),
+            "",
+            &pidstr,
+            &comment,
+            "",
+        );
+    }
+
+    #[inline]
+    fn print_deadprocs(&self, ut: &Utmpx) {
+        let comment = format!("id={}", ut.terminal_suffix());
+        let pidstr = format!("{}", ut.pid());
+        let e = ut.exit_status();
+        let exitstr = format!("term={} exit={}", e.0, e.1);
+        self.print_line(
+            "",
+            ' ',
+            &ut.tty_device(),
+            &time_string(ut),
+            "",
+            &pidstr,
+            &comment,
+            &exitstr,
+        );
+    }
+
+    #[inline]
+    fn print_initspawn(&self, ut: &Utmpx) {
+        let comment = format!("id={}", ut.terminal_suffix());
+        let pidstr = format!("{}", ut.pid());
+        self.print_line(
+            "",
+            ' ',
+            &ut.tty_device(),
+            &time_string(ut),
+            "",
+            &pidstr,
+            &comment,
+            "",
+        );
+    }
+
+    #[inline]
+    fn print_boottime(&self, ut: &Utmpx) {
+        self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
+    }
+
+    fn print_user(&self, ut: &Utmpx) -> UResult<()> {
+        let mut p = PathBuf::from("/dev");
+        p.push(ut.tty_device().as_str());
+        let mesg;
+        let last_change;
+        match p.metadata() {
+            Ok(meta) => {
+                #[cfg(all(
+                    not(target_os = "android"),
+                    not(target_os = "freebsd"),
+                    not(target_vendor = "apple")
+                ))]
+                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 { '+' };
+                last_change = meta.atime();
+            }
+            _ => {
+                mesg = '?';
+                last_change = 0;
+            }
+        }
+
+        let idle = if last_change == 0 {
+            "  ?".into()
+        } else {
+            idle_string(last_change, 0)
+        };
+
+        let s = if self.do_lookup {
+            ut.canon_host().map_err_context(|| {
+                let host = ut.host();
+                format!(
+                    "failed to canonicalize {}",
+                    host.split(':').next().unwrap_or(&host).quote()
+                )
+            })?
+        } else {
+            ut.host()
+        };
+        let hoststr = if s.is_empty() { s } else { format!("({s})") };
+
+        self.print_line(
+            ut.user().as_ref(),
+            mesg,
+            ut.tty_device().as_ref(),
+            time_string(ut).as_str(),
+            idle.as_ref(),
+            format!("{}", ut.pid()).as_str(),
+            hoststr.as_str(),
+            "",
+        );
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn print_line(
+        &self,
+        user: &str,
+        state: char,
+        line: &str,
+        time: &str,
+        idle: &str,
+        pid: &str,
+        comment: &str,
+        exit: &str,
+    ) {
+        let mut buf = String::with_capacity(64);
+        let msg = vec![' ', state].into_iter().collect::<String>();
+
+        write!(buf, "{user:<8}").unwrap();
+        if self.include_mesg {
+            buf.push_str(&msg);
+        }
+        write!(buf, " {line:<12}").unwrap();
+        // "%b %e %H:%M" (LC_ALL=C)
+        let time_size = 3 + 2 + 2 + 1 + 2;
+        write!(buf, " {time:<time_size$}").unwrap();
+
+        if !self.short_output {
+            if self.include_idle {
+                write!(buf, " {idle:<6}").unwrap();
+            }
+            write!(buf, " {pid:>10}").unwrap();
+        }
+        write!(buf, " {comment:<8}").unwrap();
+        if self.include_exit {
+            write!(buf, " {exit:<12}").unwrap();
+        }
+        println!("{}", buf.trim_end());
+    }
+
+    #[inline]
+    fn print_heading(&self) {
+        self.print_line(
+            "NAME", ' ', "LINE", "TIME", "IDLE", "PID", "COMMENT", "EXIT",
+        );
+    }
+}
diff --git a/src/uu/who/src/who.rs b/src/uu/who/src/who.rs
index 29929b13866..2203bbbd119 100644
--- a/src/uu/who/src/who.rs
+++ b/src/uu/who/src/who.rs
@@ -5,19 +5,11 @@
 
 // spell-checker:ignore (ToDO) ttyname hostnames runlevel mesg wtmp statted boottime deadprocs initspawn clockchange curr runlvline pidstr exitstr hoststr
 
-use uucore::display::Quotable;
-use uucore::error::{FromIo, UResult};
-use uucore::libc::{ttyname, STDIN_FILENO, S_IWGRP};
-use uucore::utmpx::{self, time, Utmpx};
-
-use clap::{crate_version, Arg, ArgAction, Command};
-use std::borrow::Cow;
-use std::ffi::CStr;
-use std::fmt::Write;
-use std::os::unix::fs::MetadataExt;
-use std::path::PathBuf;
+use clap::{Arg, ArgAction, Command};
 use uucore::{format_usage, help_about, help_usage};
 
+mod platform;
+
 mod options {
     pub const ALL: &str = "all";
     pub const BOOT: &str = "boot";
@@ -36,7 +28,17 @@ mod options {
     pub const FILE: &str = "FILE"; // if length=1: FILE, if length=2: ARG1 ARG2
 }
 
+#[cfg(target_env = "musl")]
+const ABOUT: &str = concat!(
+    help_about!("who.md"),
+    "\n\nNote: When built with musl libc, the `who` utility will not display any \n",
+    "information about logged-in users. This is due to musl's stub implementation \n",
+    "of `utmpx` functions, which prevents access to the necessary data."
+);
+
+#[cfg(not(target_env = "musl"))]
 const ABOUT: &str = help_about!("who.md");
+
 const USAGE: &str = help_usage!("who.md");
 
 #[cfg(target_os = "linux")]
@@ -44,113 +46,12 @@ static RUNLEVEL_HELP: &str = "print current runlevel";
 #[cfg(not(target_os = "linux"))]
 static RUNLEVEL_HELP: &str = "print current runlevel (This is meaningless on non Linux)";
 
-fn get_long_usage() -> String {
-    format!(
-        "If FILE is not specified, use {}.  /var/log/wtmp as FILE is common.\n\
-         If ARG1 ARG2 given, -m presumed: 'am i' or 'mom likes' are usual.",
-        utmpx::DEFAULT_FILE,
-    )
-}
-
 #[uucore::main]
-pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    let args = args.collect_ignore();
-
-    let matches = uu_app()
-        .after_help(get_long_usage())
-        .try_get_matches_from(args)?;
-
-    let files: Vec<String> = matches
-        .get_many::<String>(options::FILE)
-        .map(|v| v.map(ToString::to_string).collect())
-        .unwrap_or_default();
-
-    // If true, attempt to canonicalize hostnames via a DNS lookup.
-    let do_lookup = matches.get_flag(options::LOOKUP);
-
-    // If true, display only a list of usernames and count of
-    // the users logged on.
-    // Ignored for 'who am i'.
-    let short_list = matches.get_flag(options::COUNT);
-
-    let all = matches.get_flag(options::ALL);
-
-    // If true, display a line at the top describing each field.
-    let include_heading = matches.get_flag(options::HEADING);
-
-    // If true, display a '+' for each user if mesg y, a '-' if mesg n,
-    // or a '?' if their tty cannot be statted.
-    let include_mesg = all || matches.get_flag(options::MESG);
-
-    // If true, display the last boot time.
-    let need_boottime = all || matches.get_flag(options::BOOT);
-
-    // If true, display dead processes.
-    let need_deadprocs = all || matches.get_flag(options::DEAD);
-
-    // If true, display processes waiting for user login.
-    let need_login = all || matches.get_flag(options::LOGIN);
-
-    // If true, display processes started by init.
-    let need_initspawn = all || matches.get_flag(options::PROCESS);
-
-    // If true, display the last clock change.
-    let need_clockchange = all || matches.get_flag(options::TIME);
-
-    // If true, display the current runlevel.
-    let need_runlevel = all || matches.get_flag(options::RUNLEVEL);
-
-    let use_defaults = !(all
-        || need_boottime
-        || need_deadprocs
-        || need_login
-        || need_initspawn
-        || need_runlevel
-        || need_clockchange
-        || matches.get_flag(options::USERS));
-
-    // If true, display user processes.
-    let need_users = all || matches.get_flag(options::USERS) || use_defaults;
-
-    // If true, display the hours:minutes since each user has touched
-    // the keyboard, or "." if within the last minute, or "old" if
-    // not within the last day.
-    let include_idle = need_deadprocs || need_login || need_runlevel || need_users;
-
-    // If true, display process termination & exit status.
-    let include_exit = need_deadprocs;
-
-    // If true, display only name, line, and time fields.
-    let short_output = !include_exit && use_defaults;
-
-    // If true, display info only for the controlling tty.
-    let my_line_only = matches.get_flag(options::ONLY_HOSTNAME_USER) || files.len() == 2;
-
-    let mut who = Who {
-        do_lookup,
-        short_list,
-        short_output,
-        include_idle,
-        include_heading,
-        include_mesg,
-        include_exit,
-        need_boottime,
-        need_deadprocs,
-        need_login,
-        need_initspawn,
-        need_clockchange,
-        need_runlevel,
-        need_users,
-        my_line_only,
-        args: files,
-    };
-
-    who.exec()
-}
+use platform::uumain;
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
@@ -258,311 +159,3 @@ pub fn uu_app() -> Command {
                 .value_hint(clap::ValueHint::FilePath),
         )
 }
-
-struct Who {
-    do_lookup: bool,
-    short_list: bool,
-    short_output: bool,
-    include_idle: bool,
-    include_heading: bool,
-    include_mesg: bool,
-    include_exit: bool,
-    need_boottime: bool,
-    need_deadprocs: bool,
-    need_login: bool,
-    need_initspawn: bool,
-    need_clockchange: bool,
-    need_runlevel: bool,
-    need_users: bool,
-    my_line_only: bool,
-    args: Vec<String>,
-}
-
-fn idle_string<'a>(when: i64, boottime: i64) -> Cow<'a, str> {
-    thread_local! {
-        static NOW: time::OffsetDateTime = time::OffsetDateTime::now_local().unwrap();
-    }
-    NOW.with(|n| {
-        let now = n.unix_timestamp();
-        if boottime < when && now - 24 * 3600 < when && when <= now {
-            let seconds_idle = now - when;
-            if seconds_idle < 60 {
-                "  .  ".into()
-            } else {
-                format!(
-                    "{:02}:{:02}",
-                    seconds_idle / 3600,
-                    (seconds_idle % 3600) / 60
-                )
-                .into()
-            }
-        } else {
-            " old ".into()
-        }
-    })
-}
-
-fn time_string(ut: &Utmpx) -> String {
-    // "%b %e %H:%M"
-    let time_format: Vec<time::format_description::FormatItem> =
-        time::format_description::parse("[month repr:short] [day padding:space] [hour]:[minute]")
-            .unwrap();
-    ut.login_time().format(&time_format).unwrap() // LC_ALL=C
-}
-
-#[inline]
-fn current_tty() -> String {
-    unsafe {
-        let res = ttyname(STDIN_FILENO);
-        if res.is_null() {
-            String::new()
-        } else {
-            CStr::from_ptr(res as *const _)
-                .to_string_lossy()
-                .trim_start_matches("/dev/")
-                .to_owned()
-        }
-    }
-}
-
-impl Who {
-    fn exec(&mut self) -> UResult<()> {
-        let run_level_chk = |_record: i16| {
-            #[cfg(not(target_os = "linux"))]
-            return false;
-
-            #[cfg(target_os = "linux")]
-            return _record == utmpx::RUN_LVL;
-        };
-
-        let f = if self.args.len() == 1 {
-            self.args[0].as_ref()
-        } else {
-            utmpx::DEFAULT_FILE
-        };
-        if self.short_list {
-            let users = Utmpx::iter_all_records_from(f)
-                .filter(Utmpx::is_user_process)
-                .map(|ut| ut.user())
-                .collect::<Vec<_>>();
-            println!("{}", users.join(" "));
-            println!("# users={}", users.len());
-        } else {
-            let records = Utmpx::iter_all_records_from(f);
-
-            if self.include_heading {
-                self.print_heading();
-            }
-            let cur_tty = if self.my_line_only {
-                current_tty()
-            } else {
-                String::new()
-            };
-
-            for ut in records {
-                if !self.my_line_only || cur_tty == ut.tty_device() {
-                    if self.need_users && ut.is_user_process() {
-                        self.print_user(&ut)?;
-                    } else if self.need_runlevel && run_level_chk(ut.record_type()) {
-                        if cfg!(target_os = "linux") {
-                            self.print_runlevel(&ut);
-                        }
-                    } else if self.need_boottime && ut.record_type() == utmpx::BOOT_TIME {
-                        self.print_boottime(&ut);
-                    } else if self.need_clockchange && ut.record_type() == utmpx::NEW_TIME {
-                        self.print_clockchange(&ut);
-                    } else if self.need_initspawn && ut.record_type() == utmpx::INIT_PROCESS {
-                        self.print_initspawn(&ut);
-                    } else if self.need_login && ut.record_type() == utmpx::LOGIN_PROCESS {
-                        self.print_login(&ut);
-                    } else if self.need_deadprocs && ut.record_type() == utmpx::DEAD_PROCESS {
-                        self.print_deadprocs(&ut);
-                    }
-                }
-
-                if ut.record_type() == utmpx::BOOT_TIME {}
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn print_runlevel(&self, ut: &Utmpx) {
-        let last = (ut.pid() / 256) as u8 as char;
-        let curr = (ut.pid() % 256) as u8 as char;
-        let runlvline = format!("run-level {curr}");
-        let comment = format!("last={}", if last == 'N' { 'S' } else { 'N' });
-
-        self.print_line(
-            "",
-            ' ',
-            &runlvline,
-            &time_string(ut),
-            "",
-            "",
-            if last.is_control() { "" } else { &comment },
-            "",
-        );
-    }
-
-    #[inline]
-    fn print_clockchange(&self, ut: &Utmpx) {
-        self.print_line("", ' ', "clock change", &time_string(ut), "", "", "", "");
-    }
-
-    #[inline]
-    fn print_login(&self, ut: &Utmpx) {
-        let comment = format!("id={}", ut.terminal_suffix());
-        let pidstr = format!("{}", ut.pid());
-        self.print_line(
-            "LOGIN",
-            ' ',
-            &ut.tty_device(),
-            &time_string(ut),
-            "",
-            &pidstr,
-            &comment,
-            "",
-        );
-    }
-
-    #[inline]
-    fn print_deadprocs(&self, ut: &Utmpx) {
-        let comment = format!("id={}", ut.terminal_suffix());
-        let pidstr = format!("{}", ut.pid());
-        let e = ut.exit_status();
-        let exitstr = format!("term={} exit={}", e.0, e.1);
-        self.print_line(
-            "",
-            ' ',
-            &ut.tty_device(),
-            &time_string(ut),
-            "",
-            &pidstr,
-            &comment,
-            &exitstr,
-        );
-    }
-
-    #[inline]
-    fn print_initspawn(&self, ut: &Utmpx) {
-        let comment = format!("id={}", ut.terminal_suffix());
-        let pidstr = format!("{}", ut.pid());
-        self.print_line(
-            "",
-            ' ',
-            &ut.tty_device(),
-            &time_string(ut),
-            "",
-            &pidstr,
-            &comment,
-            "",
-        );
-    }
-
-    #[inline]
-    fn print_boottime(&self, ut: &Utmpx) {
-        self.print_line("", ' ', "system boot", &time_string(ut), "", "", "", "");
-    }
-
-    fn print_user(&self, ut: &Utmpx) -> UResult<()> {
-        let mut p = PathBuf::from("/dev");
-        p.push(ut.tty_device().as_str());
-        let mesg;
-        let last_change;
-        match p.metadata() {
-            Ok(meta) => {
-                #[cfg(all(
-                    not(target_os = "android"),
-                    not(target_os = "freebsd"),
-                    not(target_vendor = "apple")
-                ))]
-                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 { '+' };
-                last_change = meta.atime();
-            }
-            _ => {
-                mesg = '?';
-                last_change = 0;
-            }
-        }
-
-        let idle = if last_change == 0 {
-            "  ?".into()
-        } else {
-            idle_string(last_change, 0)
-        };
-
-        let s = if self.do_lookup {
-            ut.canon_host().map_err_context(|| {
-                let host = ut.host();
-                format!(
-                    "failed to canonicalize {}",
-                    host.split(':').next().unwrap_or(&host).quote()
-                )
-            })?
-        } else {
-            ut.host()
-        };
-        let hoststr = if s.is_empty() { s } else { format!("({s})") };
-
-        self.print_line(
-            ut.user().as_ref(),
-            mesg,
-            ut.tty_device().as_ref(),
-            time_string(ut).as_str(),
-            idle.as_ref(),
-            format!("{}", ut.pid()).as_str(),
-            hoststr.as_str(),
-            "",
-        );
-
-        Ok(())
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn print_line(
-        &self,
-        user: &str,
-        state: char,
-        line: &str,
-        time: &str,
-        idle: &str,
-        pid: &str,
-        comment: &str,
-        exit: &str,
-    ) {
-        let mut buf = String::with_capacity(64);
-        let msg = vec![' ', state].into_iter().collect::<String>();
-
-        write!(buf, "{user:<8}").unwrap();
-        if self.include_mesg {
-            buf.push_str(&msg);
-        }
-        write!(buf, " {line:<12}").unwrap();
-        // "%b %e %H:%M" (LC_ALL=C)
-        let time_size = 3 + 2 + 2 + 1 + 2;
-        write!(buf, " {time:<time_size$}").unwrap();
-
-        if !self.short_output {
-            if self.include_idle {
-                write!(buf, " {idle:<6}").unwrap();
-            }
-            write!(buf, " {pid:>10}").unwrap();
-        }
-        write!(buf, " {comment:<8}").unwrap();
-        if self.include_exit {
-            write!(buf, " {exit:<12}").unwrap();
-        }
-        println!("{}", buf.trim_end());
-    }
-
-    #[inline]
-    fn print_heading(&self) {
-        self.print_line(
-            "NAME", ' ', "LINE", "TIME", "IDLE", "PID", "COMMENT", "EXIT",
-        );
-    }
-}
diff --git a/src/uu/whoami/Cargo.toml b/src/uu/whoami/Cargo.toml
index 331755a9651..0ba42e88f69 100644
--- a/src/uu/whoami/Cargo.toml
+++ b/src/uu/whoami/Cargo.toml
@@ -1,22 +1,25 @@
 [package]
 name = "uu_whoami"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "whoami ~ (uutils) display user name of current effective user ID"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/whoami"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/whoami.rs"
 
 [dependencies]
 clap = { workspace = true }
-uucore = { workspace = true, features = ["entries"] }
+uucore = { workspace = true, features = ["entries", "process"] }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows-sys = { workspace = true, features = [
@@ -25,9 +28,6 @@ windows-sys = { workspace = true, features = [
   "Win32_Foundation",
 ] }
 
-[target.'cfg(unix)'.dependencies]
-libc = { workspace = true }
-
 [[bin]]
 name = "whoami"
 path = "src/main.rs"
diff --git a/src/uu/whoami/src/platform/unix.rs b/src/uu/whoami/src/platform/unix.rs
index 31ab16fba4c..9310a6de0a2 100644
--- a/src/uu/whoami/src/platform/unix.rs
+++ b/src/uu/whoami/src/platform/unix.rs
@@ -7,10 +7,9 @@ use std::ffi::OsString;
 use std::io;
 
 use uucore::entries::uid2usr;
+use uucore::process::geteuid;
 
 pub fn get_username() -> io::Result<OsString> {
-    // SAFETY: getuid() does nothing with memory and is always successful.
-    let uid = unsafe { libc::geteuid() };
     // uid2usr should arguably return an OsString but currently doesn't
-    uid2usr(uid).map(Into::into)
+    uid2usr(geteuid()).map(Into::into)
 }
diff --git a/src/uu/whoami/src/whoami.rs b/src/uu/whoami/src/whoami.rs
index cb8bcd9c735..a1fe6e62239 100644
--- a/src/uu/whoami/src/whoami.rs
+++ b/src/uu/whoami/src/whoami.rs
@@ -3,9 +3,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-/* last synced with: whoami (GNU coreutils) 8.21 */
+use std::ffi::OsString;
 
-use clap::{crate_version, Command};
+use clap::Command;
 
 use uucore::display::println_verbatim;
 use uucore::error::{FromIo, UResult};
@@ -19,14 +19,19 @@ const USAGE: &str = help_usage!("whoami.md");
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     uu_app().try_get_matches_from(args)?;
-    let username = platform::get_username().map_err_context(|| "failed to get username".into())?;
+    let username = whoami()?;
     println_verbatim(username).map_err_context(|| "failed to print username".into())?;
     Ok(())
 }
 
+/// Get the current username
+pub fn whoami() -> UResult<OsString> {
+    platform::get_username().map_err_context(|| "failed to get username".into())
+}
+
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .infer_long_args(true)
diff --git a/src/uu/yes/Cargo.toml b/src/uu/yes/Cargo.toml
index eff09155119..d9d5c028493 100644
--- a/src/uu/yes/Cargo.toml
+++ b/src/uu/yes/Cargo.toml
@@ -1,15 +1,18 @@
 [package]
 name = "uu_yes"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "yes ~ (uutils) repeatedly display a line with STRING (or 'y')"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uu/yes"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+edition.workspace = true
+readme.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 path = "src/yes.rs"
diff --git a/src/uu/yes/src/splice.rs b/src/uu/yes/src/splice.rs
deleted file mode 100644
index a95fc35af47..00000000000
--- a/src/uu/yes/src/splice.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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.
-//! On Linux we can use vmsplice() to write data more efficiently.
-//!
-//! This does not always work. We're not allowed to splice to some targets,
-//! and on some systems (notably WSL 1) it isn't supported at all.
-//!
-//! If we get an error code that suggests splicing isn't supported then we
-//! tell that to the caller so it can fall back to a robust naïve method. If
-//! we get another kind of error we bubble it up as normal.
-//!
-//! vmsplice() can only splice into a pipe, so if the output is not a pipe
-//! we make our own and use splice() to bridge the gap from the pipe to the
-//! output.
-//!
-//! We assume that an "unsupported" error will only ever happen before any
-//! data was successfully written to the output. That way we don't have to
-//! make any effort to rescue data from the pipe if splice() fails, we can
-//! just fall back and start over from the beginning.
-
-use std::{io, os::unix::io::AsRawFd};
-
-use nix::{errno::Errno, libc::S_IFIFO, sys::stat::fstat};
-
-use uucore::pipes::{pipe, splice_exact, vmsplice};
-
-pub(crate) fn splice_data(bytes: &[u8], out: &impl AsRawFd) -> Result<()> {
-    let is_pipe = fstat(out.as_raw_fd())?.st_mode as nix::libc::mode_t & S_IFIFO != 0;
-
-    if is_pipe {
-        loop {
-            let mut bytes = bytes;
-            while !bytes.is_empty() {
-                let len = vmsplice(out, bytes).map_err(maybe_unsupported)?;
-                bytes = &bytes[len..];
-            }
-        }
-    } else {
-        let (read, write) = pipe()?;
-        loop {
-            let mut bytes = bytes;
-            while !bytes.is_empty() {
-                let len = vmsplice(&write, bytes).map_err(maybe_unsupported)?;
-                splice_exact(&read, out, len).map_err(maybe_unsupported)?;
-                bytes = &bytes[len..];
-            }
-        }
-    }
-}
-
-pub(crate) enum Error {
-    Unsupported,
-    Io(io::Error),
-}
-
-type Result<T> = std::result::Result<T, Error>;
-
-impl From<nix::Error> for Error {
-    fn from(error: nix::Error) -> Self {
-        Self::Io(io::Error::from_raw_os_error(error as i32))
-    }
-}
-
-fn maybe_unsupported(error: nix::Error) -> Error {
-    match error {
-        Errno::EINVAL | Errno::ENOSYS | Errno::EBADF => Error::Unsupported,
-        _ => error.into(),
-    }
-}
diff --git a/src/uu/yes/src/yes.rs b/src/uu/yes/src/yes.rs
index e6868d9d85e..df77be28947 100644
--- a/src/uu/yes/src/yes.rs
+++ b/src/uu/yes/src/yes.rs
@@ -3,11 +3,9 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-/* last synced with: yes (GNU coreutils) 8.13 */
-
 // cSpell:ignore strs
 
-use clap::{builder::ValueParser, crate_version, Arg, ArgAction, Command};
+use clap::{Arg, ArgAction, Command, builder::ValueParser};
 use std::error::Error;
 use std::ffi::OsString;
 use std::io::{self, Write};
@@ -15,8 +13,6 @@ 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;
 
 const ABOUT: &str = help_about!("yes.md");
 const USAGE: &str = help_usage!("yes.md");
@@ -42,7 +38,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
 pub fn uu_app() -> Command {
     Command::new(uucore::util_name())
-        .version(crate_version!())
+        .version(uucore::crate_version!())
         .about(ABOUT)
         .override_usage(format_usage(USAGE))
         .arg(
@@ -58,10 +54,7 @@ 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 {
+    let Some(i) = i else {
         buf.extend_from_slice(b"y\n");
         return Ok(());
     };
@@ -121,15 +114,6 @@ pub fn exec(bytes: &[u8]) -> io::Result<()> {
     #[cfg(unix)]
     enable_pipe_errors()?;
 
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    {
-        match splice::splice_data(bytes, &stdout) {
-            Ok(_) => return Ok(()),
-            Err(splice::Error::Io(err)) => return Err(err),
-            Err(splice::Error::Unsupported) => (),
-        }
-    }
-
     loop {
         stdout.write_all(bytes)?;
     }
@@ -160,7 +144,7 @@ mod tests {
         ];
 
         for (line, final_len) in tests {
-            let mut v = std::iter::repeat(b'a').take(line).collect::<Vec<_>>();
+            let mut v = std::iter::repeat_n(b'a', line).collect::<Vec<_>>();
             prepare_buffer(&mut v);
             assert_eq!(v.len(), final_len);
         }
diff --git a/src/uucore/Cargo.toml b/src/uucore/Cargo.toml
index fcbfdeac757..be2db18e578 100644
--- a/src/uucore/Cargo.toml
+++ b/src/uucore/Cargo.toml
@@ -1,43 +1,46 @@
-# spell-checker:ignore (features) zerocopy
+# spell-checker:ignore (features) bigdecimal zerocopy extendedbigdecimal
 
 [package]
 name = "uucore"
-version = "0.0.21"
-authors = ["uutils developers"]
-license = "MIT"
 description = "uutils ~ 'core' uutils code library (cross-platform)"
-
-homepage = "https://github.com/uutils/coreutils"
 repository = "https://github.com/uutils/coreutils/tree/main/src/uucore"
 # readme = "README.md"
-keywords = ["coreutils", "uutils", "cross-platform", "cli", "utility"]
-categories = ["command-line-utilities"]
-edition = "2021"
+authors.workspace = true
+categories.workspace = true
+edition.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+license.workspace = true
+version.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
 
 [lib]
 path = "src/lib/lib.rs"
 
 [dependencies]
+chrono = { workspace = true, optional = true }
+chrono-tz = { workspace = true, optional = true }
 clap = { workspace = true }
 uucore_procs = { workspace = true }
-dns-lookup = { version = "2.0.2", optional = true }
+number_prefix = { workspace = true }
+dns-lookup = { workspace = true, optional = true }
 dunce = { version = "1.0.4", optional = true }
-wild = "2.1"
-glob = { workspace = true }
-# * optional
+wild = "2.2.1"
+glob = { workspace = true, optional = true }
+iana-time-zone = { workspace = true, optional = true }
 itertools = { workspace = true, optional = true }
-thiserror = { workspace = true, optional = true }
 time = { workspace = true, optional = true, features = [
   "formatting",
   "local-offset",
   "macros",
 ] }
 # * "problem" dependencies (pinned)
-data-encoding = { version = "2.4", optional = true }
-data-encoding-macro = { version = "0.1.13", optional = true }
+data-encoding = { version = "2.6", optional = true }
+data-encoding-macro = { version = "0.1.15", optional = true }
 z85 = { version = "3.0.5", optional = true }
 libc = { workspace = true, optional = true }
-once_cell = { workspace = true }
 os_display = "0.1.3"
 
 digest = { workspace = true, optional = true }
@@ -50,40 +53,72 @@ sha3 = { workspace = true, optional = true }
 blake2b_simd = { workspace = true, optional = true }
 blake3 = { workspace = true, optional = true }
 sm3 = { workspace = true, optional = true }
+crc32fast = { workspace = true, optional = true }
+regex = { workspace = true, optional = true }
+bigdecimal = { workspace = true, optional = true }
+num-traits = { workspace = true, optional = true }
+selinux = { workspace = true, optional = true }
 
+# Fluent dependencies
+fluent-bundle = { workspace = true }
+fluent = { workspace = true }
+unic-langid = { workspace = true }
+thiserror = { workspace = true }
 [target.'cfg(unix)'.dependencies]
 walkdir = { workspace = true, optional = true }
 nix = { workspace = true, features = ["fs", "uio", "zerocopy", "signal"] }
+xattr = { workspace = true, optional = true }
 
 [dev-dependencies]
-clap = { workspace = true }
-once_cell = { workspace = true }
 tempfile = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi-util = { workspace = true, optional = true }
 windows-sys = { workspace = true, optional = true, default-features = false, features = [
+  "Wdk_System_SystemInformation",
   "Win32_Storage_FileSystem",
   "Win32_Foundation",
+  "Win32_System_RemoteDesktop",
+  "Win32_System_SystemInformation",
   "Win32_System_WindowsProgramming",
 ] }
 
+[target.'cfg(target_os = "openbsd")'.dependencies]
+utmp-classic = { workspace = true, optional = true }
+
 [features]
 default = []
 # * non-default features
 backup-control = []
-encoding = ["data-encoding", "data-encoding-macro", "z85", "thiserror"]
+colors = []
+checksum = ["data-encoding", "sum"]
+encoding = ["data-encoding", "data-encoding-macro", "z85"]
 entries = ["libc"]
+extendedbigdecimal = ["bigdecimal", "num-traits"]
+fast-inc = []
 fs = ["dunce", "libc", "winapi-util", "windows-sys"]
-fsext = ["libc", "time", "windows-sys"]
+fsext = ["libc", "windows-sys"]
+fsxattr = ["xattr"]
 lines = []
-memo = ["itertools"]
+format = [
+  "bigdecimal",
+  "extendedbigdecimal",
+  "itertools",
+  "parser",
+  "num-traits",
+  "quoting-style",
+]
 mode = ["libc"]
-perms = ["libc", "walkdir"]
+perms = ["entries", "libc", "walkdir"]
+buf-copy = []
+parser = ["extendedbigdecimal", "glob", "num-traits"]
 pipes = []
 process = ["libc"]
+proc-info = ["tty", "walkdir"]
+quoting-style = []
 ranges = []
 ringbuffer = []
+selinux = ["dep:selinux"]
 signals = []
 sum = [
   "digest",
@@ -96,8 +131,13 @@ sum = [
   "blake2b_simd",
   "blake3",
   "sm3",
+  "crc32fast",
 ]
-update-control = []
+update-control = ["parser"]
 utf8 = []
 utmpx = ["time", "time/macros", "libc", "dns-lookup"]
+version-cmp = []
 wide = []
+custom-tz-fmt = ["chrono", "chrono-tz", "iana-time-zone"]
+tty = []
+uptime = ["chrono", "libc", "windows-sys", "utmpx", "utmp-classic"]
diff --git a/src/uucore/src/lib/features.rs b/src/uucore/src/lib/features.rs
index 786a6468239..257043e00ba 100644
--- a/src/uucore/src/lib/features.rs
+++ b/src/uucore/src/lib/features.rs
@@ -3,29 +3,49 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // features ~ feature-gated modules (core/bundler file)
+//
+// spell-checker:ignore (features) extendedbigdecimal
 
 #[cfg(feature = "backup-control")]
 pub mod backup_control;
+#[cfg(feature = "buf-copy")]
+pub mod buf_copy;
+#[cfg(feature = "checksum")]
+pub mod checksum;
+#[cfg(feature = "colors")]
+pub mod colors;
+#[cfg(feature = "custom-tz-fmt")]
+pub mod custom_tz_fmt;
 #[cfg(feature = "encoding")]
 pub mod encoding;
+#[cfg(feature = "extendedbigdecimal")]
+pub mod extendedbigdecimal;
+#[cfg(feature = "fast-inc")]
+pub mod fast_inc;
+#[cfg(feature = "format")]
+pub mod format;
 #[cfg(feature = "fs")]
 pub mod fs;
 #[cfg(feature = "fsext")]
 pub mod fsext;
 #[cfg(feature = "lines")]
 pub mod lines;
-#[cfg(feature = "memo")]
-pub mod memo;
+#[cfg(feature = "parser")]
+pub mod parser;
+#[cfg(feature = "quoting-style")]
+pub mod quoting_style;
 #[cfg(feature = "ranges")]
 pub mod ranges;
 #[cfg(feature = "ringbuffer")]
 pub mod ringbuffer;
 #[cfg(feature = "sum")]
 pub mod sum;
-#[cfg(feature = "memo")]
-mod tokenize;
 #[cfg(feature = "update-control")]
 pub mod update_control;
+#[cfg(feature = "uptime")]
+pub mod uptime;
+#[cfg(feature = "version-cmp")]
+pub mod version_cmp;
 
 // * (platform-specific) feature-gated modules
 // ** non-windows (i.e. Unix + Fuchsia)
@@ -37,19 +57,27 @@ pub mod mode;
 pub mod entries;
 #[cfg(all(unix, feature = "perms"))]
 pub mod perms;
-#[cfg(all(unix, feature = "pipes"))]
+#[cfg(all(unix, any(feature = "pipes", feature = "buf-copy")))]
 pub mod pipes;
+#[cfg(all(target_os = "linux", feature = "proc-info"))]
+pub mod proc_info;
 #[cfg(all(unix, feature = "process"))]
 pub mod process;
+#[cfg(all(target_os = "linux", feature = "tty"))]
+pub mod tty;
 
+#[cfg(all(unix, feature = "fsxattr"))]
+pub mod fsxattr;
+#[cfg(all(target_os = "linux", feature = "selinux"))]
+pub mod selinux;
 #[cfg(all(unix, not(target_os = "fuchsia"), feature = "signals"))]
 pub mod signals;
 #[cfg(all(
     unix,
     not(target_os = "android"),
     not(target_os = "fuchsia"),
+    not(target_os = "openbsd"),
     not(target_os = "redox"),
-    not(target_env = "musl"),
     feature = "utmpx"
 ))]
 pub mod utmpx;
diff --git a/src/uucore/src/lib/features/backup_control.rs b/src/uucore/src/lib/features/backup_control.rs
index 86c7cd72b1d..c438a772035 100644
--- a/src/uucore/src/lib/features/backup_control.rs
+++ b/src/uucore/src/lib/features/backup_control.rs
@@ -53,8 +53,7 @@
 //!         .arg(backup_control::arguments::suffix())
 //!         .override_usage(usage)
 //!         .after_help(format!(
-//!             "{}\n{}",
-//!             long_usage,
+//!             "{long_usage}\n{}",
 //!             backup_control::BACKUP_CONTROL_LONG_HELP
 //!         ))
 //!         .get_matches_from(vec![
@@ -114,20 +113,23 @@ static VALID_ARGS_HELP: &str = "Valid arguments are:
   - 'existing', 'nil'
   - 'numbered', 't'";
 
+pub const DEFAULT_BACKUP_SUFFIX: &str = "~";
+
 /// Available backup modes.
 ///
 /// The mapping of the backup modes to the CLI arguments is annotated on the
 /// enum variants.
-#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
 pub enum BackupMode {
     /// Argument 'none', 'off'
-    NoBackup,
+    #[default]
+    None,
     /// Argument 'simple', 'never'
-    SimpleBackup,
+    Simple,
     /// Argument 'numbered', 't'
-    NumberedBackup,
+    Numbered,
     /// Argument 'existing', 'nil'
-    ExistingBackup,
+    Existing,
 }
 
 /// Backup error types.
@@ -173,17 +175,13 @@ impl Display for BackupError {
         match self {
             Self::InvalidArgument(arg, origin) => write!(
                 f,
-                "invalid argument {} for '{}'\n{}",
+                "invalid argument {} for '{origin}'\n{VALID_ARGS_HELP}",
                 arg.quote(),
-                origin,
-                VALID_ARGS_HELP
             ),
             Self::AmbiguousArgument(arg, origin) => write!(
                 f,
-                "ambiguous argument {} for '{}'\n{}",
+                "ambiguous argument {} for '{origin}'\n{VALID_ARGS_HELP}",
                 arg.quote(),
-                origin,
-                VALID_ARGS_HELP
             ),
             Self::BackupImpossible() => write!(f, "cannot create backup"),
             // Placeholder for later
@@ -254,7 +252,7 @@ pub fn determine_backup_suffix(matches: &ArgMatches) -> String {
     if let Some(suffix) = supplied_suffix {
         String::from(suffix)
     } else {
-        env::var("SIMPLE_BACKUP_SUFFIX").unwrap_or_else(|_| "~".to_owned())
+        env::var("SIMPLE_BACKUP_SUFFIX").unwrap_or_else(|_| DEFAULT_BACKUP_SUFFIX.to_owned())
     }
 }
 
@@ -305,7 +303,7 @@ pub fn determine_backup_suffix(matches: &ArgMatches) -> String {
 ///         ]);
 ///
 ///     let backup_mode = backup_control::determine_backup_mode(&matches).unwrap();
-///     assert_eq!(backup_mode, BackupMode::NumberedBackup)
+///     assert_eq!(backup_mode, BackupMode::Numbered)
 /// }
 /// ```
 ///
@@ -350,15 +348,20 @@ pub fn determine_backup_mode(matches: &ArgMatches) -> UResult<BackupMode> {
             match_method(&method, "$VERSION_CONTROL")
         } else {
             // Default if no argument is provided to '--backup'
-            Ok(BackupMode::ExistingBackup)
+            Ok(BackupMode::Existing)
         }
     } else if matches.get_flag(arguments::OPT_BACKUP_NO_ARG) {
         // the short form of this option, -b does not accept any argument.
-        // Using -b is equivalent to using --backup=existing.
-        Ok(BackupMode::ExistingBackup)
+        // if VERSION_CONTROL is not set then using -b is equivalent to
+        // using --backup=existing.
+        if let Ok(method) = env::var("VERSION_CONTROL") {
+            match_method(&method, "$VERSION_CONTROL")
+        } else {
+            Ok(BackupMode::Existing)
+        }
     } else {
         // No option was present at all
-        Ok(BackupMode::NoBackup)
+        Ok(BackupMode::None)
     }
 }
 
@@ -388,10 +391,10 @@ fn match_method(method: &str, origin: &str) -> UResult<BackupMode> {
         .collect();
     if matches.len() == 1 {
         match *matches[0] {
-            "simple" | "never" => Ok(BackupMode::SimpleBackup),
-            "numbered" | "t" => Ok(BackupMode::NumberedBackup),
-            "existing" | "nil" => Ok(BackupMode::ExistingBackup),
-            "none" | "off" => Ok(BackupMode::NoBackup),
+            "simple" | "never" => Ok(BackupMode::Simple),
+            "numbered" | "t" => Ok(BackupMode::Numbered),
+            "existing" | "nil" => Ok(BackupMode::Existing),
+            "none" | "off" => Ok(BackupMode::None),
             _ => unreachable!(), // cannot happen as we must have exactly one match
                                  // from the list above.
         }
@@ -408,33 +411,37 @@ pub fn get_backup_path(
     suffix: &str,
 ) -> Option<PathBuf> {
     match backup_mode {
-        BackupMode::NoBackup => None,
-        BackupMode::SimpleBackup => Some(simple_backup_path(backup_path, suffix)),
-        BackupMode::NumberedBackup => Some(numbered_backup_path(backup_path)),
-        BackupMode::ExistingBackup => Some(existing_backup_path(backup_path, suffix)),
+        BackupMode::None => None,
+        BackupMode::Simple => Some(simple_backup_path(backup_path, suffix)),
+        BackupMode::Numbered => Some(numbered_backup_path(backup_path)),
+        BackupMode::Existing => Some(existing_backup_path(backup_path, suffix)),
     }
 }
 
 fn simple_backup_path(path: &Path, suffix: &str) -> PathBuf {
-    let mut p = path.to_string_lossy().into_owned();
-    p.push_str(suffix);
-    PathBuf::from(p)
+    let mut file_name = path.file_name().unwrap_or_default().to_os_string();
+    file_name.push(suffix);
+    path.with_file_name(file_name)
 }
 
 fn numbered_backup_path(path: &Path) -> PathBuf {
+    let file_name = path.file_name().unwrap_or_default();
     for i in 1_u64.. {
-        let path_str = &format!("{}.~{}~", path.to_string_lossy(), i);
-        let path = Path::new(path_str);
+        let mut numbered_file_name = file_name.to_os_string();
+        numbered_file_name.push(format!(".~{i}~"));
+        let path = path.with_file_name(numbered_file_name);
         if !path.exists() {
-            return path.to_path_buf();
+            return path;
         }
     }
     panic!("cannot create backup")
 }
 
 fn existing_backup_path(path: &Path, suffix: &str) -> PathBuf {
-    let test_path_str = &format!("{}.~1~", path.to_string_lossy());
-    let test_path = Path::new(test_path_str);
+    let file_name = path.file_name().unwrap_or_default();
+    let mut numbered_file_name = file_name.to_os_string();
+    numbered_file_name.push(".~1~");
+    let test_path = path.with_file_name(numbered_file_name);
     if test_path.exists() {
         numbered_backup_path(path)
     } else {
@@ -474,11 +481,9 @@ pub fn source_is_target_backup(source: &Path, target: &Path, suffix: &str) -> bo
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::env;
     // Required to instantiate mutex in shared context
     use clap::Command;
-    use once_cell::sync::Lazy;
-    use std::sync::Mutex;
+    use std::sync::{LazyLock, Mutex};
 
     // The mutex is required here as by default all tests are run as separate
     // threads under the same parent process. As environment variables are
@@ -486,7 +491,7 @@ mod tests {
     // occur if no precautions are taken. Thus we have all tests that rely on
     // environment variables lock this empty mutex to ensure they don't access
     // it concurrently.
-    static TEST_MUTEX: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+    static TEST_MUTEX: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
 
     // Environment variable for "VERSION_CONTROL"
     static ENV_VERSION_CONTROL: &str = "VERSION_CONTROL";
@@ -506,7 +511,7 @@ mod tests {
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::ExistingBackup);
+        assert_eq!(result, BackupMode::Existing);
     }
 
     // --backup takes precedence over -b
@@ -517,7 +522,7 @@ mod tests {
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::NoBackup);
+        assert_eq!(result, BackupMode::None);
     }
 
     // --backup can be passed without an argument
@@ -528,7 +533,7 @@ mod tests {
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::ExistingBackup);
+        assert_eq!(result, BackupMode::Existing);
     }
 
     // --backup can be passed with an argument only
@@ -539,7 +544,7 @@ mod tests {
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::SimpleBackup);
+        assert_eq!(result, BackupMode::Simple);
     }
 
     // --backup errors on invalid argument
@@ -576,40 +581,40 @@ mod tests {
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::SimpleBackup);
+        assert_eq!(result, BackupMode::Simple);
     }
 
-    // -b ignores the "VERSION_CONTROL" environment variable
+    // -b doesn't ignores the "VERSION_CONTROL" environment variable
     #[test]
-    fn test_backup_mode_short_only_ignore_env() {
+    fn test_backup_mode_short_does_not_ignore_env() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        env::set_var(ENV_VERSION_CONTROL, "none");
+        unsafe { env::set_var(ENV_VERSION_CONTROL, "numbered") };
         let matches = make_app().get_matches_from(vec!["command", "-b"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::ExistingBackup);
-        env::remove_var(ENV_VERSION_CONTROL);
+        assert_eq!(result, BackupMode::Numbered);
+        unsafe { env::remove_var(ENV_VERSION_CONTROL) };
     }
 
     // --backup can be passed without an argument, but reads env var if existent
     #[test]
     fn test_backup_mode_long_without_args_with_env() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        env::set_var(ENV_VERSION_CONTROL, "none");
+        unsafe { env::set_var(ENV_VERSION_CONTROL, "none") };
         let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::NoBackup);
-        env::remove_var(ENV_VERSION_CONTROL);
+        assert_eq!(result, BackupMode::None);
+        unsafe { env::remove_var(ENV_VERSION_CONTROL) };
     }
 
     // --backup errors on invalid VERSION_CONTROL env var
     #[test]
     fn test_backup_mode_long_with_env_var_invalid() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        env::set_var(ENV_VERSION_CONTROL, "foobar");
+        unsafe { env::set_var(ENV_VERSION_CONTROL, "foobar") };
         let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches);
@@ -617,14 +622,14 @@ mod tests {
         assert!(result.is_err());
         let text = format!("{}", result.unwrap_err());
         assert!(text.contains("invalid argument 'foobar' for '$VERSION_CONTROL'"));
-        env::remove_var(ENV_VERSION_CONTROL);
+        unsafe { env::remove_var(ENV_VERSION_CONTROL) };
     }
 
     // --backup errors on ambiguous VERSION_CONTROL env var
     #[test]
     fn test_backup_mode_long_with_env_var_ambiguous() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        env::set_var(ENV_VERSION_CONTROL, "n");
+        unsafe { env::set_var(ENV_VERSION_CONTROL, "n") };
         let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches);
@@ -632,20 +637,20 @@ mod tests {
         assert!(result.is_err());
         let text = format!("{}", result.unwrap_err());
         assert!(text.contains("ambiguous argument 'n' for '$VERSION_CONTROL'"));
-        env::remove_var(ENV_VERSION_CONTROL);
+        unsafe { env::remove_var(ENV_VERSION_CONTROL) };
     }
 
     // --backup accepts shortened env vars (si for simple)
     #[test]
     fn test_backup_mode_long_with_env_var_shortened() {
         let _dummy = TEST_MUTEX.lock().unwrap();
-        env::set_var(ENV_VERSION_CONTROL, "si");
+        unsafe { env::set_var(ENV_VERSION_CONTROL, "si") };
         let matches = make_app().get_matches_from(vec!["command", "--backup"]);
 
         let result = determine_backup_mode(&matches).unwrap();
 
-        assert_eq!(result, BackupMode::SimpleBackup);
-        env::remove_var(ENV_VERSION_CONTROL);
+        assert_eq!(result, BackupMode::Simple);
+        unsafe { env::remove_var(ENV_VERSION_CONTROL) };
     }
 
     #[test]
@@ -656,13 +661,48 @@ mod tests {
         let result = determine_backup_suffix(&matches);
         assert_eq!(result, "-v");
     }
+
+    #[test]
+    fn test_numbered_backup_path() {
+        assert_eq!(numbered_backup_path(Path::new("")), PathBuf::from(".~1~"));
+        assert_eq!(numbered_backup_path(Path::new("/")), PathBuf::from("/.~1~"));
+        assert_eq!(
+            numbered_backup_path(Path::new("/hello/world")),
+            PathBuf::from("/hello/world.~1~")
+        );
+        assert_eq!(
+            numbered_backup_path(Path::new("/hello/world/")),
+            PathBuf::from("/hello/world.~1~")
+        );
+    }
+
+    #[test]
+    fn test_simple_backup_path() {
+        assert_eq!(
+            simple_backup_path(Path::new(""), ".bak"),
+            PathBuf::from(".bak")
+        );
+        assert_eq!(
+            simple_backup_path(Path::new("/"), ".bak"),
+            PathBuf::from("/.bak")
+        );
+        assert_eq!(
+            simple_backup_path(Path::new("/hello/world"), ".bak"),
+            PathBuf::from("/hello/world.bak")
+        );
+        assert_eq!(
+            simple_backup_path(Path::new("/hello/world/"), ".bak"),
+            PathBuf::from("/hello/world.bak")
+        );
+    }
+
     #[test]
     fn test_source_is_target_backup() {
         let source = Path::new("data.txt.bak");
         let target = Path::new("data.txt");
         let suffix = String::from(".bak");
 
-        assert!(source_is_target_backup(&source, &target, &suffix));
+        assert!(source_is_target_backup(source, target, &suffix));
     }
 
     #[test]
@@ -671,7 +711,7 @@ mod tests {
         let target = Path::new("backup.txt");
         let suffix = String::from(".bak");
 
-        assert!(!source_is_target_backup(&source, &target, &suffix));
+        assert!(!source_is_target_backup(source, target, &suffix));
     }
 
     #[test]
@@ -680,6 +720,6 @@ mod tests {
         let target = Path::new("example");
         let suffix = String::from("~");
 
-        assert!(source_is_target_backup(&source, &target, &suffix));
+        assert!(source_is_target_backup(source, target, &suffix));
     }
 }
diff --git a/src/uucore/src/lib/features/buf_copy.rs b/src/uucore/src/lib/features/buf_copy.rs
new file mode 100644
index 00000000000..3ab2814bc24
--- /dev/null
+++ b/src/uucore/src/lib/features/buf_copy.rs
@@ -0,0 +1,116 @@
+// 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.
+
+//! This module provides several buffer-based copy/write functions that leverage
+//! the `splice` system call in Linux systems, thus increasing the I/O
+//! performance of copying between two file descriptors. This module is mostly
+//! used by utilities to work around the limitations of Rust's `fs::copy` which
+//! does not handle copying special files (e.g pipes, character/block devices).
+
+pub mod common;
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub mod linux;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub use linux::*;
+
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
+pub mod other;
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
+pub use other::copy_stream;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use tempfile::tempdir;
+
+    #[cfg(unix)]
+    use {
+        crate::pipes,
+        std::fs::OpenOptions,
+        std::{
+            io::{Seek, SeekFrom},
+            thread,
+        },
+    };
+
+    use std::io::{Read, Write};
+
+    #[cfg(unix)]
+    fn new_temp_file() -> File {
+        let temp_dir = tempdir().unwrap();
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(temp_dir.path().join("file.txt"))
+            .unwrap()
+    }
+
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[test]
+    fn test_copy_exact() {
+        let (mut pipe_read, mut pipe_write) = pipes::pipe().unwrap();
+        let data = b"Hello, world!";
+        let n = pipe_write.write(data).unwrap();
+        assert_eq!(n, data.len());
+        let mut buf = [0; 1024];
+        let n = copy_exact(&pipe_read, &pipe_write, data.len()).unwrap();
+        let n2 = pipe_read.read(&mut buf).unwrap();
+        assert_eq!(n, n2);
+        assert_eq!(&buf[..n], data);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_copy_stream() {
+        let mut dest_file = new_temp_file();
+
+        let (mut pipe_read, mut pipe_write) = pipes::pipe().unwrap();
+        let data = b"Hello, world!";
+        let thread = thread::spawn(move || {
+            pipe_write.write_all(data).unwrap();
+        });
+        let result = copy_stream(&mut pipe_read, &mut dest_file).unwrap();
+        thread.join().unwrap();
+        assert_eq!(result, data.len() as u64);
+
+        // We would have been at the end already, so seek again to the start.
+        dest_file.seek(SeekFrom::Start(0)).unwrap();
+
+        let mut buf = Vec::new();
+        dest_file.read_to_end(&mut buf).unwrap();
+
+        assert_eq!(buf, data);
+    }
+
+    #[test]
+    #[cfg(not(unix))]
+    // Test for non-unix platforms. We use regular files instead.
+    fn test_copy_stream() {
+        let temp_dir = tempdir().unwrap();
+        let src_path = temp_dir.path().join("src.txt");
+        let dest_path = temp_dir.path().join("dest.txt");
+
+        let mut src_file = File::create(&src_path).unwrap();
+        let mut dest_file = File::create(&dest_path).unwrap();
+
+        let data = b"Hello, world!";
+        src_file.write_all(data).unwrap();
+        src_file.sync_all().unwrap();
+
+        let mut src_file = File::open(&src_path).unwrap();
+        let bytes_copied = copy_stream(&mut src_file, &mut dest_file).unwrap();
+
+        let mut dest_file = File::open(&dest_path).unwrap();
+        let mut buf = Vec::new();
+        dest_file.read_to_end(&mut buf).unwrap();
+
+        assert_eq!(bytes_copied as usize, data.len());
+        assert_eq!(buf, data);
+    }
+}
diff --git a/src/uucore/src/lib/features/buf_copy/common.rs b/src/uucore/src/lib/features/buf_copy/common.rs
new file mode 100644
index 00000000000..82ae815f370
--- /dev/null
+++ b/src/uucore/src/lib/features/buf_copy/common.rs
@@ -0,0 +1,34 @@
+// 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.
+
+use crate::error::UError;
+
+/// Error types used by buffer-copying functions from the `buf_copy` module.
+#[derive(Debug)]
+pub enum Error {
+    Io(std::io::Error),
+    WriteError(String),
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::WriteError(msg) => write!(f, "splice() write error: {msg}"),
+            Error::Io(err) => write!(f, "I/O error: {err}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl UError for Error {
+    fn code(&self) -> i32 {
+        1
+    }
+
+    fn usage(&self) -> bool {
+        false
+    }
+}
diff --git a/src/uucore/src/lib/features/buf_copy/linux.rs b/src/uucore/src/lib/features/buf_copy/linux.rs
new file mode 100644
index 00000000000..7760d668025
--- /dev/null
+++ b/src/uucore/src/lib/features/buf_copy/linux.rs
@@ -0,0 +1,144 @@
+// 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.
+
+//! Buffer-based copying implementation for Linux and Android.
+
+use crate::{
+    error::UResult,
+    pipes::{pipe, splice, splice_exact},
+};
+
+/// Buffer-based copying utilities for unix (excluding Linux).
+use std::{
+    io::{Read, Write},
+    os::fd::{AsFd, AsRawFd},
+};
+
+use super::common::Error;
+
+/// A readable file descriptor.
+pub trait FdReadable: Read + AsRawFd + AsFd {}
+
+impl<T> FdReadable for T where T: Read + AsFd + AsRawFd {}
+
+/// A writable file descriptor.
+pub trait FdWritable: Write + AsFd + AsRawFd {}
+
+impl<T> FdWritable for T where T: Write + AsFd + AsRawFd {}
+
+const SPLICE_SIZE: usize = 1024 * 128;
+const BUF_SIZE: usize = 1024 * 16;
+
+/// Conversion from a `nix::Error` into our `Error` which implements `UError`.
+impl From<nix::Error> for Error {
+    fn from(error: nix::Error) -> Self {
+        Self::Io(std::io::Error::from_raw_os_error(error as i32))
+    }
+}
+
+/// Copy data from `Read` implementor `source` into a `Write` implementor
+/// `dest`. This works by reading a chunk of data from `source` and writing the
+/// data to `dest` in a loop.
+///
+/// This function uses the Linux-specific `splice` call when possible which does
+/// not use any intermediate user-space buffer. It falls backs to
+/// `std::io::copy` when the call fails and is still recoverable.
+///
+/// # Arguments
+/// * `source` - `Read` implementor to copy data from.
+/// * `dest` - `Write` implementor to copy data to.
+///
+/// # Returns
+///
+/// Result of operation and bytes successfully written (as a `u64`) when
+/// operation is successful.
+pub fn copy_stream<R, S>(src: &mut R, dest: &mut S) -> UResult<u64>
+where
+    R: Read + AsFd + AsRawFd,
+    S: Write + AsFd + AsRawFd,
+{
+    // If we're on Linux or Android, try to use the splice() system call
+    // for faster writing. If it works, we're done.
+    let result = splice_write(src, &dest.as_fd())?;
+    if !result.1 {
+        return Ok(result.0);
+    }
+
+    // If the splice() call failed, fall back on slower writing.
+    let result = std::io::copy(src, dest)?;
+
+    // If the splice() call failed and there has been some data written to
+    // stdout via while loop above AND there will be second splice() call
+    // that will succeed, data pushed through splice will be output before
+    // the data buffered in stdout.lock. Therefore additional explicit flush
+    // is required here.
+    dest.flush()?;
+    Ok(result)
+}
+
+/// Write from source `handle` into destination `write_fd` using Linux-specific
+/// `splice` system call.
+///
+/// # Arguments
+/// - `source` - source handle
+/// - `dest` - destination handle
+#[inline]
+pub(crate) fn splice_write<R, S>(source: &R, dest: &S) -> UResult<(u64, bool)>
+where
+    R: Read + AsFd + AsRawFd,
+    S: AsRawFd + AsFd,
+{
+    let (pipe_rd, pipe_wr) = pipe()?;
+    let mut bytes: u64 = 0;
+
+    loop {
+        match splice(&source, &pipe_wr, SPLICE_SIZE) {
+            Ok(n) => {
+                if n == 0 {
+                    return Ok((bytes, false));
+                }
+                if splice_exact(&pipe_rd, dest, n).is_err() {
+                    // If the first splice manages to copy to the intermediate
+                    // pipe, but the second splice to stdout fails for some reason
+                    // we can recover by copying the data that we have from the
+                    // intermediate pipe to stdout using normal read/write. Then
+                    // we tell the caller to fall back.
+                    copy_exact(&pipe_rd, dest, n)?;
+                    return Ok((bytes, true));
+                }
+
+                bytes += n as u64;
+            }
+            Err(_) => {
+                return Ok((bytes, true));
+            }
+        }
+    }
+}
+
+/// Move exactly `num_bytes` bytes from `read_fd` to `write_fd` using the `read`
+/// and `write` calls.
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub(crate) fn copy_exact(
+    read_fd: &impl AsFd,
+    write_fd: &impl AsFd,
+    num_bytes: usize,
+) -> std::io::Result<usize> {
+    use nix::unistd;
+
+    let mut left = num_bytes;
+    let mut buf = [0; BUF_SIZE];
+    let mut written = 0;
+    while left > 0 {
+        let read = unistd::read(read_fd, &mut buf)?;
+        assert_ne!(read, 0, "unexpected end of pipe");
+        while written < read {
+            let n = unistd::write(write_fd, &buf[written..read])?;
+            written += n;
+        }
+        left -= read;
+    }
+    Ok(written)
+}
diff --git a/src/uucore/src/lib/features/buf_copy/other.rs b/src/uucore/src/lib/features/buf_copy/other.rs
new file mode 100644
index 00000000000..61dd13e6cea
--- /dev/null
+++ b/src/uucore/src/lib/features/buf_copy/other.rs
@@ -0,0 +1,32 @@
+// 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.
+//!
+//! Buffer-based copying implementation for other platforms.
+
+use std::io::{Read, Write};
+
+use crate::error::UResult;
+
+/// Copy data from `Read` implementor `source` into a `Write` implementor
+/// `dest`. This works by reading a chunk of data from `source` and writing the
+/// data to `dest` in a loop, using std::io::copy. This is implemented for
+/// non-Linux platforms.
+///
+/// # Arguments
+/// * `source` - `Read` implementor to copy data from.
+/// * `dest` - `Write` implementor to copy data to.
+///
+/// # Returns
+///
+/// Result of operation and bytes successfully written (as a `u64`) when
+/// operation is successful.
+pub fn copy_stream<R, S>(src: &mut R, dest: &mut S) -> UResult<u64>
+where
+    R: Read,
+    S: Write,
+{
+    let result = std::io::copy(src, dest)?;
+    Ok(result)
+}
diff --git a/src/uucore/src/lib/features/checksum.rs b/src/uucore/src/lib/features/checksum.rs
new file mode 100644
index 00000000000..f7b36a9b8a8
--- /dev/null
+++ b/src/uucore/src/lib/features/checksum.rs
@@ -0,0 +1,1641 @@
+// 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.
+// spell-checker:ignore anotherfile invalidchecksum JWZG FFFD xffname prefixfilename bytelen bitlen hexdigit rsplit
+
+use data_encoding::BASE64;
+use os_display::Quotable;
+use std::{
+    borrow::Cow,
+    ffi::OsStr,
+    fmt::Display,
+    fs::File,
+    io::{self, BufReader, Read, Write, stdin},
+    path::Path,
+    str,
+};
+
+use crate::{
+    error::{FromIo, UError, UResult, USimpleError},
+    os_str_as_bytes, os_str_from_bytes, read_os_string_lines, show, show_error, show_warning_caps,
+    sum::{
+        Blake2b, Blake3, Bsd, CRC32B, Crc, Digest, DigestWriter, Md5, Sha1, Sha3_224, Sha3_256,
+        Sha3_384, Sha3_512, Sha224, Sha256, Sha384, Sha512, Shake128, Shake256, Sm3, SysV,
+    },
+    util_name,
+};
+use thiserror::Error;
+
+pub const ALGORITHM_OPTIONS_SYSV: &str = "sysv";
+pub const ALGORITHM_OPTIONS_BSD: &str = "bsd";
+pub const ALGORITHM_OPTIONS_CRC: &str = "crc";
+pub const ALGORITHM_OPTIONS_CRC32B: &str = "crc32b";
+pub const ALGORITHM_OPTIONS_MD5: &str = "md5";
+pub const ALGORITHM_OPTIONS_SHA1: &str = "sha1";
+pub const ALGORITHM_OPTIONS_SHA3: &str = "sha3";
+
+pub const ALGORITHM_OPTIONS_SHA224: &str = "sha224";
+pub const ALGORITHM_OPTIONS_SHA256: &str = "sha256";
+pub const ALGORITHM_OPTIONS_SHA384: &str = "sha384";
+pub const ALGORITHM_OPTIONS_SHA512: &str = "sha512";
+pub const ALGORITHM_OPTIONS_BLAKE2B: &str = "blake2b";
+pub const ALGORITHM_OPTIONS_BLAKE3: &str = "blake3";
+pub const ALGORITHM_OPTIONS_SM3: &str = "sm3";
+pub const ALGORITHM_OPTIONS_SHAKE128: &str = "shake128";
+pub const ALGORITHM_OPTIONS_SHAKE256: &str = "shake256";
+
+pub const SUPPORTED_ALGORITHMS: [&str; 16] = [
+    ALGORITHM_OPTIONS_SYSV,
+    ALGORITHM_OPTIONS_BSD,
+    ALGORITHM_OPTIONS_CRC,
+    ALGORITHM_OPTIONS_CRC32B,
+    ALGORITHM_OPTIONS_MD5,
+    ALGORITHM_OPTIONS_SHA1,
+    ALGORITHM_OPTIONS_SHA3,
+    ALGORITHM_OPTIONS_SHA224,
+    ALGORITHM_OPTIONS_SHA256,
+    ALGORITHM_OPTIONS_SHA384,
+    ALGORITHM_OPTIONS_SHA512,
+    ALGORITHM_OPTIONS_BLAKE2B,
+    ALGORITHM_OPTIONS_BLAKE3,
+    ALGORITHM_OPTIONS_SM3,
+    ALGORITHM_OPTIONS_SHAKE128,
+    ALGORITHM_OPTIONS_SHAKE256,
+];
+
+pub struct HashAlgorithm {
+    pub name: &'static str,
+    pub create_fn: Box<dyn Fn() -> Box<dyn Digest + 'static>>,
+    pub bits: usize,
+}
+
+/// This structure holds the count of checksum test lines' outcomes.
+#[derive(Default)]
+struct ChecksumResult {
+    /// Number of lines in the file where the computed checksum MATCHES
+    /// the expectation.
+    pub correct: u32,
+    /// Number of lines in the file where the computed checksum DIFFERS
+    /// from the expectation.
+    pub failed_cksum: u32,
+    pub failed_open_file: u32,
+    /// Number of improperly formatted lines.
+    pub bad_format: u32,
+    /// Total number of non-empty, non-comment lines.
+    pub total: u32,
+}
+
+impl ChecksumResult {
+    #[inline]
+    fn total_properly_formatted(&self) -> u32 {
+        self.total - self.bad_format
+    }
+}
+
+/// Represents a reason for which the processing of a checksum line
+/// could not proceed to digest comparison.
+enum LineCheckError {
+    /// a generic UError was encountered in sub-functions
+    UError(Box<dyn UError>),
+    /// the computed checksum digest differs from the expected one
+    DigestMismatch,
+    /// the line is empty or is a comment
+    Skipped,
+    /// the line has a formatting error
+    ImproperlyFormatted,
+    /// file exists but is impossible to read
+    CantOpenFile,
+    /// there is nothing at the given path
+    FileNotFound,
+    /// the given path leads to a directory
+    FileIsDirectory,
+}
+
+impl From<Box<dyn UError>> for LineCheckError {
+    fn from(value: Box<dyn UError>) -> Self {
+        Self::UError(value)
+    }
+}
+
+impl From<ChecksumError> for LineCheckError {
+    fn from(value: ChecksumError) -> Self {
+        Self::UError(Box::new(value))
+    }
+}
+
+/// Represents an error that was encountered when processing a checksum file.
+enum FileCheckError {
+    /// a generic UError was encountered in sub-functions
+    UError(Box<dyn UError>),
+    /// reading of the checksum file failed
+    CantOpenChecksumFile,
+    /// processing of the file is considered as a failure regarding the
+    /// provided flags. This however does not stop the processing of
+    /// further files.
+    Failed,
+}
+
+impl From<Box<dyn UError>> for FileCheckError {
+    fn from(value: Box<dyn UError>) -> Self {
+        Self::UError(value)
+    }
+}
+
+impl From<ChecksumError> for FileCheckError {
+    fn from(value: ChecksumError) -> Self {
+        Self::UError(Box::new(value))
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]
+pub enum ChecksumVerbose {
+    Status,
+    Quiet,
+    Normal,
+    Warning,
+}
+
+impl ChecksumVerbose {
+    pub fn new(status: bool, quiet: bool, warn: bool) -> Self {
+        use ChecksumVerbose::*;
+
+        // Assume only one of the three booleans will be enabled at once.
+        // This is ensured by clap's overriding arguments.
+        match (status, quiet, warn) {
+            (true, _, _) => Status,
+            (_, true, _) => Quiet,
+            (_, _, true) => Warning,
+            _ => Normal,
+        }
+    }
+
+    #[inline]
+    pub fn over_status(self) -> bool {
+        self > Self::Status
+    }
+
+    #[inline]
+    pub fn over_quiet(self) -> bool {
+        self > Self::Quiet
+    }
+
+    #[inline]
+    pub fn at_least_warning(self) -> bool {
+        self >= Self::Warning
+    }
+}
+
+impl Default for ChecksumVerbose {
+    fn default() -> Self {
+        Self::Normal
+    }
+}
+
+/// This struct regroups CLI flags.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct ChecksumOptions {
+    pub binary: bool,
+    pub ignore_missing: bool,
+    pub strict: bool,
+    pub verbose: ChecksumVerbose,
+}
+
+#[derive(Debug, Error)]
+pub enum ChecksumError {
+    #[error("the --raw option is not supported with multiple files")]
+    RawMultipleFiles,
+    #[error("the --ignore-missing option is meaningful only when verifying checksums")]
+    IgnoreNotCheck,
+    #[error("the --strict option is meaningful only when verifying checksums")]
+    StrictNotCheck,
+    #[error("the --quiet option is meaningful only when verifying checksums")]
+    QuietNotCheck,
+    #[error("Invalid output size for SHA3 (expected 224, 256, 384, or 512)")]
+    InvalidOutputSizeForSha3,
+    #[error("--bits required for SHA3")]
+    BitsRequiredForSha3,
+    #[error("--bits required for SHAKE128")]
+    BitsRequiredForShake128,
+    #[error("--bits required for SHAKE256")]
+    BitsRequiredForShake256,
+    #[error("unknown algorithm: clap should have prevented this case")]
+    UnknownAlgorithm,
+    #[error("length is not a multiple of 8")]
+    InvalidLength,
+    #[error("--length is only supported with --algorithm=blake2b")]
+    LengthOnlyForBlake2b,
+    #[error("the --binary and --text options are meaningless when verifying checksums")]
+    BinaryTextConflict,
+    #[error("--check is not supported with --algorithm={{bsd,sysv,crc,crc32b}}")]
+    AlgorithmNotSupportedWithCheck,
+    #[error("You cannot combine multiple hash algorithms!")]
+    CombineMultipleAlgorithms,
+    #[error("Needs an algorithm to hash with.\nUse --help for more information.")]
+    NeedAlgorithmToHash,
+}
+
+impl UError for ChecksumError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+/// Creates a SHA3 hasher instance based on the specified bits argument.
+///
+/// # Returns
+///
+/// Returns a UResult of a tuple containing the algorithm name, the hasher instance, and
+/// the output length in bits or an Err if an unsupported output size is provided, or if
+/// the `--bits` flag is missing.
+pub fn create_sha3(bits: Option<usize>) -> UResult<HashAlgorithm> {
+    match bits {
+        Some(224) => Ok(HashAlgorithm {
+            name: "SHA3_224",
+            create_fn: Box::new(|| Box::new(Sha3_224::new())),
+            bits: 224,
+        }),
+        Some(256) => Ok(HashAlgorithm {
+            name: "SHA3_256",
+            create_fn: Box::new(|| Box::new(Sha3_256::new())),
+            bits: 256,
+        }),
+        Some(384) => Ok(HashAlgorithm {
+            name: "SHA3_384",
+            create_fn: Box::new(|| Box::new(Sha3_384::new())),
+            bits: 384,
+        }),
+        Some(512) => Ok(HashAlgorithm {
+            name: "SHA3_512",
+            create_fn: Box::new(|| Box::new(Sha3_512::new())),
+            bits: 512,
+        }),
+
+        Some(_) => Err(ChecksumError::InvalidOutputSizeForSha3.into()),
+        None => Err(ChecksumError::BitsRequiredForSha3.into()),
+    }
+}
+
+#[allow(clippy::comparison_chain)]
+fn print_cksum_report(res: &ChecksumResult) {
+    if res.bad_format == 1 {
+        show_warning_caps!("{} line is improperly formatted", res.bad_format);
+    } else if res.bad_format > 1 {
+        show_warning_caps!("{} lines are improperly formatted", res.bad_format);
+    }
+
+    if res.failed_cksum == 1 {
+        show_warning_caps!("{} computed checksum did NOT match", res.failed_cksum);
+    } else if res.failed_cksum > 1 {
+        show_warning_caps!("{} computed checksums did NOT match", res.failed_cksum);
+    }
+
+    if res.failed_open_file == 1 {
+        show_warning_caps!("{} listed file could not be read", res.failed_open_file);
+    } else if res.failed_open_file > 1 {
+        show_warning_caps!("{} listed files could not be read", res.failed_open_file);
+    }
+}
+
+/// Print a "no properly formatted lines" message in stderr
+#[inline]
+fn log_no_properly_formatted(filename: String) {
+    show_error!("{filename}: no properly formatted checksum lines found");
+}
+
+/// Represents the different outcomes that can happen to a file
+/// that is being checked.
+#[derive(Debug, Clone, Copy)]
+enum FileChecksumResult {
+    Ok,
+    Failed,
+    CantOpen,
+}
+
+impl FileChecksumResult {
+    /// Creates a `FileChecksumResult` from a digest comparison that
+    /// either succeeded or failed.
+    fn from_bool(checksum_correct: bool) -> Self {
+        if checksum_correct {
+            FileChecksumResult::Ok
+        } else {
+            FileChecksumResult::Failed
+        }
+    }
+
+    /// The cli options might prevent to display on the outcome of the
+    /// comparison on STDOUT.
+    fn can_display(&self, verbose: ChecksumVerbose) -> bool {
+        match self {
+            FileChecksumResult::Ok => verbose.over_quiet(),
+            FileChecksumResult::Failed => verbose.over_status(),
+            FileChecksumResult::CantOpen => true,
+        }
+    }
+}
+
+impl Display for FileChecksumResult {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FileChecksumResult::Ok => write!(f, "OK"),
+            FileChecksumResult::Failed => write!(f, "FAILED"),
+            FileChecksumResult::CantOpen => write!(f, "FAILED open or read"),
+        }
+    }
+}
+
+/// Print to the given buffer the checksum validation status of a file which
+/// name might contain non-utf-8 characters.
+fn print_file_report<W: Write>(
+    mut w: W,
+    filename: &[u8],
+    result: FileChecksumResult,
+    prefix: &str,
+    verbose: ChecksumVerbose,
+) {
+    if result.can_display(verbose) {
+        let _ = write!(w, "{prefix}");
+        let _ = w.write_all(filename);
+        let _ = writeln!(w, ": {result}");
+    }
+}
+
+pub fn detect_algo(algo: &str, length: Option<usize>) -> UResult<HashAlgorithm> {
+    match algo {
+        ALGORITHM_OPTIONS_SYSV => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SYSV,
+            create_fn: Box::new(|| Box::new(SysV::new())),
+            bits: 512,
+        }),
+        ALGORITHM_OPTIONS_BSD => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_BSD,
+            create_fn: Box::new(|| Box::new(Bsd::new())),
+            bits: 1024,
+        }),
+        ALGORITHM_OPTIONS_CRC => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_CRC,
+            create_fn: Box::new(|| Box::new(Crc::new())),
+            bits: 256,
+        }),
+        ALGORITHM_OPTIONS_CRC32B => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_CRC32B,
+            create_fn: Box::new(|| Box::new(CRC32B::new())),
+            bits: 32,
+        }),
+        ALGORITHM_OPTIONS_MD5 | "md5sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_MD5,
+            create_fn: Box::new(|| Box::new(Md5::new())),
+            bits: 128,
+        }),
+        ALGORITHM_OPTIONS_SHA1 | "sha1sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SHA1,
+            create_fn: Box::new(|| Box::new(Sha1::new())),
+            bits: 160,
+        }),
+        ALGORITHM_OPTIONS_SHA224 | "sha224sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SHA224,
+            create_fn: Box::new(|| Box::new(Sha224::new())),
+            bits: 224,
+        }),
+        ALGORITHM_OPTIONS_SHA256 | "sha256sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SHA256,
+            create_fn: Box::new(|| Box::new(Sha256::new())),
+            bits: 256,
+        }),
+        ALGORITHM_OPTIONS_SHA384 | "sha384sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SHA384,
+            create_fn: Box::new(|| Box::new(Sha384::new())),
+            bits: 384,
+        }),
+        ALGORITHM_OPTIONS_SHA512 | "sha512sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SHA512,
+            create_fn: Box::new(|| Box::new(Sha512::new())),
+            bits: 512,
+        }),
+        ALGORITHM_OPTIONS_BLAKE2B | "b2sum" => {
+            // Set default length to 512 if None
+            let bits = length.unwrap_or(512);
+            if bits == 512 {
+                Ok(HashAlgorithm {
+                    name: ALGORITHM_OPTIONS_BLAKE2B,
+                    create_fn: Box::new(move || Box::new(Blake2b::new())),
+                    bits: 512,
+                })
+            } else {
+                Ok(HashAlgorithm {
+                    name: ALGORITHM_OPTIONS_BLAKE2B,
+                    create_fn: Box::new(move || Box::new(Blake2b::with_output_bytes(bits))),
+                    bits,
+                })
+            }
+        }
+        ALGORITHM_OPTIONS_BLAKE3 | "b3sum" => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_BLAKE3,
+            create_fn: Box::new(|| Box::new(Blake3::new())),
+            bits: 256,
+        }),
+        ALGORITHM_OPTIONS_SM3 => Ok(HashAlgorithm {
+            name: ALGORITHM_OPTIONS_SM3,
+            create_fn: Box::new(|| Box::new(Sm3::new())),
+            bits: 512,
+        }),
+        ALGORITHM_OPTIONS_SHAKE128 | "shake128sum" => {
+            let bits =
+                length.ok_or_else(|| USimpleError::new(1, "--bits required for SHAKE128"))?;
+            Ok(HashAlgorithm {
+                name: ALGORITHM_OPTIONS_SHAKE128,
+                create_fn: Box::new(|| Box::new(Shake128::new())),
+                bits,
+            })
+        }
+        ALGORITHM_OPTIONS_SHAKE256 | "shake256sum" => {
+            let bits =
+                length.ok_or_else(|| USimpleError::new(1, "--bits required for SHAKE256"))?;
+            Ok(HashAlgorithm {
+                name: ALGORITHM_OPTIONS_SHAKE256,
+                create_fn: Box::new(|| Box::new(Shake256::new())),
+                bits,
+            })
+        }
+        //ALGORITHM_OPTIONS_SHA3 | "sha3" => (
+        _ if algo.starts_with("sha3") => create_sha3(length),
+
+        _ => Err(ChecksumError::UnknownAlgorithm.into()),
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum LineFormat {
+    AlgoBased,
+    SingleSpace,
+    Untagged,
+}
+
+impl LineFormat {
+    /// parse [tagged output format]
+    /// Normally the format is simply space separated but openssl does not
+    /// respect the gnu definition.
+    ///
+    /// [tagged output format]: https://www.gnu.org/software/coreutils/manual/html_node/cksum-output-modes.html#cksum-output-modes-1
+    fn parse_algo_based(line: &[u8]) -> Option<LineInfo> {
+        //   r"\MD5 (a\\ b) = abc123",
+        //   BLAKE2b(44)= a45a4c4883cce4b50d844fab460414cc2080ca83690e74d850a9253e757384366382625b218c8585daee80f34dc9eb2f2fde5fb959db81cd48837f9216e7b0fa
+        let trimmed = line.trim_ascii_start();
+        let algo_start = if trimmed.starts_with(b"\\") { 1 } else { 0 };
+        let rest = &trimmed[algo_start..];
+
+        enum SubCase {
+            Posix,
+            OpenSSL,
+        }
+        // find the next parenthesis  using byte search (not next whitespace) because openssl's
+        // tagged format does not put a space before (filename)
+
+        let par_idx = rest.iter().position(|&b| b == b'(')?;
+        let sub_case = if rest[par_idx - 1] == b' ' {
+            SubCase::Posix
+        } else {
+            SubCase::OpenSSL
+        };
+
+        let algo_substring = match sub_case {
+            SubCase::Posix => &rest[..par_idx - 1],
+            SubCase::OpenSSL => &rest[..par_idx],
+        };
+        let mut algo_parts = algo_substring.splitn(2, |&b| b == b'-');
+        let algo = algo_parts.next()?;
+
+        // Parse algo_bits if present
+        let algo_bits = algo_parts
+            .next()
+            .and_then(|s| std::str::from_utf8(s).ok()?.parse::<usize>().ok());
+
+        // Check algo format: uppercase ASCII or digits or "BLAKE2b"
+        let is_valid_algo = algo == b"BLAKE2b"
+            || algo
+                .iter()
+                .all(|&b| b.is_ascii_uppercase() || b.is_ascii_digit());
+        if !is_valid_algo {
+            return None;
+        }
+        // SAFETY: we just validated the contents of algo, we can unsafely make a
+        // String from it
+        let algo_utf8 = unsafe { String::from_utf8_unchecked(algo.to_vec()) };
+        // stripping '(' not ' (' since we matched on ( not whitespace because of openssl.
+        let after_paren = rest.get(par_idx + 1..)?;
+        let (filename, checksum) = match sub_case {
+            SubCase::Posix => ByteSliceExt::rsplit_once(after_paren, b") = ")?,
+            SubCase::OpenSSL => ByteSliceExt::rsplit_once(after_paren, b")= ")?,
+        };
+
+        fn is_valid_checksum(checksum: &[u8]) -> bool {
+            if checksum.is_empty() {
+                return false;
+            }
+
+            let mut parts = checksum.splitn(2, |&b| b == b'=');
+            let main = parts.next().unwrap(); // Always exists since checksum isn't empty
+            let padding = parts.next().unwrap_or_default(); // Empty if no '='
+
+            main.iter()
+                .all(|&b| b.is_ascii_alphanumeric() || b == b'+' || b == b'/')
+                && !main.is_empty()
+                && padding.len() <= 2
+                && padding.iter().all(|&b| b == b'=')
+        }
+        if !is_valid_checksum(checksum) {
+            return None;
+        }
+        // SAFETY: we just validated the contents of checksum, we can unsafely make a
+        // String from it
+        let checksum_utf8 = unsafe { String::from_utf8_unchecked(checksum.to_vec()) };
+
+        Some(LineInfo {
+            algo_name: Some(algo_utf8),
+            algo_bit_len: algo_bits,
+            checksum: checksum_utf8,
+            filename: filename.to_vec(),
+            format: LineFormat::AlgoBased,
+        })
+    }
+
+    #[allow(rustdoc::invalid_html_tags)]
+    /// parse [untagged output format]
+    /// The format is simple, either "<checksum>  <filename>" or
+    /// "<checksum> *<filename>"
+    ///
+    /// [untagged output format]: https://www.gnu.org/software/coreutils/manual/html_node/cksum-output-modes.html#cksum-output-modes-1
+    fn parse_untagged(line: &[u8]) -> Option<LineInfo> {
+        let space_idx = line.iter().position(|&b| b == b' ')?;
+        let checksum = &line[..space_idx];
+        if !checksum.iter().all(|&b| b.is_ascii_hexdigit()) || checksum.is_empty() {
+            return None;
+        }
+        // SAFETY: we just validated the contents of checksum, we can unsafely make a
+        // String from it
+        let checksum_utf8 = unsafe { String::from_utf8_unchecked(checksum.to_vec()) };
+
+        let rest = &line[space_idx..];
+        let filename = rest
+            .strip_prefix(b"  ")
+            .or_else(|| rest.strip_prefix(b" *"))?;
+
+        Some(LineInfo {
+            algo_name: None,
+            algo_bit_len: None,
+            checksum: checksum_utf8,
+            filename: filename.to_vec(),
+            format: LineFormat::Untagged,
+        })
+    }
+
+    #[allow(rustdoc::invalid_html_tags)]
+    /// parse [untagged output format]
+    /// Normally the format is simple, either "<checksum>  <filename>" or
+    /// "<checksum> *<filename>"
+    /// But the bsd tests expect special single space behavior where
+    /// checksum and filename are separated only by a space, meaning the second
+    /// space or asterisk is part of the file name.
+    /// This parser accounts for this variation
+    ///
+    /// [untagged output format]: https://www.gnu.org/software/coreutils/manual/html_node/cksum-output-modes.html#cksum-output-modes-1
+    fn parse_single_space(line: &[u8]) -> Option<LineInfo> {
+        // Find first space
+        let space_idx = line.iter().position(|&b| b == b' ')?;
+        let checksum = &line[..space_idx];
+        if !checksum.iter().all(|&b| b.is_ascii_hexdigit()) || checksum.is_empty() {
+            return None;
+        }
+        // SAFETY: we just validated the contents of checksum, we can unsafely make a
+        // String from it
+        let checksum_utf8 = unsafe { String::from_utf8_unchecked(checksum.to_vec()) };
+
+        let filename = line.get(space_idx + 1..)?; // Skip single space
+
+        Some(LineInfo {
+            algo_name: None,
+            algo_bit_len: None,
+            checksum: checksum_utf8,
+            filename: filename.to_vec(),
+            format: LineFormat::SingleSpace,
+        })
+    }
+}
+
+// Helper trait for byte slice operations
+trait ByteSliceExt {
+    /// Look for a pattern from right to left, return surrounding parts if found.
+    fn rsplit_once(&self, pattern: &[u8]) -> Option<(&Self, &Self)>;
+}
+
+impl ByteSliceExt for [u8] {
+    fn rsplit_once(&self, pattern: &[u8]) -> Option<(&Self, &Self)> {
+        let pos = self
+            .windows(pattern.len())
+            .rev()
+            .position(|w| w == pattern)?;
+        Some((
+            &self[..self.len() - pattern.len() - pos],
+            &self[self.len() - pos..],
+        ))
+    }
+}
+
+/// Hold the data extracted from a checksum line.
+struct LineInfo {
+    algo_name: Option<String>,
+    algo_bit_len: Option<usize>,
+    checksum: String,
+    filename: Vec<u8>,
+    format: LineFormat,
+}
+
+impl LineInfo {
+    /// Returns a `LineInfo` parsed from a checksum line.
+    /// The function will run 3 parsers against the line and select the first one that matches
+    /// to populate the fields of the struct.
+    /// However, there is a catch to handle regarding the handling of `cached_line_format`.
+    /// In case of non-algo-based format, if `cached_line_format` is Some, it must take the priority
+    /// over the detected format. Otherwise, we must set it the the detected format.
+    /// This specific behavior is emphasized by the test
+    /// `test_hashsum::test_check_md5sum_only_one_space`.
+    fn parse(s: impl AsRef<OsStr>, cached_line_format: &mut Option<LineFormat>) -> Option<Self> {
+        let line_bytes = os_str_as_bytes(s.as_ref()).ok()?;
+
+        if let Some(info) = LineFormat::parse_algo_based(line_bytes) {
+            return Some(info);
+        }
+        if let Some(cached_format) = cached_line_format {
+            match cached_format {
+                LineFormat::Untagged => LineFormat::parse_untagged(line_bytes),
+                LineFormat::SingleSpace => LineFormat::parse_single_space(line_bytes),
+                _ => unreachable!("we never catch the algo based format"),
+            }
+        } else if let Some(info) = LineFormat::parse_untagged(line_bytes) {
+            *cached_line_format = Some(LineFormat::Untagged);
+            Some(info)
+        } else if let Some(info) = LineFormat::parse_single_space(line_bytes) {
+            *cached_line_format = Some(LineFormat::SingleSpace);
+            Some(info)
+        } else {
+            None
+        }
+    }
+}
+
+fn get_filename_for_output(filename: &OsStr, input_is_stdin: bool) -> String {
+    if input_is_stdin {
+        "standard input"
+    } else {
+        filename.to_str().unwrap()
+    }
+    .maybe_quote()
+    .to_string()
+}
+
+/// Extract the expected digest from the checksum string
+fn get_expected_digest_as_hex_string(
+    line_info: &LineInfo,
+    len_hint: Option<usize>,
+) -> Option<Cow<str>> {
+    let ck = &line_info.checksum;
+
+    let against_hint = |len| len_hint.is_none_or(|l| l == len);
+
+    if ck.len() % 2 != 0 {
+        // If the length of the digest is not a multiple of 2, then it
+        // must be improperly formatted (1 hex digit is 2 characters)
+        return None;
+    }
+
+    // If the digest can be decoded as hexadecimal AND its length matches the
+    // one expected (in case it's given), just go with it.
+    if ck.as_bytes().iter().all(u8::is_ascii_hexdigit) && against_hint(ck.len()) {
+        return Some(Cow::Borrowed(ck));
+    }
+
+    // If hexadecimal digest fails for any reason, interpret the digest as base 64.
+    BASE64
+        .decode(ck.as_bytes()) // Decode the string as encoded base64
+        .map(hex::encode) // Encode it back as hexadecimal
+        .map(Cow::<str>::Owned)
+        .ok()
+        .and_then(|s| {
+            // Check the digest length
+            if against_hint(s.len()) { Some(s) } else { None }
+        })
+}
+
+/// Returns a reader that reads from the specified file, or from stdin if `filename_to_check` is "-".
+fn get_file_to_check(
+    filename: &OsStr,
+    opts: ChecksumOptions,
+) -> Result<Box<dyn Read>, LineCheckError> {
+    let filename_bytes = os_str_as_bytes(filename).expect("UTF-8 error");
+    let filename_lossy = String::from_utf8_lossy(filename_bytes);
+    if filename == "-" {
+        Ok(Box::new(stdin())) // Use stdin if "-" is specified in the checksum file
+    } else {
+        let failed_open = || {
+            print_file_report(
+                std::io::stdout(),
+                filename_bytes,
+                FileChecksumResult::CantOpen,
+                "",
+                opts.verbose,
+            );
+        };
+        match File::open(filename) {
+            Ok(f) => {
+                if f.metadata()
+                    .map_err(|_| LineCheckError::CantOpenFile)?
+                    .is_dir()
+                {
+                    show!(USimpleError::new(
+                        1,
+                        format!("{filename_lossy}: Is a directory")
+                    ));
+                    // also regarded as a failed open
+                    failed_open();
+                    Err(LineCheckError::FileIsDirectory)
+                } else {
+                    Ok(Box::new(f))
+                }
+            }
+            Err(err) => {
+                if !opts.ignore_missing {
+                    // yes, we have both stderr and stdout here
+                    show!(err.map_err_context(|| filename_lossy.to_string()));
+                    failed_open();
+                }
+                // we could not open the file but we want to continue
+                Err(LineCheckError::FileNotFound)
+            }
+        }
+    }
+}
+
+/// Returns a reader to the list of checksums
+fn get_input_file(filename: &OsStr) -> UResult<Box<dyn Read>> {
+    match File::open(filename) {
+        Ok(f) => {
+            if f.metadata()?.is_dir() {
+                Err(
+                    io::Error::other(format!("{}: Is a directory", filename.to_string_lossy()))
+                        .into(),
+                )
+            } else {
+                Ok(Box::new(f))
+            }
+        }
+        Err(_) => Err(io::Error::other(format!(
+            "{}: No such file or directory",
+            filename.to_string_lossy()
+        ))
+        .into()),
+    }
+}
+
+/// Gets the algorithm name and length from the `LineInfo` if the algo-based format is matched.
+fn identify_algo_name_and_length(
+    line_info: &LineInfo,
+    algo_name_input: Option<&str>,
+    last_algo: &mut Option<String>,
+) -> Result<(String, Option<usize>), LineCheckError> {
+    let algo_from_line = line_info.algo_name.clone().unwrap_or_default();
+    let algorithm = algo_from_line.to_lowercase();
+    *last_algo = Some(algo_from_line);
+
+    // check if we are called with XXXsum (example: md5sum) but we detected a different algo parsing the file
+    // (for example SHA1 (f) = d...)
+    // Also handle the case cksum -s sm3 but the file contains other formats
+    if algo_name_input.is_some() && algo_name_input != Some(&algorithm) {
+        return Err(LineCheckError::ImproperlyFormatted);
+    }
+
+    if !SUPPORTED_ALGORITHMS.contains(&algorithm.as_str()) {
+        // Not supported algo, leave early
+        return Err(LineCheckError::ImproperlyFormatted);
+    }
+
+    let bytes = if let Some(bitlen) = line_info.algo_bit_len {
+        if algorithm != ALGORITHM_OPTIONS_BLAKE2B || bitlen % 8 != 0 {
+            // Either
+            //  the algo based line is provided with a bit length
+            //  with an algorithm that does not support it (only Blake2B does).
+            //
+            //  eg: MD5-128 (foo.txt) = fffffffff
+            //          ^ This is illegal
+            // OR
+            //  the given length is wrong because it's not a multiple of 8.
+            return Err(LineCheckError::ImproperlyFormatted);
+        }
+        Some(bitlen / 8)
+    } else if algorithm == ALGORITHM_OPTIONS_BLAKE2B {
+        // Default length with BLAKE2b,
+        Some(64)
+    } else {
+        None
+    };
+
+    Ok((algorithm, bytes))
+}
+
+/// Given a filename and an algorithm, compute the digest and compare it with
+/// the expected one.
+fn compute_and_check_digest_from_file(
+    filename: &[u8],
+    expected_checksum: &str,
+    mut algo: HashAlgorithm,
+    opts: ChecksumOptions,
+) -> Result<(), LineCheckError> {
+    let (filename_to_check_unescaped, prefix) = unescape_filename(filename);
+    let real_filename_to_check = os_str_from_bytes(&filename_to_check_unescaped)?;
+
+    // Open the input file
+    let file_to_check = get_file_to_check(&real_filename_to_check, opts)?;
+    let mut file_reader = BufReader::new(file_to_check);
+
+    // Read the file and calculate the checksum
+    let create_fn = &mut algo.create_fn;
+    let mut digest = create_fn();
+    let (calculated_checksum, _) =
+        digest_reader(&mut digest, &mut file_reader, opts.binary, algo.bits).unwrap();
+
+    // Do the checksum validation
+    let checksum_correct = expected_checksum == calculated_checksum;
+    print_file_report(
+        std::io::stdout(),
+        filename,
+        FileChecksumResult::from_bool(checksum_correct),
+        prefix,
+        opts.verbose,
+    );
+
+    if checksum_correct {
+        Ok(())
+    } else {
+        Err(LineCheckError::DigestMismatch)
+    }
+}
+
+/// Check a digest checksum with non-algo based pre-treatment.
+fn process_algo_based_line(
+    line_info: &LineInfo,
+    cli_algo_name: Option<&str>,
+    opts: ChecksumOptions,
+    last_algo: &mut Option<String>,
+) -> Result<(), LineCheckError> {
+    let filename_to_check = line_info.filename.as_slice();
+
+    let (algo_name, algo_byte_len) =
+        identify_algo_name_and_length(line_info, cli_algo_name, last_algo)?;
+
+    // If the digest bitlen is known, we can check the format of the expected
+    // checksum with it.
+    let digest_char_length_hint = match (algo_name.as_str(), algo_byte_len) {
+        (ALGORITHM_OPTIONS_BLAKE2B, Some(bytelen)) => Some(bytelen * 2),
+        _ => None,
+    };
+
+    let expected_checksum = get_expected_digest_as_hex_string(line_info, digest_char_length_hint)
+        .ok_or(LineCheckError::ImproperlyFormatted)?;
+
+    let algo = detect_algo(&algo_name, algo_byte_len)?;
+
+    compute_and_check_digest_from_file(filename_to_check, &expected_checksum, algo, opts)
+}
+
+/// Check a digest checksum with non-algo based pre-treatment.
+fn process_non_algo_based_line(
+    line_number: usize,
+    line_info: &LineInfo,
+    cli_algo_name: &str,
+    cli_algo_length: Option<usize>,
+    opts: ChecksumOptions,
+) -> Result<(), LineCheckError> {
+    let mut filename_to_check = line_info.filename.as_slice();
+    if filename_to_check.starts_with(b"*")
+        && line_number == 0
+        && line_info.format == LineFormat::SingleSpace
+    {
+        // Remove the leading asterisk if present - only for the first line
+        filename_to_check = &filename_to_check[1..];
+    }
+    let expected_checksum = get_expected_digest_as_hex_string(line_info, None)
+        .ok_or(LineCheckError::ImproperlyFormatted)?;
+
+    // When a specific algorithm name is input, use it and use the provided bits
+    // except when dealing with blake2b, where we will detect the length
+    let (algo_name, algo_byte_len) = if cli_algo_name == ALGORITHM_OPTIONS_BLAKE2B {
+        // division by 2 converts the length of the Blake2b checksum from hexadecimal
+        // characters to bytes, as each byte is represented by two hexadecimal characters.
+        let length = Some(expected_checksum.len() / 2);
+        (ALGORITHM_OPTIONS_BLAKE2B.to_string(), length)
+    } else {
+        (cli_algo_name.to_lowercase(), cli_algo_length)
+    };
+
+    let algo = detect_algo(&algo_name, algo_byte_len)?;
+
+    compute_and_check_digest_from_file(filename_to_check, &expected_checksum, algo, opts)
+}
+
+/// Parses a checksum line, detect the algorithm to use, read the file and produce
+/// its digest, and compare it to the expected value.
+///
+/// Returns `Ok(bool)` if the comparison happened, bool indicates if the digest
+/// matched the expected.
+/// If the comparison didn't happen, return a `LineChecksumError`.
+fn process_checksum_line(
+    line: &OsStr,
+    i: usize,
+    cli_algo_name: Option<&str>,
+    cli_algo_length: Option<usize>,
+    opts: ChecksumOptions,
+    cached_line_format: &mut Option<LineFormat>,
+    last_algo: &mut Option<String>,
+) -> Result<(), LineCheckError> {
+    let line_bytes = os_str_as_bytes(line)?;
+
+    // Early return on empty or commented lines.
+    if line.is_empty() || line_bytes.starts_with(b"#") {
+        return Err(LineCheckError::Skipped);
+    }
+
+    // Use `LineInfo` to extract the data of a line.
+    // Then, depending on its format, apply a different pre-treatment.
+    let Some(line_info) = LineInfo::parse(line, cached_line_format) else {
+        return Err(LineCheckError::ImproperlyFormatted);
+    };
+
+    if line_info.format == LineFormat::AlgoBased {
+        process_algo_based_line(&line_info, cli_algo_name, opts, last_algo)
+    } else if let Some(cli_algo) = cli_algo_name {
+        // If we match a non-algo based parser, we expect a cli argument
+        // to give us the algorithm to use
+        process_non_algo_based_line(i, &line_info, cli_algo, cli_algo_length, opts)
+    } else {
+        // We have no clue of what algorithm to use
+        return Err(LineCheckError::ImproperlyFormatted);
+    }
+}
+
+fn process_checksum_file(
+    filename_input: &OsStr,
+    cli_algo_name: Option<&str>,
+    cli_algo_length: Option<usize>,
+    opts: ChecksumOptions,
+) -> Result<(), FileCheckError> {
+    let mut res = ChecksumResult::default();
+
+    let input_is_stdin = filename_input == OsStr::new("-");
+
+    let file: Box<dyn Read> = if input_is_stdin {
+        // Use stdin if "-" is specified
+        Box::new(stdin())
+    } else {
+        match get_input_file(filename_input) {
+            Ok(f) => f,
+            Err(e) => {
+                // Could not read the file, show the error and continue to the next file
+                show_error!("{e}");
+                return Err(FileCheckError::CantOpenChecksumFile);
+            }
+        }
+    };
+
+    let reader = BufReader::new(file);
+    let lines = read_os_string_lines(reader).collect::<Vec<_>>();
+
+    // cached_line_format is used to ensure that several non algo-based checksum line
+    // will use the same parser.
+    let mut cached_line_format = None;
+    // last_algo caches the algorithm used in the last line to print a warning
+    // message for the current line if improperly formatted.
+    // Behavior tested in gnu_cksum_c::test_warn
+    let mut last_algo = None;
+
+    for (i, line) in lines.iter().enumerate() {
+        let line_result = process_checksum_line(
+            line,
+            i,
+            cli_algo_name,
+            cli_algo_length,
+            opts,
+            &mut cached_line_format,
+            &mut last_algo,
+        );
+
+        // Match a first time to elude critical UErrors, and increment the total
+        // in all cases except on skipped.
+        use LineCheckError::*;
+        match line_result {
+            Err(UError(e)) => return Err(e.into()),
+            Err(Skipped) => (),
+            _ => res.total += 1,
+        }
+
+        // Match a second time to update the right field of `res`.
+        match line_result {
+            Ok(()) => res.correct += 1,
+            Err(DigestMismatch) => res.failed_cksum += 1,
+            Err(ImproperlyFormatted) => {
+                res.bad_format += 1;
+
+                if opts.verbose.at_least_warning() {
+                    let algo = if let Some(algo_name_input) = cli_algo_name {
+                        Cow::Owned(algo_name_input.to_uppercase())
+                    } else if let Some(algo) = &last_algo {
+                        Cow::Borrowed(algo.as_str())
+                    } else {
+                        Cow::Borrowed("Unknown algorithm")
+                    };
+                    eprintln!(
+                        "{}: {}: {}: improperly formatted {algo} checksum line",
+                        util_name(),
+                        filename_input.maybe_quote(),
+                        i + 1,
+                    );
+                }
+            }
+            Err(CantOpenFile | FileIsDirectory) => res.failed_open_file += 1,
+            Err(FileNotFound) if !opts.ignore_missing => res.failed_open_file += 1,
+            _ => continue,
+        };
+    }
+
+    // not a single line correctly formatted found
+    // return an error
+    if res.total_properly_formatted() == 0 {
+        if opts.verbose.over_status() {
+            log_no_properly_formatted(get_filename_for_output(filename_input, input_is_stdin));
+        }
+        return Err(FileCheckError::Failed);
+    }
+
+    // if any incorrectly formatted line, show it
+    if opts.verbose.over_status() {
+        print_cksum_report(&res);
+    }
+
+    if opts.ignore_missing && res.correct == 0 {
+        // we have only bad format
+        // and we had ignore-missing
+        if opts.verbose.over_status() {
+            eprintln!(
+                "{}: {}: no file was verified",
+                util_name(),
+                filename_input.maybe_quote(),
+            );
+        }
+        return Err(FileCheckError::Failed);
+    }
+
+    // strict means that we should have an exit code.
+    if opts.strict && res.bad_format > 0 {
+        return Err(FileCheckError::Failed);
+    }
+
+    // If a file was missing, return an error unless we explicitly ignore it.
+    if res.failed_open_file > 0 && !opts.ignore_missing {
+        return Err(FileCheckError::Failed);
+    }
+
+    // Obviously, if a checksum failed at some point, report the error.
+    if res.failed_cksum > 0 {
+        return Err(FileCheckError::Failed);
+    }
+
+    Ok(())
+}
+
+/***
+ * Do the checksum validation (can be strict or not)
+*/
+pub fn perform_checksum_validation<'a, I>(
+    files: I,
+    algo_name_input: Option<&str>,
+    length_input: Option<usize>,
+    opts: ChecksumOptions,
+) -> UResult<()>
+where
+    I: Iterator<Item = &'a OsStr>,
+{
+    let mut failed = false;
+
+    // if cksum has several input files, it will print the result for each file
+    for filename_input in files {
+        use FileCheckError::*;
+        match process_checksum_file(filename_input, algo_name_input, length_input, opts) {
+            Err(UError(e)) => return Err(e),
+            Err(Failed | CantOpenChecksumFile) => failed = true,
+            Ok(_) => continue,
+        }
+    }
+
+    if failed {
+        Err(USimpleError::new(1, ""))
+    } else {
+        Ok(())
+    }
+}
+
+pub fn digest_reader<T: Read>(
+    digest: &mut Box<dyn Digest>,
+    reader: &mut BufReader<T>,
+    binary: bool,
+    output_bits: usize,
+) -> io::Result<(String, usize)> {
+    digest.reset();
+
+    // Read bytes from `reader` and write those bytes to `digest`.
+    //
+    // If `binary` is `false` and the operating system is Windows, then
+    // `DigestWriter` replaces "\r\n" with "\n" before it writes the
+    // bytes into `digest`. Otherwise, it just inserts the bytes as-is.
+    //
+    // In order to support replacing "\r\n", we must call `finalize()`
+    // in order to support the possibility that the last character read
+    // from the reader was "\r". (This character gets buffered by
+    // `DigestWriter` and only written if the following character is
+    // "\n". But when "\r" is the last character read, we need to force
+    // it to be written.)
+    let mut digest_writer = DigestWriter::new(digest, binary);
+    let output_size = std::io::copy(reader, &mut digest_writer)? as usize;
+    digest_writer.finalize();
+
+    if digest.output_bits() > 0 {
+        Ok((digest.result_str(), output_size))
+    } else {
+        // Assume it's SHAKE.  result_str() doesn't work with shake (as of 8/30/2016)
+        let mut bytes = vec![0; output_bits.div_ceil(8)];
+        digest.hash_finalize(&mut bytes);
+        Ok((hex::encode(bytes), output_size))
+    }
+}
+
+/// Calculates the length of the digest.
+pub fn calculate_blake2b_length(length: usize) -> UResult<Option<usize>> {
+    match length {
+        0 => Ok(None),
+        n if n % 8 != 0 => {
+            show_error!("invalid length: \u{2018}{length}\u{2019}");
+            Err(io::Error::new(io::ErrorKind::InvalidInput, "length is not a multiple of 8").into())
+        }
+        n if n > 512 => {
+            show_error!("invalid length: \u{2018}{length}\u{2019}");
+            Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "maximum digest length for \u{2018}BLAKE2b\u{2019} is 512 bits",
+            )
+            .into())
+        }
+        n => {
+            // Divide by 8, as our blake2b implementation expects bytes instead of bits.
+            if n == 512 {
+                // When length is 512, it is blake2b's default.
+                // So, don't show it
+                Ok(None)
+            } else {
+                Ok(Some(n / 8))
+            }
+        }
+    }
+}
+
+pub fn unescape_filename(filename: &[u8]) -> (Vec<u8>, &'static str) {
+    let mut unescaped = Vec::with_capacity(filename.len());
+    let mut byte_iter = filename.iter().peekable();
+    loop {
+        let Some(byte) = byte_iter.next() else {
+            break;
+        };
+        if *byte == b'\\' {
+            match byte_iter.next() {
+                Some(b'\\') => unescaped.push(b'\\'),
+                Some(b'n') => unescaped.push(b'\n'),
+                Some(b'r') => unescaped.push(b'\r'),
+                Some(x) => {
+                    unescaped.push(b'\\');
+                    unescaped.push(*x);
+                }
+                _ => {}
+            }
+        } else {
+            unescaped.push(*byte);
+        }
+    }
+    let prefix = if unescaped == filename { "" } else { "\\" };
+    (unescaped, prefix)
+}
+
+pub fn escape_filename(filename: &Path) -> (String, &'static str) {
+    let original = filename.as_os_str().to_string_lossy();
+    let escaped = original
+        .replace('\\', "\\\\")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r");
+    let prefix = if escaped == original { "" } else { "\\" };
+    (escaped, prefix)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::OsString;
+
+    #[test]
+    fn test_unescape_filename() {
+        let (unescaped, prefix) = unescape_filename(b"test\\nfile.txt");
+        assert_eq!(unescaped, b"test\nfile.txt");
+        assert_eq!(prefix, "\\");
+        let (unescaped, prefix) = unescape_filename(b"test\\nfile.txt");
+        assert_eq!(unescaped, b"test\nfile.txt");
+        assert_eq!(prefix, "\\");
+
+        let (unescaped, prefix) = unescape_filename(b"test\\rfile.txt");
+        assert_eq!(unescaped, b"test\rfile.txt");
+        assert_eq!(prefix, "\\");
+
+        let (unescaped, prefix) = unescape_filename(b"test\\\\file.txt");
+        assert_eq!(unescaped, b"test\\file.txt");
+        assert_eq!(prefix, "\\");
+    }
+
+    #[test]
+    fn test_escape_filename() {
+        let (escaped, prefix) = escape_filename(Path::new("testfile.txt"));
+        assert_eq!(escaped, "testfile.txt");
+        assert_eq!(prefix, "");
+
+        let (escaped, prefix) = escape_filename(Path::new("test\nfile.txt"));
+        assert_eq!(escaped, "test\\nfile.txt");
+        assert_eq!(prefix, "\\");
+
+        let (escaped, prefix) = escape_filename(Path::new("test\rfile.txt"));
+        assert_eq!(escaped, "test\\rfile.txt");
+        assert_eq!(prefix, "\\");
+
+        let (escaped, prefix) = escape_filename(Path::new("test\\file.txt"));
+        assert_eq!(escaped, "test\\\\file.txt");
+        assert_eq!(prefix, "\\");
+    }
+
+    #[test]
+    fn test_calculate_blake2b_length() {
+        assert_eq!(calculate_blake2b_length(0).unwrap(), None);
+        assert!(calculate_blake2b_length(10).is_err());
+        assert!(calculate_blake2b_length(520).is_err());
+        assert_eq!(calculate_blake2b_length(512).unwrap(), None);
+        assert_eq!(calculate_blake2b_length(256).unwrap(), Some(32));
+    }
+
+    #[test]
+    fn test_detect_algo() {
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SYSV, None).unwrap().name,
+            ALGORITHM_OPTIONS_SYSV
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_BSD, None).unwrap().name,
+            ALGORITHM_OPTIONS_BSD
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_CRC, None).unwrap().name,
+            ALGORITHM_OPTIONS_CRC
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_MD5, None).unwrap().name,
+            ALGORITHM_OPTIONS_MD5
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA1, None).unwrap().name,
+            ALGORITHM_OPTIONS_SHA1
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA224, None).unwrap().name,
+            ALGORITHM_OPTIONS_SHA224
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA256, None).unwrap().name,
+            ALGORITHM_OPTIONS_SHA256
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA384, None).unwrap().name,
+            ALGORITHM_OPTIONS_SHA384
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHA512, None).unwrap().name,
+            ALGORITHM_OPTIONS_SHA512
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_BLAKE2B, None).unwrap().name,
+            ALGORITHM_OPTIONS_BLAKE2B
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_BLAKE3, None).unwrap().name,
+            ALGORITHM_OPTIONS_BLAKE3
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SM3, None).unwrap().name,
+            ALGORITHM_OPTIONS_SM3
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHAKE128, Some(128))
+                .unwrap()
+                .name,
+            ALGORITHM_OPTIONS_SHAKE128
+        );
+        assert_eq!(
+            detect_algo(ALGORITHM_OPTIONS_SHAKE256, Some(256))
+                .unwrap()
+                .name,
+            ALGORITHM_OPTIONS_SHAKE256
+        );
+        assert_eq!(detect_algo("sha3_224", Some(224)).unwrap().name, "SHA3_224");
+        assert_eq!(detect_algo("sha3_256", Some(256)).unwrap().name, "SHA3_256");
+        assert_eq!(detect_algo("sha3_384", Some(384)).unwrap().name, "SHA3_384");
+        assert_eq!(detect_algo("sha3_512", Some(512)).unwrap().name, "SHA3_512");
+
+        assert!(detect_algo("sha3_512", None).is_err());
+    }
+
+    #[test]
+    fn test_algo_based_parser() {
+        #[allow(clippy::type_complexity)]
+        let test_cases: &[(&[u8], Option<(&[u8], Option<&[u8]>, &[u8], &[u8])>)] = &[
+            (b"SHA256 (example.txt) = d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", Some((b"SHA256", None, b"example.txt", b"d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2"))),
+            // cspell:disable
+            (b"BLAKE2b-512 (file) = abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef", Some((b"BLAKE2b", Some(b"512"), b"file", b"abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef"))),
+            (b" MD5 (test) = 9e107d9d372bb6826bd81d3542a419d6", Some((b"MD5", None, b"test", b"9e107d9d372bb6826bd81d3542a419d6"))),
+            (b"SHA-1 (anotherfile) = a9993e364706816aba3e25717850c26c9cd0d89d", Some((b"SHA", Some(b"1"), b"anotherfile", b"a9993e364706816aba3e25717850c26c9cd0d89d"))),
+            (b" MD5 (anothertest) = fds65dsf46as5df4d6f54asds5d7f7g9", Some((b"MD5", None, b"anothertest", b"fds65dsf46as5df4d6f54asds5d7f7g9"))),
+            (b" MD5(anothertest2) = fds65dsf46as5df4d6f54asds5d7f7g9", None),
+            (b" MD5(weirdfilename0)= stillfilename)= fds65dsf46as5df4d6f54asds5d7f7g9", Some((b"MD5", None, b"weirdfilename0)= stillfilename", b"fds65dsf46as5df4d6f54asds5d7f7g9"))),
+            (b" MD5(weirdfilename1)= )= fds65dsf46as5df4d6f54asds5d7f7g9", Some((b"MD5", None, b"weirdfilename1)= ", b"fds65dsf46as5df4d6f54asds5d7f7g9"))),
+            (b" MD5(weirdfilename2) = )= fds65dsf46as5df4d6f54asds5d7f7g9", Some((b"MD5", None, b"weirdfilename2) = ", b"fds65dsf46as5df4d6f54asds5d7f7g9"))),
+            (b" MD5 (weirdfilename3)= ) = fds65dsf46as5df4d6f54asds5d7f7g9", Some((b"MD5", None, b"weirdfilename3)= ", b"fds65dsf46as5df4d6f54asds5d7f7g9"))),
+            (b" MD5 (weirdfilename4) = ) = fds65dsf46as5df4d6f54asds5d7f7g9", Some((b"MD5", None, b"weirdfilename4) = ", b"fds65dsf46as5df4d6f54asds5d7f7g9"))),
+            (b" MD5(weirdfilename5)= ) = fds65dsf46as5df4d6f54asds5d7f7g9", None),
+            (b" MD5(weirdfilename6) = ) = fds65dsf46as5df4d6f54asds5d7f7g9", None),
+            (b" MD5 (weirdfilename7)= )= fds65dsf46as5df4d6f54asds5d7f7g9", None),
+            (b" MD5 (weirdfilename8) = )= fds65dsf46as5df4d6f54asds5d7f7g9", None),
+        ];
+
+        // cspell:enable
+        for (input, expected) in test_cases {
+            let line_info = LineFormat::parse_algo_based(input);
+            match expected {
+                Some((algo, bits, filename, checksum)) => {
+                    assert!(
+                        line_info.is_some(),
+                        "expected Some, got None for {}",
+                        String::from_utf8_lossy(filename)
+                    );
+                    let line_info = line_info.unwrap();
+                    assert_eq!(
+                        &line_info.algo_name.unwrap().as_bytes(),
+                        algo,
+                        "failed for {}",
+                        String::from_utf8_lossy(filename)
+                    );
+                    assert_eq!(
+                        line_info
+                            .algo_bit_len
+                            .map(|m| m.to_string().as_bytes().to_owned()),
+                        bits.map(|b| b.to_owned()),
+                        "failed for {}",
+                        String::from_utf8_lossy(filename)
+                    );
+                    assert_eq!(
+                        &line_info.filename,
+                        filename,
+                        "failed for {}",
+                        String::from_utf8_lossy(filename)
+                    );
+                    assert_eq!(
+                        &line_info.checksum.as_bytes(),
+                        checksum,
+                        "failed for {}",
+                        String::from_utf8_lossy(filename)
+                    );
+                }
+                None => {
+                    assert!(
+                        line_info.is_none(),
+                        "failed for {}",
+                        String::from_utf8_lossy(input)
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_double_space_parser() {
+        #[allow(clippy::type_complexity)]
+        let test_cases: &[(&[u8], Option<(&[u8], &[u8])>)] = &[
+            (
+                b"60b725f10c9c85c70d97880dfe8191b3  a",
+                Some((b"60b725f10c9c85c70d97880dfe8191b3", b"a")),
+            ),
+            (
+                b"bf35d7536c785cf06730d5a40301eba2   b",
+                Some((b"bf35d7536c785cf06730d5a40301eba2", b" b")),
+            ),
+            (
+                b"f5b61709718c1ecf8db1aea8547d4698  *c",
+                Some((b"f5b61709718c1ecf8db1aea8547d4698", b"*c")),
+            ),
+            (
+                b"b064a020db8018f18ff5ae367d01b212  dd",
+                Some((b"b064a020db8018f18ff5ae367d01b212", b"dd")),
+            ),
+            (
+                b"b064a020db8018f18ff5ae367d01b212   ",
+                Some((b"b064a020db8018f18ff5ae367d01b212", b" ")),
+            ),
+            (b"invalidchecksum  test", None),
+        ];
+
+        for (input, expected) in test_cases {
+            let line_info = LineFormat::parse_untagged(input);
+            match expected {
+                Some((checksum, filename)) => {
+                    assert!(line_info.is_some());
+                    let line_info = line_info.unwrap();
+                    assert_eq!(&line_info.filename, filename);
+                    assert_eq!(&line_info.checksum.as_bytes(), checksum);
+                }
+                None => {
+                    assert!(line_info.is_none());
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_single_space_parser() {
+        #[allow(clippy::type_complexity)]
+        let test_cases: &[(&[u8], Option<(&[u8], &[u8])>)] = &[
+            (
+                b"60b725f10c9c85c70d97880dfe8191b3 a",
+                Some((b"60b725f10c9c85c70d97880dfe8191b3", b"a")),
+            ),
+            (
+                b"bf35d7536c785cf06730d5a40301eba2 b",
+                Some((b"bf35d7536c785cf06730d5a40301eba2", b"b")),
+            ),
+            (
+                b"f5b61709718c1ecf8db1aea8547d4698 *c",
+                Some((b"f5b61709718c1ecf8db1aea8547d4698", b"*c")),
+            ),
+            (
+                b"b064a020db8018f18ff5ae367d01b212 dd",
+                Some((b"b064a020db8018f18ff5ae367d01b212", b"dd")),
+            ),
+            (b"invalidchecksum test", None),
+        ];
+
+        for (input, expected) in test_cases {
+            let line_info = LineFormat::parse_single_space(input);
+            match expected {
+                Some((checksum, filename)) => {
+                    assert!(line_info.is_some());
+                    let line_info = line_info.unwrap();
+                    assert_eq!(&line_info.filename, filename);
+                    assert_eq!(&line_info.checksum.as_bytes(), checksum);
+                }
+                None => {
+                    assert!(line_info.is_none());
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_line_info() {
+        let mut cached_line_format = None;
+
+        // Test algo-based parser
+        let line_algo_based =
+            OsString::from("MD5 (example.txt) = d41d8cd98f00b204e9800998ecf8427e");
+        let line_info = LineInfo::parse(&line_algo_based, &mut cached_line_format).unwrap();
+        assert_eq!(line_info.algo_name.as_deref(), Some("MD5"));
+        assert!(line_info.algo_bit_len.is_none());
+        assert_eq!(line_info.filename, b"example.txt");
+        assert_eq!(line_info.checksum, "d41d8cd98f00b204e9800998ecf8427e");
+        assert_eq!(line_info.format, LineFormat::AlgoBased);
+        assert!(cached_line_format.is_none());
+
+        // Test double-space parser
+        let line_double_space = OsString::from("d41d8cd98f00b204e9800998ecf8427e  example.txt");
+        let line_info = LineInfo::parse(&line_double_space, &mut cached_line_format).unwrap();
+        assert!(line_info.algo_name.is_none());
+        assert!(line_info.algo_bit_len.is_none());
+        assert_eq!(line_info.filename, b"example.txt");
+        assert_eq!(line_info.checksum, "d41d8cd98f00b204e9800998ecf8427e");
+        assert_eq!(line_info.format, LineFormat::Untagged);
+        assert!(cached_line_format.is_some());
+
+        cached_line_format = None;
+
+        // Test single-space parser
+        let line_single_space = OsString::from("d41d8cd98f00b204e9800998ecf8427e example.txt");
+        let line_info = LineInfo::parse(&line_single_space, &mut cached_line_format).unwrap();
+        assert!(line_info.algo_name.is_none());
+        assert!(line_info.algo_bit_len.is_none());
+        assert_eq!(line_info.filename, b"example.txt");
+        assert_eq!(line_info.checksum, "d41d8cd98f00b204e9800998ecf8427e");
+        assert_eq!(line_info.format, LineFormat::SingleSpace);
+        assert!(cached_line_format.is_some());
+
+        cached_line_format = None;
+
+        // Test invalid checksum line
+        let line_invalid = OsString::from("invalid checksum line");
+        assert!(LineInfo::parse(&line_invalid, &mut cached_line_format).is_none());
+        assert!(cached_line_format.is_none());
+
+        // Test leading space before checksum line
+        let line_algo_based_leading_space =
+            OsString::from("   MD5 (example.txt) = d41d8cd98f00b204e9800998ecf8427e");
+        let line_info =
+            LineInfo::parse(&line_algo_based_leading_space, &mut cached_line_format).unwrap();
+        assert_eq!(line_info.format, LineFormat::AlgoBased);
+        assert!(cached_line_format.is_none());
+
+        // Test trailing space after checksum line (should fail)
+        let line_algo_based_leading_space =
+            OsString::from("MD5 (example.txt) = d41d8cd98f00b204e9800998ecf8427e ");
+        let res = LineInfo::parse(&line_algo_based_leading_space, &mut cached_line_format);
+        assert!(res.is_none());
+        assert!(cached_line_format.is_none());
+    }
+
+    #[test]
+    fn test_get_expected_digest() {
+        let line = OsString::from("SHA256 (empty) = 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=");
+        let mut cached_line_format = None;
+        let line_info = LineInfo::parse(&line, &mut cached_line_format).unwrap();
+
+        let result = get_expected_digest_as_hex_string(&line_info, None);
+
+        assert_eq!(
+            result.unwrap(),
+            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+        );
+    }
+
+    #[test]
+    fn test_get_expected_checksum_invalid() {
+        // The line misses a '=' at the end to be valid base64
+        let line = OsString::from("SHA256 (empty) = 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU");
+        let mut cached_line_format = None;
+        let line_info = LineInfo::parse(&line, &mut cached_line_format).unwrap();
+
+        let result = get_expected_digest_as_hex_string(&line_info, None);
+
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_print_file_report() {
+        let opts = ChecksumOptions::default();
+
+        let cases: &[(&[u8], FileChecksumResult, &str, &[u8])] = &[
+            (b"filename", FileChecksumResult::Ok, "", b"filename: OK\n"),
+            (
+                b"filename",
+                FileChecksumResult::Failed,
+                "",
+                b"filename: FAILED\n",
+            ),
+            (
+                b"filename",
+                FileChecksumResult::CantOpen,
+                "",
+                b"filename: FAILED open or read\n",
+            ),
+            (
+                b"filename",
+                FileChecksumResult::Ok,
+                "prefix",
+                b"prefixfilename: OK\n",
+            ),
+            (
+                b"funky\xffname",
+                FileChecksumResult::Ok,
+                "",
+                b"funky\xffname: OK\n",
+            ),
+        ];
+
+        for (filename, result, prefix, expected) in cases {
+            let mut buffer: Vec<u8> = vec![];
+            print_file_report(&mut buffer, filename, *result, prefix, opts.verbose);
+            assert_eq!(&buffer, expected)
+        }
+    }
+}
diff --git a/src/uucore/src/lib/features/colors.rs b/src/uucore/src/lib/features/colors.rs
new file mode 100644
index 00000000000..885ae2fe967
--- /dev/null
+++ b/src/uucore/src/lib/features/colors.rs
@@ -0,0 +1,269 @@
+// 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.
+// cSpell:disable
+
+//! Provides color handling for `ls` and other utilities.
+
+/// The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
+/// slackware version of dircolors) are recognized but ignored.
+/// Global config options can be specified before TERM or COLORTERM entries
+/// below are TERM or COLORTERM entries, which can be glob patterns, which
+/// restrict following config to systems with matching environment variables.
+pub static TERMS: &[&str] = &[
+    "Eterm",
+    "alacritty*",
+    "ansi",
+    "*color*",
+    "con[0-9]*x[0-9]*",
+    "cons25",
+    "console",
+    "cygwin",
+    "*direct*",
+    "dtterm",
+    "foot",
+    "gnome",
+    "hurd",
+    "jfbterm",
+    "konsole",
+    "kterm",
+    "linux",
+    "linux-c",
+    "mlterm",
+    "putty",
+    "rxvt*",
+    "screen*",
+    "st",
+    "terminator",
+    "tmux*",
+    "vt100",
+    "xterm*",
+];
+
+/// Below are the color init strings for the basic file types.
+/// One can use codes for 256 or more colors supported by modern terminals.
+/// The default color codes use the capabilities of an 8 color terminal
+/// with some additional attributes as per the following codes:
+/// Attribute codes:
+/// 00=none 01=bold 04=underscore 05=blink 07=reverse 08=concealed
+/// Text color codes:
+/// 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white
+/// Background color codes:
+/// 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
+/// #NORMAL 00 /// no color code at all
+/// #FILE 00 /// regular file: use no color at all
+pub static FILE_TYPES: &[(&str, &str, &str)] = &[
+    ("RESET", "rs", "0"),                     // reset to "normal" color
+    ("DIR", "di", "01;34"),                   // directory
+    ("LINK", "ln", "01;36"),                  // symbolic link
+    ("MULTIHARDLINK", "mh", "00"),            // regular file with more than one link
+    ("FIFO", "pi", "40;33"),                  // pipe
+    ("SOCK", "so", "01;35"),                  // socket
+    ("DOOR", "do", "01;35"),                  // door
+    ("BLK", "bd", "40;33;01"),                // block device driver
+    ("CHR", "cd", "40;33;01"),                // character device driver
+    ("ORPHAN", "or", "40;31;01"),             // symlink to nonexistent file, or non-stat'able file
+    ("MISSING", "mi", "00"),                  // ... and the files they point to
+    ("SETUID", "su", "37;41"),                // file that is setuid (u+s)
+    ("SETGID", "sg", "30;43"),                // file that is setgid (g+s)
+    ("CAPABILITY", "ca", "00"),               // file with capability
+    ("STICKY_OTHER_WRITABLE", "tw", "30;42"), // dir that is sticky and other-writable (+t,o+w)
+    ("OTHER_WRITABLE", "ow", "34;42"),        // dir that is other-writable (o+w) and not sticky
+    ("STICKY", "st", "37;44"), // dir with the sticky bit set (+t) and not other-writable
+    ("EXEC", "ex", "01;32"),   // files with execute permission
+];
+
+/// Colors for file types
+///
+/// List any file extensions like '.gz' or '.tar' that you would like ls
+/// to color below. Put the extension, a space, and the color init string.
+/// (and any comments you want to add after a '#')
+pub static FILE_COLORS: &[(&str, &str)] = &[
+    /*
+    // Executables (Windows)
+    (".cmd", "01;32"),
+    (".exe", "01;32"),
+    (".com", "01;32"),
+    (".btm", "01;32"),
+    (".bat", "01;32"),
+    (".sh", "01;32"),
+    (".csh", "01;32"),*/
+    // Archives or compressed
+    (".tar", "01;31"),
+    (".tgz", "01;31"),
+    (".arc", "01;31"),
+    (".arj", "01;31"),
+    (".taz", "01;31"),
+    (".lha", "01;31"),
+    (".lz4", "01;31"),
+    (".lzh", "01;31"),
+    (".lzma", "01;31"),
+    (".tlz", "01;31"),
+    (".txz", "01;31"),
+    (".tzo", "01;31"),
+    (".t7z", "01;31"),
+    (".zip", "01;31"),
+    (".z", "01;31"),
+    (".dz", "01;31"),
+    (".gz", "01;31"),
+    (".lrz", "01;31"),
+    (".lz", "01;31"),
+    (".lzo", "01;31"),
+    (".xz", "01;31"),
+    (".zst", "01;31"),
+    (".tzst", "01;31"),
+    (".bz2", "01;31"),
+    (".bz", "01;31"),
+    (".tbz", "01;31"),
+    (".tbz2", "01;31"),
+    (".tz", "01;31"),
+    (".deb", "01;31"),
+    (".rpm", "01;31"),
+    (".jar", "01;31"),
+    (".war", "01;31"),
+    (".ear", "01;31"),
+    (".sar", "01;31"),
+    (".rar", "01;31"),
+    (".alz", "01;31"),
+    (".ace", "01;31"),
+    (".zoo", "01;31"),
+    (".cpio", "01;31"),
+    (".7z", "01;31"),
+    (".rz", "01;31"),
+    (".cab", "01;31"),
+    (".wim", "01;31"),
+    (".swm", "01;31"),
+    (".dwm", "01;31"),
+    (".esd", "01;31"),
+    // Image formats
+    (".avif", "01;35"),
+    (".jpg", "01;35"),
+    (".jpeg", "01;35"),
+    (".mjpg", "01;35"),
+    (".mjpeg", "01;35"),
+    (".gif", "01;35"),
+    (".bmp", "01;35"),
+    (".pbm", "01;35"),
+    (".pgm", "01;35"),
+    (".ppm", "01;35"),
+    (".tga", "01;35"),
+    (".xbm", "01;35"),
+    (".xpm", "01;35"),
+    (".tif", "01;35"),
+    (".tiff", "01;35"),
+    (".png", "01;35"),
+    (".svg", "01;35"),
+    (".svgz", "01;35"),
+    (".mng", "01;35"),
+    (".pcx", "01;35"),
+    (".mov", "01;35"),
+    (".mpg", "01;35"),
+    (".mpeg", "01;35"),
+    (".m2v", "01;35"),
+    (".mkv", "01;35"),
+    (".webm", "01;35"),
+    (".webp", "01;35"),
+    (".ogm", "01;35"),
+    (".mp4", "01;35"),
+    (".m4v", "01;35"),
+    (".mp4v", "01;35"),
+    (".vob", "01;35"),
+    (".qt", "01;35"),
+    (".nuv", "01;35"),
+    (".wmv", "01;35"),
+    (".asf", "01;35"),
+    (".rm", "01;35"),
+    (".rmvb", "01;35"),
+    (".flc", "01;35"),
+    (".avi", "01;35"),
+    (".fli", "01;35"),
+    (".flv", "01;35"),
+    (".gl", "01;35"),
+    (".dl", "01;35"),
+    (".xcf", "01;35"),
+    (".xwd", "01;35"),
+    (".yuv", "01;35"),
+    (".cgm", "01;35"),
+    (".emf", "01;35"),
+    // https://wiki.xiph.org/MIME_Types_and_File_Extensions
+    (".ogv", "01;35"),
+    (".ogx", "01;35"),
+    // Audio formats
+    (".aac", "00;36"),
+    (".au", "00;36"),
+    (".flac", "00;36"),
+    (".m4a", "00;36"),
+    (".mid", "00;36"),
+    (".midi", "00;36"),
+    (".mka", "00;36"),
+    (".mp3", "00;36"),
+    (".mpc", "00;36"),
+    (".ogg", "00;36"),
+    (".ra", "00;36"),
+    (".wav", "00;36"),
+    // https://wiki.xiph.org/MIME_Types_and_File_Extensions
+    (".oga", "00;36"),
+    (".opus", "00;36"),
+    (".spx", "00;36"),
+    (".xspf", "00;36"),
+    // Backup files
+    ("*~", "00;90"),
+    ("*#", "00;90"),
+    (".bak", "00;90"),
+    (".old", "00;90"),
+    (".orig", "00;90"),
+    (".part", "00;90"),
+    (".rej", "00;90"),
+    (".swp", "00;90"),
+    (".tmp", "00;90"),
+    (".dpkg-dist", "00;90"),
+    (".dpkg-old", "00;90"),
+    (".ucf-dist", "00;90"),
+    (".ucf-new", "00;90"),
+    (".ucf-old", "00;90"),
+    (".rpmnew", "00;90"),
+    (".rpmorig", "00;90"),
+    (".rpmsave", "00;90"),
+];
+
+/// Below are the terminal color capabilities
+pub static FILE_ATTRIBUTE_CODES: &[(&str, &str)] = &[
+    ("normal", "no"),
+    ("norm", "no"),
+    ("file", "fi"),
+    ("reset", "rs"),
+    ("dir", "di"),
+    ("lnk", "ln"),
+    ("link", "ln"),
+    ("symlink", "ln"),
+    ("orphan", "or"),
+    ("missing", "mi"),
+    ("fifo", "pi"),
+    ("pipe", "pi"),
+    ("sock", "so"),
+    ("blk", "bd"),
+    ("block", "bd"),
+    ("chr", "cd"),
+    ("char", "cd"),
+    ("door", "do"),
+    ("exec", "ex"),
+    ("left", "lc"),
+    ("leftcode", "lc"),
+    ("right", "rc"),
+    ("rightcode", "rc"),
+    ("end", "ec"),
+    ("endcode", "ec"),
+    ("suid", "su"),
+    ("setuid", "su"),
+    ("sgid", "sg"),
+    ("setgid", "sg"),
+    ("sticky", "st"),
+    ("other_writable", "ow"),
+    ("owr", "ow"),
+    ("sticky_other_writable", "tw"),
+    ("owt", "tw"),
+    ("capability", "ca"),
+    ("multihardlink", "mh"),
+    ("clrtoeol", "cl"),
+];
diff --git a/src/uucore/src/lib/features/custom_tz_fmt.rs b/src/uucore/src/lib/features/custom_tz_fmt.rs
new file mode 100644
index 00000000000..0d2b6aebe41
--- /dev/null
+++ b/src/uucore/src/lib/features/custom_tz_fmt.rs
@@ -0,0 +1,60 @@
+// 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.
+
+use chrono::{TimeZone, Utc};
+use chrono_tz::{OffsetName, Tz};
+use iana_time_zone::get_timezone;
+
+/// Get the alphabetic abbreviation of the current timezone.
+///
+/// For example, "UTC" or "CET" or "PDT"
+fn timezone_abbreviation() -> String {
+    let tz = match std::env::var("TZ") {
+        // TODO Support other time zones...
+        Ok(s) if s == "UTC0" || s.is_empty() => Tz::Etc__UTC,
+        _ => match get_timezone() {
+            Ok(tz_str) => tz_str.parse().unwrap(),
+            Err(_) => Tz::Etc__UTC,
+        },
+    };
+
+    let offset = tz.offset_from_utc_date(&Utc::now().date_naive());
+    offset.abbreviation().unwrap_or("UTC").to_string()
+}
+
+/// Adapt the given string to be accepted by the chrono library crate.
+///
+/// # Arguments
+///
+/// fmt: the format of the string
+///
+/// # Return
+///
+/// A string that can be used as parameter of the chrono functions that use formats
+pub fn custom_time_format(fmt: &str) -> String {
+    // TODO - Revisit when chrono 0.5 is released. https://github.com/chronotope/chrono/issues/970
+    // chrono crashes on %#z, but it's the same as %z anyway.
+    // GNU `date` uses `%N` for nano seconds, however the `chrono` crate uses `%f`.
+    fmt.replace("%#z", "%z")
+        .replace("%N", "%f")
+        .replace("%Z", timezone_abbreviation().as_ref())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{custom_time_format, timezone_abbreviation};
+
+    #[test]
+    fn test_custom_time_format() {
+        assert_eq!(custom_time_format("%Y-%m-%d %H-%M-%S"), "%Y-%m-%d %H-%M-%S");
+        assert_eq!(custom_time_format("%d-%m-%Y %H-%M-%S"), "%d-%m-%Y %H-%M-%S");
+        assert_eq!(custom_time_format("%Y-%m-%d %H-%M-%S"), "%Y-%m-%d %H-%M-%S");
+        assert_eq!(
+            custom_time_format("%Y-%m-%d %H-%M-%S.%N"),
+            "%Y-%m-%d %H-%M-%S.%f"
+        );
+        assert_eq!(custom_time_format("%Z"), timezone_abbreviation());
+    }
+}
diff --git a/src/uucore/src/lib/features/encoding.rs b/src/uucore/src/lib/features/encoding.rs
index 14fdbb38ee7..b9150114b8a 100644
--- a/src/uucore/src/lib/features/encoding.rs
+++ b/src/uucore/src/lib/features/encoding.rs
@@ -3,35 +3,24 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (strings) ABCDEFGHIJKLMNOPQRSTUVWXYZ ABCDEFGHIJKLMNOPQRSTUV
-// spell-checker:ignore (encodings) lsbf msbf hexupper
+// spell-checker:ignore (encodings) lsbf msbf
+// spell-checker:ignore unpadded
 
-use data_encoding::{self, BASE32, BASE64};
-
-use std::io::{self, Read, Write};
-
-use data_encoding::{Encoding, BASE32HEX, BASE64URL, HEXUPPER};
+use crate::error::{UResult, USimpleError};
+use data_encoding::Encoding;
 use data_encoding_macro::new_encoding;
-#[cfg(feature = "thiserror")]
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum DecodeError {
-    #[error("{}", _0)]
-    Decode(#[from] data_encoding::DecodeError),
-    #[error("{}", _0)]
-    DecodeZ85(#[from] z85::DecodeError),
-    #[error("{}", _0)]
-    Io(#[from] io::Error),
-}
+use std::collections::VecDeque;
 
-pub enum EncodeError {
-    Z85InputLenNotMultipleOf4,
+// Re-export for the faster decoding/encoding logic
+pub mod for_base_common {
+    pub use data_encoding::*;
 }
 
-pub type DecodeResult = Result<Vec<u8>, DecodeError>;
+pub mod for_cksum {
+    pub use data_encoding::BASE64;
+}
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub enum Format {
     Base64,
     Base64Url,
@@ -42,136 +31,182 @@ pub enum Format {
     Base2Msbf,
     Z85,
 }
-use self::Format::*;
 
-const BASE2LSBF: Encoding = new_encoding! {
+pub const BASE2LSBF: Encoding = new_encoding! {
     symbols: "01",
     bit_order: LeastSignificantFirst,
 };
-const BASE2MSBF: Encoding = new_encoding! {
+
+pub const BASE2MSBF: Encoding = new_encoding! {
     symbols: "01",
     bit_order: MostSignificantFirst,
 };
 
-pub fn encode(f: Format, input: &[u8]) -> Result<String, EncodeError> {
-    Ok(match f {
-        Base32 => BASE32.encode(input),
-        Base64 => BASE64.encode(input),
-        Base64Url => BASE64URL.encode(input),
-        Base32Hex => BASE32HEX.encode(input),
-        Base16 => HEXUPPER.encode(input),
-        Base2Lsbf => BASE2LSBF.encode(input),
-        Base2Msbf => BASE2MSBF.encode(input),
-        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 {
-                z85::encode(input)
-            } else {
-                return Err(EncodeError::Z85InputLenNotMultipleOf4);
-            }
-        }
-    })
+pub struct Z85Wrapper {}
+
+pub struct EncodingWrapper {
+    pub alphabet: &'static [u8],
+    pub encoding: Encoding,
+    pub unpadded_multiple: usize,
+    pub valid_decoding_multiple: usize,
 }
 
-pub fn decode(f: Format, input: &[u8]) -> DecodeResult {
-    Ok(match f {
-        Base32 => BASE32.decode(input)?,
-        Base64 => BASE64.decode(input)?,
-        Base64Url => BASE64URL.decode(input)?,
-        Base32Hex => BASE32HEX.decode(input)?,
-        Base16 => HEXUPPER.decode(input)?,
-        Base2Lsbf => BASE2LSBF.decode(input)?,
-        Base2Msbf => BASE2MSBF.decode(input)?,
-        Z85 => {
-            // The z85 crate implements a padded encoding by using a leading '#' which is otherwise not allowed.
-            // We manually check for a leading '#' and return an error ourselves.
-            if input.starts_with(&[b'#']) {
-                return Err(z85::DecodeError::InvalidByte(0, b'#').into());
-            } else {
-                z85::decode(input)?
-            }
+impl EncodingWrapper {
+    pub fn new(
+        encoding: Encoding,
+        valid_decoding_multiple: usize,
+        unpadded_multiple: usize,
+        alphabet: &'static [u8],
+    ) -> Self {
+        assert!(valid_decoding_multiple > 0);
+
+        assert!(unpadded_multiple > 0);
+
+        assert!(!alphabet.is_empty());
+
+        Self {
+            alphabet,
+            encoding,
+            unpadded_multiple,
+            valid_decoding_multiple,
         }
-    })
+    }
 }
 
-pub struct Data<R: Read> {
-    line_wrap: usize,
-    ignore_garbage: bool,
-    input: R,
-    format: Format,
-    alphabet: &'static [u8],
+pub trait SupportsFastDecodeAndEncode {
+    /// Returns the list of characters used by this encoding
+    fn alphabet(&self) -> &'static [u8];
+
+    fn decode_into_vec(&self, input: &[u8], output: &mut Vec<u8>) -> UResult<()>;
+
+    fn encode_to_vec_deque(&self, input: &[u8], output: &mut VecDeque<u8>) -> UResult<()>;
+
+    /// Inputs with a length that is a multiple of this number do not have padding when encoded. For instance:
+    ///
+    /// "The quick brown"
+    ///
+    /// is 15 characters (divisible by 3), so it is encoded in Base64 without padding:
+    ///
+    /// "VGhlIHF1aWNrIGJyb3du"
+    ///
+    /// While:
+    ///
+    /// "The quick brown fox"
+    ///
+    /// is 19 characters, which is not divisible by 3, so its Base64 representation has padding:
+    ///
+    /// "VGhlIHF1aWNrIGJyb3duIGZveA=="
+    ///
+    /// The encoding performed by `fast_encode` depends on this number being correct.
+    fn unpadded_multiple(&self) -> usize;
+
+    /// Data to decode must be a length that is multiple of this number
+    ///
+    /// The decoding performed by `fast_decode` depends on this number being correct.
+    fn valid_decoding_multiple(&self) -> usize;
 }
 
-impl<R: Read> Data<R> {
-    pub fn new(input: R, format: Format) -> Self {
-        Self {
-            line_wrap: 76,
-            ignore_garbage: false,
-            input,
-            format,
-            alphabet: match format {
-                Base32 => b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
-                Base64 => b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=+/",
-                Base64Url => b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=_-",
-                Base32Hex => b"0123456789ABCDEFGHIJKLMNOPQRSTUV=",
-                Base16 => b"0123456789ABCDEF",
-                Base2Lsbf => b"01",
-                Base2Msbf => b"01",
-                Z85 => b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#",
-            },
-        }
+impl SupportsFastDecodeAndEncode for Z85Wrapper {
+    fn alphabet(&self) -> &'static [u8] {
+        // Z85 alphabet
+        b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#"
     }
 
-    #[must_use]
-    pub fn line_wrap(mut self, wrap: usize) -> Self {
-        self.line_wrap = wrap;
-        self
+    fn decode_into_vec(&self, input: &[u8], output: &mut Vec<u8>) -> UResult<()> {
+        if input.first() == Some(&b'#') {
+            return Err(USimpleError::new(1, "error: invalid input".to_owned()));
+        }
+
+        let decode_result = match z85::decode(input) {
+            Ok(ve) => ve,
+            Err(_de) => {
+                return Err(USimpleError::new(1, "error: invalid input".to_owned()));
+            }
+        };
+
+        output.extend_from_slice(&decode_result);
+
+        Ok(())
     }
 
-    #[must_use]
-    pub fn ignore_garbage(mut self, ignore: bool) -> Self {
-        self.ignore_garbage = ignore;
-        self
+    fn valid_decoding_multiple(&self) -> usize {
+        5
     }
 
-    pub fn decode(&mut self) -> DecodeResult {
-        let mut buf = vec![];
-        self.input.read_to_end(&mut buf)?;
-        if self.ignore_garbage {
-            buf.retain(|c| self.alphabet.contains(c));
-        } else {
-            buf.retain(|&c| c != b'\r' && c != b'\n');
-        };
-        decode(self.format, &buf)
+    fn encode_to_vec_deque(&self, input: &[u8], output: &mut VecDeque<u8>) -> UResult<()> {
+        // 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(USimpleError::new(
+                1,
+                "error: invalid input (length must be multiple of 4 characters)".to_owned(),
+            ));
+        }
+
+        let string = z85::encode(input);
+
+        output.extend(string.as_bytes());
+
+        Ok(())
     }
 
-    pub fn encode(&mut self) -> Result<String, EncodeError> {
-        let mut buf: Vec<u8> = vec![];
-        self.input.read_to_end(&mut buf).unwrap();
-        encode(self.format, buf.as_slice())
+    fn unpadded_multiple(&self) -> usize {
+        4
     }
 }
 
-// NOTE: this will likely be phased out at some point
-pub fn wrap_print<R: Read>(data: &Data<R>, res: &str) {
-    let stdout = io::stdout();
-    wrap_write(stdout.lock(), data.line_wrap, res).unwrap();
-}
+impl SupportsFastDecodeAndEncode for EncodingWrapper {
+    fn alphabet(&self) -> &'static [u8] {
+        self.alphabet
+    }
+
+    // Adapted from `decode` in the "data-encoding" crate
+    fn decode_into_vec(&self, input: &[u8], output: &mut Vec<u8>) -> UResult<()> {
+        let decode_len_result = match self.encoding.decode_len(input.len()) {
+            Ok(us) => us,
+            Err(_de) => {
+                return Err(USimpleError::new(1, "error: invalid input".to_owned()));
+            }
+        };
+
+        let output_len = output.len();
 
-pub fn wrap_write<W: Write>(mut writer: W, line_wrap: usize, res: &str) -> io::Result<()> {
-    use std::cmp::min;
+        output.resize(output_len + decode_len_result, 0);
 
-    if line_wrap == 0 {
-        return write!(writer, "{res}");
+        match self.encoding.decode_mut(input, &mut (output[output_len..])) {
+            Ok(us) => {
+                // See:
+                // https://docs.rs/data-encoding/latest/data_encoding/struct.Encoding.html#method.decode_mut
+                // "Returns the length of the decoded output. This length may be smaller than the output length if the input contained padding or ignored characters. The output bytes after the returned length are not initialized and should not be read."
+                output.truncate(output_len + us);
+            }
+            Err(_de) => {
+                return Err(USimpleError::new(1, "error: invalid input".to_owned()));
+            }
+        }
+
+        Ok(())
     }
 
-    let mut start = 0;
-    while start < res.len() {
-        let end = min(start + line_wrap, res.len());
-        writeln!(writer, "{}", &res[start..end])?;
-        start = end;
+    fn valid_decoding_multiple(&self) -> usize {
+        self.valid_decoding_multiple
     }
 
-    Ok(())
+    // Adapted from `encode_append` in the "data-encoding" crate
+    fn encode_to_vec_deque(&self, input: &[u8], output: &mut VecDeque<u8>) -> UResult<()> {
+        let output_len = output.len();
+
+        output.resize(output_len + self.encoding.encode_len(input.len()), 0);
+
+        let make_contiguous_result = output.make_contiguous();
+
+        self.encoding
+            .encode_mut(input, &mut (make_contiguous_result[output_len..]));
+
+        Ok(())
+    }
+
+    fn unpadded_multiple(&self) -> usize {
+        self.unpadded_multiple
+    }
 }
diff --git a/src/uucore/src/lib/features/entries.rs b/src/uucore/src/lib/features/entries.rs
index 29c9b437234..9fa7b94ab99 100644
--- a/src/uucore/src/lib/features/entries.rs
+++ b/src/uucore/src/lib/features/entries.rs
@@ -35,7 +35,6 @@
 #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
 use libc::time_t;
 use libc::{c_char, c_int, gid_t, uid_t};
-#[cfg(not(target_os = "redox"))]
 use libc::{getgrgid, getgrnam, getgroups};
 use libc::{getpwnam, getpwuid, group, passwd};
 
@@ -44,11 +43,9 @@ use std::io::Error as IOError;
 use std::io::ErrorKind;
 use std::io::Result as IOResult;
 use std::ptr;
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
-use once_cell::sync::Lazy;
-
-extern "C" {
+unsafe extern "C" {
     /// From: `<https://man7.org/linux/man-pages/man3/getgrouplist.3.html>`
     /// > The getgrouplist() function scans the group database to obtain
     /// > the list of groups that user belongs to.
@@ -67,7 +64,6 @@ extern "C" {
 /// > supplementary group IDs for the process is returned.  This allows
 /// > the caller to determine the size of a dynamically allocated list
 /// > to be used in a further call to getgroups().
-#[cfg(not(target_os = "redox"))]
 pub fn get_groups() -> IOResult<Vec<gid_t>> {
     let mut groups = Vec::new();
     loop {
@@ -85,13 +81,14 @@ pub fn get_groups() -> IOResult<Vec<gid_t>> {
         if res == -1 {
             let err = IOError::last_os_error();
             if err.raw_os_error() == Some(libc::EINVAL) {
-                // Number of groups changed, retry
+                // Number of groups has increased, retry
                 continue;
             } else {
                 return Err(err);
             }
         } else {
-            groups.truncate(ngroups.try_into().unwrap());
+            // Number of groups may have decreased
+            groups.truncate(res.try_into().unwrap());
             return Ok(groups);
         }
     }
@@ -126,7 +123,7 @@ pub fn get_groups_gnu(arg_id: Option<u32>) -> IOResult<Vec<gid_t>> {
     Ok(sort_groups(groups, egid))
 }
 
-#[cfg(all(unix, feature = "process"))]
+#[cfg(all(unix, not(target_os = "redox"), feature = "process"))]
 fn sort_groups(mut groups: Vec<gid_t>, egid: gid_t) -> Vec<gid_t> {
     if let Some(index) = groups.iter().position(|&x| x == egid) {
         groups[..=index].rotate_right(1);
@@ -163,18 +160,21 @@ pub struct Passwd {
     pub expiration: time_t,
 }
 
-/// SAFETY: ptr must point to a valid C string.
+/// # Safety
+/// ptr must point to a valid C string.
+///
 /// Returns None if ptr is null.
-unsafe fn cstr2string(ptr: *const c_char) -> Option<String> {
+fn cstr2string(ptr: *const c_char) -> Option<String> {
     if ptr.is_null() {
         None
     } else {
-        Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
+        Some(unsafe { CStr::from_ptr(ptr).to_string_lossy().into_owned() })
     }
 }
 
 impl Passwd {
-    /// SAFETY: All the pointed-to strings must be valid and not change while
+    /// # Safety
+    /// All the pointed-to strings must be valid and not change while
     /// the function runs. That means PW_LOCK must be held.
     unsafe fn from_raw(raw: passwd) -> Self {
         Self {
@@ -248,7 +248,8 @@ pub struct Group {
 }
 
 impl Group {
-    /// SAFETY: gr_name must be valid and not change while
+    /// # Safety
+    /// gr_name must be valid and not change while
     /// the function runs. That means PW_LOCK must be held.
     unsafe fn from_raw(raw: group) -> Self {
         Self {
@@ -273,7 +274,7 @@ pub trait Locate<K> {
 // to, so we must copy all the data we want before releasing the lock.
 // (Technically we must also ensure that the raw functions aren't being called
 // anywhere else in the program.)
-static PW_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+static PW_LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
 
 macro_rules! f {
     ($fnam:ident, $fid:ident, $t:ident, $st:ident) => {
@@ -293,7 +294,7 @@ macro_rules! f {
                         // The same applies for the two cases below.
                         Err(IOError::new(
                             ErrorKind::NotFound,
-                            format!("No such id: {}", k),
+                            format!("No such id: {k}"),
                         ))
                     }
                 }
@@ -312,7 +313,7 @@ macro_rules! f {
                         } else {
                             Err(IOError::new(
                                 ErrorKind::NotFound,
-                                format!("No such id: {}", id),
+                                format!("No such id: {id}"),
                             ))
                         }
                     }
@@ -324,10 +325,7 @@ macro_rules! f {
                         if !data.is_null() {
                             Ok($st::from_raw(ptr::read(data as *const _)))
                         } else {
-                            Err(IOError::new(
-                                ErrorKind::NotFound,
-                                format!("Not found: {}", k),
-                            ))
+                            Err(IOError::new(ErrorKind::NotFound, format!("Not found: {k}")))
                         }
                     }
                 }
@@ -337,7 +335,6 @@ macro_rules! f {
 }
 
 f!(getpwnam, getpwuid, uid_t, Passwd);
-#[cfg(not(target_os = "redox"))]
 f!(getgrnam, getgrgid, gid_t, Group);
 
 #[inline]
@@ -345,7 +342,6 @@ pub fn uid2usr(id: uid_t) -> IOResult<String> {
     Passwd::locate(id).map(|p| p.name)
 }
 
-#[cfg(not(target_os = "redox"))]
 #[inline]
 pub fn gid2grp(id: gid_t) -> IOResult<String> {
     Group::locate(id).map(|p| p.name)
@@ -356,7 +352,6 @@ pub fn usr2uid(name: &str) -> IOResult<uid_t> {
     Passwd::locate(name).map(|p| p.uid)
 }
 
-#[cfg(not(target_os = "redox"))]
 #[inline]
 pub fn grp2gid(name: &str) -> IOResult<gid_t> {
     Group::locate(name).map(|p| p.gid)
diff --git a/src/uu/seq/src/extendedbigdecimal.rs b/src/uucore/src/lib/features/extendedbigdecimal.rs
similarity index 69%
rename from src/uu/seq/src/extendedbigdecimal.rs
rename to src/uucore/src/lib/features/extendedbigdecimal.rs
index 388046ba368..396b6f35941 100644
--- a/src/uu/seq/src/extendedbigdecimal.rs
+++ b/src/uucore/src/lib/features/extendedbigdecimal.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 bigdecimal extendedbigdecimal extendedbigint
+// spell-checker:ignore bigdecimal extendedbigdecimal biguint
 //! An arbitrary precision float that can also represent infinity, NaN, etc.
 //!
 //! The finite values are stored as [`BigDecimal`] instances. Because
@@ -21,17 +21,15 @@
 //! assert_eq!(summand1 + summand2, ExtendedBigDecimal::Infinity);
 //! ```
 use std::cmp::Ordering;
-use std::fmt::Display;
 use std::ops::Add;
+use std::ops::Neg;
 
 use bigdecimal::BigDecimal;
-use num_bigint::BigInt;
-use num_bigint::ToBigInt;
-use num_traits::One;
+use bigdecimal::num_bigint::BigUint;
+use num_traits::FromPrimitive;
+use num_traits::Signed;
 use num_traits::Zero;
 
-use crate::extendedbigint::ExtendedBigInt;
-
 #[derive(Debug, Clone)]
 pub enum ExtendedBigDecimal {
     /// Arbitrary precision floating point number.
@@ -70,72 +68,59 @@ pub enum ExtendedBigDecimal {
     ///
     /// [0]: https://github.com/akubera/bigdecimal-rs/issues/67
     Nan,
-}
 
-/// The smallest integer greater than or equal to this number.
-fn ceil(x: BigDecimal) -> BigInt {
-    if x.is_integer() {
-        // Unwrapping the Option because it always returns Some
-        x.to_bigint().unwrap()
-    } else {
-        (x + BigDecimal::one().half()).round(0).to_bigint().unwrap()
-    }
+    /// Floating point negative NaN.
+    ///
+    /// This is represented as its own enumeration member instead of as
+    /// a [`BigDecimal`] because the `bigdecimal` library does not
+    /// support NaN, see [here][0].
+    ///
+    /// [0]: https://github.com/akubera/bigdecimal-rs/issues/67
+    MinusNan,
 }
 
-/// The largest integer less than or equal to this number.
-fn floor(x: BigDecimal) -> BigInt {
-    if x.is_integer() {
-        // Unwrapping the Option because it always returns Some
-        x.to_bigint().unwrap()
-    } else {
-        (x - BigDecimal::one().half()).round(0).to_bigint().unwrap()
+impl From<f64> for ExtendedBigDecimal {
+    fn from(val: f64) -> Self {
+        if val.is_nan() {
+            if val.is_sign_negative() {
+                ExtendedBigDecimal::MinusNan
+            } else {
+                ExtendedBigDecimal::Nan
+            }
+        } else if val.is_infinite() {
+            if val.is_sign_negative() {
+                ExtendedBigDecimal::MinusInfinity
+            } else {
+                ExtendedBigDecimal::Infinity
+            }
+        } else if val.is_zero() && val.is_sign_negative() {
+            ExtendedBigDecimal::MinusZero
+        } else {
+            ExtendedBigDecimal::BigDecimal(BigDecimal::from_f64(val).unwrap())
+        }
     }
 }
 
 impl ExtendedBigDecimal {
-    /// The smallest integer greater than or equal to this number.
-    pub fn ceil(self) -> ExtendedBigInt {
-        match self {
-            Self::BigDecimal(x) => ExtendedBigInt::BigInt(ceil(x)),
-            other => From::from(other),
-        }
-    }
-
-    /// The largest integer less than or equal to this number.
-    pub fn floor(self) -> ExtendedBigInt {
-        match self {
-            Self::BigDecimal(x) => ExtendedBigInt::BigInt(floor(x)),
-            other => From::from(other),
-        }
+    pub fn zero() -> Self {
+        Self::BigDecimal(0.into())
     }
-}
 
-impl From<ExtendedBigInt> for ExtendedBigDecimal {
-    fn from(big_int: ExtendedBigInt) -> Self {
-        match big_int {
-            ExtendedBigInt::BigInt(n) => Self::BigDecimal(BigDecimal::from(n)),
-            ExtendedBigInt::Infinity => Self::Infinity,
-            ExtendedBigInt::MinusInfinity => Self::MinusInfinity,
-            ExtendedBigInt::MinusZero => Self::MinusZero,
-            ExtendedBigInt::Nan => Self::Nan,
-        }
+    pub fn one() -> Self {
+        Self::BigDecimal(1.into())
     }
-}
 
-impl Display for ExtendedBigDecimal {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    pub fn to_biguint(&self) -> Option<BigUint> {
         match self {
-            Self::BigDecimal(x) => {
-                let (n, p) = x.as_bigint_and_exponent();
-                match p {
-                    0 => Self::BigDecimal(BigDecimal::new(n * 10, 1)).fmt(f),
-                    _ => x.fmt(f),
+            ExtendedBigDecimal::BigDecimal(big_decimal) => {
+                let (bi, scale) = big_decimal.as_bigint_and_scale();
+                if bi.is_negative() || scale > 0 || scale < -(u32::MAX as i64) {
+                    return None;
                 }
+                bi.to_biguint()
+                    .map(|bi| bi * BigUint::from(10u32).pow(-scale as u32))
             }
-            Self::Infinity => f32::INFINITY.fmt(f),
-            Self::MinusInfinity => f32::NEG_INFINITY.fmt(f),
-            Self::MinusZero => (-0.0f32).fmt(f),
-            Self::Nan => "nan".fmt(f),
+            _ => None,
         }
     }
 }
@@ -153,6 +138,12 @@ impl Zero for ExtendedBigDecimal {
     }
 }
 
+impl Default for ExtendedBigDecimal {
+    fn default() -> Self {
+        Self::zero()
+    }
+}
+
 impl Add for ExtendedBigDecimal {
     type Output = Self;
 
@@ -161,19 +152,19 @@ impl Add for ExtendedBigDecimal {
             (Self::BigDecimal(m), Self::BigDecimal(n)) => Self::BigDecimal(m.add(n)),
             (Self::BigDecimal(_), Self::MinusInfinity) => Self::MinusInfinity,
             (Self::BigDecimal(_), Self::Infinity) => Self::Infinity,
-            (Self::BigDecimal(_), Self::Nan) => Self::Nan,
             (Self::BigDecimal(m), Self::MinusZero) => Self::BigDecimal(m),
             (Self::Infinity, Self::BigDecimal(_)) => Self::Infinity,
             (Self::Infinity, Self::Infinity) => Self::Infinity,
             (Self::Infinity, Self::MinusZero) => Self::Infinity,
             (Self::Infinity, Self::MinusInfinity) => Self::Nan,
-            (Self::Infinity, Self::Nan) => Self::Nan,
             (Self::MinusInfinity, Self::BigDecimal(_)) => Self::MinusInfinity,
             (Self::MinusInfinity, Self::MinusInfinity) => Self::MinusInfinity,
             (Self::MinusInfinity, Self::MinusZero) => Self::MinusInfinity,
             (Self::MinusInfinity, Self::Infinity) => Self::Nan,
-            (Self::MinusInfinity, Self::Nan) => Self::Nan,
             (Self::Nan, _) => Self::Nan,
+            (_, Self::Nan) => Self::Nan,
+            (Self::MinusNan, _) => Self::MinusNan,
+            (_, Self::MinusNan) => Self::MinusNan,
             (Self::MinusZero, other) => other,
         }
     }
@@ -185,24 +176,23 @@ impl PartialEq for ExtendedBigDecimal {
             (Self::BigDecimal(m), Self::BigDecimal(n)) => m.eq(n),
             (Self::BigDecimal(_), Self::MinusInfinity) => false,
             (Self::BigDecimal(_), Self::Infinity) => false,
-            (Self::BigDecimal(_), Self::Nan) => false,
             (Self::BigDecimal(_), Self::MinusZero) => false,
             (Self::Infinity, Self::BigDecimal(_)) => false,
             (Self::Infinity, Self::Infinity) => true,
             (Self::Infinity, Self::MinusZero) => false,
             (Self::Infinity, Self::MinusInfinity) => false,
-            (Self::Infinity, Self::Nan) => false,
             (Self::MinusInfinity, Self::BigDecimal(_)) => false,
             (Self::MinusInfinity, Self::Infinity) => false,
             (Self::MinusInfinity, Self::MinusZero) => false,
             (Self::MinusInfinity, Self::MinusInfinity) => true,
-            (Self::MinusInfinity, Self::Nan) => false,
-            (Self::Nan, _) => false,
             (Self::MinusZero, Self::BigDecimal(_)) => false,
             (Self::MinusZero, Self::Infinity) => false,
             (Self::MinusZero, Self::MinusZero) => true,
             (Self::MinusZero, Self::MinusInfinity) => false,
-            (Self::MinusZero, Self::Nan) => false,
+            (Self::Nan, _) => false,
+            (Self::MinusNan, _) => false,
+            (_, Self::Nan) => false,
+            (_, Self::MinusNan) => false,
         }
     }
 }
@@ -213,24 +203,44 @@ impl PartialOrd for ExtendedBigDecimal {
             (Self::BigDecimal(m), Self::BigDecimal(n)) => m.partial_cmp(n),
             (Self::BigDecimal(_), Self::MinusInfinity) => Some(Ordering::Greater),
             (Self::BigDecimal(_), Self::Infinity) => Some(Ordering::Less),
-            (Self::BigDecimal(_), Self::Nan) => None,
             (Self::BigDecimal(m), Self::MinusZero) => m.partial_cmp(&BigDecimal::zero()),
             (Self::Infinity, Self::BigDecimal(_)) => Some(Ordering::Greater),
             (Self::Infinity, Self::Infinity) => Some(Ordering::Equal),
             (Self::Infinity, Self::MinusZero) => Some(Ordering::Greater),
             (Self::Infinity, Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::Infinity, Self::Nan) => None,
             (Self::MinusInfinity, Self::BigDecimal(_)) => Some(Ordering::Less),
             (Self::MinusInfinity, Self::Infinity) => Some(Ordering::Less),
             (Self::MinusInfinity, Self::MinusZero) => Some(Ordering::Less),
             (Self::MinusInfinity, Self::MinusInfinity) => Some(Ordering::Equal),
-            (Self::MinusInfinity, Self::Nan) => None,
-            (Self::Nan, _) => None,
             (Self::MinusZero, Self::BigDecimal(n)) => BigDecimal::zero().partial_cmp(n),
             (Self::MinusZero, Self::Infinity) => Some(Ordering::Less),
             (Self::MinusZero, Self::MinusZero) => Some(Ordering::Equal),
             (Self::MinusZero, Self::MinusInfinity) => Some(Ordering::Greater),
-            (Self::MinusZero, Self::Nan) => None,
+            (Self::Nan, _) => None,
+            (Self::MinusNan, _) => None,
+            (_, Self::Nan) => None,
+            (_, Self::MinusNan) => None,
+        }
+    }
+}
+
+impl Neg for ExtendedBigDecimal {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        match self {
+            Self::BigDecimal(bd) => {
+                if bd.is_zero() {
+                    Self::MinusZero
+                } else {
+                    Self::BigDecimal(bd.neg())
+                }
+            }
+            Self::MinusZero => Self::BigDecimal(BigDecimal::zero()),
+            Self::Infinity => Self::MinusInfinity,
+            Self::MinusInfinity => Self::Infinity,
+            Self::Nan => Self::MinusNan,
+            Self::MinusNan => Self::Nan,
         }
     }
 }
@@ -267,16 +277,4 @@ mod tests {
             _ => unreachable!(),
         }
     }
-
-    #[test]
-    fn test_display() {
-        assert_eq!(
-            format!("{}", ExtendedBigDecimal::BigDecimal(BigDecimal::zero())),
-            "0.0"
-        );
-        assert_eq!(format!("{}", ExtendedBigDecimal::Infinity), "inf");
-        assert_eq!(format!("{}", ExtendedBigDecimal::MinusInfinity), "-inf");
-        assert_eq!(format!("{}", ExtendedBigDecimal::Nan), "nan");
-        assert_eq!(format!("{}", ExtendedBigDecimal::MinusZero), "-0");
-    }
 }
diff --git a/src/uucore/src/lib/features/fast_inc.rs b/src/uucore/src/lib/features/fast_inc.rs
new file mode 100644
index 00000000000..165cf273f3d
--- /dev/null
+++ b/src/uucore/src/lib/features/fast_inc.rs
@@ -0,0 +1,209 @@
+// 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.
+
+/// Fast increment function, operating on ASCII strings.
+///
+/// Add inc to the string val[start..end]. This operates on ASCII digits, assuming
+/// val and inc are well formed.
+///
+/// Updates `start` if we have a carry, or if inc > start.
+///
+/// We also assume that there is enough space in val to expand if start needs
+/// to be updated.
+/// ```
+/// use uucore::fast_inc::fast_inc;
+///
+/// // Start with a buffer containing "0", with one byte of head space
+/// let mut val = Vec::from(".0".as_bytes());
+/// let mut start = val.len()-1;
+/// let end = val.len();
+/// let inc = "6".as_bytes();
+/// assert_eq!(&val[start..end], "0".as_bytes());
+/// fast_inc(val.as_mut(), &mut start, end, inc);
+/// assert_eq!(&val[start..end], "6".as_bytes());
+/// fast_inc(val.as_mut(), &mut start, end, inc);
+/// assert_eq!(&val[start..end], "12".as_bytes());
+/// ```
+#[inline]
+pub fn fast_inc(val: &mut [u8], start: &mut usize, end: usize, inc: &[u8]) {
+    // To avoid a lot of casts to signed integers, we make sure to decrement pos
+    // as late as possible, so that it does not ever go negative.
+    let mut pos = end;
+    let mut carry = 0u8;
+
+    // First loop, add all digits of inc into val.
+    for inc_pos in (0..inc.len()).rev() {
+        // The decrement operation would also panic in debug mode, print a message for developer convenience.
+        debug_assert!(
+            pos > 0,
+            "Buffer overflowed, make sure you allocate val with enough headroom."
+        );
+        pos -= 1;
+
+        let mut new_val = inc[inc_pos] + carry;
+        // Be careful here, only add existing digit of val.
+        if pos >= *start {
+            new_val += val[pos] - b'0';
+        }
+        if new_val > b'9' {
+            carry = 1;
+            new_val -= 10;
+        } else {
+            carry = 0;
+        }
+        val[pos] = new_val;
+    }
+
+    // Done, now, if we have a carry, add that to the upper digits of val.
+    if carry == 0 {
+        *start = (*start).min(pos);
+        return;
+    }
+
+    fast_inc_one(val, start, pos)
+}
+
+/// Fast increment by one function, operating on ASCII strings.
+///
+/// Add 1 to the string val[start..end]. This operates on ASCII digits, assuming
+/// val is well formed.
+///
+/// Updates `start` if we have a carry, or if inc > start.
+///
+/// We also assume that there is enough space in val to expand if start needs
+/// to be updated.
+/// ```
+/// use uucore::fast_inc::fast_inc_one;
+///
+/// // Start with a buffer containing "8", with one byte of head space
+/// let mut val = Vec::from(".8".as_bytes());
+/// let mut start = val.len()-1;
+/// let end = val.len();
+/// assert_eq!(&val[start..end], "8".as_bytes());
+/// fast_inc_one(val.as_mut(), &mut start, end);
+/// assert_eq!(&val[start..end], "9".as_bytes());
+/// fast_inc_one(val.as_mut(), &mut start, end);
+/// assert_eq!(&val[start..end], "10".as_bytes());
+/// ```
+#[inline]
+pub fn fast_inc_one(val: &mut [u8], start: &mut usize, end: usize) {
+    let mut pos = end;
+
+    while pos > *start {
+        pos -= 1;
+
+        if val[pos] == b'9' {
+            // 9+1 = 10. Carry propagating, keep going.
+            val[pos] = b'0';
+        } else {
+            // Carry stopped propagating, return unchanged start.
+            val[pos] += 1;
+            return;
+        }
+    }
+
+    // The following decrement operation would also panic in debug mode, print a message for developer convenience.
+    debug_assert!(
+        *start > 0,
+        "Buffer overflowed, make sure you allocate val with enough headroom."
+    );
+    // The carry propagated so far that a new digit was added.
+    val[*start - 1] = b'1';
+    *start -= 1;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::fast_inc::fast_inc;
+    use crate::fast_inc::fast_inc_one;
+
+    #[test]
+    fn test_fast_inc_simple() {
+        let mut val = Vec::from("...0_".as_bytes());
+        let mut start: usize = 3;
+        let inc = "4".as_bytes();
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 3);
+        assert_eq!(val, "...4_".as_bytes());
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 3);
+        assert_eq!(val, "...8_".as_bytes());
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 2); // carried 1 more digit
+        assert_eq!(val, "..12_".as_bytes());
+
+        let mut val = Vec::from("0_".as_bytes());
+        let mut start: usize = 0;
+        let inc = "2".as_bytes();
+        fast_inc(val.as_mut(), &mut start, 1, inc);
+        assert_eq!(start, 0);
+        assert_eq!(val, "2_".as_bytes());
+        fast_inc(val.as_mut(), &mut start, 1, inc);
+        assert_eq!(start, 0);
+        assert_eq!(val, "4_".as_bytes());
+        fast_inc(val.as_mut(), &mut start, 1, inc);
+        assert_eq!(start, 0);
+        assert_eq!(val, "6_".as_bytes());
+    }
+
+    // Check that we handle increment > val correctly.
+    #[test]
+    fn test_fast_inc_large_inc() {
+        let mut val = Vec::from("...7_".as_bytes());
+        let mut start: usize = 3;
+        let inc = "543".as_bytes();
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 1); // carried 2 more digits
+        assert_eq!(val, ".550_".as_bytes());
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 0); // carried 1 more digit
+        assert_eq!(val, "1093_".as_bytes());
+    }
+
+    // Check that we handle longer carries
+    #[test]
+    fn test_fast_inc_carry() {
+        let mut val = Vec::from(".999_".as_bytes());
+        let mut start: usize = 1;
+        let inc = "1".as_bytes();
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 0);
+        assert_eq!(val, "1000_".as_bytes());
+
+        let mut val = Vec::from(".999_".as_bytes());
+        let mut start: usize = 1;
+        let inc = "11".as_bytes();
+        fast_inc(val.as_mut(), &mut start, 4, inc);
+        assert_eq!(start, 0);
+        assert_eq!(val, "1010_".as_bytes());
+    }
+
+    #[test]
+    fn test_fast_inc_one_simple() {
+        let mut val = Vec::from("...8_".as_bytes());
+        let mut start: usize = 3;
+        fast_inc_one(val.as_mut(), &mut start, 4);
+        assert_eq!(start, 3);
+        assert_eq!(val, "...9_".as_bytes());
+        fast_inc_one(val.as_mut(), &mut start, 4);
+        assert_eq!(start, 2); // carried 1 more digit
+        assert_eq!(val, "..10_".as_bytes());
+        fast_inc_one(val.as_mut(), &mut start, 4);
+        assert_eq!(start, 2);
+        assert_eq!(val, "..11_".as_bytes());
+
+        let mut val = Vec::from("0_".as_bytes());
+        let mut start: usize = 0;
+        fast_inc_one(val.as_mut(), &mut start, 1);
+        assert_eq!(start, 0);
+        assert_eq!(val, "1_".as_bytes());
+        fast_inc_one(val.as_mut(), &mut start, 1);
+        assert_eq!(start, 0);
+        assert_eq!(val, "2_".as_bytes());
+        fast_inc_one(val.as_mut(), &mut start, 1);
+        assert_eq!(start, 0);
+        assert_eq!(val, "3_".as_bytes());
+    }
+}
diff --git a/src/uucore/src/lib/features/format/argument.rs b/src/uucore/src/lib/features/format/argument.rs
new file mode 100644
index 00000000000..f3edbae5576
--- /dev/null
+++ b/src/uucore/src/lib/features/format/argument.rs
@@ -0,0 +1,464 @@
+// 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.
+
+use super::ExtendedBigDecimal;
+use crate::format::spec::ArgumentLocation;
+use crate::{
+    error::set_exit_code,
+    parser::num_parser::{ExtendedParser, ExtendedParserError},
+    quoting_style::{Quotes, QuotingStyle, escape_name},
+    show_error, show_warning,
+};
+use os_display::Quotable;
+use std::{ffi::OsStr, num::NonZero};
+
+/// An argument for formatting
+///
+/// Each of these variants is only accepted by their respective directives. For
+/// example, [`FormatArgument::Char`] requires a `%c` directive.
+///
+/// The [`FormatArgument::Unparsed`] variant contains a string that can be
+/// parsed into other types. This is used by the `printf` utility.
+#[derive(Clone, Debug, PartialEq)]
+pub enum FormatArgument {
+    Char(char),
+    String(String),
+    UnsignedInt(u64),
+    SignedInt(i64),
+    Float(ExtendedBigDecimal),
+    /// Special argument that gets coerced into the other variants
+    Unparsed(String),
+}
+
+/// A struct that holds a slice of format arguments and provides methods to access them
+#[derive(Debug, PartialEq)]
+pub struct FormatArguments<'a> {
+    args: &'a [FormatArgument],
+    next_arg_position: usize,
+    highest_arg_position: Option<usize>,
+    current_offset: usize,
+}
+
+impl<'a> FormatArguments<'a> {
+    /// Create a new FormatArguments from a slice of FormatArgument
+    pub fn new(args: &'a [FormatArgument]) -> Self {
+        Self {
+            args,
+            next_arg_position: 0,
+            highest_arg_position: None,
+            current_offset: 0,
+        }
+    }
+
+    /// Get the next argument that would be used
+    pub fn peek_arg(&self) -> Option<&'a FormatArgument> {
+        self.args.get(self.next_arg_position)
+    }
+
+    /// Check if all arguments have been consumed
+    pub fn is_exhausted(&self) -> bool {
+        self.current_offset >= self.args.len()
+    }
+
+    pub fn start_next_batch(&mut self) {
+        self.current_offset = self
+            .next_arg_position
+            .max(self.highest_arg_position.map_or(0, |x| x.saturating_add(1)));
+        self.next_arg_position = self.current_offset;
+    }
+
+    pub fn next_char(&mut self, position: &ArgumentLocation) -> u8 {
+        match self.next_arg(position) {
+            Some(FormatArgument::Char(c)) => *c as u8,
+            Some(FormatArgument::Unparsed(s)) => s.bytes().next().unwrap_or(b'\0'),
+            _ => b'\0',
+        }
+    }
+
+    pub fn next_string(&mut self, position: &ArgumentLocation) -> &'a str {
+        match self.next_arg(position) {
+            Some(FormatArgument::Unparsed(s) | FormatArgument::String(s)) => s,
+            _ => "",
+        }
+    }
+
+    pub fn next_i64(&mut self, position: &ArgumentLocation) -> i64 {
+        match self.next_arg(position) {
+            Some(FormatArgument::SignedInt(n)) => *n,
+            Some(FormatArgument::Unparsed(s)) => extract_value(i64::extended_parse(s), s),
+            _ => 0,
+        }
+    }
+
+    pub fn next_u64(&mut self, position: &ArgumentLocation) -> u64 {
+        match self.next_arg(position) {
+            Some(FormatArgument::UnsignedInt(n)) => *n,
+            Some(FormatArgument::Unparsed(s)) => {
+                // Check if the string is a character literal enclosed in quotes
+                if s.starts_with(['"', '\'']) {
+                    // Extract the content between the quotes safely using chars
+                    let mut chars = s.trim_matches(|c| c == '"' || c == '\'').chars();
+                    if let Some(first_char) = chars.next() {
+                        if chars.clone().count() > 0 {
+                            // Emit a warning if there are additional characters
+                            let remaining: String = chars.collect();
+                            show_warning!(
+                                "{}: character(s) following character constant have been ignored",
+                                remaining
+                            );
+                        }
+                        return first_char as u64; // Use only the first character
+                    }
+                    return 0; // Empty quotes
+                }
+                extract_value(u64::extended_parse(s), s)
+            }
+            _ => 0,
+        }
+    }
+
+    pub fn next_extended_big_decimal(&mut self, position: &ArgumentLocation) -> ExtendedBigDecimal {
+        match self.next_arg(position) {
+            Some(FormatArgument::Float(n)) => n.clone(),
+            Some(FormatArgument::Unparsed(s)) => {
+                extract_value(ExtendedBigDecimal::extended_parse(s), s)
+            }
+            _ => ExtendedBigDecimal::zero(),
+        }
+    }
+
+    fn get_at_relative_position(&mut self, pos: NonZero<usize>) -> Option<&'a FormatArgument> {
+        let pos: usize = pos.into();
+        let pos = (pos - 1).saturating_add(self.current_offset);
+        self.highest_arg_position = Some(self.highest_arg_position.map_or(pos, |x| x.max(pos)));
+        self.args.get(pos)
+    }
+
+    fn next_arg(&mut self, position: &ArgumentLocation) -> Option<&'a FormatArgument> {
+        match position {
+            ArgumentLocation::NextArgument => {
+                let arg = self.args.get(self.next_arg_position);
+                self.next_arg_position += 1;
+                arg
+            }
+            ArgumentLocation::Position(pos) => self.get_at_relative_position(*pos),
+        }
+    }
+}
+
+fn extract_value<T: Default>(p: Result<T, ExtendedParserError<'_, T>>, input: &str) -> T {
+    match p {
+        Ok(v) => v,
+        Err(e) => {
+            set_exit_code(1);
+            let input = escape_name(
+                OsStr::new(input),
+                &QuotingStyle::C {
+                    quotes: Quotes::None,
+                },
+            );
+            match e {
+                ExtendedParserError::Overflow(v) => {
+                    show_error!("{}: Numerical result out of range", input.quote());
+                    v
+                }
+                ExtendedParserError::Underflow(v) => {
+                    show_error!("{}: Numerical result out of range", input.quote());
+                    v
+                }
+                ExtendedParserError::NotNumeric => {
+                    show_error!("{}: expected a numeric value", input.quote());
+                    Default::default()
+                }
+                ExtendedParserError::PartialMatch(v, rest) => {
+                    let bytes = input.as_encoded_bytes();
+                    if !bytes.is_empty() && (bytes[0] == b'\'' || bytes[0] == b'"') {
+                        show_warning!(
+                            "{rest}: character(s) following character constant have been ignored"
+                        );
+                    } else {
+                        show_error!("{}: value not completely converted", input.quote());
+                    }
+                    v
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format_arguments_empty() {
+        let args = FormatArguments::new(&[]);
+        assert_eq!(None, args.peek_arg());
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_format_arguments_single_element() {
+        let mut args = FormatArguments::new(&[FormatArgument::Char('a')]);
+        assert!(!args.is_exhausted());
+        assert_eq!(Some(&FormatArgument::Char('a')), args.peek_arg());
+        assert!(!args.is_exhausted()); // Peek shouldn't consume
+        assert_eq!(b'a', args.next_char(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(args.is_exhausted()); // After batch, exhausted with a single arg
+        assert_eq!(None, args.peek_arg());
+    }
+
+    #[test]
+    fn test_sequential_next_char() {
+        // Test with consistent sequential next_char calls
+        let mut args = FormatArguments::new(&[
+            FormatArgument::Char('z'),
+            FormatArgument::Char('y'),
+            FormatArgument::Char('x'),
+            FormatArgument::Char('w'),
+            FormatArgument::Char('v'),
+            FormatArgument::Char('u'),
+            FormatArgument::Char('t'),
+            FormatArgument::Char('s'),
+        ]);
+
+        // First batch - two sequential calls
+        assert_eq!(b'z', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!(b'y', args.next_char(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same pattern
+        assert_eq!(b'x', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!(b'w', args.next_char(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Third batch - same pattern
+        assert_eq!(b'v', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!(b'u', args.next_char(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Fourth batch - same pattern (last batch)
+        assert_eq!(b't', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!(b's', args.next_char(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_sequential_different_methods() {
+        // Test with different method types in sequence
+        let args = [
+            FormatArgument::Char('a'),
+            FormatArgument::String("hello".to_string()),
+            FormatArgument::Unparsed("123".to_string()),
+            FormatArgument::String("world".to_string()),
+            FormatArgument::Char('z'),
+            FormatArgument::String("test".to_string()),
+        ];
+        let mut args = FormatArguments::new(&args);
+
+        // First batch - next_char followed by next_string
+        assert_eq!(b'a', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!("hello", args.next_string(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same pattern
+        assert_eq!(b'1', args.next_char(&ArgumentLocation::NextArgument)); // First byte of 123
+        assert_eq!("world", args.next_string(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Third batch - same pattern (last batch)
+        assert_eq!(b'z', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!("test", args.next_string(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    fn non_zero_pos(n: usize) -> ArgumentLocation {
+        ArgumentLocation::Position(NonZero::new(n).unwrap())
+    }
+
+    #[test]
+    fn test_position_access_pattern() {
+        // Test with consistent positional access patterns
+        let mut args = FormatArguments::new(&[
+            FormatArgument::Char('a'),
+            FormatArgument::Char('b'),
+            FormatArgument::Char('c'),
+            FormatArgument::Char('d'),
+            FormatArgument::Char('e'),
+            FormatArgument::Char('f'),
+            FormatArgument::Char('g'),
+            FormatArgument::Char('h'),
+            FormatArgument::Char('i'),
+        ]);
+
+        // First batch - positional access
+        assert_eq!(b'b', args.next_char(&non_zero_pos(2))); // Position 2
+        assert_eq!(b'a', args.next_char(&non_zero_pos(1))); // Position 1
+        assert_eq!(b'c', args.next_char(&non_zero_pos(3))); // Position 3
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same positional pattern
+        assert_eq!(b'e', args.next_char(&non_zero_pos(2))); // Position 2
+        assert_eq!(b'd', args.next_char(&non_zero_pos(1))); // Position 1
+        assert_eq!(b'f', args.next_char(&non_zero_pos(3))); // Position 3
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Third batch - same positional pattern (last batch)
+        assert_eq!(b'h', args.next_char(&non_zero_pos(2))); // Position 2
+        assert_eq!(b'g', args.next_char(&non_zero_pos(1))); // Position 1
+        assert_eq!(b'i', args.next_char(&non_zero_pos(3))); // Position 3
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_mixed_access_pattern() {
+        // Test with mixed sequential and positional access
+        let mut args = FormatArguments::new(&[
+            FormatArgument::Char('a'),
+            FormatArgument::Char('b'),
+            FormatArgument::Char('c'),
+            FormatArgument::Char('d'),
+            FormatArgument::Char('e'),
+            FormatArgument::Char('f'),
+            FormatArgument::Char('g'),
+            FormatArgument::Char('h'),
+        ]);
+
+        // First batch - mix of sequential and positional
+        assert_eq!(b'a', args.next_char(&ArgumentLocation::NextArgument)); // Sequential
+        assert_eq!(b'c', args.next_char(&non_zero_pos(3))); // Positional
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same mixed pattern
+        assert_eq!(b'd', args.next_char(&ArgumentLocation::NextArgument)); // Sequential
+        assert_eq!(b'f', args.next_char(&non_zero_pos(3))); // Positional
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Last batch - same mixed pattern
+        assert_eq!(b'g', args.next_char(&ArgumentLocation::NextArgument)); // Sequential
+        assert_eq!(b'\0', args.next_char(&non_zero_pos(3))); // Out of bounds
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_numeric_argument_types() {
+        // Test with numeric argument types
+        let args = [
+            FormatArgument::SignedInt(10),
+            FormatArgument::UnsignedInt(20),
+            FormatArgument::Float(ExtendedBigDecimal::zero()),
+            FormatArgument::SignedInt(30),
+            FormatArgument::UnsignedInt(40),
+            FormatArgument::Float(ExtendedBigDecimal::zero()),
+        ];
+        let mut args = FormatArguments::new(&args);
+
+        // First batch - i64, u64, decimal
+        assert_eq!(10, args.next_i64(&ArgumentLocation::NextArgument));
+        assert_eq!(20, args.next_u64(&ArgumentLocation::NextArgument));
+        let result = args.next_extended_big_decimal(&ArgumentLocation::NextArgument);
+        assert_eq!(ExtendedBigDecimal::zero(), result);
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same pattern
+        assert_eq!(30, args.next_i64(&ArgumentLocation::NextArgument));
+        assert_eq!(40, args.next_u64(&ArgumentLocation::NextArgument));
+        let result = args.next_extended_big_decimal(&ArgumentLocation::NextArgument);
+        assert_eq!(ExtendedBigDecimal::zero(), result);
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_unparsed_arguments() {
+        // Test with unparsed arguments that get coerced
+        let args = [
+            FormatArgument::Unparsed("hello".to_string()),
+            FormatArgument::Unparsed("123".to_string()),
+            FormatArgument::Unparsed("hello".to_string()),
+            FormatArgument::Unparsed("456".to_string()),
+        ];
+        let mut args = FormatArguments::new(&args);
+
+        // First batch - string, number
+        assert_eq!("hello", args.next_string(&ArgumentLocation::NextArgument));
+        assert_eq!(123, args.next_i64(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same pattern
+        assert_eq!("hello", args.next_string(&ArgumentLocation::NextArgument));
+        assert_eq!(456, args.next_i64(&ArgumentLocation::NextArgument));
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_mixed_types_with_positions() {
+        // Test with mixed types and positional access
+        let args = [
+            FormatArgument::Char('a'),
+            FormatArgument::String("test".to_string()),
+            FormatArgument::UnsignedInt(42),
+            FormatArgument::Char('b'),
+            FormatArgument::String("more".to_string()),
+            FormatArgument::UnsignedInt(99),
+        ];
+        let mut args = FormatArguments::new(&args);
+
+        // First batch - positional access of different types
+        assert_eq!(b'a', args.next_char(&non_zero_pos(1)));
+        assert_eq!("test", args.next_string(&non_zero_pos(2)));
+        assert_eq!(42, args.next_u64(&non_zero_pos(3)));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch - same pattern
+        assert_eq!(b'b', args.next_char(&non_zero_pos(1)));
+        assert_eq!("more", args.next_string(&non_zero_pos(2)));
+        assert_eq!(99, args.next_u64(&non_zero_pos(3)));
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+
+    #[test]
+    fn test_partial_last_batch() {
+        // Test with a partial last batch (fewer elements than batch size)
+        let mut args = FormatArguments::new(&[
+            FormatArgument::Char('a'),
+            FormatArgument::Char('b'),
+            FormatArgument::Char('c'),
+            FormatArgument::Char('d'),
+            FormatArgument::Char('e'), // Last batch has fewer elements
+        ]);
+
+        // First batch
+        assert_eq!(b'a', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!(b'c', args.next_char(&non_zero_pos(3)));
+        args.start_next_batch();
+        assert!(!args.is_exhausted());
+
+        // Second batch (partial)
+        assert_eq!(b'd', args.next_char(&ArgumentLocation::NextArgument));
+        assert_eq!(b'\0', args.next_char(&non_zero_pos(3))); // Out of bounds
+        args.start_next_batch();
+        assert!(args.is_exhausted());
+    }
+}
diff --git a/src/uucore/src/lib/features/format/escape.rs b/src/uucore/src/lib/features/format/escape.rs
new file mode 100644
index 00000000000..da6e691eaaf
--- /dev/null
+++ b/src/uucore/src/lib/features/format/escape.rs
@@ -0,0 +1,237 @@
+// 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.
+
+//! Parsing of escape sequences
+
+use crate::format::FormatError;
+
+#[derive(Debug)]
+pub enum EscapedChar {
+    /// A single byte
+    Byte(u8),
+    /// A unicode character
+    Char(char),
+    /// A character prefixed with a backslash (i.e. an invalid escape sequence)
+    Backslash(u8),
+    /// Specifies that the string should stop (`\c`)
+    End,
+}
+
+#[derive(Clone, Copy, Default)]
+pub enum OctalParsing {
+    #[default]
+    TwoDigits = 2,
+    ThreeDigits = 3,
+}
+
+#[derive(Clone, Copy)]
+enum Base {
+    Oct(OctalParsing),
+    Hex,
+}
+
+impl Base {
+    fn as_base(&self) -> u8 {
+        match self {
+            Base::Oct(_) => 8,
+            Base::Hex => 16,
+        }
+    }
+
+    fn max_digits(&self) -> u8 {
+        match self {
+            Self::Oct(parsing) => *parsing as u8,
+            Self::Hex => 2,
+        }
+    }
+
+    fn convert_digit(&self, c: u8) -> Option<u8> {
+        match self {
+            Self::Oct(_) => {
+                if matches!(c, b'0'..=b'7') {
+                    Some(c - b'0')
+                } else {
+                    None
+                }
+            }
+            Self::Hex => match c {
+                b'0'..=b'9' => Some(c - b'0'),
+                b'A'..=b'F' => Some(c - b'A' + 10),
+                b'a'..=b'f' => Some(c - b'a' + 10),
+                _ => None,
+            },
+        }
+    }
+}
+
+/// Parse the numeric part of the `\xHHH` and `\0NNN` escape sequences
+fn parse_code(input: &mut &[u8], base: Base) -> Option<u8> {
+    // All arithmetic on `ret` needs to be wrapping, because octal input can
+    // take 3 digits, which is 9 bits, and therefore more than what fits in a
+    // `u8`. GNU just seems to wrap these values.
+    // Note that if we instead make `ret` a `u32` and use `char::from_u32` will
+    // yield incorrect results because it will interpret values larger than
+    // `u8::MAX` as unicode.
+    let [c, rest @ ..] = input else { return None };
+    let mut ret = base.convert_digit(*c)?;
+    *input = rest;
+
+    for _ in 1..base.max_digits() {
+        let [c, rest @ ..] = input else { break };
+        let Some(n) = base.convert_digit(*c) else {
+            break;
+        };
+        ret = ret.wrapping_mul(base.as_base()).wrapping_add(n);
+        *input = rest;
+    }
+
+    Some(ret)
+}
+
+// spell-checker:disable-next
+/// Parse `\uHHHH` and `\UHHHHHHHH`
+fn parse_unicode(input: &mut &[u8], digits: u8) -> Result<char, EscapeError> {
+    if let Some((new_digits, rest)) = input.split_at_checked(digits as usize) {
+        *input = rest;
+        let ret = new_digits
+            .iter()
+            .map(|c| Base::Hex.convert_digit(*c))
+            .collect::<Option<Vec<u8>>>()
+            .ok_or(EscapeError::MissingHexadecimalNumber)?
+            .iter()
+            .map(|n| *n as u32)
+            .reduce(|ret, n| ret.wrapping_mul(Base::Hex.as_base() as u32).wrapping_add(n))
+            .expect("must have multiple digits in unicode string");
+        char::from_u32(ret).ok_or_else(|| EscapeError::InvalidCharacters(new_digits.to_vec()))
+    } else {
+        Err(EscapeError::MissingHexadecimalNumber)
+    }
+}
+
+/// Represents an invalid escape sequence.
+#[derive(Debug, PartialEq)]
+pub enum EscapeError {
+    InvalidCharacters(Vec<u8>),
+    MissingHexadecimalNumber,
+}
+
+/// Parse an escape sequence, like `\n` or `\xff`, etc.
+pub fn parse_escape_code(
+    rest: &mut &[u8],
+    zero_octal_parsing: OctalParsing,
+) -> Result<EscapedChar, FormatError> {
+    if let [c, new_rest @ ..] = rest {
+        // This is for the \NNN syntax for octal sequences.
+        // Note that '0' is intentionally omitted because that
+        // would be the \0NNN syntax.
+        if let b'1'..=b'7' = c {
+            if let Some(parsed) = parse_code(rest, Base::Oct(OctalParsing::ThreeDigits)) {
+                return Ok(EscapedChar::Byte(parsed));
+            }
+        }
+
+        *rest = new_rest;
+        match c {
+            b'\\' => Ok(EscapedChar::Byte(b'\\')),
+            b'"' => Ok(EscapedChar::Byte(b'"')),
+            b'a' => Ok(EscapedChar::Byte(b'\x07')),
+            b'b' => Ok(EscapedChar::Byte(b'\x08')),
+            b'c' => Ok(EscapedChar::End),
+            b'e' => Ok(EscapedChar::Byte(b'\x1b')),
+            b'f' => Ok(EscapedChar::Byte(b'\x0c')),
+            b'n' => Ok(EscapedChar::Byte(b'\n')),
+            b'r' => Ok(EscapedChar::Byte(b'\r')),
+            b't' => Ok(EscapedChar::Byte(b'\t')),
+            b'v' => Ok(EscapedChar::Byte(b'\x0b')),
+            b'x' => {
+                if let Some(c) = parse_code(rest, Base::Hex) {
+                    Ok(EscapedChar::Byte(c))
+                } else {
+                    Err(FormatError::MissingHex)
+                }
+            }
+            b'0' => Ok(EscapedChar::Byte(
+                parse_code(rest, Base::Oct(zero_octal_parsing)).unwrap_or(b'\0'),
+            )),
+            b'u' => match parse_unicode(rest, 4) {
+                Ok(c) => Ok(EscapedChar::Char(c)),
+                Err(EscapeError::MissingHexadecimalNumber) => Err(FormatError::MissingHex),
+                Err(EscapeError::InvalidCharacters(chars)) => {
+                    Err(FormatError::InvalidCharacter('u', chars))
+                }
+            },
+            b'U' => match parse_unicode(rest, 8) {
+                Ok(c) => Ok(EscapedChar::Char(c)),
+                Err(EscapeError::MissingHexadecimalNumber) => Err(FormatError::MissingHex),
+                Err(EscapeError::InvalidCharacters(chars)) => {
+                    Err(FormatError::InvalidCharacter('U', chars))
+                }
+            },
+            c => Ok(EscapedChar::Backslash(*c)),
+        }
+    } else {
+        Ok(EscapedChar::Byte(b'\\'))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod parse_unicode {
+        use super::*;
+
+        #[test]
+        fn parse_ascii() {
+            let input = b"2a";
+            assert_eq!(parse_unicode(&mut &input[..], 2), Ok('*'));
+
+            let input = b"002A";
+            assert_eq!(parse_unicode(&mut &input[..], 4), Ok('*'));
+        }
+
+        #[test]
+        fn parse_emoji_codepoint() {
+            let input = b"0001F60A";
+            assert_eq!(parse_unicode(&mut &input[..], 8), Ok('😊'));
+        }
+
+        #[test]
+        fn no_characters() {
+            let input = b"";
+            assert_eq!(
+                parse_unicode(&mut &input[..], 8),
+                Err(EscapeError::MissingHexadecimalNumber)
+            );
+        }
+
+        #[test]
+        fn incomplete_hexadecimal_number() {
+            let input = b"123";
+            assert_eq!(
+                parse_unicode(&mut &input[..], 4),
+                Err(EscapeError::MissingHexadecimalNumber)
+            );
+        }
+
+        #[test]
+        fn invalid_hex() {
+            let input = b"duck";
+            assert_eq!(
+                parse_unicode(&mut &input[..], 4),
+                Err(EscapeError::MissingHexadecimalNumber)
+            );
+        }
+
+        #[test]
+        fn surrogate_code_point() {
+            let input = b"d800";
+            assert_eq!(
+                parse_unicode(&mut &input[..], 4),
+                Err(EscapeError::InvalidCharacters(Vec::from(b"d800")))
+            );
+        }
+    }
+}
diff --git a/src/uucore/src/lib/features/format/human.rs b/src/uucore/src/lib/features/format/human.rs
new file mode 100644
index 00000000000..3acccf88fb7
--- /dev/null
+++ b/src/uucore/src/lib/features/format/human.rs
@@ -0,0 +1,65 @@
+// 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.
+
+// spell-checker:ignore gnulibs sfmt
+
+//! `human`-size formatting
+//!
+//! Format sizes like gnulibs human_readable() would
+
+use number_prefix::NumberPrefix;
+
+#[derive(Copy, Clone, PartialEq)]
+pub enum SizeFormat {
+    Bytes,
+    Binary,  // Powers of 1024, --human-readable, -h
+    Decimal, // Powers of 1000, --si
+}
+
+// There are a few peculiarities to how GNU formats the sizes:
+// 1. One decimal place is given if and only if the size is smaller than 10
+// 2. It rounds sizes up.
+// 3. The human-readable format uses powers for 1024, but does not display the "i"
+//    that is commonly used to denote Kibi, Mebi, etc.
+// 4. Kibi and Kilo are denoted differently ("k" and "K", respectively)
+fn format_prefixed(prefixed: &NumberPrefix<f64>) -> String {
+    match prefixed {
+        NumberPrefix::Standalone(bytes) => bytes.to_string(),
+        NumberPrefix::Prefixed(prefix, bytes) => {
+            // Remove the "i" from "Ki", "Mi", etc. if present
+            let prefix_str = prefix.symbol().trim_end_matches('i');
+
+            // Check whether we get more than 10 if we round up to the first decimal
+            // because we want do display 9.81 as "9.9", not as "10".
+            if (10.0 * bytes).ceil() >= 100.0 {
+                format!("{:.0}{prefix_str}", bytes.ceil())
+            } else {
+                format!("{:.1}{prefix_str}", (10.0 * bytes).ceil() / 10.0)
+            }
+        }
+    }
+}
+
+pub fn human_readable(size: u64, sfmt: SizeFormat) -> String {
+    match sfmt {
+        SizeFormat::Binary => format_prefixed(&NumberPrefix::binary(size as f64)),
+        SizeFormat::Decimal => format_prefixed(&NumberPrefix::decimal(size as f64)),
+        SizeFormat::Bytes => size.to_string(),
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn test_human_readable() {
+    let test_cases = [
+        (133_456_345, SizeFormat::Binary, "128M"),
+        (12 * 1024 * 1024, SizeFormat::Binary, "12M"),
+        (8500, SizeFormat::Binary, "8.4K"),
+    ];
+
+    for &(size, sfmt, expected_str) in &test_cases {
+        assert_eq!(human_readable(size, sfmt), expected_str);
+    }
+}
diff --git a/src/uucore/src/lib/features/format/mod.rs b/src/uucore/src/lib/features/format/mod.rs
new file mode 100644
index 00000000000..ee17d96da79
--- /dev/null
+++ b/src/uucore/src/lib/features/format/mod.rs
@@ -0,0 +1,392 @@
+// 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.
+// spell-checker:ignore extendedbigdecimal
+
+//! `printf`-style formatting
+//!
+//! Rust has excellent formatting capabilities, but the coreutils require very
+//! specific formatting that needs to work exactly like the GNU utilities.
+//! Naturally, the GNU behavior is based on the C `printf` functionality.
+//!
+//! Additionally, we need support for escape sequences for the `printf` utility.
+//!
+//! The [`printf`] and [`sprintf`] functions closely match the behavior of the
+//! corresponding C functions: the former renders a formatted string
+//! to stdout, the latter renders to a new [`String`] object.
+//!
+//! There are three kinds of parsing that we might want to do:
+//!
+//!  1. Parse only `printf` directives (for e.g. `seq`, `dd`)
+//!  2. Parse only escape sequences (for e.g. `echo`)
+//!  3. Parse both `printf` specifiers and escape sequences (for e.g. `printf`)
+//!
+//! This module aims to combine all three use cases. An iterator parsing each
+//! of these cases is provided by [`parse_spec_only`], [`parse_escape_only`]
+//! and [`parse_spec_and_escape`], respectively.
+//!
+//! There is a special [`Format`] type, which can be used to parse a format
+//! string containing exactly one directive and does not use any `*` in that
+//! directive. This format can be printed in a type-safe manner without failing
+//! (modulo IO errors).
+
+mod argument;
+mod escape;
+pub mod human;
+pub mod num_format;
+mod spec;
+
+use crate::extendedbigdecimal::ExtendedBigDecimal;
+pub use argument::*;
+pub use spec::Spec;
+use std::{
+    error::Error,
+    fmt::Display,
+    io::{Write, stdout},
+    marker::PhantomData,
+    ops::ControlFlow,
+};
+
+use os_display::Quotable;
+
+use crate::error::UError;
+
+pub use self::{
+    escape::{EscapedChar, OctalParsing, parse_escape_code},
+    num_format::Formatter,
+};
+
+#[derive(Debug)]
+pub enum FormatError {
+    SpecError(Vec<u8>),
+    IoError(std::io::Error),
+    NoMoreArguments,
+    InvalidArgument(FormatArgument),
+    TooManySpecs(Vec<u8>),
+    NeedAtLeastOneSpec(Vec<u8>),
+    WrongSpecType,
+    InvalidPrecision(String),
+    /// The format specifier ends with a %, as in `%f%`.
+    EndsWithPercent(Vec<u8>),
+    /// The escape sequence `\x` appears without a literal hexadecimal value.
+    MissingHex,
+    /// The hexadecimal characters represent a code point that cannot represent a
+    /// Unicode character (e.g., a surrogate code point)
+    InvalidCharacter(char, Vec<u8>),
+}
+
+impl Error for FormatError {}
+impl UError for FormatError {}
+
+impl From<std::io::Error> for FormatError {
+    fn from(value: std::io::Error) -> Self {
+        Self::IoError(value)
+    }
+}
+
+impl Display for FormatError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::SpecError(s) => write!(
+                f,
+                "%{}: invalid conversion specification",
+                String::from_utf8_lossy(s)
+            ),
+            Self::TooManySpecs(s) => write!(
+                f,
+                "format '{}' has too many % directives",
+                String::from_utf8_lossy(s)
+            ),
+            Self::NeedAtLeastOneSpec(s) => write!(
+                f,
+                "format '{}' has no % directive",
+                String::from_utf8_lossy(s)
+            ),
+            Self::EndsWithPercent(s) => {
+                write!(f, "format {} ends in %", String::from_utf8_lossy(s).quote())
+            }
+            Self::InvalidPrecision(precision) => write!(f, "invalid precision: '{precision}'"),
+            // TODO: Error message below needs some work
+            Self::WrongSpecType => write!(f, "wrong % directive type was given"),
+            Self::IoError(_) => write!(f, "io error"),
+            Self::NoMoreArguments => write!(f, "no more arguments"),
+            Self::InvalidArgument(_) => write!(f, "invalid argument"),
+            Self::MissingHex => write!(f, "missing hexadecimal number in escape"),
+            Self::InvalidCharacter(escape_char, digits) => write!(
+                f,
+                "invalid universal character name \\{}{}",
+                escape_char,
+                String::from_utf8_lossy(digits)
+            ),
+        }
+    }
+}
+
+/// A single item to format
+pub enum FormatItem<C: FormatChar> {
+    /// A format specifier
+    Spec(Spec),
+    /// A single character
+    Char(C),
+}
+
+pub trait FormatChar {
+    fn write(&self, writer: impl Write) -> std::io::Result<ControlFlow<()>>;
+}
+
+impl FormatChar for u8 {
+    fn write(&self, mut writer: impl Write) -> std::io::Result<ControlFlow<()>> {
+        writer.write_all(&[*self])?;
+        Ok(ControlFlow::Continue(()))
+    }
+}
+
+impl FormatChar for EscapedChar {
+    fn write(&self, mut writer: impl Write) -> std::io::Result<ControlFlow<()>> {
+        match self {
+            Self::Byte(c) => {
+                writer.write_all(&[*c])?;
+            }
+            Self::Char(c) => {
+                write!(writer, "{c}")?;
+            }
+            Self::Backslash(c) => {
+                writer.write_all(&[b'\\', *c])?;
+            }
+            Self::End => return Ok(ControlFlow::Break(())),
+        }
+        Ok(ControlFlow::Continue(()))
+    }
+}
+
+impl<C: FormatChar> FormatItem<C> {
+    pub fn write(
+        &self,
+        writer: impl Write,
+        args: &mut FormatArguments,
+    ) -> Result<ControlFlow<()>, FormatError> {
+        match self {
+            Self::Spec(spec) => spec.write(writer, args)?,
+            Self::Char(c) => return c.write(writer).map_err(FormatError::IoError),
+        };
+        Ok(ControlFlow::Continue(()))
+    }
+}
+
+/// Parse a format string containing % directives and escape sequences
+pub fn parse_spec_and_escape(
+    fmt: &[u8],
+) -> impl Iterator<Item = Result<FormatItem<EscapedChar>, FormatError>> + '_ {
+    let mut current = fmt;
+    std::iter::from_fn(move || match current {
+        [] => None,
+        [b'%', b'%', rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(EscapedChar::Byte(b'%'))))
+        }
+        [b'%', rest @ ..] => {
+            current = rest;
+            let spec = match Spec::parse(&mut current) {
+                Ok(spec) => spec,
+                Err(slice) => return Some(Err(FormatError::SpecError(slice.to_vec()))),
+            };
+            Some(Ok(FormatItem::Spec(spec)))
+        }
+        [b'\\', rest @ ..] => {
+            current = rest;
+            Some(parse_escape_code(&mut current, OctalParsing::default()).map(FormatItem::Char))
+        }
+        [c, rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(EscapedChar::Byte(*c))))
+        }
+    })
+}
+
+/// Parse a format string containing % directives
+pub fn parse_spec_only(
+    fmt: &[u8],
+) -> impl Iterator<Item = Result<FormatItem<u8>, FormatError>> + '_ {
+    let mut current = fmt;
+    std::iter::from_fn(move || match current {
+        [] => None,
+        [b'%'] => Some(Err(FormatError::EndsWithPercent(fmt.to_vec()))),
+        [b'%', b'%', rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(b'%')))
+        }
+        [b'%', rest @ ..] => {
+            current = rest;
+            let spec = match Spec::parse(&mut current) {
+                Ok(spec) => spec,
+                Err(slice) => return Some(Err(FormatError::SpecError(slice.to_vec()))),
+            };
+            Some(Ok(FormatItem::Spec(spec)))
+        }
+        [c, rest @ ..] => {
+            current = rest;
+            Some(Ok(FormatItem::Char(*c)))
+        }
+    })
+}
+
+/// Parse a format string containing escape sequences
+pub fn parse_escape_only(
+    fmt: &[u8],
+    zero_octal_parsing: OctalParsing,
+) -> impl Iterator<Item = EscapedChar> + '_ {
+    let mut current = fmt;
+    std::iter::from_fn(move || match current {
+        [] => None,
+        [b'\\', rest @ ..] => {
+            current = rest;
+            Some(
+                parse_escape_code(&mut current, zero_octal_parsing)
+                    .unwrap_or(EscapedChar::Backslash(b'x')),
+            )
+        }
+        [c, rest @ ..] => {
+            current = rest;
+            Some(EscapedChar::Byte(*c))
+        }
+    })
+}
+
+/// Write a formatted string to stdout.
+///
+/// `format_string` contains the template and `args` contains the
+/// arguments to render into the template.
+///
+/// See also [`sprintf`], which creates a new formatted [`String`].
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::format::{printf, FormatArgument};
+///
+/// printf("hello %s", &[FormatArgument::String("world".into())]).unwrap();
+/// // prints "hello world"
+/// ```
+pub fn printf<'a>(
+    format_string: impl AsRef<[u8]>,
+    arguments: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<(), FormatError> {
+    printf_writer(stdout(), format_string, arguments)
+}
+
+fn printf_writer<'a>(
+    mut writer: impl Write,
+    format_string: impl AsRef<[u8]>,
+    args: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<(), FormatError> {
+    let args = args.into_iter().cloned().collect::<Vec<_>>();
+    let mut args = FormatArguments::new(&args);
+    for item in parse_spec_only(format_string.as_ref()) {
+        if item?.write(&mut writer, &mut args)?.is_break() {
+            break;
+        }
+    }
+    Ok(())
+}
+
+/// Create a new formatted string.
+///
+/// `format_string` contains the template and `args` contains the
+/// arguments to render into the template.
+///
+/// See also [`printf`], which prints to stdout.
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::format::{sprintf, FormatArgument};
+///
+/// let s = sprintf("hello %s", &[FormatArgument::String("world".into())]).unwrap();
+/// let s = std::str::from_utf8(&s).unwrap();
+/// assert_eq!(s, "hello world");
+/// ```
+pub fn sprintf<'a>(
+    format_string: impl AsRef<[u8]>,
+    arguments: impl IntoIterator<Item = &'a FormatArgument>,
+) -> Result<Vec<u8>, FormatError> {
+    let mut writer = Vec::new();
+    printf_writer(&mut writer, format_string, arguments)?;
+    Ok(writer)
+}
+
+/// A format for a single numerical value of type T
+///
+/// This is used by `seq` and `csplit`. It can be constructed with [`Format::from_formatter`]
+/// or [`Format::parse`] and can write a value with [`Format::fmt`].
+///
+/// [`Format::parse`] can only accept a single specification without any asterisk parameters.
+/// If it does get more specifications, it will return an error.
+pub struct Format<F: Formatter<T>, T> {
+    prefix: Vec<u8>,
+    suffix: Vec<u8>,
+    formatter: F,
+    _marker: PhantomData<T>,
+}
+
+impl<F: Formatter<T>, T> Format<F, T> {
+    pub fn from_formatter(formatter: F) -> Self {
+        Self {
+            prefix: Vec::<u8>::new(),
+            suffix: Vec::<u8>::new(),
+            formatter,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn parse(format_string: impl AsRef<[u8]>) -> Result<Self, FormatError> {
+        let mut iter = parse_spec_only(format_string.as_ref());
+
+        let mut prefix = Vec::new();
+        let mut spec = None;
+        for item in &mut iter {
+            match item? {
+                FormatItem::Spec(s) => {
+                    spec = Some(s);
+                    break;
+                }
+                FormatItem::Char(c) => prefix.push(c),
+            }
+        }
+
+        let Some(spec) = spec else {
+            return Err(FormatError::NeedAtLeastOneSpec(
+                format_string.as_ref().to_vec(),
+            ));
+        };
+
+        let formatter = F::try_from_spec(spec)?;
+
+        let mut suffix = Vec::new();
+        for item in &mut iter {
+            match item {
+                // If the `format_string` is of the form `%f%f` or
+                // `%f%`, then return an error.
+                Ok(FormatItem::Spec(_)) | Err(FormatError::EndsWithPercent(_)) => {
+                    return Err(FormatError::TooManySpecs(format_string.as_ref().to_vec()));
+                }
+                Ok(FormatItem::Char(c)) => suffix.push(c),
+                Err(e) => return Err(e),
+            }
+        }
+
+        Ok(Self {
+            prefix,
+            suffix,
+            formatter,
+            _marker: PhantomData,
+        })
+    }
+
+    pub fn fmt(&self, mut w: impl Write, f: T) -> std::io::Result<()> {
+        w.write_all(&self.prefix)?;
+        self.formatter.fmt(&mut w, f)?;
+        w.write_all(&self.suffix)?;
+        Ok(())
+    }
+}
diff --git a/src/uucore/src/lib/features/format/num_format.rs b/src/uucore/src/lib/features/format/num_format.rs
new file mode 100644
index 00000000000..12e19a0950f
--- /dev/null
+++ b/src/uucore/src/lib/features/format/num_format.rs
@@ -0,0 +1,1288 @@
+// 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.
+// spell-checker:ignore bigdecimal prec cppreference
+//! Utilities for formatting numbers in various formats
+
+use bigdecimal::BigDecimal;
+use bigdecimal::num_bigint::ToBigInt;
+use num_traits::Signed;
+use num_traits::Zero;
+use std::cmp::min;
+use std::io::Write;
+
+use super::{
+    ExtendedBigDecimal, FormatError,
+    spec::{CanAsterisk, Spec},
+};
+
+pub trait Formatter<T> {
+    fn fmt(&self, writer: impl Write, x: T) -> std::io::Result<()>;
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError>
+    where
+        Self: Sized;
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum UnsignedIntVariant {
+    Decimal,
+    Octal(Prefix),
+    Hexadecimal(Case, Prefix),
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum FloatVariant {
+    Decimal,
+    Scientific,
+    Shortest,
+    Hexadecimal,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Case {
+    Lowercase,
+    Uppercase,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Prefix {
+    No,
+    Yes,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ForceDecimal {
+    No,
+    Yes,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum PositiveSign {
+    None,
+    Plus,
+    Space,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum NumberAlignment {
+    Left,
+    RightSpace,
+    RightZero,
+}
+
+pub struct SignedInt {
+    pub width: usize,
+    pub precision: usize,
+    pub positive_sign: PositiveSign,
+    pub alignment: NumberAlignment,
+}
+
+impl Formatter<i64> for SignedInt {
+    fn fmt(&self, writer: impl Write, x: i64) -> std::io::Result<()> {
+        // -i64::MIN is actually 1 larger than i64::MAX, so we need to cast to i128 first.
+        let abs = (x as i128).abs();
+        let s = if self.precision > 0 {
+            format!("{abs:0>width$}", width = self.precision)
+        } else {
+            abs.to_string()
+        };
+
+        let sign_indicator = get_sign_indicator(self.positive_sign, x.is_negative());
+
+        write_output(writer, sign_indicator, s, self.width, self.alignment)
+    }
+
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError> {
+        let Spec::SignedInt {
+            width,
+            precision,
+            positive_sign,
+            alignment,
+            position: _position,
+        } = s
+        else {
+            return Err(FormatError::WrongSpecType);
+        };
+
+        let width = match width {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk(_)) => return Err(FormatError::WrongSpecType),
+        };
+
+        let precision = match precision {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk(_)) => return Err(FormatError::WrongSpecType),
+        };
+
+        Ok(Self {
+            width,
+            precision,
+            positive_sign,
+            alignment,
+        })
+    }
+}
+
+pub struct UnsignedInt {
+    pub variant: UnsignedIntVariant,
+    pub width: usize,
+    pub precision: usize,
+    pub alignment: NumberAlignment,
+}
+
+impl Formatter<u64> for UnsignedInt {
+    fn fmt(&self, mut writer: impl Write, x: u64) -> std::io::Result<()> {
+        let mut s = match self.variant {
+            UnsignedIntVariant::Decimal => format!("{x}"),
+            UnsignedIntVariant::Octal(_) => format!("{x:o}"),
+            UnsignedIntVariant::Hexadecimal(Case::Lowercase, _) => {
+                format!("{x:x}")
+            }
+            UnsignedIntVariant::Hexadecimal(Case::Uppercase, _) => {
+                format!("{x:X}")
+            }
+        };
+
+        // Zeroes do not get a prefix. An octal value does also not get a
+        // prefix if the padded value does not start with a zero.
+        let prefix = match (x, self.variant) {
+            (1.., UnsignedIntVariant::Hexadecimal(Case::Lowercase, Prefix::Yes)) => "0x",
+            (1.., UnsignedIntVariant::Hexadecimal(Case::Uppercase, Prefix::Yes)) => "0X",
+            (1.., UnsignedIntVariant::Octal(Prefix::Yes)) if s.len() >= self.precision => "0",
+            _ => "",
+        };
+
+        s = format!("{prefix}{s:0>width$}", width = self.precision);
+
+        match self.alignment {
+            NumberAlignment::Left => write!(writer, "{s:<width$}", width = self.width),
+            NumberAlignment::RightSpace => write!(writer, "{s:>width$}", width = self.width),
+            NumberAlignment::RightZero => write!(writer, "{s:0>width$}", width = self.width),
+        }
+    }
+
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError> {
+        // A signed int spec might be mapped to an unsigned int spec if no sign is specified
+        let s = if let Spec::SignedInt {
+            width,
+            precision,
+            positive_sign: PositiveSign::None,
+            alignment,
+            position,
+        } = s
+        {
+            Spec::UnsignedInt {
+                variant: UnsignedIntVariant::Decimal,
+                width,
+                precision,
+                alignment,
+                position,
+            }
+        } else {
+            s
+        };
+
+        let Spec::UnsignedInt {
+            variant,
+            width,
+            precision,
+            alignment,
+            position: _position,
+        } = s
+        else {
+            return Err(FormatError::WrongSpecType);
+        };
+
+        let width = match width {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk(_)) => return Err(FormatError::WrongSpecType),
+        };
+
+        let precision = match precision {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk(_)) => return Err(FormatError::WrongSpecType),
+        };
+
+        Ok(Self {
+            variant,
+            width,
+            precision,
+            alignment,
+        })
+    }
+}
+
+pub struct Float {
+    pub variant: FloatVariant,
+    pub case: Case,
+    pub force_decimal: ForceDecimal,
+    pub width: usize,
+    pub positive_sign: PositiveSign,
+    pub alignment: NumberAlignment,
+    // For float, the default precision depends on the format, usually 6,
+    // but something architecture-specific for %a. Set this to None to
+    // use the default.
+    pub precision: Option<usize>,
+}
+
+impl Default for Float {
+    fn default() -> Self {
+        Self {
+            variant: FloatVariant::Decimal,
+            case: Case::Lowercase,
+            force_decimal: ForceDecimal::No,
+            width: 0,
+            positive_sign: PositiveSign::None,
+            alignment: NumberAlignment::Left,
+            precision: None,
+        }
+    }
+}
+
+impl Formatter<&ExtendedBigDecimal> for Float {
+    fn fmt(&self, writer: impl Write, e: &ExtendedBigDecimal) -> std::io::Result<()> {
+        /* TODO: Might be nice to implement Signed trait for ExtendedBigDecimal (for abs)
+         * at some point, but that requires implementing a _lot_ of traits.
+         * Note that "negative" would be the output of "is_sign_negative" on a f64:
+         * it returns true on `-0.0`.
+         */
+        let (abs, negative) = match e {
+            ExtendedBigDecimal::BigDecimal(bd) => {
+                (ExtendedBigDecimal::BigDecimal(bd.abs()), bd.is_negative())
+            }
+            ExtendedBigDecimal::MinusZero => (ExtendedBigDecimal::zero(), true),
+            ExtendedBigDecimal::Infinity => (ExtendedBigDecimal::Infinity, false),
+            ExtendedBigDecimal::MinusInfinity => (ExtendedBigDecimal::Infinity, true),
+            ExtendedBigDecimal::Nan => (ExtendedBigDecimal::Nan, false),
+            ExtendedBigDecimal::MinusNan => (ExtendedBigDecimal::Nan, true),
+        };
+
+        let mut alignment = self.alignment;
+
+        let s = match abs {
+            ExtendedBigDecimal::BigDecimal(bd) => match self.variant {
+                FloatVariant::Decimal => {
+                    format_float_decimal(&bd, self.precision, self.force_decimal)
+                }
+                FloatVariant::Scientific => {
+                    format_float_scientific(&bd, self.precision, self.case, self.force_decimal)
+                }
+                FloatVariant::Shortest => {
+                    format_float_shortest(&bd, self.precision, self.case, self.force_decimal)
+                }
+                FloatVariant::Hexadecimal => {
+                    format_float_hexadecimal(&bd, self.precision, self.case, self.force_decimal)
+                }
+            },
+            _ => {
+                // Pad non-finite numbers with spaces, not zeros.
+                if alignment == NumberAlignment::RightZero {
+                    alignment = NumberAlignment::RightSpace;
+                };
+                format_float_non_finite(&abs, self.case)
+            }
+        };
+        let sign_indicator = get_sign_indicator(self.positive_sign, negative);
+
+        write_output(writer, sign_indicator, s, self.width, alignment)
+    }
+
+    fn try_from_spec(s: Spec) -> Result<Self, FormatError>
+    where
+        Self: Sized,
+    {
+        let Spec::Float {
+            variant,
+            case,
+            force_decimal,
+            width,
+            positive_sign,
+            alignment,
+            precision,
+            position: _position,
+        } = s
+        else {
+            return Err(FormatError::WrongSpecType);
+        };
+
+        let width = match width {
+            Some(CanAsterisk::Fixed(x)) => x,
+            None => 0,
+            Some(CanAsterisk::Asterisk(_)) => return Err(FormatError::WrongSpecType),
+        };
+
+        let precision = match precision {
+            Some(CanAsterisk::Fixed(x)) => Some(x),
+            None => None,
+            Some(CanAsterisk::Asterisk(_)) => return Err(FormatError::WrongSpecType),
+        };
+
+        Ok(Self {
+            variant,
+            case,
+            force_decimal,
+            width,
+            positive_sign,
+            alignment,
+            precision,
+        })
+    }
+}
+
+fn get_sign_indicator(sign: PositiveSign, negative: bool) -> String {
+    if !negative {
+        match sign {
+            PositiveSign::None => String::new(),
+            PositiveSign::Plus => String::from("+"),
+            PositiveSign::Space => String::from(" "),
+        }
+    } else {
+        String::from("-")
+    }
+}
+
+fn format_float_non_finite(e: &ExtendedBigDecimal, case: Case) -> String {
+    let mut s = match e {
+        ExtendedBigDecimal::Infinity => String::from("inf"),
+        ExtendedBigDecimal::Nan => String::from("nan"),
+        _ => {
+            debug_assert!(false);
+            String::from("INVALID")
+        }
+    };
+
+    if case == Case::Uppercase {
+        s.make_ascii_uppercase();
+    }
+    s
+}
+
+fn format_float_decimal(
+    bd: &BigDecimal,
+    precision: Option<usize>,
+    force_decimal: ForceDecimal,
+) -> String {
+    debug_assert!(!bd.is_negative());
+    let precision = precision.unwrap_or(6); // Default %f precision (C standard)
+    if precision == 0 {
+        let (bi, scale) = bd.as_bigint_and_scale();
+        if scale == 0 && force_decimal != ForceDecimal::Yes {
+            // Optimization when printing integers.
+            return bi.to_str_radix(10);
+        } else if force_decimal == ForceDecimal::Yes {
+            return format!("{bd:.0}.");
+        }
+    }
+    format!("{bd:.precision$}")
+}
+
+fn format_float_scientific(
+    bd: &BigDecimal,
+    precision: Option<usize>,
+    case: Case,
+    force_decimal: ForceDecimal,
+) -> String {
+    debug_assert!(!bd.is_negative());
+    let precision = precision.unwrap_or(6); // Default %e precision (C standard)
+    let exp_char = match case {
+        Case::Lowercase => 'e',
+        Case::Uppercase => 'E',
+    };
+
+    if BigDecimal::zero().eq(bd) {
+        return if force_decimal == ForceDecimal::Yes && precision == 0 {
+            format!("0.{exp_char}+00")
+        } else {
+            format!("{:.*}{exp_char}+00", precision, 0.0)
+        };
+    }
+
+    // Round bd to (1 + precision) digits (including the leading digit)
+    // We call `with_prec` twice as it will produce an extra digit if rounding overflows
+    // (e.g. 9995.with_prec(3) => 1000 * 10^1, but we want 100 * 10^2).
+    let bd_round = bd
+        .with_prec(precision as u64 + 1)
+        .with_prec(precision as u64 + 1);
+
+    // Convert to the form XXX * 10^-e (XXX is 1+precision digit long)
+    let (frac, e) = bd_round.as_bigint_and_exponent();
+
+    // Scale down "XXX" to "X.XX": that divides by 10^precision, so add that to the exponent.
+    let digits = frac.to_str_radix(10);
+    let (first_digit, remaining_digits) = digits.split_at(1);
+    let exponent = -e + precision as i64;
+
+    let dot =
+        if !remaining_digits.is_empty() || (precision == 0 && ForceDecimal::Yes == force_decimal) {
+            "."
+        } else {
+            ""
+        };
+
+    format!("{first_digit}{dot}{remaining_digits}{exp_char}{exponent:+03}")
+}
+
+fn format_float_shortest(
+    bd: &BigDecimal,
+    precision: Option<usize>,
+    case: Case,
+    force_decimal: ForceDecimal,
+) -> String {
+    debug_assert!(!bd.is_negative());
+    let precision = precision.unwrap_or(6); // Default %g precision (C standard)
+
+    // Note: Precision here is how many digits should be displayed in total,
+    // instead of how many digits in the fractional part.
+
+    // Precision 0 is equivalent to precision 1.
+    let precision = precision.max(1);
+
+    if BigDecimal::zero().eq(bd) {
+        return match (force_decimal, precision) {
+            (ForceDecimal::Yes, 1) => "0.".into(),
+            (ForceDecimal::Yes, _) => {
+                format!("{:.*}", precision - 1, 0.0)
+            }
+            (ForceDecimal::No, _) => "0".into(),
+        };
+    }
+
+    // Round bd to precision digits (including the leading digit)
+    // We call `with_prec` twice as it will produce an extra digit if rounding overflows
+    // (e.g. 9995.with_prec(3) => 1000 * 10^1, but we want 100 * 10^2).
+    let bd_round = bd.with_prec(precision as u64).with_prec(precision as u64);
+
+    // Convert to the form XXX * 10^-p (XXX is precision digit long)
+    let (frac, e) = bd_round.as_bigint_and_exponent();
+
+    let digits = frac.to_str_radix(10);
+    // If we end up with scientific formatting, we would convert XXX to X.XX:
+    // that divides by 10^(precision-1), so add that to the exponent.
+    let exponent = -e + precision as i64 - 1;
+
+    if exponent < -4 || exponent >= precision as i64 {
+        // Scientific-ish notation (with a few differences)
+
+        // Scale down "XXX" to "X.XX"
+        let (first_digit, remaining_digits) = digits.split_at(1);
+
+        // Always add the dot, we might trim it later.
+        let mut normalized = format!("{first_digit}.{remaining_digits}");
+
+        if force_decimal == ForceDecimal::No {
+            strip_fractional_zeroes_and_dot(&mut normalized);
+        }
+
+        let exp_char = match case {
+            Case::Lowercase => 'e',
+            Case::Uppercase => 'E',
+        };
+
+        format!("{normalized}{exp_char}{exponent:+03}")
+    } else {
+        // Decimal-ish notation with a few differences:
+        //  - The precision works differently and specifies the total number
+        //    of digits instead of the digits in the fractional part.
+        //  - If we don't force the decimal, `.` and trailing `0` in the fractional part
+        //    are trimmed.
+        let mut formatted = if exponent < 0 {
+            // Small number, prepend some "0.00" string
+            let zeros = "0".repeat(-exponent as usize - 1);
+            format!("0.{zeros}{digits}")
+        } else {
+            // exponent >= 0, slot in a dot at the right spot
+            let (first_digits, remaining_digits) = digits.split_at(exponent as usize + 1);
+
+            // Always add `.` even if it's trailing, we might trim it later
+            format!("{first_digits}.{remaining_digits}")
+        };
+
+        if force_decimal == ForceDecimal::No {
+            strip_fractional_zeroes_and_dot(&mut formatted);
+        }
+
+        formatted
+    }
+}
+
+fn format_float_hexadecimal(
+    bd: &BigDecimal,
+    precision: Option<usize>,
+    case: Case,
+    force_decimal: ForceDecimal,
+) -> String {
+    debug_assert!(!bd.is_negative());
+    // Default precision for %a is supposed to be sufficient to represent the
+    // exact value. This is platform specific, GNU coreutils uses a `long double`,
+    // which can be equivalent to a f64, f128, or an x86(-64) specific "f80".
+    // We have arbitrary precision in base 10, so we can't always represent
+    // the value exactly (e.g. 0.1 is c.ccccc...).
+    //
+    // Note that this is the maximum precision, trailing 0's are trimmed when
+    // printing.
+    //
+    // Emulate x86(-64) behavior, where 64 bits at _most_ are printed in total,
+    // that's 16 hex digits, including 1 before the decimal point (so 15 after).
+    //
+    // TODO: Make this configurable? e.g. arm64 value would be 28 (f128),
+    // arm value 13 (f64).
+    let max_precision = precision.unwrap_or(15);
+
+    let (prefix, exp_char) = match case {
+        Case::Lowercase => ("0x", 'p'),
+        Case::Uppercase => ("0X", 'P'),
+    };
+
+    if BigDecimal::zero().eq(bd) {
+        // To print 0, we don't ever need any digits after the decimal point, so default to
+        // that if precision is not specified.
+        return if force_decimal == ForceDecimal::Yes && precision.unwrap_or(0) == 0 {
+            format!("0x0.{exp_char}+0")
+        } else {
+            format!("0x{:.*}{exp_char}+0", precision.unwrap_or(0), 0.0)
+        };
+    }
+
+    // Convert to the form frac10 * 10^exp
+    let (frac10, p) = bd.as_bigint_and_exponent();
+    // We cast this to u32 below, but we probably do not care about exponents
+    // that would overflow u32. We should probably detect this and fail
+    // gracefully though.
+    let exp10 = -p;
+
+    // We want something that looks like this: frac2 * 2^exp2,
+    // without losing precision.
+    // frac10 * 10^exp10 = (frac10 * 5^exp10) * 2^exp10 = frac2 * 2^exp2
+
+    // TODO: this is most accurate, but frac2 will grow a lot for large
+    // precision or exponent, and formatting will get very slow.
+    // The precision can't technically be a very large number (up to 32-bit int),
+    // but we can trim some of the lower digits, if we want to only keep what a
+    // `long double` (80-bit or 128-bit at most) implementation would be able to
+    // display.
+    // The exponent is less of a problem if we matched `long double` implementation,
+    // as a 80/128-bit floats only covers a 15-bit exponent.
+
+    let (mut frac2, mut exp2) = if exp10 >= 0 {
+        // Positive exponent. 5^exp10 is an integer, so we can just multiply.
+        (frac10 * 5.to_bigint().unwrap().pow(exp10 as u32), exp10)
+    } else {
+        // Negative exponent: We're going to need to divide by 5^-exp10,
+        // so we first shift left by some margin to make sure we do not lose digits.
+
+        // We want to make sure we have at least precision+1 hex digits to start with.
+        // Then, dividing by 5^-exp10 loses at most -exp10*3 binary digits
+        // (since 5^-exp10 < 8^-exp10), so we add that, and another bit for
+        // rounding.
+        let margin =
+            ((max_precision + 1) as i64 * 4 - frac10.bits() as i64).max(0) + -exp10 * 3 + 1;
+
+        // frac10 * 10^exp10 = frac10 * 2^margin * 10^exp10 * 2^-margin =
+        // (frac10 * 2^margin * 5^exp10) * 2^exp10 * 2^-margin =
+        // (frac10 * 2^margin / 5^-exp10) * 2^(exp10-margin)
+        (
+            (frac10 << margin) / 5.to_bigint().unwrap().pow(-exp10 as u32),
+            exp10 - margin,
+        )
+    };
+
+    // Emulate x86(-64) behavior, we display 4 binary digits before the decimal point,
+    // so the value will always be between 0x8 and 0xf.
+    // TODO: Make this configurable? e.g. arm64 only displays 1 digit.
+    const BEFORE_BITS: usize = 4;
+    let wanted_bits = (BEFORE_BITS + max_precision * 4) as u64;
+    let bits = frac2.bits();
+
+    exp2 += bits as i64 - wanted_bits as i64;
+    if bits > wanted_bits {
+        // Shift almost all the way, round up if needed, then finish shifting.
+        frac2 >>= bits - wanted_bits - 1;
+        let add = frac2.bit(0);
+        frac2 >>= 1;
+
+        if add {
+            frac2 += 0x1;
+            if frac2.bits() > wanted_bits {
+                // We overflowed, drop one more hex digit.
+                // Note: Yes, the leading hex digit will now contain only 1 binary digit,
+                // but that emulates coreutils behavior on x86(-64).
+                frac2 >>= 4;
+                exp2 += 4;
+            }
+        }
+    } else {
+        frac2 <<= wanted_bits - bits;
+    };
+
+    // Convert "XXX" to "X.XX": that divides by 16^precision = 2^(4*precision), so add that to the exponent.
+    let mut digits = frac2.to_str_radix(16);
+    if case == Case::Uppercase {
+        digits.make_ascii_uppercase();
+    }
+    let (first_digit, remaining_digits) = digits.split_at(1);
+    let exponent = exp2 + (4 * max_precision) as i64;
+
+    let mut remaining_digits = remaining_digits.to_string();
+    if precision.is_none() {
+        // Trim trailing zeros
+        strip_fractional_zeroes(&mut remaining_digits);
+    }
+
+    let dot = if !remaining_digits.is_empty()
+        || (precision.unwrap_or(0) == 0 && ForceDecimal::Yes == force_decimal)
+    {
+        "."
+    } else {
+        ""
+    };
+
+    format!("{prefix}{first_digit}{dot}{remaining_digits}{exp_char}{exponent:+}")
+}
+
+fn strip_fractional_zeroes(s: &mut String) {
+    let mut trim_to = s.len();
+    for (pos, c) in s.char_indices().rev() {
+        if pos + c.len_utf8() == trim_to {
+            if c == '0' {
+                trim_to = pos;
+            } else {
+                break;
+            }
+        }
+    }
+    s.truncate(trim_to);
+}
+
+fn strip_fractional_zeroes_and_dot(s: &mut String) {
+    let mut trim_to = s.len();
+    for (pos, c) in s.char_indices().rev() {
+        if pos + c.len_utf8() == trim_to && (c == '0' || c == '.') {
+            trim_to = pos;
+        }
+        if c == '.' {
+            s.truncate(trim_to);
+            break;
+        }
+    }
+}
+
+fn write_output(
+    mut writer: impl Write,
+    sign_indicator: String,
+    mut s: String,
+    width: usize,
+    alignment: NumberAlignment,
+) -> std::io::Result<()> {
+    if width == 0 {
+        writer.write_all(sign_indicator.as_bytes())?;
+        writer.write_all(s.as_bytes())?;
+        return Ok(());
+    }
+    // Take length of `sign_indicator`, which could be 0 or 1, into consideration when padding
+    // by storing remaining_width indicating the actual width needed.
+    // Using min() because self.width could be 0, 0usize - 1usize should be avoided
+    let remaining_width = width - min(width, sign_indicator.len());
+    match alignment {
+        NumberAlignment::Left => write!(writer, "{sign_indicator}{s:<remaining_width$}"),
+        NumberAlignment::RightSpace => {
+            let is_sign = sign_indicator.starts_with('-') || sign_indicator.starts_with('+'); // When sign_indicator is in ['-', '+']
+            if is_sign && remaining_width > 0 {
+                // Make sure sign_indicator is just next to number, e.g. "% +5.1f" 1 ==> $ +1.0
+                s = sign_indicator + s.as_str();
+                write!(writer, "{s:>width$}", width = remaining_width + 1) // Since we now add sign_indicator and s together, plus 1
+            } else {
+                write!(writer, "{sign_indicator}{s:>remaining_width$}")
+            }
+        }
+        NumberAlignment::RightZero => {
+            write!(writer, "{sign_indicator}{s:0>remaining_width$}")
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use bigdecimal::BigDecimal;
+    use num_traits::FromPrimitive;
+    use std::str::FromStr;
+
+    use crate::format::{
+        ExtendedBigDecimal, Format,
+        num_format::{Case, Float, ForceDecimal, UnsignedInt},
+    };
+
+    use super::{Formatter, SignedInt};
+
+    #[test]
+    fn unsigned_octal() {
+        use super::{Formatter, NumberAlignment, Prefix, UnsignedInt, UnsignedIntVariant};
+        let f = |x| {
+            let mut s = Vec::new();
+            UnsignedInt {
+                variant: UnsignedIntVariant::Octal(Prefix::Yes),
+                width: 0,
+                precision: 0,
+                alignment: NumberAlignment::Left,
+            }
+            .fmt(&mut s, x)
+            .unwrap();
+            String::from_utf8(s).unwrap()
+        };
+
+        assert_eq!(f(0), "0");
+        assert_eq!(f(5), "05");
+        assert_eq!(f(8), "010");
+    }
+
+    #[test]
+    fn non_finite_float() {
+        use super::format_float_non_finite;
+        let f = |x| format_float_non_finite(x, Case::Lowercase);
+        assert_eq!(f(&ExtendedBigDecimal::Nan), "nan");
+        assert_eq!(f(&ExtendedBigDecimal::Infinity), "inf");
+
+        let f = |x| format_float_non_finite(x, Case::Uppercase);
+        assert_eq!(f(&ExtendedBigDecimal::Nan), "NAN");
+        assert_eq!(f(&ExtendedBigDecimal::Infinity), "INF");
+    }
+
+    #[test]
+    fn decimal_float() {
+        use super::format_float_decimal;
+        let f =
+            |x| format_float_decimal(&BigDecimal::from_f64(x).unwrap(), Some(6), ForceDecimal::No);
+        assert_eq!(f(0.0), "0.000000");
+        assert_eq!(f(1.0), "1.000000");
+        assert_eq!(f(100.0), "100.000000");
+        assert_eq!(f(123_456.789), "123456.789000");
+        assert_eq!(f(12.345_678_9), "12.345679");
+        assert_eq!(f(1_000_000.0), "1000000.000000");
+        assert_eq!(f(99_999_999.0), "99999999.000000");
+        assert_eq!(f(1.999_999_5), "1.999999");
+        assert_eq!(f(1.999_999_6), "2.000000");
+
+        let f = |x| {
+            format_float_decimal(
+                &BigDecimal::from_f64(x).unwrap(),
+                Some(0),
+                ForceDecimal::Yes,
+            )
+        };
+        assert_eq!(f(100.0), "100.");
+
+        // Test arbitrary precision: long inputs that would not fit in a f64, print 24 digits after decimal point.
+        let f = |x| {
+            format_float_decimal(
+                &BigDecimal::from_str(x).unwrap(),
+                Some(24),
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f("0.12345678901234567890"), "0.123456789012345678900000");
+        assert_eq!(
+            f("1234567890.12345678901234567890"),
+            "1234567890.123456789012345678900000"
+        );
+    }
+
+    #[test]
+    fn decimal_float_zero() {
+        use super::format_float_decimal;
+        let f = |digits, scale| {
+            format_float_decimal(
+                &BigDecimal::from_bigint(digits, scale),
+                Some(6),
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.into(), 0), "0.000000");
+        assert_eq!(f(0.into(), -10), "0.000000");
+        assert_eq!(f(0.into(), 10), "0.000000");
+    }
+
+    #[test]
+    fn scientific_float() {
+        use super::format_float_scientific;
+        let f = |x| {
+            format_float_scientific(
+                &BigDecimal::from_f64(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.0), "0.000000e+00");
+        assert_eq!(f(1.0), "1.000000e+00");
+        assert_eq!(f(100.0), "1.000000e+02");
+        assert_eq!(f(123_456.789), "1.234568e+05");
+        assert_eq!(f(12.345_678_9), "1.234568e+01");
+        assert_eq!(f(1_000_000.0), "1.000000e+06");
+        assert_eq!(f(99_999_999.0), "1.000000e+08");
+
+        let f = |x| {
+            format_float_scientific(
+                &BigDecimal::from_f64(x).unwrap(),
+                Some(6),
+                Case::Uppercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.0), "0.000000E+00");
+        assert_eq!(f(123_456.789), "1.234568E+05");
+
+        // Test "0e10"/"0e-10". From cppreference.com: "If the value is ​0​, the exponent is also ​0​."
+        let f = |digits, scale| {
+            format_float_scientific(
+                &BigDecimal::from_bigint(digits, scale),
+                Some(6),
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.into(), 0), "0.000000e+00");
+        assert_eq!(f(0.into(), -10), "0.000000e+00");
+        assert_eq!(f(0.into(), 10), "0.000000e+00");
+    }
+
+    #[test]
+    fn scientific_float_zero_precision() {
+        use super::format_float_scientific;
+
+        let f = |x| {
+            format_float_scientific(
+                &BigDecimal::from_f64(x).unwrap(),
+                Some(0),
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.0), "0e+00");
+        assert_eq!(f(1.0), "1e+00");
+        assert_eq!(f(100.0), "1e+02");
+        assert_eq!(f(123_456.789), "1e+05");
+        assert_eq!(f(12.345_678_9), "1e+01");
+        assert_eq!(f(1_000_000.0), "1e+06");
+        assert_eq!(f(99_999_999.0), "1e+08");
+
+        let f = |x| {
+            format_float_scientific(
+                &BigDecimal::from_f64(x).unwrap(),
+                Some(0),
+                Case::Lowercase,
+                ForceDecimal::Yes,
+            )
+        };
+        assert_eq!(f(0.0), "0.e+00");
+        assert_eq!(f(1.0), "1.e+00");
+        assert_eq!(f(100.0), "1.e+02");
+        assert_eq!(f(123_456.789), "1.e+05");
+        assert_eq!(f(12.345_678_9), "1.e+01");
+        assert_eq!(f(1_000_000.0), "1.e+06");
+        assert_eq!(f(99_999_999.0), "1.e+08");
+    }
+
+    #[test]
+    fn shortest_float() {
+        use super::format_float_shortest;
+        let f = |x| {
+            format_float_shortest(
+                &BigDecimal::from_f64(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.0), "0");
+        assert_eq!(f(0.00001), "1e-05");
+        assert_eq!(f(0.0001), "0.0001");
+        assert_eq!(f(1.0), "1");
+        assert_eq!(f(100.0), "100");
+        assert_eq!(f(123_456.789), "123457");
+        assert_eq!(f(12.345_678_9), "12.3457");
+        assert_eq!(f(1_000_000.0), "1e+06");
+        assert_eq!(f(99_999_999.0), "1e+08");
+    }
+
+    #[test]
+    fn shortest_float_force_decimal() {
+        use super::format_float_shortest;
+        let f = |x| {
+            format_float_shortest(
+                &BigDecimal::from_f64(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::Yes,
+            )
+        };
+        assert_eq!(f(0.0), "0.00000");
+        assert_eq!(f(0.00001), "1.00000e-05");
+        assert_eq!(f(0.0001), "0.000100000");
+        assert_eq!(f(1.0), "1.00000");
+        assert_eq!(f(100.0), "100.000");
+        assert_eq!(f(123_456.789), "123457.");
+        assert_eq!(f(12.345_678_9), "12.3457");
+        assert_eq!(f(1_000_000.0), "1.00000e+06");
+        assert_eq!(f(99_999_999.0), "1.00000e+08");
+    }
+
+    #[test]
+    fn shortest_float_force_decimal_zero_precision() {
+        use super::format_float_shortest;
+        let f = |x| {
+            format_float_shortest(
+                &BigDecimal::from_f64(x).unwrap(),
+                Some(0),
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.0), "0");
+        assert_eq!(f(0.00001), "1e-05");
+        assert_eq!(f(0.0001), "0.0001");
+        assert_eq!(f(1.0), "1");
+        assert_eq!(f(10.0), "1e+01");
+        assert_eq!(f(100.0), "1e+02");
+        assert_eq!(f(123_456.789), "1e+05");
+        assert_eq!(f(12.345_678_9), "1e+01");
+        assert_eq!(f(1_000_000.0), "1e+06");
+        assert_eq!(f(99_999_999.0), "1e+08");
+
+        let f = |x| {
+            format_float_shortest(
+                &BigDecimal::from_f64(x).unwrap(),
+                Some(0),
+                Case::Lowercase,
+                ForceDecimal::Yes,
+            )
+        };
+        assert_eq!(f(0.0), "0.");
+        assert_eq!(f(0.00001), "1.e-05");
+        assert_eq!(f(0.0001), "0.0001");
+        assert_eq!(f(1.0), "1.");
+        assert_eq!(f(10.0), "1.e+01");
+        assert_eq!(f(100.0), "1.e+02");
+        assert_eq!(f(123_456.789), "1.e+05");
+        assert_eq!(f(12.345_678_9), "1.e+01");
+        assert_eq!(f(1_000_000.0), "1.e+06");
+        assert_eq!(f(99_999_999.0), "1.e+08");
+    }
+
+    #[test]
+    fn hexadecimal_float() {
+        // It's important to create the BigDecimal from a string: going through a f64
+        // will lose some precision.
+
+        use super::format_float_hexadecimal;
+        let f = |x| {
+            format_float_hexadecimal(
+                &BigDecimal::from_str(x).unwrap(),
+                Some(6),
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f("0"), "0x0.000000p+0");
+        assert_eq!(f("0.00001"), "0xa.7c5ac4p-20");
+        assert_eq!(f("0.125"), "0x8.000000p-6");
+        assert_eq!(f("256.0"), "0x8.000000p+5");
+        assert_eq!(f("65536.0"), "0x8.000000p+13");
+        assert_eq!(f("1.9999999999"), "0x1.000000p+1"); // Corner case: leading hex digit only contains 1 binary digit
+
+        let f = |x| {
+            format_float_hexadecimal(
+                &BigDecimal::from_str(x).unwrap(),
+                Some(0),
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f("0"), "0x0p+0");
+        assert_eq!(f("0.125"), "0x8p-6");
+        assert_eq!(f("256.0"), "0x8p+5");
+
+        let f = |x| {
+            format_float_hexadecimal(
+                &BigDecimal::from_str(x).unwrap(),
+                Some(0),
+                Case::Lowercase,
+                ForceDecimal::Yes,
+            )
+        };
+        assert_eq!(f("0"), "0x0.p+0");
+        assert_eq!(f("0.125"), "0x8.p-6");
+        assert_eq!(f("256.0"), "0x8.p+5");
+
+        // Default precision, maximum 13 digits (x86-64 behavior)
+        let f = |x| {
+            format_float_hexadecimal(
+                &BigDecimal::from_str(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f("0"), "0x0p+0");
+        assert_eq!(f("0.00001"), "0xa.7c5ac471b478423p-20");
+        assert_eq!(f("0.125"), "0x8p-6");
+        assert_eq!(f("4.25"), "0x8.8p-1");
+        assert_eq!(f("17.203125"), "0x8.9ap+1");
+        assert_eq!(f("256.0"), "0x8p+5");
+        assert_eq!(f("1000.01"), "0xf.a00a3d70a3d70a4p+6");
+        assert_eq!(f("65536.0"), "0x8p+13");
+
+        let f = |x| {
+            format_float_hexadecimal(
+                &BigDecimal::from_str(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::Yes,
+            )
+        };
+        assert_eq!(f("0"), "0x0.p+0");
+        assert_eq!(f("0.125"), "0x8.p-6");
+        assert_eq!(f("4.25"), "0x8.8p-1");
+        assert_eq!(f("256.0"), "0x8.p+5");
+
+        let f = |x| {
+            format_float_hexadecimal(
+                &BigDecimal::from_str(x).unwrap(),
+                Some(6),
+                Case::Uppercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f("0.00001"), "0XA.7C5AC4P-20");
+        assert_eq!(f("0.125"), "0X8.000000P-6");
+
+        // Test "0e10"/"0e-10". From cppreference.com: "If the value is ​0​, the exponent is also ​0​."
+        let f = |digits, scale| {
+            format_float_hexadecimal(
+                &BigDecimal::from_bigint(digits, scale),
+                Some(6),
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.into(), 0), "0x0.000000p+0");
+        assert_eq!(f(0.into(), -10), "0x0.000000p+0");
+        assert_eq!(f(0.into(), 10), "0x0.000000p+0");
+    }
+
+    #[test]
+    fn strip_insignificant_end() {
+        use super::strip_fractional_zeroes_and_dot;
+        let f = |s| {
+            let mut s = String::from(s);
+            strip_fractional_zeroes_and_dot(&mut s);
+            s
+        };
+        assert_eq!(&f("1000"), "1000");
+        assert_eq!(&f("1000."), "1000");
+        assert_eq!(&f("1000.02030"), "1000.0203");
+        assert_eq!(&f("1000.00000"), "1000");
+    }
+
+    #[test]
+    fn shortest_float_abs_value_less_than_one() {
+        use super::format_float_shortest;
+        let f = |x| {
+            format_float_shortest(
+                &BigDecimal::from_f64(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.1171875), "0.117188");
+        assert_eq!(f(0.01171875), "0.0117188");
+        assert_eq!(f(0.001171875), "0.00117187");
+        assert_eq!(f(0.0001171875), "0.000117187");
+        assert_eq!(f(0.001171875001), "0.00117188");
+    }
+
+    #[test]
+    fn shortest_float_switch_decimal_scientific() {
+        use super::format_float_shortest;
+        let f = |x| {
+            format_float_shortest(
+                &BigDecimal::from_f64(x).unwrap(),
+                None,
+                Case::Lowercase,
+                ForceDecimal::No,
+            )
+        };
+        assert_eq!(f(0.001), "0.001");
+        assert_eq!(f(0.0001), "0.0001");
+        assert_eq!(f(0.00001), "1e-05");
+        assert_eq!(f(0.000001), "1e-06");
+    }
+
+    // Wrapper function to get a string out of Format.fmt()
+    fn fmt<U, T>(format: &Format<U, T>, n: T) -> String
+    where
+        U: Formatter<T>,
+    {
+        let mut v = Vec::<u8>::new();
+        format.fmt(&mut v, n).unwrap();
+        String::from_utf8_lossy(&v).to_string()
+    }
+
+    // Some end-to-end tests, `printf` will also test some of those but it's easier to add more
+    // tests here. We mostly focus on padding, negative numbers, and format specifiers that are not
+    // covered above.
+    #[test]
+    fn format_signed_int() {
+        let format = Format::<SignedInt, i64>::parse("%d").unwrap();
+        assert_eq!(fmt(&format, 123i64), "123");
+        assert_eq!(fmt(&format, -123i64), "-123");
+        assert_eq!(fmt(&format, i64::MAX), "9223372036854775807");
+        assert_eq!(fmt(&format, i64::MIN), "-9223372036854775808");
+
+        let format = Format::<SignedInt, i64>::parse("%i").unwrap();
+        assert_eq!(fmt(&format, 123i64), "123");
+        assert_eq!(fmt(&format, -123i64), "-123");
+
+        let format = Format::<SignedInt, i64>::parse("%6d").unwrap();
+        assert_eq!(fmt(&format, 123i64), "   123");
+        assert_eq!(fmt(&format, -123i64), "  -123");
+
+        let format = Format::<SignedInt, i64>::parse("%06d").unwrap();
+        assert_eq!(fmt(&format, 123i64), "000123");
+        assert_eq!(fmt(&format, -123i64), "-00123");
+
+        let format = Format::<SignedInt, i64>::parse("%+6d").unwrap();
+        assert_eq!(fmt(&format, 123i64), "  +123");
+        assert_eq!(fmt(&format, -123i64), "  -123");
+
+        let format = Format::<SignedInt, i64>::parse("% d").unwrap();
+        assert_eq!(fmt(&format, 123i64), " 123");
+        assert_eq!(fmt(&format, -123i64), "-123");
+    }
+
+    #[test]
+    #[ignore = "Need issue #7509 to be fixed"]
+    fn format_signed_int_precision_zero() {
+        let format = Format::<SignedInt, i64>::parse("%.0d").unwrap();
+        assert_eq!(fmt(&format, 123i64), "123");
+        // From cppreference.com: "If both the converted value and the precision are ​0​ the conversion results in no characters."
+        assert_eq!(fmt(&format, 0i64), "");
+    }
+
+    #[test]
+    fn format_unsigned_int() {
+        let f = |fmt_str: &str, n: u64| {
+            let format = Format::<UnsignedInt, u64>::parse(fmt_str).unwrap();
+            fmt(&format, n)
+        };
+
+        assert_eq!(f("%u", 123u64), "123");
+        assert_eq!(f("%o", 123u64), "173");
+        assert_eq!(f("%#o", 123u64), "0173");
+        assert_eq!(f("%6x", 123u64), "    7b");
+        assert_eq!(f("%#6x", 123u64), "  0x7b");
+        assert_eq!(f("%06X", 123u64), "00007B");
+        assert_eq!(f("%+6u", 123u64), "   123"); // '+' is ignored for unsigned numbers.
+        assert_eq!(f("% u", 123u64), "123"); // ' ' is ignored for unsigned numbers.
+        assert_eq!(f("%#x", 0), "0"); // No prefix for 0
+    }
+
+    #[test]
+    #[ignore = "Need issues #7509 and #7510 to be fixed"]
+    fn format_unsigned_int_broken() {
+        // TODO: Merge this back into format_unsigned_int.
+        let f = |fmt_str: &str, n: u64| {
+            let format = Format::<UnsignedInt, u64>::parse(fmt_str).unwrap();
+            fmt(&format, n)
+        };
+
+        // #7509
+        assert_eq!(f("%.0o", 0), "");
+        assert_eq!(f("%#0o", 0), "0"); // Already correct, but probably an accident.
+        assert_eq!(f("%.0x", 0), "");
+        // #7510
+        assert_eq!(f("%#06x", 123u64), "0x007b");
+    }
+
+    #[test]
+    fn format_float_decimal() {
+        let format = Format::<Float, &ExtendedBigDecimal>::parse("%f").unwrap();
+        assert_eq!(fmt(&format, &123.0.into()), "123.000000");
+        assert_eq!(fmt(&format, &(-123.0).into()), "-123.000000");
+        assert_eq!(fmt(&format, &123.15e-8.into()), "0.000001");
+        assert_eq!(fmt(&format, &(-123.15e8).into()), "-12315000000.000000");
+        let zero_exp = |exp| ExtendedBigDecimal::BigDecimal(BigDecimal::from_bigint(0.into(), exp));
+        // We've had issues with "0e10"/"0e-10" formatting, and our current workaround is in Format.fmt function.
+        assert_eq!(fmt(&format, &zero_exp(0)), "0.000000");
+        assert_eq!(fmt(&format, &zero_exp(10)), "0.000000");
+        assert_eq!(fmt(&format, &zero_exp(-10)), "0.000000");
+
+        let format = Format::<Float, &ExtendedBigDecimal>::parse("%12f").unwrap();
+        assert_eq!(fmt(&format, &123.0.into()), "  123.000000");
+        assert_eq!(fmt(&format, &(-123.0).into()), " -123.000000");
+        assert_eq!(fmt(&format, &123.15e-8.into()), "    0.000001");
+        assert_eq!(fmt(&format, &(-123.15e8).into()), "-12315000000.000000");
+        assert_eq!(
+            fmt(&format, &(ExtendedBigDecimal::Infinity)),
+            "         inf"
+        );
+        assert_eq!(
+            fmt(&format, &(ExtendedBigDecimal::MinusInfinity)),
+            "        -inf"
+        );
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::Nan)), "         nan");
+        assert_eq!(
+            fmt(&format, &(ExtendedBigDecimal::MinusNan)),
+            "        -nan"
+        );
+
+        let format = Format::<Float, &ExtendedBigDecimal>::parse("%+#.0f").unwrap();
+        assert_eq!(fmt(&format, &123.0.into()), "+123.");
+        assert_eq!(fmt(&format, &(-123.0).into()), "-123.");
+        assert_eq!(fmt(&format, &123.15e-8.into()), "+0.");
+        assert_eq!(fmt(&format, &(-123.15e8).into()), "-12315000000.");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::Infinity)), "+inf");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::Nan)), "+nan");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::MinusZero)), "-0.");
+
+        let format = Format::<Float, &ExtendedBigDecimal>::parse("%#06.0f").unwrap();
+        assert_eq!(fmt(&format, &123.0.into()), "00123.");
+        assert_eq!(fmt(&format, &(-123.0).into()), "-0123.");
+        assert_eq!(fmt(&format, &123.15e-8.into()), "00000.");
+        assert_eq!(fmt(&format, &(-123.15e8).into()), "-12315000000.");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::Infinity)), "   inf");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::MinusInfinity)), "  -inf");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::Nan)), "   nan");
+        assert_eq!(fmt(&format, &(ExtendedBigDecimal::MinusNan)), "  -nan");
+    }
+
+    #[test]
+    fn format_float_others() {
+        let f = |fmt_str: &str, n: &ExtendedBigDecimal| {
+            let format = Format::<Float, &ExtendedBigDecimal>::parse(fmt_str).unwrap();
+            fmt(&format, n)
+        };
+
+        assert_eq!(f("%e", &(-123.0).into()), "-1.230000e+02");
+        assert_eq!(f("%#09.e", &(-100.0).into()), "-001.e+02");
+        assert_eq!(f("%# 9.E", &100.0.into()), "   1.E+02");
+        assert_eq!(f("% 12.2A", &(-100.0).into()), "  -0XC.80P+3");
+    }
+
+    #[test]
+    #[ignore = "Need issue #7510 to be fixed"]
+    fn format_float_others_broken() {
+        // TODO: Merge this back into format_float_others.
+        let f = |fmt_str: &str, n: &ExtendedBigDecimal| {
+            let format = Format::<Float, &ExtendedBigDecimal>::parse(fmt_str).unwrap();
+            fmt(&format, n)
+        };
+
+        // #7510
+        assert_eq!(f("%012.2a", &(-100.0).into()), "-0x00c.80p+3");
+    }
+}
diff --git a/src/uucore/src/lib/features/format/spec.rs b/src/uucore/src/lib/features/format/spec.rs
new file mode 100644
index 00000000000..d2262659012
--- /dev/null
+++ b/src/uucore/src/lib/features/format/spec.rs
@@ -0,0 +1,757 @@
+// 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.
+
+// spell-checker:ignore (vars) intmax ptrdiff padlen
+
+use crate::quoting_style::{QuotingStyle, escape_name};
+
+use super::{
+    ExtendedBigDecimal, FormatChar, FormatError, OctalParsing,
+    num_format::{
+        self, Case, FloatVariant, ForceDecimal, Formatter, NumberAlignment, PositiveSign, Prefix,
+        UnsignedIntVariant,
+    },
+    parse_escape_only,
+};
+use crate::format::FormatArguments;
+use std::{io::Write, num::NonZero, ops::ControlFlow};
+
+/// A parsed specification for formatting a value
+///
+/// This might require more than one argument to resolve width or precision
+/// values that are given as `*`.
+#[derive(Debug)]
+pub enum Spec {
+    Char {
+        position: ArgumentLocation,
+        width: Option<CanAsterisk<usize>>,
+        align_left: bool,
+    },
+    String {
+        position: ArgumentLocation,
+        precision: Option<CanAsterisk<usize>>,
+        width: Option<CanAsterisk<usize>>,
+        align_left: bool,
+    },
+    EscapedString {
+        position: ArgumentLocation,
+    },
+    QuotedString {
+        position: ArgumentLocation,
+    },
+    SignedInt {
+        position: ArgumentLocation,
+        width: Option<CanAsterisk<usize>>,
+        precision: Option<CanAsterisk<usize>>,
+        positive_sign: PositiveSign,
+        alignment: NumberAlignment,
+    },
+    UnsignedInt {
+        position: ArgumentLocation,
+        variant: UnsignedIntVariant,
+        width: Option<CanAsterisk<usize>>,
+        precision: Option<CanAsterisk<usize>>,
+        alignment: NumberAlignment,
+    },
+    Float {
+        position: ArgumentLocation,
+        variant: FloatVariant,
+        case: Case,
+        force_decimal: ForceDecimal,
+        width: Option<CanAsterisk<usize>>,
+        positive_sign: PositiveSign,
+        alignment: NumberAlignment,
+        precision: Option<CanAsterisk<usize>>,
+    },
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ArgumentLocation {
+    NextArgument,
+    Position(NonZero<usize>),
+}
+
+/// Precision and width specified might use an asterisk to indicate that they are
+/// determined by an argument.
+#[derive(Clone, Copy, Debug)]
+pub enum CanAsterisk<T> {
+    Fixed(T),
+    Asterisk(ArgumentLocation),
+}
+
+/// Size of the expected type (ignored)
+///
+/// We ignore this parameter entirely, but we do parse it.
+/// It could be used in the future if the need arises.
+enum Length {
+    /// signed/unsigned char ("hh")
+    Char,
+    /// signed/unsigned short int ("h")
+    Short,
+    /// signed/unsigned long int ("l")
+    Long,
+    /// signed/unsigned long long int ("ll")
+    LongLong,
+    /// intmax_t ("j")
+    IntMaxT,
+    /// size_t ("z")
+    SizeT,
+    /// ptrdiff_t ("t")
+    PtfDiffT,
+    /// long double ("L")
+    LongDouble,
+}
+
+#[derive(Default, PartialEq, Eq)]
+struct Flags {
+    minus: bool,
+    plus: bool,
+    space: bool,
+    hash: bool,
+    zero: bool,
+    quote: bool,
+}
+
+impl Flags {
+    pub fn parse(rest: &mut &[u8], index: &mut usize) -> Self {
+        let mut flags = Self::default();
+
+        while let Some(x) = rest.get(*index) {
+            match x {
+                b'-' => flags.minus = true,
+                b'+' => flags.plus = true,
+                b' ' => flags.space = true,
+                b'#' => flags.hash = true,
+                b'0' => flags.zero = true,
+                b'\'' => {
+                    // the thousands separator is printed with numbers using the ' flag, but
+                    // this is a no-op in the "C" locale. We only save this flag for reporting errors
+                    flags.quote = true;
+                }
+                _ => break,
+            }
+            *index += 1;
+        }
+
+        flags
+    }
+
+    /// Whether any of the flags is set to true
+    fn any(&self) -> bool {
+        self != &Self::default()
+    }
+}
+
+impl Spec {
+    pub fn parse<'a>(rest: &mut &'a [u8]) -> Result<Self, &'a [u8]> {
+        // Based on the C++ reference and the Single UNIX Specification,
+        // the spec format looks like:
+        //
+        //   %[argumentNum$][flags][width][.precision][length]specifier
+        //
+        // However, we have already parsed the '%'.
+        let mut index = 0;
+        let start = *rest;
+
+        // Check for a positional specifier (%m$)
+        let Some(position) = eat_argument_position(rest, &mut index) else {
+            return Err(&start[..index]);
+        };
+
+        let flags = Flags::parse(rest, &mut index);
+
+        let positive_sign = match flags {
+            Flags { plus: true, .. } => PositiveSign::Plus,
+            Flags { space: true, .. } => PositiveSign::Space,
+            _ => PositiveSign::None,
+        };
+
+        let width = eat_asterisk_or_number(rest, &mut index);
+
+        let precision = if let Some(b'.') = rest.get(index) {
+            index += 1;
+            Some(eat_asterisk_or_number(rest, &mut index).unwrap_or(CanAsterisk::Fixed(0)))
+        } else {
+            None
+        };
+
+        // The `0` flag is ignored if `-` is given or a precision is specified.
+        // So the only case for RightZero, is when `-` is not given and the
+        // precision is none.
+        let alignment = if flags.minus {
+            NumberAlignment::Left
+        } else if flags.zero && precision.is_none() {
+            NumberAlignment::RightZero
+        } else {
+            NumberAlignment::RightSpace
+        };
+
+        // We ignore the length. It's not really relevant to printf
+        let _ = Self::parse_length(rest, &mut index);
+
+        let Some(type_spec) = rest.get(index) else {
+            return Err(&start[..index]);
+        };
+        index += 1;
+        *rest = &start[index..];
+
+        Ok(match type_spec {
+            // GNU accepts minus, plus and space even though they are not used
+            b'c' => {
+                if flags.zero || flags.hash || precision.is_some() {
+                    return Err(&start[..index]);
+                }
+                Self::Char {
+                    position,
+                    width,
+                    align_left: flags.minus,
+                }
+            }
+            b's' => {
+                if flags.zero || flags.hash || flags.quote {
+                    return Err(&start[..index]);
+                }
+                Self::String {
+                    position,
+                    precision,
+                    width,
+                    align_left: flags.minus,
+                }
+            }
+            b'b' => {
+                if flags.any() || width.is_some() || precision.is_some() {
+                    return Err(&start[..index]);
+                }
+                Self::EscapedString { position }
+            }
+            b'q' => {
+                if flags.any() || width.is_some() || precision.is_some() {
+                    return Err(&start[..index]);
+                }
+                Self::QuotedString { position }
+            }
+            b'd' | b'i' => {
+                if flags.hash {
+                    return Err(&start[..index]);
+                }
+                Self::SignedInt {
+                    position,
+                    width,
+                    precision,
+                    alignment,
+                    positive_sign,
+                }
+            }
+            c @ (b'u' | b'o' | b'x' | b'X') => {
+                // Normal unsigned integer cannot have a prefix
+                if *c == b'u' && flags.hash {
+                    return Err(&start[..index]);
+                }
+                let prefix = if flags.hash { Prefix::Yes } else { Prefix::No };
+                let variant = match c {
+                    b'u' => UnsignedIntVariant::Decimal,
+                    b'o' => UnsignedIntVariant::Octal(prefix),
+                    b'x' => UnsignedIntVariant::Hexadecimal(Case::Lowercase, prefix),
+                    b'X' => UnsignedIntVariant::Hexadecimal(Case::Uppercase, prefix),
+                    _ => unreachable!(),
+                };
+                Self::UnsignedInt {
+                    position,
+                    variant,
+                    precision,
+                    width,
+                    alignment,
+                }
+            }
+            c @ (b'f' | b'F' | b'e' | b'E' | b'g' | b'G' | b'a' | b'A') => Self::Float {
+                position,
+                width,
+                precision,
+                variant: match c {
+                    b'f' | b'F' => FloatVariant::Decimal,
+                    b'e' | b'E' => FloatVariant::Scientific,
+                    b'g' | b'G' => FloatVariant::Shortest,
+                    b'a' | b'A' => FloatVariant::Hexadecimal,
+                    _ => unreachable!(),
+                },
+                force_decimal: if flags.hash {
+                    ForceDecimal::Yes
+                } else {
+                    ForceDecimal::No
+                },
+                case: if c.is_ascii_uppercase() {
+                    Case::Uppercase
+                } else {
+                    Case::Lowercase
+                },
+                alignment: if flags.zero && !flags.minus {
+                    NumberAlignment::RightZero // float should always try to zero pad despite the precision
+                } else {
+                    alignment
+                },
+                positive_sign,
+            },
+            _ => return Err(&start[..index]),
+        })
+    }
+
+    fn parse_length(rest: &mut &[u8], index: &mut usize) -> Option<Length> {
+        // Parse 0..N length options, keep the last one
+        // Even though it is just ignored. We might want to use it later and we
+        // should parse those characters.
+        //
+        // TODO: This needs to be configurable: `seq` accepts only one length
+        //       param
+        let mut length = None;
+        loop {
+            let new_length = rest.get(*index).and_then(|c| {
+                Some(match c {
+                    b'h' => {
+                        if let Some(b'h') = rest.get(*index + 1) {
+                            *index += 1;
+                            Length::Char
+                        } else {
+                            Length::Short
+                        }
+                    }
+                    b'l' => {
+                        if let Some(b'l') = rest.get(*index + 1) {
+                            *index += 1;
+                            Length::Long
+                        } else {
+                            Length::LongLong
+                        }
+                    }
+                    b'j' => Length::IntMaxT,
+                    b'z' => Length::SizeT,
+                    b't' => Length::PtfDiffT,
+                    b'L' => Length::LongDouble,
+                    _ => return None,
+                })
+            });
+            if new_length.is_some() {
+                *index += 1;
+                length = new_length;
+            } else {
+                break;
+            }
+        }
+        length
+    }
+
+    pub fn write(
+        &self,
+        mut writer: impl Write,
+        args: &mut FormatArguments,
+    ) -> Result<(), FormatError> {
+        match self {
+            Self::Char {
+                width,
+                align_left,
+                position,
+            } => {
+                let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or_default();
+                write_padded(
+                    writer,
+                    &[args.next_char(position)],
+                    width,
+                    *align_left || neg_width,
+                )
+            }
+            Self::String {
+                width,
+                align_left,
+                precision,
+                position,
+            } => {
+                let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or_default();
+
+                // GNU does do this truncation on a byte level, see for instance:
+                //     printf "%.1s" 🙃
+                //     > �
+                // For now, we let printf panic when we truncate within a code point.
+                // TODO: We need to not use Rust's formatting for aligning the output,
+                // so that we can just write bytes to stdout without panicking.
+                let precision = resolve_asterisk_precision(*precision, args);
+                let s = args.next_string(position);
+                let truncated = match precision {
+                    Some(p) if p < s.len() => &s[..p],
+                    _ => s,
+                };
+                write_padded(
+                    writer,
+                    truncated.as_bytes(),
+                    width,
+                    *align_left || neg_width,
+                )
+            }
+            Self::EscapedString { position } => {
+                let s = args.next_string(position);
+                let mut parsed = Vec::new();
+                for c in parse_escape_only(s.as_bytes(), OctalParsing::ThreeDigits) {
+                    match c.write(&mut parsed)? {
+                        ControlFlow::Continue(()) => {}
+                        ControlFlow::Break(()) => {
+                            // TODO: This should break the _entire execution_ of printf
+                            break;
+                        }
+                    };
+                }
+                writer.write_all(&parsed).map_err(FormatError::IoError)
+            }
+            Self::QuotedString { position } => {
+                let s = escape_name(
+                    args.next_string(position).as_ref(),
+                    &QuotingStyle::Shell {
+                        escape: true,
+                        always_quote: false,
+                        show_control: false,
+                    },
+                );
+                #[cfg(unix)]
+                let bytes = std::os::unix::ffi::OsStringExt::into_vec(s);
+                #[cfg(not(unix))]
+                let bytes = s.to_string_lossy().as_bytes().to_owned();
+
+                writer.write_all(&bytes).map_err(FormatError::IoError)
+            }
+            Self::SignedInt {
+                width,
+                precision,
+                positive_sign,
+                alignment,
+                position,
+            } => {
+                let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or((0, false));
+                let precision = resolve_asterisk_precision(*precision, args).unwrap_or_default();
+                let i = args.next_i64(position);
+
+                if precision as u64 > i32::MAX as u64 {
+                    return Err(FormatError::InvalidPrecision(precision.to_string()));
+                }
+
+                num_format::SignedInt {
+                    width,
+                    precision,
+                    positive_sign: *positive_sign,
+                    alignment: if neg_width {
+                        NumberAlignment::Left
+                    } else {
+                        *alignment
+                    },
+                }
+                .fmt(writer, i)
+                .map_err(FormatError::IoError)
+            }
+            Self::UnsignedInt {
+                variant,
+                width,
+                precision,
+                alignment,
+                position,
+            } => {
+                let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or((0, false));
+                let precision = resolve_asterisk_precision(*precision, args).unwrap_or_default();
+                let i = args.next_u64(position);
+
+                if precision as u64 > i32::MAX as u64 {
+                    return Err(FormatError::InvalidPrecision(precision.to_string()));
+                }
+
+                num_format::UnsignedInt {
+                    variant: *variant,
+                    precision,
+                    width,
+                    alignment: if neg_width {
+                        NumberAlignment::Left
+                    } else {
+                        *alignment
+                    },
+                }
+                .fmt(writer, i)
+                .map_err(FormatError::IoError)
+            }
+            Self::Float {
+                variant,
+                case,
+                force_decimal,
+                width,
+                positive_sign,
+                alignment,
+                precision,
+                position,
+            } => {
+                let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or((0, false));
+                let precision = resolve_asterisk_precision(*precision, args);
+                let f: ExtendedBigDecimal = args.next_extended_big_decimal(position);
+
+                if precision.is_some_and(|p| p as u64 > i32::MAX as u64) {
+                    return Err(FormatError::InvalidPrecision(
+                        precision.unwrap().to_string(),
+                    ));
+                }
+
+                num_format::Float {
+                    width,
+                    precision,
+                    variant: *variant,
+                    case: *case,
+                    force_decimal: *force_decimal,
+                    positive_sign: *positive_sign,
+                    alignment: if neg_width {
+                        NumberAlignment::Left
+                    } else {
+                        *alignment
+                    },
+                }
+                .fmt(writer, &f)
+                .map_err(FormatError::IoError)
+            }
+        }
+    }
+}
+
+/// Determine the width, potentially getting a value from args
+/// Returns the non-negative width and whether the value should be left-aligned.
+fn resolve_asterisk_width(
+    option: Option<CanAsterisk<usize>>,
+    args: &mut FormatArguments,
+) -> Option<(usize, bool)> {
+    match option {
+        None => None,
+        Some(CanAsterisk::Asterisk(loc)) => {
+            let nb = args.next_i64(&loc);
+            if nb < 0 {
+                Some((usize::try_from(-(nb as isize)).ok().unwrap_or(0), true))
+            } else {
+                Some((usize::try_from(nb).ok().unwrap_or(0), false))
+            }
+        }
+        Some(CanAsterisk::Fixed(w)) => Some((w, false)),
+    }
+}
+
+/// Determines the precision, which should (if defined)
+/// be a non-negative number.
+fn resolve_asterisk_precision(
+    option: Option<CanAsterisk<usize>>,
+    args: &mut FormatArguments,
+) -> Option<usize> {
+    match option {
+        None => None,
+        Some(CanAsterisk::Asterisk(loc)) => match args.next_i64(&loc) {
+            v if v >= 0 => usize::try_from(v).ok(),
+            v if v < 0 => Some(0usize),
+            _ => None,
+        },
+        Some(CanAsterisk::Fixed(w)) => Some(w),
+    }
+}
+
+fn write_padded(
+    mut writer: impl Write,
+    text: &[u8],
+    width: usize,
+    left: bool,
+) -> Result<(), FormatError> {
+    let padlen = width.saturating_sub(text.len());
+    if left {
+        writer.write_all(text)?;
+        write!(writer, "{: <padlen$}", "")
+    } else {
+        write!(writer, "{: >padlen$}", "")?;
+        writer.write_all(text)
+    }
+    .map_err(FormatError::IoError)
+}
+
+// Check for a number ending with a '$'
+fn eat_argument_position(rest: &mut &[u8], index: &mut usize) -> Option<ArgumentLocation> {
+    let original_index = *index;
+    if let Some(pos) = eat_number(rest, index) {
+        if let Some(&b'$') = rest.get(*index) {
+            *index += 1;
+            Some(ArgumentLocation::Position(NonZero::new(pos)?))
+        } else {
+            *index = original_index;
+            Some(ArgumentLocation::NextArgument)
+        }
+    } else {
+        *index = original_index;
+        Some(ArgumentLocation::NextArgument)
+    }
+}
+
+fn eat_asterisk_or_number(rest: &mut &[u8], index: &mut usize) -> Option<CanAsterisk<usize>> {
+    if let Some(b'*') = rest.get(*index) {
+        *index += 1;
+        // Check for a positional specifier (*m$)
+        Some(CanAsterisk::Asterisk(eat_argument_position(rest, index)?))
+    } else {
+        eat_number(rest, index).map(CanAsterisk::Fixed)
+    }
+}
+
+fn eat_number(rest: &mut &[u8], index: &mut usize) -> Option<usize> {
+    match rest[*index..].iter().position(|b| !b.is_ascii_digit()) {
+        None | Some(0) => None,
+        Some(i) => {
+            // TODO: This might need to handle errors better
+            // For example in case of overflow.
+            let parsed = std::str::from_utf8(&rest[*index..(*index + i)])
+                .unwrap()
+                .parse()
+                .unwrap();
+            *index += i;
+            Some(parsed)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod resolve_asterisk_width {
+        use super::*;
+        use crate::format::FormatArgument;
+
+        #[test]
+        fn no_width() {
+            assert_eq!(
+                None,
+                resolve_asterisk_width(None, &mut FormatArguments::new(&[]))
+            );
+        }
+
+        #[test]
+        fn fixed_width() {
+            assert_eq!(
+                Some((42, false)),
+                resolve_asterisk_width(
+                    Some(CanAsterisk::Fixed(42)),
+                    &mut FormatArguments::new(&[])
+                )
+            );
+        }
+
+        #[test]
+        fn asterisks_with_numbers() {
+            assert_eq!(
+                Some((42, false)),
+                resolve_asterisk_width(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::SignedInt(42)]),
+                )
+            );
+            assert_eq!(
+                Some((42, false)),
+                resolve_asterisk_width(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::Unparsed("42".to_string())]),
+                )
+            );
+
+            assert_eq!(
+                Some((42, true)),
+                resolve_asterisk_width(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::SignedInt(-42)]),
+                )
+            );
+            assert_eq!(
+                Some((42, true)),
+                resolve_asterisk_width(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::Unparsed("-42".to_string())]),
+                )
+            );
+
+            assert_eq!(
+                Some((2, false)),
+                resolve_asterisk_width(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::Position(
+                        NonZero::new(2).unwrap()
+                    ))),
+                    &mut FormatArguments::new(&[
+                        FormatArgument::Unparsed("1".to_string()),
+                        FormatArgument::Unparsed("2".to_string()),
+                        FormatArgument::Unparsed("3".to_string())
+                    ]),
+                )
+            );
+        }
+    }
+
+    mod resolve_asterisk_precision {
+        use super::*;
+        use crate::format::FormatArgument;
+
+        #[test]
+        fn no_width() {
+            assert_eq!(
+                None,
+                resolve_asterisk_precision(None, &mut FormatArguments::new(&[]))
+            );
+        }
+
+        #[test]
+        fn fixed_width() {
+            assert_eq!(
+                Some(42),
+                resolve_asterisk_precision(
+                    Some(CanAsterisk::Fixed(42)),
+                    &mut FormatArguments::new(&[])
+                )
+            );
+        }
+
+        #[test]
+        fn asterisks_with_numbers() {
+            assert_eq!(
+                Some(42),
+                resolve_asterisk_precision(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::SignedInt(42)]),
+                )
+            );
+            assert_eq!(
+                Some(42),
+                resolve_asterisk_precision(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::Unparsed("42".to_string())]),
+                )
+            );
+
+            assert_eq!(
+                Some(0),
+                resolve_asterisk_precision(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::SignedInt(-42)]),
+                )
+            );
+            assert_eq!(
+                Some(0),
+                resolve_asterisk_precision(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                    &mut FormatArguments::new(&[FormatArgument::Unparsed("-42".to_string())]),
+                )
+            );
+            assert_eq!(
+                Some(2),
+                resolve_asterisk_precision(
+                    Some(CanAsterisk::Asterisk(ArgumentLocation::Position(
+                        NonZero::new(2).unwrap()
+                    ))),
+                    &mut FormatArguments::new(&[
+                        FormatArgument::Unparsed("1".to_string()),
+                        FormatArgument::Unparsed("2".to_string()),
+                        FormatArgument::Unparsed("3".to_string())
+                    ]),
+                )
+            );
+        }
+    }
+}
diff --git a/src/uucore/src/lib/features/fs.rs b/src/uucore/src/lib/features/fs.rs
index 3def63ad6b1..5c228376d02 100644
--- a/src/uucore/src/lib/features/fs.rs
+++ b/src/uucore/src/lib/features/fs.rs
@@ -3,28 +3,32 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-//! Set of functions to manage files and symlinks
+//! Set of functions to manage regular files, special files, and links.
 
 // spell-checker:ignore backport
 
 #[cfg(unix)]
 use libc::{
-    mode_t, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRGRP,
-    S_IROTH, S_IRUSR, S_ISGID, S_ISUID, S_ISVTX, S_IWGRP, S_IWOTH, S_IWUSR, S_IXGRP, S_IXOTH,
-    S_IXUSR,
+    S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRGRP, S_IROTH,
+    S_IRUSR, S_ISGID, S_ISUID, S_ISVTX, S_IWGRP, S_IWOTH, S_IWUSR, S_IXGRP, S_IXOTH, S_IXUSR,
+    mkfifo, mode_t,
 };
-use std::borrow::Cow;
 use std::collections::HashSet;
 use std::collections::VecDeque;
 use std::env;
+#[cfg(unix)]
+use std::ffi::CString;
 use std::ffi::{OsStr, OsString};
 use std::fs;
 use std::fs::read_dir;
 use std::hash::Hash;
+use std::io::Stdin;
 use std::io::{Error, ErrorKind, Result as IOResult};
 #[cfg(unix)]
-use std::os::unix::{fs::MetadataExt, io::AsRawFd};
-use std::path::{Component, Path, PathBuf, MAIN_SEPARATOR};
+use std::os::fd::AsFd;
+#[cfg(unix)]
+use std::os::unix::fs::MetadataExt;
+use std::path::{Component, MAIN_SEPARATOR, Path, PathBuf};
 #[cfg(target_os = "windows")]
 use winapi_util::AsHandleRef;
 
@@ -48,8 +52,8 @@ pub struct FileInformation(
 impl FileInformation {
     /// Get information from a currently open file
     #[cfg(unix)]
-    pub fn from_file(file: &impl AsRawFd) -> IOResult<Self> {
-        let stat = nix::sys::stat::fstat(file.as_raw_fd())?;
+    pub fn from_file(file: &impl AsFd) -> IOResult<Self> {
+        let stat = nix::sys::stat::fstat(file)?;
         Ok(Self(stat))
     }
 
@@ -112,10 +116,17 @@ impl FileInformation {
         #[cfg(all(
             unix,
             not(target_vendor = "apple"),
+            not(target_os = "aix"),
             not(target_os = "android"),
             not(target_os = "freebsd"),
+            not(target_os = "netbsd"),
+            not(target_os = "openbsd"),
+            not(target_os = "illumos"),
+            not(target_os = "solaris"),
             not(target_arch = "aarch64"),
             not(target_arch = "riscv64"),
+            not(target_arch = "loongarch64"),
+            not(target_arch = "sparc64"),
             target_pointer_width = "64"
         ))]
         return self.0.st_nlink;
@@ -125,21 +136,36 @@ impl FileInformation {
                 target_vendor = "apple",
                 target_os = "android",
                 target_os = "freebsd",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "illumos",
+                target_os = "solaris",
                 target_arch = "aarch64",
                 target_arch = "riscv64",
+                target_arch = "loongarch64",
+                target_arch = "sparc64",
                 not(target_pointer_width = "64")
             )
         ))]
         return self.0.st_nlink.into();
+        #[cfg(target_os = "aix")]
+        return self.0.st_nlink.try_into().unwrap();
         #[cfg(windows)]
         return self.0.number_of_links();
     }
 
     #[cfg(unix)]
     pub fn inode(&self) -> u64 {
-        #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+        #[cfg(all(
+            not(any(target_os = "freebsd", target_os = "netbsd")),
+            target_pointer_width = "64"
+        ))]
         return self.0.st_ino;
-        #[cfg(any(target_os = "freebsd", not(target_pointer_width = "64")))]
+        #[cfg(any(
+            target_os = "freebsd",
+            target_os = "netbsd",
+            not(target_pointer_width = "64")
+        ))]
         return self.0.st_ino.into();
     }
 }
@@ -176,30 +202,6 @@ impl Hash for FileInformation {
     }
 }
 
-/// resolve a relative path
-pub fn resolve_relative_path(path: &Path) -> Cow<Path> {
-    if path.components().all(|e| e != Component::ParentDir) {
-        return path.into();
-    }
-    let root = Component::RootDir.as_os_str();
-    let mut result = env::current_dir().unwrap_or_else(|_| PathBuf::from(root));
-    for comp in path.components() {
-        match comp {
-            Component::ParentDir => {
-                if let Ok(p) = result.read_link() {
-                    result = p;
-                }
-                result.pop();
-            }
-            Component::CurDir => (),
-            Component::RootDir | Component::Normal(_) | Component::Prefix(_) => {
-                result.push(comp.as_os_str());
-            }
-        }
-    }
-    result.into()
-}
-
 /// Controls how symbolic links should be handled when canonicalizing a path.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum MissingHandling {
@@ -234,7 +236,7 @@ pub enum ResolveMode {
 /// replace this once that lands
 pub fn normalize_path(path: &Path) -> PathBuf {
     let mut components = path.components().peekable();
-    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
+    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().copied() {
         components.next();
         PathBuf::from(c.as_os_str())
     } else {
@@ -426,6 +428,7 @@ pub fn canonicalize<P: AsRef<Path>>(
 }
 
 #[cfg(not(unix))]
+/// Display the permissions of a file
 pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) -> String {
     let write = if metadata.permissions().readonly() {
         '-'
@@ -450,12 +453,40 @@ pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) ->
 
 #[cfg(unix)]
 /// Display the permissions of a file
-/// On non unix like system, just show '----------'
 pub fn display_permissions(metadata: &fs::Metadata, display_file_type: bool) -> String {
     let mode: mode_t = metadata.mode() as mode_t;
     display_permissions_unix(mode, display_file_type)
 }
 
+/// Returns a character representation of the file type based on its mode.
+/// This function is specific to Unix-like systems.
+///
+/// - `mode`: The mode of the file, typically obtained from file metadata.
+///
+/// # Returns
+/// - 'd' for directories
+/// - 'c' for character devices
+/// - 'b' for block devices
+/// - '-' for regular files
+/// - 'p' for FIFOs (named pipes)
+/// - 'l' for symbolic links
+/// - 's' for sockets
+/// - '?' for any other unrecognized file types
+#[cfg(unix)]
+fn get_file_display(mode: mode_t) -> char {
+    match mode & S_IFMT {
+        S_IFDIR => 'd',
+        S_IFCHR => 'c',
+        S_IFBLK => 'b',
+        S_IFREG => '-',
+        S_IFIFO => 'p',
+        S_IFLNK => 'l',
+        S_IFSOCK => 's',
+        // TODO: Other file types
+        _ => '?',
+    }
+}
+
 // The logic below is more readable written this way.
 #[allow(clippy::if_not_else)]
 #[allow(clippy::cognitive_complexity)]
@@ -465,17 +496,7 @@ pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String
     let mut result;
     if display_file_type {
         result = String::with_capacity(10);
-        result.push(match mode & S_IFMT {
-            S_IFDIR => 'd',
-            S_IFCHR => 'c',
-            S_IFBLK => 'b',
-            S_IFREG => '-',
-            S_IFIFO => 'p',
-            S_IFLNK => 'l',
-            S_IFSOCK => 's',
-            // TODO: Other file types
-            _ => '?',
-        });
+        result.push(get_file_display(mode));
     } else {
         result = String::with_capacity(9);
     }
@@ -483,11 +504,7 @@ pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String
     result.push(if has!(mode, S_IRUSR) { 'r' } else { '-' });
     result.push(if has!(mode, S_IWUSR) { 'w' } else { '-' });
     result.push(if has!(mode, S_ISUID as mode_t) {
-        if has!(mode, S_IXUSR) {
-            's'
-        } else {
-            'S'
-        }
+        if has!(mode, S_IXUSR) { 's' } else { 'S' }
     } else if has!(mode, S_IXUSR) {
         'x'
     } else {
@@ -497,11 +514,7 @@ pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String
     result.push(if has!(mode, S_IRGRP) { 'r' } else { '-' });
     result.push(if has!(mode, S_IWGRP) { 'w' } else { '-' });
     result.push(if has!(mode, S_ISGID as mode_t) {
-        if has!(mode, S_IXGRP) {
-            's'
-        } else {
-            'S'
-        }
+        if has!(mode, S_IXGRP) { 's' } else { 'S' }
     } else if has!(mode, S_IXGRP) {
         'x'
     } else {
@@ -511,11 +524,7 @@ pub fn display_permissions_unix(mode: mode_t, display_file_type: bool) -> String
     result.push(if has!(mode, S_IROTH) { 'r' } else { '-' });
     result.push(if has!(mode, S_IWOTH) { 'w' } else { '-' });
     result.push(if has!(mode, S_ISVTX as mode_t) {
-        if has!(mode, S_IXOTH) {
-            't'
-        } else {
-            'T'
-        }
+        if has!(mode, S_IXOTH) { 't' } else { 'T' }
     } else if has!(mode, S_IXOTH) {
         'x'
     } else {
@@ -635,14 +644,10 @@ pub fn are_hardlinks_to_same_file(_source: &Path, _target: &Path) -> bool {
 /// * `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::symlink_metadata(source) {
-        Ok(metadata) => metadata,
-        Err(_) => return false,
-    };
-
-    let target_metadata = match fs::symlink_metadata(target) {
-        Ok(metadata) => metadata,
-        Err(_) => return false,
+    let (Ok(source_metadata), Ok(target_metadata)) =
+        (fs::symlink_metadata(source), fs::symlink_metadata(target))
+    else {
+        return false;
     };
 
     source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
@@ -665,19 +670,169 @@ pub fn are_hardlinks_or_one_way_symlink_to_same_file(_source: &Path, _target: &P
 /// * `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,
+    let (Ok(source_metadata), Ok(target_metadata)) =
+        (fs::metadata(source), fs::symlink_metadata(target))
+    else {
+        return false;
     };
 
     source_metadata.ino() == target_metadata.ino() && source_metadata.dev() == target_metadata.dev()
 }
 
+/// Returns true if the passed `path` ends with a path terminator.
+///
+/// This function examines the last character of the path to determine
+/// if it is a directory separator. It supports both Unix-style (`/`)
+/// and Windows-style (`\`) separators.
+///
+/// # Arguments
+///
+/// * `path` - A reference to the path to be checked.
+#[cfg(unix)]
+pub fn path_ends_with_terminator(path: &Path) -> bool {
+    use std::os::unix::prelude::OsStrExt;
+    path.as_os_str()
+        .as_bytes()
+        .last()
+        .is_some_and(|&byte| byte == b'/' || byte == b'\\')
+}
+
+#[cfg(windows)]
+pub fn path_ends_with_terminator(path: &Path) -> bool {
+    use std::os::windows::prelude::OsStrExt;
+    path.as_os_str()
+        .encode_wide()
+        .last()
+        .is_some_and(|wide| wide == b'/'.into() || wide == b'\\'.into())
+}
+
+/// Checks if the standard input (stdin) is a directory.
+///
+/// # Arguments
+///
+/// * `stdin` - A reference to the standard input handle.
+///
+/// # Returns
+///
+/// * `bool` - Returns `true` if stdin is a directory, `false` otherwise.
+pub fn is_stdin_directory(stdin: &Stdin) -> bool {
+    #[cfg(unix)]
+    {
+        use nix::sys::stat::fstat;
+        let mode = fstat(stdin.as_fd()).unwrap().st_mode as mode_t;
+        has!(mode, S_IFDIR)
+    }
+
+    #[cfg(windows)]
+    {
+        use std::os::windows::io::AsRawHandle;
+        let handle = stdin.as_raw_handle();
+        if let Ok(metadata) = fs::metadata(format!("{}", handle as usize)) {
+            return metadata.is_dir();
+        }
+        false
+    }
+}
+
+pub mod sane_blksize {
+
+    #[cfg(not(target_os = "windows"))]
+    use std::os::unix::fs::MetadataExt;
+    use std::{fs::metadata, path::Path};
+
+    pub const DEFAULT: u64 = 512;
+    pub const MAX: u64 = (u32::MAX / 8 + 1) as u64;
+
+    /// Provides sanity checked blksize value from the provided value.
+    ///
+    /// If the provided value is a invalid values a meaningful adaption
+    /// of that value is done.
+    pub fn sane_blksize(st_blksize: u64) -> u64 {
+        match st_blksize {
+            0 => DEFAULT,
+            1..=MAX => st_blksize,
+            _ => DEFAULT,
+        }
+    }
+
+    /// Provides the blksize information from the provided metadata.
+    ///
+    /// If the metadata contain invalid values a meaningful adaption
+    /// of that value is done.
+    pub fn sane_blksize_from_metadata(_metadata: &std::fs::Metadata) -> u64 {
+        #[cfg(not(target_os = "windows"))]
+        {
+            sane_blksize(_metadata.blksize())
+        }
+
+        #[cfg(target_os = "windows")]
+        {
+            DEFAULT
+        }
+    }
+
+    /// Provides the blksize information from given file path's filesystem.
+    ///
+    /// If the metadata can't be fetched or contain invalid values a
+    /// meaningful adaption of that value is done.
+    pub fn sane_blksize_from_path(path: &Path) -> u64 {
+        match metadata(path) {
+            Ok(metadata) => sane_blksize_from_metadata(&metadata),
+            Err(_) => DEFAULT,
+        }
+    }
+}
+
+/// Extracts the filename component from the given `file` path and returns it as an `Option<&str>`.
+///
+/// If the `file` path contains a filename, this function returns `Some(filename)` where `filename` is
+/// the extracted filename as a string slice (`&str`). If the `file` path does not have a filename
+/// component or if the filename is not valid UTF-8, it returns `None`.
+///
+/// # Arguments
+///
+/// * `file`: A reference to a `Path` representing the file path from which to extract the filename.
+///
+/// # Returns
+///
+/// * `Some(filename)`: If a valid filename exists in the `file` path, where `filename` is the
+///   extracted filename as a string slice (`&str`).
+/// * `None`: If the `file` path does not contain a valid filename or if the filename is not valid UTF-8.
+pub fn get_filename(file: &Path) -> Option<&str> {
+    file.file_name().and_then(|filename| filename.to_str())
+}
+
+/// Make a FIFO, also known as a named pipe.
+///
+/// This is a safe wrapper for the unsafe [`libc::mkfifo`] function,
+/// which makes a [named
+/// pipe](https://en.wikipedia.org/wiki/Named_pipe) on Unix systems.
+///
+/// # Errors
+///
+/// If the named pipe cannot be created.
+///
+/// # Examples
+///
+/// ```ignore
+/// use uucore::fs::make_fifo;
+///
+/// make_fifo("my-pipe").expect("failed to create the named pipe");
+///
+/// std::thread::spawn(|| { std::fs::write("my-pipe", b"hello").unwrap(); });
+/// assert_eq!(std::fs::read("my-pipe").unwrap(), b"hello");
+/// ```
+#[cfg(unix)]
+pub fn make_fifo(path: &Path) -> std::io::Result<()> {
+    let name = CString::new(path.to_str().unwrap()).unwrap();
+    let err = unsafe { mkfifo(name.as_ptr(), 0o666) };
+    if err == -1 {
+        Err(std::io::Error::from_raw_os_error(err))
+    } else {
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     // Note this useful idiom: importing names from outer (for mod tests) scope.
@@ -687,7 +842,9 @@ mod tests {
     #[cfg(unix)]
     use std::os::unix;
     #[cfg(unix)]
-    use tempfile::{tempdir, NamedTempFile};
+    use std::os::unix::fs::FileTypeExt;
+    #[cfg(unix)]
+    use tempfile::{NamedTempFile, tempdir};
 
     struct NormalizePathTestCase<'a> {
         path: &'a str,
@@ -842,7 +999,7 @@ mod tests {
         let path1 = temp_file.path();
         let path2 = temp_file.path();
 
-        assert!(are_hardlinks_to_same_file(&path1, &path2));
+        assert!(are_hardlinks_to_same_file(path1, path2));
     }
 
     #[cfg(unix)]
@@ -857,7 +1014,7 @@ mod tests {
         let path1 = temp_file1.path();
         let path2 = temp_file2.path();
 
-        assert!(!are_hardlinks_to_same_file(&path1, &path2));
+        assert!(!are_hardlinks_to_same_file(path1, path2));
     }
 
     #[cfg(unix)]
@@ -868,8 +1025,76 @@ mod tests {
         let path1 = temp_file.path();
 
         let path2 = temp_file.path().with_extension("hardlink");
-        fs::hard_link(&path1, &path2).unwrap();
+        fs::hard_link(path1, &path2).unwrap();
+
+        assert!(are_hardlinks_to_same_file(path1, &path2));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_get_file_display() {
+        assert_eq!(get_file_display(S_IFDIR | 0o755), 'd');
+        assert_eq!(get_file_display(S_IFCHR | 0o644), 'c');
+        assert_eq!(get_file_display(S_IFBLK | 0o600), 'b');
+        assert_eq!(get_file_display(S_IFREG | 0o777), '-');
+        assert_eq!(get_file_display(S_IFIFO | 0o666), 'p');
+        assert_eq!(get_file_display(S_IFLNK | 0o777), 'l');
+        assert_eq!(get_file_display(S_IFSOCK | 0o600), 's');
+        assert_eq!(get_file_display(0o777), '?');
+    }
+
+    #[test]
+    fn test_path_ends_with_terminator() {
+        // Path ends with a forward slash
+        assert!(path_ends_with_terminator(Path::new("/some/path/")));
+
+        // Path ends with a backslash
+        assert!(path_ends_with_terminator(Path::new("C:\\some\\path\\")));
+
+        // Path does not end with a terminator
+        assert!(!path_ends_with_terminator(Path::new("/some/path")));
+        assert!(!path_ends_with_terminator(Path::new("C:\\some\\path")));
+
+        // Empty path
+        assert!(!path_ends_with_terminator(Path::new("")));
+
+        // Root path
+        assert!(path_ends_with_terminator(Path::new("/")));
+        assert!(path_ends_with_terminator(Path::new("C:\\")));
+    }
 
-        assert!(are_hardlinks_to_same_file(&path1, &path2));
+    #[test]
+    fn test_sane_blksize() {
+        assert_eq!(512, sane_blksize::sane_blksize(0));
+        assert_eq!(512, sane_blksize::sane_blksize(512));
+        assert_eq!(4096, sane_blksize::sane_blksize(4096));
+        assert_eq!(0x2000_0000, sane_blksize::sane_blksize(0x2000_0000));
+        assert_eq!(512, sane_blksize::sane_blksize(0x2000_0001));
+    }
+    #[test]
+    fn test_get_file_name() {
+        let file_path = PathBuf::from("~/foo.txt");
+        assert!(matches!(get_filename(&file_path), Some("foo.txt")));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_make_fifo() {
+        // Create the FIFO in a temporary directory.
+        let tempdir = tempdir().unwrap();
+        let path = tempdir.path().join("f");
+        assert!(make_fifo(&path).is_ok());
+
+        // Check that it is indeed a FIFO.
+        assert!(std::fs::metadata(&path).unwrap().file_type().is_fifo());
+
+        // Check that we can write to it and read from it.
+        //
+        // Write and read need to happen in different threads,
+        // otherwise `write` would block indefinitely while waiting
+        // for the `read`.
+        let path2 = path.clone();
+        std::thread::spawn(move || assert!(std::fs::write(&path2, b"foo").is_ok()));
+        assert_eq!(std::fs::read(&path).unwrap(), b"foo");
     }
 }
diff --git a/src/uucore/src/lib/features/fsext.rs b/src/uucore/src/lib/features/fsext.rs
index 52c079e2ed9..aeeb8d2c2f2 100644
--- a/src/uucore/src/lib/features/fsext.rs
+++ b/src/uucore/src/lib/features/fsext.rs
@@ -5,49 +5,42 @@
 
 //! Set of functions to manage file systems
 
-// spell-checker:ignore DATETIME subsecond (arch) bitrig ; (fs) cifs smbfs
-
-use time::macros::format_description;
-use time::UtcOffset;
-
-pub use crate::*; // import macros from `../../macros.rs`
+// spell-checker:ignore DATETIME getmntinfo subsecond (fs) cifs smbfs
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const LINUX_MTAB: &str = "/etc/mtab";
 #[cfg(any(target_os = "linux", target_os = "android"))]
 const LINUX_MOUNTINFO: &str = "/proc/self/mountinfo";
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
 static MOUNT_OPT_BIND: &str = "bind";
 #[cfg(windows)]
 const MAX_PATH: usize = 266;
-#[cfg(not(unix))]
+#[cfg(windows)]
 static EXIT_ERR: i32 = 1;
 
+#[cfg(any(
+    windows,
+    target_os = "freebsd",
+    target_vendor = "apple",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+#[cfg(windows)]
+use crate::show_warning;
+
 #[cfg(windows)]
 use std::ffi::OsStr;
 #[cfg(windows)]
 use std::os::windows::ffi::OsStrExt;
 #[cfg(windows)]
-use windows_sys::Win32::Foundation::{ERROR_NO_MORE_FILES, INVALID_HANDLE_VALUE};
-#[cfg(windows)]
-use windows_sys::Win32::Storage::FileSystem::{
-    FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, GetDiskFreeSpaceW, GetDriveTypeW,
-    GetVolumeInformationW, GetVolumePathNamesForVolumeNameW, QueryDosDeviceW,
+use windows_sys::Win32::{
+    Foundation::{ERROR_NO_MORE_FILES, INVALID_HANDLE_VALUE},
+    Storage::FileSystem::{
+        FindFirstVolumeW, FindNextVolumeW, FindVolumeClose, GetDiskFreeSpaceW, GetDriveTypeW,
+        GetVolumeInformationW, GetVolumePathNamesForVolumeNameW, QueryDosDeviceW,
+    },
+    System::WindowsProgramming::DRIVE_REMOTE,
 };
-#[cfg(windows)]
-use windows_sys::Win32::System::WindowsProgramming::DRIVE_REMOTE;
-
-// Warning: the pointer has to be used *immediately* or the Vec
-// it points to will be dropped!
-#[cfg(windows)]
-macro_rules! String2LPWSTR {
-    ($str: expr) => {
-        OsStr::new(&$str)
-            .encode_wide()
-            .chain(Some(0))
-            .collect::<Vec<u16>>()
-            .as_ptr()
-    };
-}
 
 #[cfg(windows)]
 #[allow(non_snake_case)]
@@ -56,27 +49,27 @@ fn LPWSTR2String(buf: &[u16]) -> String {
     String::from_utf16(&buf[..len]).unwrap()
 }
 
+#[cfg(windows)]
+fn to_nul_terminated_wide_string(s: impl AsRef<OsStr>) -> Vec<u16> {
+    s.as_ref()
+        .encode_wide()
+        .chain(Some(0))
+        .collect::<Vec<u16>>()
+}
+
 #[cfg(unix)]
 use libc::{
-    mode_t, strerror, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK,
+    S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, mode_t, strerror,
 };
 use std::borrow::Cow;
-use std::convert::{AsRef, From};
-#[cfg(any(
-    target_vendor = "apple",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd",
-    target_os = "linux",
-    target_os = "android",
-))]
+#[cfg(unix)]
 use std::ffi::CStr;
-#[cfg(not(windows))]
+#[cfg(unix)]
 use std::ffi::CString;
 use std::io::Error as IOError;
 #[cfg(unix)]
 use std::mem;
-#[cfg(not(unix))]
+#[cfg(windows)]
 use std::path::Path;
 use std::time::UNIX_EPOCH;
 
@@ -89,8 +82,8 @@ use std::time::UNIX_EPOCH;
 ))]
 pub use libc::statfs as StatFs;
 #[cfg(any(
+    target_os = "aix",
     target_os = "netbsd",
-    target_os = "bitrig",
     target_os = "dragonfly",
     target_os = "illumos",
     target_os = "solaris",
@@ -104,101 +97,68 @@ pub use libc::statvfs as StatFs;
     target_vendor = "apple",
     target_os = "freebsd",
     target_os = "openbsd",
-    target_os = "redox"
 ))]
 pub use libc::statfs as statfs_fn;
 #[cfg(any(
+    target_os = "aix",
     target_os = "netbsd",
-    target_os = "bitrig",
     target_os = "illumos",
     target_os = "solaris",
-    target_os = "dragonfly"
+    target_os = "dragonfly",
+    target_os = "redox"
 ))]
 pub use libc::statvfs as statfs_fn;
 
 pub trait BirthTime {
-    fn pretty_birth(&self) -> String;
-    fn birth(&self) -> u64;
+    fn birth(&self) -> Option<(u64, u32)>;
 }
 
 use std::fs::Metadata;
 impl BirthTime for Metadata {
-    fn pretty_birth(&self) -> String {
-        self.created()
-            .ok()
-            .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
-            .map(|e| pretty_time(e.as_secs() as i64, i64::from(e.subsec_nanos())))
-            .unwrap_or_else(|| "-".to_owned())
-    }
-
-    fn birth(&self) -> u64 {
+    fn birth(&self) -> Option<(u64, u32)> {
         self.created()
             .ok()
             .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
-            .map(|e| e.as_secs())
-            .unwrap_or_default()
+            .map(|e| (e.as_secs(), e.subsec_nanos()))
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct MountInfo {
-    // it stores `volume_name` in windows platform and `dev_id` in unix platform
+    /// Stores `volume_name` in windows platform and `dev_id` in unix platform
     pub dev_id: String,
     pub dev_name: String,
     pub fs_type: String,
-    pub mount_dir: String,
-    pub mount_option: String, // we only care "bind" option
     pub mount_root: String,
+    pub mount_dir: String,
+    /// We only care whether this field contains "bind"
+    pub mount_option: String,
     pub remote: bool,
     pub dummy: bool,
 }
 
-impl MountInfo {
-    fn set_missing_fields(&mut self) {
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::MetadataExt;
-            // We want to keep the dev_id on Windows
-            // but set dev_id
-            if let Ok(stat) = std::fs::metadata(&self.mount_dir) {
-                // Why do we cast this to i32?
-                self.dev_id = (stat.dev() as i32).to_string();
-            } else {
-                self.dev_id = String::new();
-            }
-        }
-        // set MountInfo::dummy
-        // spell-checker:disable
-        match self.fs_type.as_ref() {
-            "autofs" | "proc" | "subfs"
-            /* for Linux 2.6/3.x */
-            | "debugfs" | "devpts" | "fusectl" | "mqueue" | "rpc_pipefs" | "sysfs"
-            /* FreeBSD, Linux 2.4 */
-            | "devfs"
-            /* for NetBSD 3.0 */
-            | "kernfs"
-            /* for Irix 6.5 */
-            | "ignore" => self.dummy = true,
-            _ => self.dummy = self.fs_type == "none"
-                && !self.mount_option.contains(MOUNT_OPT_BIND)
-        }
-        // spell-checker:enable
-        // set MountInfo::remote
-        #[cfg(windows)]
-        {
-            self.remote = DRIVE_REMOTE == unsafe { GetDriveTypeW(String2LPWSTR!(self.mount_root)) };
-        }
-        #[cfg(unix)]
-        {
-            self.remote = self.dev_name.find(':').is_some()
-                || (self.dev_name.starts_with("//") && self.fs_type == "smbfs"
-                    || self.fs_type == "cifs")
-                || self.dev_name == "-hosts";
-        }
-    }
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn replace_special_chars(s: String) -> String {
+    // Replace
+    //
+    // * ASCII space with a regular space character,
+    // * \011 ASCII horizontal tab with a tab character,
+    // * ASCII backslash with an actual backslash character.
+    //
+    s.replace(r#"\040"#, " ")
+        .replace(r#"\011"#, "	")
+        .replace(r#"\134"#, r#"\"#)
+}
 
+impl MountInfo {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     fn new(file_name: &str, raw: &[&str]) -> Option<Self> {
+        let dev_name;
+        let fs_type;
+        let mount_root;
+        let mount_dir;
+        let mount_option;
+
         match file_name {
             // spell-checker:ignore (word) noatime
             // Format: 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
@@ -208,36 +168,38 @@ impl MountInfo {
                 let after_fields = raw[FIELDS_OFFSET..].iter().position(|c| *c == "-").unwrap()
                     + FIELDS_OFFSET
                     + 1;
-                let mut m = Self {
-                    dev_id: String::new(),
-                    dev_name: raw[after_fields + 1].to_string(),
-                    fs_type: raw[after_fields].to_string(),
-                    mount_root: raw[3].to_string(),
-                    mount_dir: raw[4].to_string(),
-                    mount_option: raw[5].to_string(),
-                    remote: false,
-                    dummy: false,
-                };
-                m.set_missing_fields();
-                Some(m)
+                dev_name = raw[after_fields + 1].to_string();
+                fs_type = raw[after_fields].to_string();
+                mount_root = raw[3].to_string();
+                mount_dir = replace_special_chars(raw[4].to_string());
+                mount_option = raw[5].to_string();
             }
             LINUX_MTAB => {
-                let mut m = Self {
-                    dev_id: String::new(),
-                    dev_name: raw[0].to_string(),
-                    fs_type: raw[2].to_string(),
-                    mount_root: String::new(),
-                    mount_dir: raw[1].to_string(),
-                    mount_option: raw[3].to_string(),
-                    remote: false,
-                    dummy: false,
-                };
-                m.set_missing_fields();
-                Some(m)
+                dev_name = raw[0].to_string();
+                fs_type = raw[2].to_string();
+                mount_root = String::new();
+                mount_dir = replace_special_chars(raw[1].to_string());
+                mount_option = raw[3].to_string();
             }
-            _ => None,
-        }
+            _ => return None,
+        };
+
+        let dev_id = mount_dev_id(&mount_dir);
+        let dummy = is_dummy_filesystem(&fs_type, &mount_option);
+        let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+        Some(Self {
+            dev_id,
+            dev_name,
+            fs_type,
+            mount_root,
+            mount_dir,
+            mount_option,
+            remote,
+            dummy,
+        })
     }
+
     #[cfg(windows)]
     fn new(mut volume_name: String) -> Option<Self> {
         let mut dev_name_buf = [0u16; MAX_PATH];
@@ -259,8 +221,9 @@ impl MountInfo {
 
         let mut mount_root_buf = [0u16; MAX_PATH];
         let success = unsafe {
+            let volume_name = to_nul_terminated_wide_string(&volume_name);
             GetVolumePathNamesForVolumeNameW(
-                String2LPWSTR!(volume_name),
+                volume_name.as_ptr(),
                 mount_root_buf.as_mut_ptr(),
                 mount_root_buf.len() as u32,
                 ptr::null_mut(),
@@ -274,8 +237,9 @@ impl MountInfo {
 
         let mut fs_type_buf = [0u16; MAX_PATH];
         let success = unsafe {
+            let mount_root = to_nul_terminated_wide_string(&mount_root);
             GetVolumeInformationW(
-                String2LPWSTR!(mount_root),
+                mount_root.as_ptr(),
                 ptr::null_mut(),
                 0,
                 ptr::null_mut(),
@@ -290,18 +254,21 @@ impl MountInfo {
         } else {
             Some(LPWSTR2String(&fs_type_buf))
         };
-        let mut mn_info = Self {
+        let remote = DRIVE_REMOTE
+            == unsafe {
+                let mount_root = to_nul_terminated_wide_string(&mount_root);
+                GetDriveTypeW(mount_root.as_ptr())
+            };
+        Some(Self {
             dev_id: volume_name,
             dev_name,
             fs_type: fs_type.unwrap_or_default(),
             mount_root,
             mount_dir: String::new(),
             mount_option: String::new(),
-            remote: false,
+            remote,
             dummy: false,
-        };
-        mn_info.set_missing_fields();
-        Some(mn_info)
+        })
     }
 }
 
@@ -309,37 +276,81 @@ impl MountInfo {
     target_os = "freebsd",
     target_vendor = "apple",
     target_os = "netbsd",
-    target_os = "openbsd"
+    target_os = "openbsd",
 ))]
 impl From<StatFs> for MountInfo {
     fn from(statfs: StatFs) -> Self {
-        let mut info = Self {
-            dev_id: String::new(),
-            dev_name: unsafe {
-                // spell-checker:disable-next-line
-                CStr::from_ptr(&statfs.f_mntfromname[0])
-                    .to_string_lossy()
-                    .into_owned()
-            },
-            fs_type: unsafe {
-                // spell-checker:disable-next-line
-                CStr::from_ptr(&statfs.f_fstypename[0])
-                    .to_string_lossy()
-                    .into_owned()
-            },
-            mount_dir: unsafe {
-                // spell-checker:disable-next-line
-                CStr::from_ptr(&statfs.f_mntonname[0])
-                    .to_string_lossy()
-                    .into_owned()
-            },
+        let dev_name = unsafe {
+            // spell-checker:disable-next-line
+            CStr::from_ptr(&statfs.f_mntfromname[0])
+                .to_string_lossy()
+                .into_owned()
+        };
+        let fs_type = unsafe {
+            // spell-checker:disable-next-line
+            CStr::from_ptr(&statfs.f_fstypename[0])
+                .to_string_lossy()
+                .into_owned()
+        };
+        let mount_dir = unsafe {
+            // spell-checker:disable-next-line
+            CStr::from_ptr(&statfs.f_mntonname[0])
+                .to_string_lossy()
+                .into_owned()
+        };
+
+        let dev_id = mount_dev_id(&mount_dir);
+        let dummy = is_dummy_filesystem(&fs_type, "");
+        let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+        Self {
+            dev_id,
+            dev_name,
+            fs_type,
+            mount_dir,
             mount_root: String::new(),
             mount_option: String::new(),
-            remote: false,
-            dummy: false,
-        };
-        info.set_missing_fields();
-        info
+            remote,
+            dummy,
+        }
+    }
+}
+
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
+fn is_dummy_filesystem(fs_type: &str, mount_option: &str) -> bool {
+    // spell-checker:disable
+    match fs_type {
+        "autofs" | "proc" | "subfs"
+        // for Linux 2.6/3.x
+        | "debugfs" | "devpts" | "fusectl" | "mqueue" | "rpc_pipefs" | "sysfs"
+        // FreeBSD, Linux 2.4
+        | "devfs"
+        // for NetBSD 3.0
+        | "kernfs"
+        // for Irix 6.5
+        | "ignore" => true,
+        _ => fs_type == "none"
+            && !mount_option.contains(MOUNT_OPT_BIND)
+    }
+    // spell-checker:enable
+}
+
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
+fn is_remote_filesystem(dev_name: &str, fs_type: &str) -> bool {
+    dev_name.find(':').is_some()
+        || (dev_name.starts_with("//") && fs_type == "smbfs" || fs_type == "cifs")
+        || dev_name == "-hosts"
+}
+
+#[cfg(all(unix, not(any(target_os = "aix", target_os = "redox"))))]
+fn mount_dev_id(mount_dir: &str) -> String {
+    use std::os::unix::fs::MetadataExt;
+
+    if let Ok(stat) = std::fs::metadata(mount_dir) {
+        // Why do we cast this to i32?
+        (stat.dev() as i32).to_string()
+    } else {
+        String::new()
     }
 }
 
@@ -356,21 +367,36 @@ use libc::c_int;
     target_os = "netbsd",
     target_os = "openbsd"
 ))]
-extern "C" {
+unsafe extern "C" {
     #[cfg(all(target_vendor = "apple", target_arch = "x86_64"))]
-    #[link_name = "getmntinfo$INODE64"] // spell-checker:disable-line
+    #[link_name = "getmntinfo$INODE64"]
     fn get_mount_info(mount_buffer_p: *mut *mut StatFs, flags: c_int) -> c_int;
 
     #[cfg(any(
-        target_os = "freebsd",
         target_os = "netbsd",
         target_os = "openbsd",
         all(target_vendor = "apple", target_arch = "aarch64")
     ))]
-    #[link_name = "getmntinfo"] // spell-checker:disable-line
+    #[link_name = "getmntinfo"]
+    fn get_mount_info(mount_buffer_p: *mut *mut StatFs, flags: c_int) -> c_int;
+
+    // Rust on FreeBSD uses 11.x ABI for filesystem metadata syscalls.
+    // Call the right version of the symbol for getmntinfo() result to
+    // match libc StatFS layout.
+    #[cfg(target_os = "freebsd")]
+    #[link_name = "getmntinfo@FBSD_1.0"]
     fn get_mount_info(mount_buffer_p: *mut *mut StatFs, flags: c_int) -> c_int;
 }
 
+use crate::error::UResult;
+#[cfg(any(
+    target_os = "freebsd",
+    target_vendor = "apple",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "windows"
+))]
+use crate::error::USimpleError;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::fs::File;
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -390,8 +416,9 @@ use std::ptr;
     target_os = "openbsd"
 ))]
 use std::slice;
+
 /// Read file system list.
-pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
+pub fn read_fs_list() -> UResult<Vec<MountInfo>> {
     #[cfg(any(target_os = "linux", target_os = "android"))]
     {
         let (file_name, f) = File::open(LINUX_MOUNTINFO)
@@ -417,7 +444,7 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
         let mut mount_buffer_ptr: *mut StatFs = ptr::null_mut();
         let len = unsafe { get_mount_info(&mut mount_buffer_ptr, 1_i32) };
         if len < 0 {
-            crash!(1, "get_mount_info() failed");
+            return Err(USimpleError::new(1, "get_mount_info() failed"));
         }
         let mounts = unsafe { slice::from_raw_parts(mount_buffer_ptr, len as usize) };
         Ok(mounts
@@ -432,17 +459,15 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
         let find_handle =
             unsafe { FindFirstVolumeW(volume_name_buf.as_mut_ptr(), volume_name_buf.len() as u32) };
         if INVALID_HANDLE_VALUE == find_handle {
-            crash!(
-                EXIT_ERR,
-                "FindFirstVolumeW failed: {}",
-                IOError::last_os_error()
-            );
+            let os_err = IOError::last_os_error();
+            let msg = format!("FindFirstVolumeW failed: {os_err}");
+            return Err(USimpleError::new(EXIT_ERR, msg));
         }
         let mut mounts = Vec::<MountInfo>::new();
         loop {
             let volume_name = LPWSTR2String(&volume_name_buf);
             if !volume_name.starts_with("\\\\?\\") || !volume_name.ends_with('\\') {
-                show_warning!("A bad path was skipped: {}", volume_name);
+                show_warning!("A bad path was skipped: {volume_name}");
                 continue;
             }
             if let Some(m) = MountInfo::new(volume_name) {
@@ -457,7 +482,8 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
             } {
                 let err = IOError::last_os_error();
                 if err.raw_os_error() != Some(ERROR_NO_MORE_FILES as i32) {
-                    crash!(EXIT_ERR, "FindNextVolumeW failed: {}", err);
+                    let msg = format!("FindNextVolumeW failed: {err}");
+                    return Err(USimpleError::new(EXIT_ERR, msg));
                 }
                 break;
             }
@@ -467,7 +493,12 @@ pub fn read_fs_list() -> Result<Vec<MountInfo>, std::io::Error> {
         }
         Ok(mounts)
     }
-    #[cfg(any(target_os = "redox", target_os = "illumos", target_os = "solaris"))]
+    #[cfg(any(
+        target_os = "aix",
+        target_os = "redox",
+        target_os = "illumos",
+        target_os = "solaris"
+    ))]
     {
         // No method to read mounts, yet
         Ok(Vec::new())
@@ -489,7 +520,10 @@ impl FsUsage {
     #[cfg(unix)]
     pub fn new(statvfs: StatFs) -> Self {
         {
-            #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+            #[cfg(all(
+                not(any(target_os = "freebsd", target_os = "openbsd")),
+                target_pointer_width = "64"
+            ))]
             return Self {
                 blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
                 blocks: statvfs.f_blocks,
@@ -499,7 +533,10 @@ impl FsUsage {
                 files: statvfs.f_files,
                 ffree: statvfs.f_ffree,
             };
-            #[cfg(all(not(target_os = "freebsd"), not(target_pointer_width = "64")))]
+            #[cfg(all(
+                not(any(target_os = "freebsd", target_os = "openbsd")),
+                not(target_pointer_width = "64")
+            ))]
             return Self {
                 blocksize: statvfs.f_bsize as u64, // or `statvfs.f_frsize` ?
                 blocks: statvfs.f_blocks.into(),
@@ -522,26 +559,40 @@ impl FsUsage {
                 files: statvfs.f_files,
                 ffree: statvfs.f_ffree.try_into().unwrap(),
             };
+            #[cfg(target_os = "openbsd")]
+            return Self {
+                blocksize: statvfs.f_bsize.into(),
+                blocks: statvfs.f_blocks,
+                bfree: statvfs.f_bfree,
+                bavail: statvfs.f_bavail.try_into().unwrap(),
+                bavail_top_bit_set: ((std::convert::TryInto::<u64>::try_into(statvfs.f_bavail)
+                    .unwrap())
+                    & (1u64.rotate_right(1)))
+                    != 0,
+                files: statvfs.f_files,
+                ffree: statvfs.f_ffree,
+            };
         }
     }
-    #[cfg(not(unix))]
-    pub fn new(path: &Path) -> Self {
+    #[cfg(windows)]
+    pub fn new(path: &Path) -> UResult<Self> {
         let mut root_path = [0u16; MAX_PATH];
         let success = unsafe {
+            let path = to_nul_terminated_wide_string(path);
             GetVolumePathNamesForVolumeNameW(
                 //path_utf8.as_ptr(),
-                String2LPWSTR!(path.as_os_str()),
+                path.as_ptr(),
                 root_path.as_mut_ptr(),
                 root_path.len() as u32,
                 ptr::null_mut(),
             )
         };
         if 0 == success {
-            crash!(
-                EXIT_ERR,
+            let msg = format!(
                 "GetVolumePathNamesForVolumeNameW failed: {}",
                 IOError::last_os_error()
             );
+            return Err(USimpleError::new(EXIT_ERR, msg));
         }
 
         let mut sectors_per_cluster = 0;
@@ -549,26 +600,19 @@ impl FsUsage {
         let mut number_of_free_clusters = 0;
         let mut total_number_of_clusters = 0;
 
-        let success = unsafe {
+        unsafe {
+            let path = to_nul_terminated_wide_string(path);
             GetDiskFreeSpaceW(
-                String2LPWSTR!(path.as_os_str()),
+                path.as_ptr(),
                 &mut sectors_per_cluster,
                 &mut bytes_per_sector,
                 &mut number_of_free_clusters,
                 &mut total_number_of_clusters,
-            )
-        };
-        if 0 == success {
-            // Fails in case of CD for example
-            // crash!(
-            //     EXIT_ERR,
-            //     "GetDiskFreeSpaceW failed: {}",
-            //     IOError::last_os_error()
-            // );
+            );
         }
 
         let bytes_per_cluster = sectors_per_cluster as u64 * bytes_per_sector as u64;
-        Self {
+        Ok(Self {
             // f_bsize      File system block size.
             blocksize: bytes_per_cluster,
             // f_blocks - Total number of blocks on the file system, in units of f_frsize.
@@ -583,7 +627,7 @@ impl FsUsage {
             files: 0, // Not available on windows
             // Total number of free file nodes (inodes).
             ffree: 0, // Meaningless on Windows
-        }
+        })
     }
 }
 
@@ -607,8 +651,14 @@ impl FsMeta for StatFs {
         #[cfg(all(
             not(target_env = "musl"),
             not(target_vendor = "apple"),
+            not(target_os = "aix"),
             not(target_os = "android"),
             not(target_os = "freebsd"),
+            not(target_os = "netbsd"),
+            not(target_os = "openbsd"),
+            not(target_os = "illumos"),
+            not(target_os = "solaris"),
+            not(target_os = "redox"),
             not(target_arch = "s390x"),
             target_pointer_width = "64"
         ))]
@@ -616,15 +666,27 @@ impl FsMeta for StatFs {
         #[cfg(all(
             not(target_env = "musl"),
             not(target_os = "freebsd"),
+            not(target_os = "netbsd"),
+            not(target_os = "redox"),
             any(
                 target_arch = "s390x",
                 target_vendor = "apple",
-                target_os = "android",
+                all(target_os = "android", target_pointer_width = "32"),
+                target_os = "openbsd",
                 not(target_pointer_width = "64")
             )
         ))]
         return self.f_bsize.into();
-        #[cfg(any(target_env = "musl", target_os = "freebsd"))]
+        #[cfg(any(
+            target_env = "musl",
+            target_os = "aix",
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "redox",
+            all(target_os = "android", target_pointer_width = "64"),
+        ))]
         return self.f_bsize.try_into().unwrap();
     }
     fn total_blocks(&self) -> u64 {
@@ -640,11 +702,19 @@ impl FsMeta for StatFs {
         return self.f_bfree.into();
     }
     fn avail_blocks(&self) -> u64 {
-        #[cfg(all(not(target_os = "freebsd"), target_pointer_width = "64"))]
+        #[cfg(all(
+            not(target_os = "freebsd"),
+            not(target_os = "openbsd"),
+            target_pointer_width = "64"
+        ))]
         return self.f_bavail;
-        #[cfg(all(not(target_os = "freebsd"), not(target_pointer_width = "64")))]
+        #[cfg(all(
+            not(target_os = "freebsd"),
+            not(target_os = "openbsd"),
+            not(target_pointer_width = "64")
+        ))]
         return self.f_bavail.into();
-        #[cfg(target_os = "freebsd")]
+        #[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
         return self.f_bavail.try_into().unwrap();
     }
     fn total_file_nodes(&self) -> u64 {
@@ -681,14 +751,17 @@ impl FsMeta for StatFs {
             not(target_env = "musl"),
             any(
                 target_vendor = "apple",
-                target_os = "android",
+                all(target_os = "android", target_pointer_width = "32"),
                 target_os = "freebsd",
                 target_arch = "s390x",
                 not(target_pointer_width = "64")
             )
         ))]
         return self.f_type.into();
-        #[cfg(target_env = "musl")]
+        #[cfg(any(
+            target_env = "musl",
+            all(target_os = "android", target_pointer_width = "64"),
+        ))]
         return self.f_type.try_into().unwrap();
     }
     #[cfg(not(any(
@@ -739,9 +812,10 @@ impl FsMeta for StatFs {
         target_os = "openbsd"
     ))]
     fn fsid(&self) -> u64 {
-        let f_fsid: &[u32; 2] =
-            unsafe { &*(&self.f_fsid as *const nix::sys::statfs::fsid_t as *const [u32; 2]) };
-        (u64::from(f_fsid[0])) << 32 | u64::from(f_fsid[1])
+        // Use type inference to determine the type of f_fsid
+        // (libc::__fsid_t on Android, libc::fsid_t on other platforms)
+        let f_fsid: &[u32; 2] = unsafe { &*(&self.f_fsid as *const _ as *const [u32; 2]) };
+        ((u64::from(f_fsid[0])) << 32) | u64::from(f_fsid[1])
     }
     #[cfg(not(any(
         target_vendor = "apple",
@@ -805,51 +879,8 @@ where
     }
 }
 
-// match strftime "%Y-%m-%d %H:%M:%S.%f %z"
-const PRETTY_DATETIME_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "\
-[year]-[month]-[day padding:zero] \
-[hour]:[minute]:[second].[subsecond digits:9] \
-[offset_hour sign:mandatory][offset_minute]"
-);
-
-pub fn pretty_time(sec: i64, nsec: i64) -> String {
-    // sec == seconds since UNIX_EPOCH
-    // nsec == nanoseconds since (UNIX_EPOCH + sec)
-    let ts_nanos: i128 = (sec * 1_000_000_000 + nsec).into();
-
-    // Return the date in UTC
-    let tm = match time::OffsetDateTime::from_unix_timestamp_nanos(ts_nanos) {
-        Ok(tm) => tm,
-        Err(e) => {
-            panic!("error: {e}");
-        }
-    };
-
-    // Get the offset to convert to local time
-    // Because of DST (daylight saving), we get the local time back when
-    // the date was set
-    let local_offset = match UtcOffset::local_offset_at(tm) {
-        Ok(lo) => lo,
-        Err(e) => {
-            panic!("error: {e}");
-        }
-    };
-
-    // Include the conversion to local time
-    let res = tm
-        .to_offset(local_offset)
-        .format(&PRETTY_DATETIME_FORMAT)
-        .unwrap();
-    if res.ends_with(" -0000") {
-        res.replace(" -0000", " +0000")
-    } else {
-        res
-    }
-}
-
 #[cfg(unix)]
-pub fn pretty_filetype<'a>(mode: mode_t, size: u64) -> &'a str {
+pub fn pretty_filetype(mode: mode_t, size: u64) -> String {
     match mode & S_IFMT {
         S_IFREG => {
             if size == 0 {
@@ -865,9 +896,9 @@ pub fn pretty_filetype<'a>(mode: mode_t, size: u64) -> &'a str {
         S_IFIFO => "fifo",
         S_IFSOCK => "socket",
         // TODO: Other file types
-        // See coreutils/gnulib/lib/file-type.c // spell-checker:disable-line
-        _ => "weird file",
+        _ => return format!("weird file ({:07o})", mode & S_IFMT),
     }
+    .to_owned()
 }
 
 pub fn pretty_fstype<'a>(fstype: i64) -> Cow<'a, str> {
@@ -882,6 +913,7 @@ pub fn pretty_fstype<'a>(fstype: i64) -> Cow<'a, str> {
         0x0187 => "autofs".into(),
         0x4246_5331 => "befs".into(),
         0x6264_6576 => "bdevfs".into(),
+        0xCA45_1A4E => "bcachefs".into(),
         0x1BAD_FACE => "bfs".into(),
         0xCAFE_4A11 => "bpf_fs".into(),
         0x4249_4E4D => "binfmt_misc".into(),
@@ -987,6 +1019,7 @@ pub fn pretty_fstype<'a>(fstype: i64) -> Cow<'a, str> {
         0x5846_5342 => "xfs".into(),
         0x012F_D16D => "xia".into(),
         0x2FC1_2FC1 => "zfs".into(),
+        0xDE => "zfs".into(),
         other => format!("UNKNOWN ({other:#x})").into(),
     }
     // spell-checker:enable
@@ -1003,19 +1036,19 @@ mod tests {
         assert_eq!("character special file", pretty_filetype(S_IFCHR, 0));
         assert_eq!("regular file", pretty_filetype(S_IFREG, 1));
         assert_eq!("regular empty file", pretty_filetype(S_IFREG, 0));
-        assert_eq!("weird file", pretty_filetype(0, 0));
+        assert_eq!("weird file (0000000)", pretty_filetype(0, 0));
     }
 
     #[test]
     fn test_fs_type() {
         // spell-checker:disable
         assert_eq!("ext2/ext3", pretty_fstype(0xEF53));
-        assert_eq!("tmpfs", pretty_fstype(0x01021994));
+        assert_eq!("tmpfs", pretty_fstype(0x0102_1994));
         assert_eq!("nfs", pretty_fstype(0x6969));
-        assert_eq!("btrfs", pretty_fstype(0x9123683e));
-        assert_eq!("xfs", pretty_fstype(0x58465342));
-        assert_eq!("zfs", pretty_fstype(0x2FC12FC1));
-        assert_eq!("ntfs", pretty_fstype(0x5346544e));
+        assert_eq!("btrfs", pretty_fstype(0x9123_683e));
+        assert_eq!("xfs", pretty_fstype(0x5846_5342));
+        assert_eq!("zfs", pretty_fstype(0x2FC1_2FC1));
+        assert_eq!("ntfs", pretty_fstype(0x5346_544e));
         assert_eq!("fat", pretty_fstype(0x4006));
         assert_eq!("UNKNOWN (0x1234)", pretty_fstype(0x1234));
         // spell-checker:enable
@@ -1062,4 +1095,28 @@ mod tests {
         assert_eq!(info.fs_type, "xfs");
         assert_eq!(info.dev_name, "/dev/fs0");
     }
+
+    #[test]
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    fn test_mountinfo_dir_special_chars() {
+        let info = MountInfo::new(
+            LINUX_MOUNTINFO,
+            &r#"317 61 7:0 / /mnt/f\134\040\011oo rw,relatime shared:641 - ext4 /dev/loop0 rw"#
+                .split_ascii_whitespace()
+                .collect::<Vec<_>>(),
+        )
+        .unwrap();
+
+        assert_eq!(info.mount_dir, r#"/mnt/f\ 	oo"#);
+
+        let info = MountInfo::new(
+            LINUX_MTAB,
+            &r#"/dev/loop0 /mnt/f\134\040\011oo ext4 rw,relatime 0 0"#
+                .split_ascii_whitespace()
+                .collect::<Vec<_>>(),
+        )
+        .unwrap();
+
+        assert_eq!(info.mount_dir, r#"/mnt/f\ 	oo"#);
+    }
 }
diff --git a/src/uucore/src/lib/features/fsxattr.rs b/src/uucore/src/lib/features/fsxattr.rs
new file mode 100644
index 00000000000..1913b0669fc
--- /dev/null
+++ b/src/uucore/src/lib/features/fsxattr.rs
@@ -0,0 +1,251 @@
+// 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.
+
+// spell-checker:ignore getxattr posix_acl_default
+
+//! Set of functions to manage xattr on files and dirs
+use std::collections::HashMap;
+use std::ffi::OsString;
+use std::path::Path;
+
+/// Copies extended attributes (xattrs) from one file or directory to another.
+///
+/// # Arguments
+///
+/// * `source` - A reference to the source path.
+/// * `dest` - A reference to the destination path.
+///
+/// # Returns
+///
+/// A result indicating success or failure.
+pub fn copy_xattrs<P: AsRef<Path>>(source: P, dest: P) -> std::io::Result<()> {
+    for attr_name in xattr::list(&source)? {
+        if let Some(value) = xattr::get(&source, &attr_name)? {
+            xattr::set(&dest, &attr_name, &value)?;
+        }
+    }
+    Ok(())
+}
+
+/// Retrieves the extended attributes (xattrs) of a given file or directory.
+///
+/// # Arguments
+///
+/// * `source` - A reference to the path of the file or directory.
+///
+/// # Returns
+///
+/// A result containing a HashMap of attributes names and values, or an error.
+pub fn retrieve_xattrs<P: AsRef<Path>>(source: P) -> std::io::Result<HashMap<OsString, Vec<u8>>> {
+    let mut attrs = HashMap::new();
+    for attr_name in xattr::list(&source)? {
+        if let Some(value) = xattr::get(&source, &attr_name)? {
+            attrs.insert(attr_name, value);
+        }
+    }
+    Ok(attrs)
+}
+
+/// Applies extended attributes (xattrs) to a given file or directory.
+///
+/// # Arguments
+///
+/// * `dest` - A reference to the path of the file or directory.
+/// * `xattrs` - A HashMap containing attribute names and their corresponding values.
+///
+/// # Returns
+///
+/// A result indicating success or failure.
+pub fn apply_xattrs<P: AsRef<Path>>(
+    dest: P,
+    xattrs: HashMap<OsString, Vec<u8>>,
+) -> std::io::Result<()> {
+    for (attr, value) in xattrs {
+        xattr::set(&dest, &attr, &value)?;
+    }
+    Ok(())
+}
+
+/// Checks if a file has an Access Control List (ACL) based on its extended attributes.
+///
+/// # Arguments
+///
+/// * `file` - A reference to the path of the file.
+///
+/// # Returns
+///
+/// `true` if the file has extended attributes (indicating an ACL), `false` otherwise.
+pub fn has_acl<P: AsRef<Path>>(file: P) -> bool {
+    // don't use exacl here, it is doing more getxattr call then needed
+    xattr::list(file).is_ok_and(|acl| {
+        // if we have extra attributes, we have an acl
+        acl.count() > 0
+    })
+}
+
+/// Returns the permissions bits of a file or directory which has Access Control List (ACL) entries based on its
+/// extended attributes (Only works for linux)
+///
+/// # Arguments
+///
+/// * `source` - A reference to the path of the file.
+///
+/// # Returns
+///
+/// `u32`  the perm bits of a file having extended attributes of type 'system.posix_acl_default' with permissions
+/// otherwise returns a 0 if perm bits are 0 or the file has no extended attributes
+pub fn get_acl_perm_bits_from_xattr<P: AsRef<Path>>(source: P) -> u32 {
+    // TODO: Modify this to work on non linux unix systems.
+
+    // Only default acl entries get inherited by objects under the path i.e. if child directories
+    // will have their permissions modified.
+    if let Ok(entries) = retrieve_xattrs(source) {
+        let mut perm: u32 = 0;
+        if let Some(value) = entries.get(&OsString::from("system.posix_acl_default")) {
+            // value is xattr byte vector
+            // value follows a starts with a 4 byte header, and then has posix_acl_entries, each
+            // posix_acl_entry is separated by a u32 sequence i.e. 0xFFFFFFFF
+            //
+            // struct posix_acl_entries {
+            // e_tag: u16
+            //  e_perm: u16
+            //  e_id: u32
+            // }
+            //
+            // Reference: `https://github.com/torvalds/linux/blob/master/include/uapi/linux/posix_acl_xattr.h`
+            //
+            // The value of the header is 0x0002, so we skip the first four bytes of the value and
+            // process the rest
+
+            let acl_entries = value
+                .split_at(3)
+                .1
+                .iter()
+                .filter(|&x| *x != 255)
+                .copied()
+                .collect::<Vec<u8>>();
+
+            for entry in acl_entries.chunks_exact(4) {
+                // Third byte and fourth byte will be the perm bits
+                perm = (perm << 3) | u32::from(entry[2]) | u32::from(entry[3]);
+            }
+            return perm;
+        }
+    }
+    0
+}
+
+// FIXME: 3 tests failed on OpenBSD
+#[cfg(not(target_os = "openbsd"))]
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_copy_xattrs() {
+        let temp_dir = tempdir().unwrap();
+        let source_path = temp_dir.path().join("source.txt");
+        let dest_path = temp_dir.path().join("dest.txt");
+
+        File::create(&source_path).unwrap();
+        File::create(&dest_path).unwrap();
+
+        let test_attr = "user.test";
+        let test_value = b"test value";
+        xattr::set(&source_path, test_attr, test_value).unwrap();
+
+        copy_xattrs(&source_path, &dest_path).unwrap();
+
+        let copied_value = xattr::get(&dest_path, test_attr).unwrap().unwrap();
+        assert_eq!(copied_value, test_value);
+    }
+
+    #[test]
+    fn test_apply_and_retrieve_xattrs() {
+        let temp_dir = tempdir().unwrap();
+        let file_path = temp_dir.path().join("test_file.txt");
+
+        File::create(&file_path).unwrap();
+
+        let mut test_xattrs = HashMap::new();
+        let test_attr = "user.test_attr";
+        let test_value = b"test value";
+        test_xattrs.insert(OsString::from(test_attr), test_value.to_vec());
+        apply_xattrs(&file_path, test_xattrs).unwrap();
+
+        let retrieved_xattrs = retrieve_xattrs(&file_path).unwrap();
+        assert!(retrieved_xattrs.contains_key(OsString::from(test_attr).as_os_str()));
+        assert_eq!(
+            retrieved_xattrs
+                .get(OsString::from(test_attr).as_os_str())
+                .unwrap(),
+            test_value
+        );
+    }
+
+    #[test]
+    #[cfg(target_os = "linux")]
+    fn test_get_perm_bits_from_xattrs() {
+        let temp_dir = tempdir().unwrap();
+        let source_path = temp_dir.path().join("source_dir");
+
+        std::fs::create_dir(&source_path).unwrap();
+
+        let test_attr = "system.posix_acl_default";
+        // posix_acl entries are in the form of
+        // struct posix_acl_entry{
+        //  tag: u16,
+        //  perm: u16,
+        //  id: u32,
+        // }
+        // the fields are serialized in little endian.
+        // The entries are preceded by a header of value of 0x0002
+        // Reference: `<https://github.com/torvalds/linux/blob/master/include/uapi/linux/posix_acl_xattr.h>`
+        // The id is undefined i.e. -1 which in u32 is 0xFFFFFFFF and tag and perm bits as given in the
+        // header file.
+        // Reference: `<https://github.com/torvalds/linux/blob/master/include/uapi/linux/posix_acl.h>`
+        //
+        //
+        // There is a bindgen bug which generates the ACL_OTHER constant whose value is 0x20 into 32.
+        // which when the bug is fixed will need to be changed back to 20 from 32 in the vec 'test_value'.
+        //
+        // Reference `<https://github.com/rust-lang/rust-bindgen/issues/2926>`
+        //
+        // The test_value vector is the header 0x0002 followed by tag and permissions for user_obj , tag
+        // and permissions and for group_obj and finally the tag and permissions for ACL_OTHER. Each
+        // entry has undefined id as mentioned above.
+        //
+        //
+
+        let test_value = vec![
+            2, 0, 0, 0, 1, 0, 7, 0, 255, 255, 255, 255, 4, 0, 0, 0, 255, 255, 255, 255, 32, 0, 0,
+            0, 255, 255, 255, 255,
+        ];
+
+        xattr::set(&source_path, test_attr, test_value.as_slice()).unwrap();
+
+        let perm_bits = get_acl_perm_bits_from_xattr(source_path);
+
+        assert_eq!(0o700, perm_bits);
+    }
+
+    #[test]
+    fn test_file_has_acl() {
+        let temp_dir = tempdir().unwrap();
+        let file_path = temp_dir.path().join("test_file.txt");
+
+        File::create(&file_path).unwrap();
+
+        assert!(!has_acl(&file_path));
+
+        let test_attr = "user.test_acl";
+        let test_value = b"test value";
+        xattr::set(&file_path, test_attr, test_value).unwrap();
+
+        assert!(has_acl(&file_path));
+    }
+}
diff --git a/src/uucore/src/lib/features/memo.rs b/src/uucore/src/lib/features/memo.rs
deleted file mode 100644
index 0603b01c51c..00000000000
--- a/src/uucore/src/lib/features/memo.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-// 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.
-//! Main entry point for our implementation of printf.
-//!
-//! The [`printf`] and [`sprintf`] closely match the behavior of the
-//! corresponding C functions: the former renders a formatted string
-//! to stdout, the latter renders to a new [`String`] object.
-use crate::display::Quotable;
-use crate::error::{UResult, USimpleError};
-use crate::features::tokenize::sub::SubParser;
-use crate::features::tokenize::token::Token;
-use crate::features::tokenize::unescaped_text::UnescapedText;
-use crate::show_warning;
-use itertools::put_back_n;
-use std::io::{stdout, Cursor, Write};
-use std::iter::Peekable;
-use std::slice::Iter;
-
-/// Memo runner of printf
-/// Takes a format string and arguments
-/// 1. tokenize format string into tokens, consuming
-/// any subst. arguments along the way.
-/// 2. feeds remaining arguments into function
-/// that prints tokens.
-struct Memo {
-    tokens: Vec<Token>,
-}
-
-fn warn_excess_args(first_arg: &str) {
-    show_warning!(
-        "ignoring excess arguments, starting with {}",
-        first_arg.quote()
-    );
-}
-
-impl Memo {
-    fn new<W>(
-        writer: &mut W,
-        pf_string: &str,
-        pf_args_it: &mut Peekable<Iter<String>>,
-    ) -> UResult<Self>
-    where
-        W: Write,
-    {
-        let mut pm = Self { tokens: Vec::new() };
-        let mut it = put_back_n(pf_string.chars());
-        let mut has_sub = false;
-        loop {
-            if let Some(x) = UnescapedText::from_it_core(writer, &mut it, false) {
-                pm.tokens.push(x);
-            }
-            if let Some(x) = SubParser::from_it(writer, &mut it, pf_args_it)? {
-                if !has_sub {
-                    has_sub = true;
-                }
-                pm.tokens.push(x);
-            }
-            if let Some(x) = it.next() {
-                it.put_back(x);
-            } else {
-                break;
-            }
-        }
-        if !has_sub {
-            let mut drain = false;
-            if let Some(first_arg) = pf_args_it.peek() {
-                warn_excess_args(first_arg);
-                drain = true;
-            }
-            if drain {
-                loop {
-                    // drain remaining args;
-                    if pf_args_it.next().is_none() {
-                        break;
-                    }
-                }
-            }
-        }
-        Ok(pm)
-    }
-    fn apply<W>(&self, writer: &mut W, pf_args_it: &mut Peekable<Iter<String>>)
-    where
-        W: Write,
-    {
-        for tkn in &self.tokens {
-            tkn.write(writer, pf_args_it);
-        }
-    }
-    fn run_all<W>(writer: &mut W, pf_string: &str, pf_args: &[String]) -> UResult<()>
-    where
-        W: Write,
-    {
-        let mut arg_it = pf_args.iter().peekable();
-        let pm = Self::new(writer, pf_string, &mut arg_it)?;
-        loop {
-            if arg_it.peek().is_none() {
-                return Ok(());
-            }
-            pm.apply(writer, &mut arg_it);
-        }
-    }
-}
-
-/// Write a formatted string to stdout.
-///
-/// `format_string` contains the template and `args` contains the
-/// arguments to render into the template.
-///
-/// See also [`sprintf`], which creates a new formatted [`String`].
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::memo::printf;
-///
-/// printf("hello %s", &["world".to_string()]).unwrap();
-/// // prints "hello world"
-/// ```
-pub fn printf(format_string: &str, args: &[String]) -> UResult<()> {
-    let mut writer = stdout();
-    Memo::run_all(&mut writer, format_string, args)
-}
-
-/// Create a new formatted string.
-///
-/// `format_string` contains the template and `args` contains the
-/// arguments to render into the template.
-///
-/// See also [`printf`], which prints to stdout.
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::memo::sprintf;
-///
-/// let s = sprintf("hello %s", &["world".to_string()]).unwrap();
-/// assert_eq!(s, "hello world".to_string());
-/// ```
-pub fn sprintf(format_string: &str, args: &[String]) -> UResult<String> {
-    let mut writer = Cursor::new(vec![]);
-    Memo::run_all(&mut writer, format_string, args)?;
-    let buf = writer.into_inner();
-    match String::from_utf8(buf) {
-        Ok(s) => Ok(s),
-        Err(e) => Err(USimpleError::new(
-            1,
-            format!("failed to parse formatted string as UTF-8: {e}"),
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::memo::sprintf;
-
-    #[test]
-    fn test_sprintf_smoke() {
-        assert_eq!(sprintf("", &[]).unwrap(), "".to_string());
-    }
-
-    #[test]
-    fn test_sprintf_no_args() {
-        assert_eq!(
-            sprintf("hello world", &[]).unwrap(),
-            "hello world".to_string()
-        );
-    }
-
-    #[test]
-    fn test_sprintf_string() {
-        assert_eq!(
-            sprintf("hello %s", &["world".to_string()]).unwrap(),
-            "hello world".to_string()
-        );
-    }
-}
diff --git a/src/uucore/src/lib/features/mode.rs b/src/uucore/src/lib/features/mode.rs
index cbaea71bf01..5a0a517276e 100644
--- a/src/uucore/src/lib/features/mode.rs
+++ b/src/uucore/src/lib/features/mode.rs
@@ -7,7 +7,7 @@
 
 // spell-checker:ignore (vars) fperm srwx
 
-use libc::{mode_t, umask, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR};
+use libc::{S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR, mode_t, umask};
 
 pub fn parse_numeric(fperm: u32, mut mode: &str, considering_dir: bool) -> Result<u32, String> {
     let (op, pos) = parse_op(mode).map_or_else(|_| (None, 0), |(op, pos)| (Some(op), pos));
@@ -137,6 +137,7 @@ fn parse_change(mode: &str, fperm: u32, considering_dir: bool) -> (u32, usize) {
     (srwx, pos)
 }
 
+#[allow(clippy::unnecessary_cast)]
 pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
     #[cfg(all(
         not(target_os = "freebsd"),
@@ -147,11 +148,10 @@ pub fn parse_mode(mode: &str) -> Result<mode_t, String> {
     #[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
     let fperm = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) as u32;
 
-    let arr: &[char] = &['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
-    let result = if mode.contains(arr) {
-        parse_numeric(fperm, mode, true)
+    let result = if mode.chars().any(|c| c.is_ascii_digit()) {
+        parse_numeric(fperm as u32, mode, true)
     } else {
-        parse_symbolic(fperm, mode, get_umask(), true)
+        parse_symbolic(fperm as u32, mode, get_umask(), true)
     };
     result.map(|mode| mode as mode_t)
 }
@@ -169,11 +169,17 @@ pub fn get_umask() -> u32 {
     #[cfg(all(
         not(target_os = "freebsd"),
         not(target_vendor = "apple"),
-        not(target_os = "android")
+        not(target_os = "android"),
+        not(target_os = "redox")
     ))]
     return mask;
-    #[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
-    return mask.into();
+    #[cfg(any(
+        target_os = "freebsd",
+        target_vendor = "apple",
+        target_os = "android",
+        target_os = "redox"
+    ))]
+    return mask as u32;
 }
 
 // Iterate 'args' and delete the first occurrence
@@ -185,14 +191,11 @@ pub fn strip_minus_from_mode(args: &mut Vec<String>) -> bool {
             break;
         }
         if let Some(arg_stripped) = arg.strip_prefix('-') {
-            if let Some(second) = arg.chars().nth(1) {
-                match second {
-                    'r' | 'w' | 'x' | 'X' | 's' | 't' | 'u' | 'g' | 'o' | '0'..='7' => {
-                        *arg = arg_stripped.to_string();
-                        return true;
-                    }
-                    _ => {}
-                }
+            if let Some('r' | 'w' | 'x' | 'X' | 's' | 't' | 'u' | 'g' | 'o' | '0'..='7') =
+                arg.chars().nth(1)
+            {
+                *arg = arg_stripped.to_string();
+                return true;
             }
         }
     }
diff --git a/src/uucore/src/lib/parser.rs b/src/uucore/src/lib/features/parser/mod.rs
similarity index 81%
rename from src/uucore/src/lib/parser.rs
rename to src/uucore/src/lib/features/parser/mod.rs
index a0de6c0d4ef..800fe6e8ca1 100644
--- a/src/uucore/src/lib/parser.rs
+++ b/src/uucore/src/lib/features/parser/mod.rs
@@ -2,6 +2,9 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+// spell-checker:ignore extendedbigdecimal
+
+pub mod num_parser;
 pub mod parse_glob;
 pub mod parse_size;
 pub mod parse_time;
diff --git a/src/uucore/src/lib/features/parser/num_parser.rs b/src/uucore/src/lib/features/parser/num_parser.rs
new file mode 100644
index 00000000000..3ee07e41357
--- /dev/null
+++ b/src/uucore/src/lib/features/parser/num_parser.rs
@@ -0,0 +1,1147 @@
+// 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.
+
+//! Utilities for parsing numbers in various formats
+
+// spell-checker:ignore powf copysign prec inity infinit infs bigdecimal extendedbigdecimal biguint underflowed
+
+use bigdecimal::{
+    BigDecimal, Context,
+    num_bigint::{BigInt, BigUint, Sign},
+};
+use num_traits::Signed;
+use num_traits::ToPrimitive;
+use num_traits::Zero;
+
+use crate::extendedbigdecimal::ExtendedBigDecimal;
+
+/// Base for number parsing
+#[derive(Clone, Copy, PartialEq)]
+enum Base {
+    /// Binary base
+    Binary = 2,
+
+    /// Octal base
+    Octal = 8,
+
+    /// Decimal base
+    Decimal = 10,
+
+    /// Hexadecimal base
+    Hexadecimal = 16,
+}
+
+impl Base {
+    /// Return the digit value of a character in the given base
+    fn digit(&self, c: char) -> Option<u64> {
+        fn from_decimal(c: char) -> u64 {
+            u64::from(c) - u64::from('0')
+        }
+        match self {
+            Self::Binary => ('0'..='1').contains(&c).then(|| from_decimal(c)),
+            Self::Octal => ('0'..='7').contains(&c).then(|| from_decimal(c)),
+            Self::Decimal => c.is_ascii_digit().then(|| from_decimal(c)),
+            Self::Hexadecimal => match c.to_ascii_lowercase() {
+                '0'..='9' => Some(from_decimal(c)),
+                c @ 'a'..='f' => Some(u64::from(c) - u64::from('a') + 10),
+                _ => None,
+            },
+        }
+    }
+
+    /// Greedily parse as many digits as possible from the string
+    /// Returns parsed digits (if any), and the rest of the string.
+    fn parse_digits<'a>(&self, str: &'a str) -> (Option<BigUint>, &'a str) {
+        let (digits, _, rest) = self.parse_digits_count(str, None);
+        (digits, rest)
+    }
+
+    /// Greedily parse as many digits as possible from the string, adding to already parsed digits.
+    /// This is meant to be used (directly) for the part after a decimal point.
+    /// Returns parsed digits (if any), the number of parsed digits, and the rest of the string.
+    fn parse_digits_count<'a>(
+        &self,
+        str: &'a str,
+        digits: Option<BigUint>,
+    ) -> (Option<BigUint>, u64, &'a str) {
+        let mut digits: Option<BigUint> = digits;
+        let mut count: u64 = 0;
+        let mut rest = str;
+        while let Some(d) = rest.chars().next().and_then(|c| self.digit(c)) {
+            (digits, count) = (
+                Some(digits.unwrap_or_default() * *self as u8 + d),
+                count + 1,
+            );
+            rest = &rest[1..];
+        }
+        (digits, count, rest)
+    }
+}
+
+/// Type returned if a number could not be parsed in its entirety
+#[derive(Debug, PartialEq)]
+pub enum ExtendedParserError<'a, T> {
+    /// The input as a whole makes no sense
+    NotNumeric,
+    /// The beginning of the input made sense and has been parsed,
+    /// while the remaining doesn't.
+    PartialMatch(T, &'a str),
+    /// The value has overflowed the type storage. The returned value
+    /// is saturated (e.g. positive or negative infinity, or min/max
+    /// value for the integer type).
+    Overflow(T),
+    // The value has underflowed the float storage (and is now 0.0 or -0.0).
+    // Does not apply to integer parsing.
+    Underflow(T),
+}
+
+impl<'a, T> ExtendedParserError<'a, T>
+where
+    T: Zero,
+{
+    // Extract the value out of an error, if possible.
+    fn extract(self) -> T {
+        match self {
+            Self::NotNumeric => T::zero(),
+            Self::PartialMatch(v, _) => v,
+            Self::Overflow(v) => v,
+            Self::Underflow(v) => v,
+        }
+    }
+
+    // Map an error to another, using the provided conversion function.
+    // The error (self) takes precedence over errors happening during the
+    // conversion.
+    fn map<U>(
+        self,
+        f: impl FnOnce(T) -> Result<U, ExtendedParserError<'a, U>>,
+    ) -> ExtendedParserError<'a, U>
+    where
+        U: Zero,
+    {
+        fn extract<U>(v: Result<U, ExtendedParserError<'_, U>>) -> U
+        where
+            U: Zero,
+        {
+            v.unwrap_or_else(|e| e.extract())
+        }
+
+        match self {
+            ExtendedParserError::NotNumeric => ExtendedParserError::NotNumeric,
+            ExtendedParserError::PartialMatch(v, rest) => {
+                ExtendedParserError::PartialMatch(extract(f(v)), rest)
+            }
+            ExtendedParserError::Overflow(v) => ExtendedParserError::Overflow(extract(f(v))),
+            ExtendedParserError::Underflow(v) => ExtendedParserError::Underflow(extract(f(v))),
+        }
+    }
+}
+
+/// A number parser for binary, octal, decimal, hexadecimal and single characters.
+///
+/// It is implemented for `u64`/`i64`, where no fractional part is parsed,
+/// and `f64` float, where octal and binary formats are not allowed.
+pub trait ExtendedParser {
+    // We pick a hopefully different name for our parser, to avoid clash with standard traits.
+    fn extended_parse(input: &str) -> Result<Self, ExtendedParserError<'_, Self>>
+    where
+        Self: Sized;
+}
+
+impl ExtendedParser for i64 {
+    /// Parse a number as i64. No fractional part is allowed.
+    fn extended_parse(input: &str) -> Result<i64, ExtendedParserError<'_, i64>> {
+        fn into_i64<'a>(ebd: ExtendedBigDecimal) -> Result<i64, ExtendedParserError<'a, i64>> {
+            match ebd {
+                ExtendedBigDecimal::BigDecimal(bd) => {
+                    let (digits, scale) = bd.into_bigint_and_scale();
+                    if scale == 0 {
+                        let negative = digits.sign() == Sign::Minus;
+                        match i64::try_from(digits) {
+                            Ok(i) => Ok(i),
+                            _ => Err(ExtendedParserError::Overflow(if negative {
+                                i64::MIN
+                            } else {
+                                i64::MAX
+                            })),
+                        }
+                    } else {
+                        // Should not happen.
+                        Err(ExtendedParserError::NotNumeric)
+                    }
+                }
+                ExtendedBigDecimal::MinusZero => Ok(0),
+                // No other case should not happen.
+                _ => Err(ExtendedParserError::NotNumeric),
+            }
+        }
+
+        match parse(input, ParseTarget::Integral, &[]) {
+            Ok(v) => into_i64(v),
+            Err(e) => Err(e.map(into_i64)),
+        }
+    }
+}
+
+impl ExtendedParser for u64 {
+    /// Parse a number as u64. No fractional part is allowed.
+    fn extended_parse(input: &str) -> Result<u64, ExtendedParserError<'_, u64>> {
+        fn into_u64<'a>(ebd: ExtendedBigDecimal) -> Result<u64, ExtendedParserError<'a, u64>> {
+            match ebd {
+                ExtendedBigDecimal::BigDecimal(bd) => {
+                    let (digits, scale) = bd.into_bigint_and_scale();
+                    if scale == 0 {
+                        let (sign, digits) = digits.into_parts();
+
+                        match u64::try_from(digits) {
+                            Ok(i) => {
+                                if sign == Sign::Minus {
+                                    Ok(!i + 1)
+                                } else {
+                                    Ok(i)
+                                }
+                            }
+                            _ => Err(ExtendedParserError::Overflow(u64::MAX)),
+                        }
+                    } else {
+                        // Should not happen.
+                        Err(ExtendedParserError::NotNumeric)
+                    }
+                }
+                ExtendedBigDecimal::MinusZero => Ok(0),
+                _ => Err(ExtendedParserError::NotNumeric),
+            }
+        }
+
+        match parse(input, ParseTarget::Integral, &[]) {
+            Ok(v) => into_u64(v),
+            Err(e) => Err(e.map(into_u64)),
+        }
+    }
+}
+
+impl ExtendedParser for f64 {
+    /// Parse a number as f64
+    fn extended_parse(input: &str) -> Result<f64, ExtendedParserError<'_, f64>> {
+        fn into_f64<'a>(ebd: ExtendedBigDecimal) -> Result<f64, ExtendedParserError<'a, f64>> {
+            // TODO: _Some_ of this is generic, so this should probably be implemented as an ExtendedBigDecimal trait (ToPrimitive).
+            let v = match ebd {
+                ExtendedBigDecimal::BigDecimal(bd) => {
+                    let f = bd.to_f64().unwrap();
+                    if f.is_infinite() {
+                        return Err(ExtendedParserError::Overflow(f));
+                    }
+                    if f.is_zero() && !bd.is_zero() {
+                        return Err(ExtendedParserError::Underflow(f));
+                    }
+                    f
+                }
+                ExtendedBigDecimal::MinusZero => -0.0,
+                ExtendedBigDecimal::Nan => f64::NAN,
+                ExtendedBigDecimal::MinusNan => -f64::NAN,
+                ExtendedBigDecimal::Infinity => f64::INFINITY,
+                ExtendedBigDecimal::MinusInfinity => -f64::INFINITY,
+            };
+            Ok(v)
+        }
+
+        match parse(input, ParseTarget::Decimal, &[]) {
+            Ok(v) => into_f64(v),
+            Err(e) => Err(e.map(into_f64)),
+        }
+    }
+}
+
+impl ExtendedParser for ExtendedBigDecimal {
+    /// Parse a number as an ExtendedBigDecimal
+    fn extended_parse(
+        input: &str,
+    ) -> Result<ExtendedBigDecimal, ExtendedParserError<'_, ExtendedBigDecimal>> {
+        parse(input, ParseTarget::Decimal, &[])
+    }
+}
+
+fn parse_digits(base: Base, str: &str, fractional: bool) -> (Option<BigUint>, u64, &str) {
+    // Parse the integral part of the number
+    let (digits, rest) = base.parse_digits(str);
+
+    // If allowed, parse the fractional part of the number if there can be one and the
+    // input contains a '.' decimal separator.
+    if fractional {
+        if let Some(rest) = rest.strip_prefix('.') {
+            return base.parse_digits_count(rest, digits);
+        }
+    }
+
+    (digits, 0, rest)
+}
+
+fn parse_exponent(base: Base, str: &str) -> (Option<BigInt>, &str) {
+    let exp_chars = match base {
+        Base::Decimal => ['e', 'E'],
+        Base::Hexadecimal => ['p', 'P'],
+        _ => unreachable!(),
+    };
+
+    // Parse the exponent part, only decimal numbers are allowed.
+    // We only update `rest` if an exponent is actually parsed.
+    if let Some(rest) = str.strip_prefix(exp_chars) {
+        let (sign, rest) = if let Some(rest) = rest.strip_prefix('-') {
+            (Sign::Minus, rest)
+        } else if let Some(rest) = rest.strip_prefix('+') {
+            (Sign::Plus, rest)
+        } else {
+            // Something else, or nothing at all: keep going.
+            (Sign::Plus, rest) // No explicit sign is equivalent to `+`.
+        };
+
+        let (exp_uint, rest) = Base::Decimal.parse_digits(rest);
+        if let Some(exp_uint) = exp_uint {
+            return (Some(BigInt::from_biguint(sign, exp_uint)), rest);
+        }
+    }
+
+    // Nothing parsed
+    (None, str)
+}
+
+// Parse a multiplier from allowed suffixes (e.g. s/m/h).
+fn parse_suffix_multiplier<'a>(str: &'a str, allowed_suffixes: &[(char, u32)]) -> (u32, &'a str) {
+    if let Some(ch) = str.chars().next() {
+        if let Some(mul) = allowed_suffixes
+            .iter()
+            .find_map(|(c, t)| (ch == *c).then_some(*t))
+        {
+            return (mul, &str[1..]);
+        }
+    }
+
+    // No suffix, just return 1 and intact string
+    (1, str)
+}
+
+fn parse_special_value<'a>(
+    input: &'a str,
+    negative: bool,
+    allowed_suffixes: &[(char, u32)],
+) -> Result<ExtendedBigDecimal, ExtendedParserError<'a, ExtendedBigDecimal>> {
+    let input_lc = input.to_ascii_lowercase();
+
+    // Array of ("String to match", return value when sign positive, when sign negative)
+    const MATCH_TABLE: &[(&str, ExtendedBigDecimal)] = &[
+        ("infinity", ExtendedBigDecimal::Infinity),
+        ("inf", ExtendedBigDecimal::Infinity),
+        ("nan", ExtendedBigDecimal::Nan),
+    ];
+
+    for (str, ebd) in MATCH_TABLE.iter() {
+        if input_lc.starts_with(str) {
+            let mut special = ebd.clone();
+            if negative {
+                special = -special;
+            }
+
+            // "infs" is a valid duration, so parse suffix multiplier in the original input string, but ignore the multiplier.
+            let (_, rest) = parse_suffix_multiplier(&input[str.len()..], allowed_suffixes);
+
+            return if rest.is_empty() {
+                Ok(special)
+            } else {
+                Err(ExtendedParserError::PartialMatch(special, rest))
+            };
+        }
+    }
+
+    Err(ExtendedParserError::NotNumeric)
+}
+
+// Underflow/Overflow errors always contain 0 or infinity.
+// overflow: true for overflow, false for underflow.
+fn make_error<'a>(overflow: bool, negative: bool) -> ExtendedParserError<'a, ExtendedBigDecimal> {
+    let mut v = if overflow {
+        ExtendedBigDecimal::Infinity
+    } else {
+        ExtendedBigDecimal::zero()
+    };
+    if negative {
+        v = -v;
+    }
+    if overflow {
+        ExtendedParserError::Overflow(v)
+    } else {
+        ExtendedParserError::Underflow(v)
+    }
+}
+
+/// Compute bd**exp using exponentiation by squaring algorithm, while maintaining the
+/// precision specified in ctx (the number of digits would otherwise explode).
+// TODO: We do lose a little bit of precision, and the last digits may not be correct.
+// TODO: Upstream this to bigdecimal-rs.
+fn pow_with_context(bd: BigDecimal, exp: u32, ctx: &bigdecimal::Context) -> BigDecimal {
+    if exp == 0 {
+        return 1.into();
+    }
+
+    fn trim_precision(bd: BigDecimal, ctx: &bigdecimal::Context) -> BigDecimal {
+        if bd.digits() > ctx.precision().get() {
+            bd.with_precision_round(ctx.precision(), ctx.rounding_mode())
+        } else {
+            bd
+        }
+    }
+
+    let bd = trim_precision(bd, ctx);
+    let ret = if exp % 2 == 0 {
+        pow_with_context(bd.square(), exp / 2, ctx)
+    } else {
+        &bd * pow_with_context(bd.square(), (exp - 1) / 2, ctx)
+    };
+    trim_precision(ret, ctx)
+}
+
+// Construct an ExtendedBigDecimal based on parsed data
+fn construct_extended_big_decimal<'a>(
+    digits: BigUint,
+    negative: bool,
+    base: Base,
+    scale: u64,
+    exponent: BigInt,
+) -> Result<ExtendedBigDecimal, ExtendedParserError<'a, ExtendedBigDecimal>> {
+    if digits == BigUint::zero() {
+        // Return return 0 if the digits are zero. In particular, we do not ever
+        // return Overflow/Underflow errors in that case.
+        return Ok(if negative {
+            ExtendedBigDecimal::MinusZero
+        } else {
+            ExtendedBigDecimal::zero()
+        });
+    }
+
+    let sign = if negative { Sign::Minus } else { Sign::Plus };
+    let signed_digits = BigInt::from_biguint(sign, digits);
+    let bd = if scale == 0 && exponent.is_zero() {
+        BigDecimal::from_bigint(signed_digits, 0)
+    } else if base == Base::Decimal {
+        let new_scale = BigInt::from(scale) - exponent;
+
+        // BigDecimal "only" supports i64 scale.
+        // Note that new_scale is a negative exponent: large value causes an underflow, small value an overflow.
+        if new_scale > i64::MAX.into() {
+            return Err(make_error(false, negative));
+        } else if new_scale < i64::MIN.into() {
+            return Err(make_error(true, negative));
+        }
+        BigDecimal::from_bigint(signed_digits, new_scale.to_i64().unwrap())
+    } else if base == Base::Hexadecimal {
+        // pow "only" supports u32 values, just error out if given more than 2**32 fractional digits.
+        if scale > u32::MAX.into() {
+            return Err(ExtendedParserError::NotNumeric);
+        }
+
+        // Base is 16, init at scale 0 then divide by base**scale.
+        let bd = BigDecimal::from_bigint(signed_digits, 0)
+            / BigDecimal::from_bigint(BigInt::from(16).pow(scale as u32), 0);
+
+        let abs_exponent = exponent.abs();
+        // Again, pow "only" supports u32 values. Just overflow/underflow if the value provided
+        // is > 2**32 or < 2**-32.
+        if abs_exponent > u32::MAX.into() {
+            return Err(make_error(exponent.is_positive(), negative));
+        }
+
+        // Confusingly, exponent is in base 2 for hex floating point numbers.
+        // Note: We cannot overflow/underflow BigDecimal here, as we will not be able to reach the
+        // maximum/minimum scale (i64 range).
+        let base: BigDecimal = if !exponent.is_negative() {
+            2.into()
+        } else {
+            BigDecimal::from(2).inverse()
+        };
+        let pow2 = pow_with_context(base, abs_exponent.to_u32().unwrap(), &Context::default());
+
+        bd * pow2
+    } else {
+        // scale != 0, which means that integral_only is not set, so only base 10 and 16 are allowed.
+        unreachable!();
+    };
+    Ok(ExtendedBigDecimal::BigDecimal(bd))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ParseTarget {
+    Decimal,
+    Integral,
+    Duration,
+}
+
+pub(crate) fn parse<'a>(
+    input: &'a str,
+    target: ParseTarget,
+    allowed_suffixes: &[(char, u32)],
+) -> Result<ExtendedBigDecimal, ExtendedParserError<'a, ExtendedBigDecimal>> {
+    // Parse the " and ' prefixes separately
+    if target != ParseTarget::Duration {
+        if let Some(rest) = input.strip_prefix(['\'', '"']) {
+            let mut chars = rest.char_indices().fuse();
+            let v = chars
+                .next()
+                .map(|(_, c)| ExtendedBigDecimal::BigDecimal(u32::from(c).into()));
+            return match (v, chars.next()) {
+                (Some(v), None) => Ok(v),
+                (Some(v), Some((i, _))) => Err(ExtendedParserError::PartialMatch(v, &rest[i..])),
+                (None, _) => Err(ExtendedParserError::NotNumeric),
+            };
+        }
+    }
+
+    let trimmed_input = input.trim_ascii_start();
+
+    // Initial minus/plus sign
+    let (negative, unsigned) = if let Some(trimmed_input) = trimmed_input.strip_prefix('-') {
+        (true, trimmed_input)
+    } else if let Some(trimmed_input) = trimmed_input.strip_prefix('+') {
+        (false, trimmed_input)
+    } else {
+        (false, trimmed_input)
+    };
+
+    // Parse an optional base prefix ("0b" / "0B" / "0" / "0x" / "0X"). "0" is octal unless a
+    // fractional part is allowed in which case it is an insignificant leading 0. A "0" prefix
+    // will not be consumed in case the parsable string contains only "0": the leading extra "0"
+    // will have no influence on the result.
+    let (base, rest) = if let Some(rest) = unsigned.strip_prefix('0') {
+        if let Some(rest) = rest.strip_prefix(['x', 'X']) {
+            (Base::Hexadecimal, rest)
+        } else if target == ParseTarget::Integral {
+            // Binary/Octal only allowed for integer parsing.
+            if let Some(rest) = rest.strip_prefix(['b', 'B']) {
+                (Base::Binary, rest)
+            } else {
+                (Base::Octal, unsigned)
+            }
+        } else {
+            (Base::Decimal, unsigned)
+        }
+    } else {
+        (Base::Decimal, unsigned)
+    };
+
+    // We only parse fractional and exponent part of the number in base 10/16 floating point numbers.
+    let parse_frac_exp =
+        matches!(base, Base::Decimal | Base::Hexadecimal) && target != ParseTarget::Integral;
+
+    // Parse the integral and fractional (if supported) part of the number
+    let (digits, scale, rest) = parse_digits(base, rest, parse_frac_exp);
+
+    // Parse exponent part of the number for supported bases.
+    let (exponent, rest) = if parse_frac_exp {
+        parse_exponent(base, rest)
+    } else {
+        (None, rest)
+    };
+
+    // If no digit has been parsed, check if this is a special value, or declare the parsing unsuccessful
+    if digits.is_none() {
+        // If we trimmed an initial `0x`/`0b`, return a partial match.
+        if let Some(partial) = unsigned.strip_prefix("0") {
+            let ebd = if negative {
+                ExtendedBigDecimal::MinusZero
+            } else {
+                ExtendedBigDecimal::zero()
+            };
+            return Err(ExtendedParserError::PartialMatch(ebd, partial));
+        }
+
+        return if target == ParseTarget::Integral {
+            Err(ExtendedParserError::NotNumeric)
+        } else {
+            parse_special_value(unsigned, negative, allowed_suffixes)
+        };
+    }
+
+    let (mul, rest) = parse_suffix_multiplier(rest, allowed_suffixes);
+
+    let digits = digits.unwrap() * mul;
+
+    let ebd_result =
+        construct_extended_big_decimal(digits, negative, base, scale, exponent.unwrap_or_default());
+
+    // Return what has been parsed so far. If there are extra characters, mark the
+    // parsing as a partial match.
+    if !rest.is_empty() {
+        Err(ExtendedParserError::PartialMatch(
+            ebd_result.unwrap_or_else(|e| e.extract()),
+            rest,
+        ))
+    } else {
+        ebd_result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use bigdecimal::BigDecimal;
+
+    use crate::extendedbigdecimal::ExtendedBigDecimal;
+
+    use super::{ExtendedParser, ExtendedParserError};
+
+    #[test]
+    fn test_decimal_u64() {
+        assert_eq!(Ok(123), u64::extended_parse("123"));
+        assert_eq!(Ok(u64::MAX), u64::extended_parse(&format!("{}", u64::MAX)));
+        assert_eq!(Ok(0), u64::extended_parse("-0"));
+        assert_eq!(Ok(u64::MAX), u64::extended_parse("-1"));
+        assert_eq!(
+            Ok(u64::MAX / 2 + 1),
+            u64::extended_parse("-9223372036854775808") // i64::MIN
+        );
+        assert_eq!(
+            Ok(1123372036854675616),
+            u64::extended_parse("-17323372036854876000") // 2*i64::MIN
+        );
+        assert_eq!(Ok(1), u64::extended_parse("-18446744073709551615")); // -u64::MAX
+        assert!(matches!(
+            u64::extended_parse("-18446744073709551616"), // -u64::MAX - 1
+            Err(ExtendedParserError::Overflow(u64::MAX))
+        ));
+        assert!(matches!(
+            u64::extended_parse("-92233720368547758150"),
+            Err(ExtendedParserError::Overflow(u64::MAX))
+        ));
+        assert!(matches!(
+            u64::extended_parse("-170141183460469231731687303715884105729"),
+            Err(ExtendedParserError::Overflow(u64::MAX))
+        ));
+        assert!(matches!(
+            u64::extended_parse(""),
+            Err(ExtendedParserError::NotNumeric)
+        ));
+        assert!(matches!(
+            u64::extended_parse("123.15"),
+            Err(ExtendedParserError::PartialMatch(123, ".15"))
+        ));
+        assert!(matches!(
+            u64::extended_parse("123e10"),
+            Err(ExtendedParserError::PartialMatch(123, "e10"))
+        ));
+    }
+
+    #[test]
+    fn test_decimal_i64() {
+        assert_eq!(Ok(123), i64::extended_parse("123"));
+        assert_eq!(Ok(123), i64::extended_parse("+123"));
+        assert_eq!(Ok(-123), i64::extended_parse("-123"));
+        assert!(matches!(
+            i64::extended_parse("--123"),
+            Err(ExtendedParserError::NotNumeric)
+        ));
+        assert_eq!(Ok(i64::MAX), i64::extended_parse(&format!("{}", i64::MAX)));
+        assert_eq!(Ok(i64::MIN), i64::extended_parse(&format!("{}", i64::MIN)));
+        assert!(matches!(
+            i64::extended_parse(&format!("{}", u64::MAX)),
+            Err(ExtendedParserError::Overflow(i64::MAX))
+        ));
+        assert!(matches!(
+            i64::extended_parse(&format!("{}", i64::MAX as u64 + 1)),
+            Err(ExtendedParserError::Overflow(i64::MAX))
+        ));
+        assert!(matches!(
+            i64::extended_parse("-123e10"),
+            Err(ExtendedParserError::PartialMatch(-123, "e10"))
+        ));
+        assert!(matches!(
+            i64::extended_parse(&format!("{}", -(u64::MAX as i128))),
+            Err(ExtendedParserError::Overflow(i64::MIN))
+        ));
+        assert!(matches!(
+            i64::extended_parse(&format!("{}", i64::MIN as i128 - 1)),
+            Err(ExtendedParserError::Overflow(i64::MIN))
+        ));
+
+        assert!(matches!(
+            i64::extended_parse(""),
+            Err(ExtendedParserError::NotNumeric)
+        ));
+        assert!(matches!(
+            i64::extended_parse("."),
+            Err(ExtendedParserError::NotNumeric)
+        ));
+    }
+
+    #[test]
+    fn test_decimal_f64() {
+        assert_eq!(Ok(123.0), f64::extended_parse("123"));
+        assert_eq!(Ok(123.0), f64::extended_parse("+123"));
+        assert_eq!(Ok(-123.0), f64::extended_parse("-123"));
+        assert_eq!(Ok(123.0), f64::extended_parse("123."));
+        assert_eq!(Ok(-123.0), f64::extended_parse("-123."));
+        assert_eq!(Ok(123.0), f64::extended_parse("123.0"));
+        assert_eq!(Ok(-123.0), f64::extended_parse("-123.0"));
+        assert_eq!(Ok(123.15), f64::extended_parse("123.15"));
+        assert_eq!(Ok(123.15), f64::extended_parse("+123.15"));
+        assert_eq!(Ok(-123.15), f64::extended_parse("-123.15"));
+        assert_eq!(Ok(0.15), f64::extended_parse(".15"));
+        assert_eq!(Ok(-0.15), f64::extended_parse("-.15"));
+        // Leading 0(s) are _not_ octal when parsed as float
+        assert_eq!(Ok(123.0), f64::extended_parse("0123"));
+        assert_eq!(Ok(123.0), f64::extended_parse("+0123"));
+        assert_eq!(Ok(-123.0), f64::extended_parse("-0123"));
+        assert_eq!(Ok(123.0), f64::extended_parse("00123"));
+        assert_eq!(Ok(123.0), f64::extended_parse("+00123"));
+        assert_eq!(Ok(-123.0), f64::extended_parse("-00123"));
+        assert_eq!(Ok(123.15), f64::extended_parse("0123.15"));
+        assert_eq!(Ok(123.15), f64::extended_parse("+0123.15"));
+        assert_eq!(Ok(-123.15), f64::extended_parse("-0123.15"));
+        assert_eq!(Ok(12315000.0), f64::extended_parse("123.15e5"));
+        assert_eq!(Ok(-12315000.0), f64::extended_parse("-123.15e5"));
+        assert_eq!(Ok(12315000.0), f64::extended_parse("123.15E+5"));
+        assert_eq!(Ok(0.0012315), f64::extended_parse("123.15E-5"));
+        assert_eq!(
+            Ok(0.15),
+            f64::extended_parse(".150000000000000000000000000231313")
+        );
+        assert!(matches!(f64::extended_parse("123.15e"),
+                         Err(ExtendedParserError::PartialMatch(f, "e")) if f == 123.15));
+        assert!(matches!(f64::extended_parse("123.15E"),
+                         Err(ExtendedParserError::PartialMatch(f, "E")) if f == 123.15));
+        assert!(matches!(f64::extended_parse("123.15e-"),
+                         Err(ExtendedParserError::PartialMatch(f, "e-")) if f == 123.15));
+        assert!(matches!(f64::extended_parse("123.15e+"),
+                         Err(ExtendedParserError::PartialMatch(f, "e+")) if f == 123.15));
+        assert!(matches!(f64::extended_parse("123.15e."),
+                         Err(ExtendedParserError::PartialMatch(f, "e.")) if f == 123.15));
+        assert!(matches!(f64::extended_parse("1.2.3"),
+                         Err(ExtendedParserError::PartialMatch(f, ".3")) if f == 1.2));
+        assert!(matches!(f64::extended_parse("123.15p5"),
+                        Err(ExtendedParserError::PartialMatch(f, "p5")) if f == 123.15));
+        // Minus zero. 0.0 == -0.0 so we explicitly check the sign.
+        assert_eq!(Ok(0.0), f64::extended_parse("-0.0"));
+        assert!(f64::extended_parse("-0.0").unwrap().is_sign_negative());
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("inf"));
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("+inf"));
+        assert_eq!(Ok(f64::NEG_INFINITY), f64::extended_parse("-inf"));
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("Inf"));
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("InF"));
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("INF"));
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("infinity"));
+        assert_eq!(Ok(f64::INFINITY), f64::extended_parse("+infiNIty"));
+        assert_eq!(Ok(f64::NEG_INFINITY), f64::extended_parse("-INfinity"));
+        assert!(f64::extended_parse("NaN").unwrap().is_nan());
+        assert!(f64::extended_parse("NaN").unwrap().is_sign_positive());
+        assert!(f64::extended_parse("+NaN").unwrap().is_nan());
+        assert!(f64::extended_parse("+NaN").unwrap().is_sign_positive());
+        assert!(f64::extended_parse("-NaN").unwrap().is_nan());
+        assert!(f64::extended_parse("-NaN").unwrap().is_sign_negative());
+        assert!(f64::extended_parse("nan").unwrap().is_nan());
+        assert!(f64::extended_parse("nan").unwrap().is_sign_positive());
+        assert!(f64::extended_parse("NAN").unwrap().is_nan());
+        assert!(f64::extended_parse("NAN").unwrap().is_sign_positive());
+        assert!(matches!(f64::extended_parse("-infinit"),
+                         Err(ExtendedParserError::PartialMatch(f, "init")) if f == f64::NEG_INFINITY));
+        assert!(matches!(f64::extended_parse("-infinity00"),
+                         Err(ExtendedParserError::PartialMatch(f, "00")) if f == f64::NEG_INFINITY));
+        assert!(f64::extended_parse(&format!("{}", u64::MAX)).is_ok());
+        assert!(f64::extended_parse(&format!("{}", i64::MIN)).is_ok());
+
+        // f64 overflow/underflow
+        assert!(matches!(
+            f64::extended_parse("1.0e9000"),
+            Err(ExtendedParserError::Overflow(f64::INFINITY))
+        ));
+        assert!(matches!(
+            f64::extended_parse("-10.0e9000"),
+            Err(ExtendedParserError::Overflow(f64::NEG_INFINITY))
+        ));
+        assert!(matches!(
+            f64::extended_parse("1.0e-9000"),
+            Err(ExtendedParserError::Underflow(0.0))
+        ));
+        assert!(matches!(
+            f64::extended_parse("-1.0e-9000"),
+            Err(ExtendedParserError::Underflow(f)) if f == 0.0 && f.is_sign_negative()));
+    }
+
+    #[test]
+    fn test_decimal_extended_big_decimal() {
+        // f64 parsing above already tested a lot of these, just do a few.
+        // Careful, we usually cannot use From<f64> to get a precise ExtendedBigDecimal as numbers like 123.15 cannot be exactly represented by a f64.
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                BigDecimal::from_str("123").unwrap()
+            )),
+            ExtendedBigDecimal::extended_parse("123")
+        );
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                BigDecimal::from_str("123.15").unwrap()
+            )),
+            ExtendedBigDecimal::extended_parse("123.15")
+        );
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(BigDecimal::from_bigint(
+                12315.into(),
+                -98
+            ))),
+            ExtendedBigDecimal::extended_parse("123.15e100")
+        );
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(BigDecimal::from_bigint(
+                12315.into(),
+                102
+            ))),
+            ExtendedBigDecimal::extended_parse("123.15E-100")
+        );
+        // Very high precision that would not fit in a f64.
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                BigDecimal::from_str(".150000000000000000000000000000000000001").unwrap()
+            )),
+            ExtendedBigDecimal::extended_parse(".150000000000000000000000000000000000001")
+        );
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse("nan"),
+            Ok(ExtendedBigDecimal::Nan)
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse("-NAN"),
+            Ok(ExtendedBigDecimal::MinusNan)
+        ));
+        assert_eq!(
+            Ok(ExtendedBigDecimal::Infinity),
+            ExtendedBigDecimal::extended_parse("InF")
+        );
+        assert_eq!(
+            Ok(ExtendedBigDecimal::MinusInfinity),
+            ExtendedBigDecimal::extended_parse("-iNf")
+        );
+        assert_eq!(
+            Ok(ExtendedBigDecimal::zero()),
+            ExtendedBigDecimal::extended_parse("0.0")
+        );
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse("-0.0"),
+            Ok(ExtendedBigDecimal::MinusZero)
+        ));
+
+        // ExtendedBigDecimal overflow/underflow
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("1e{}", i64::MAX as u64 + 2)),
+            Err(ExtendedParserError::Overflow(ExtendedBigDecimal::Infinity))
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("-0.1e{}", i64::MAX as u64 + 3)),
+            Err(ExtendedParserError::Overflow(
+                ExtendedBigDecimal::MinusInfinity
+            ))
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("1e{}", i64::MIN)),
+            Err(ExtendedParserError::Underflow(ebd)) if ebd == ExtendedBigDecimal::zero()
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("-0.01e{}", i64::MIN + 2)),
+            Err(ExtendedParserError::Underflow(
+                ExtendedBigDecimal::MinusZero
+            ))
+        ));
+
+        // But no Overflow/Underflow if the digits are 0.
+        assert_eq!(
+            ExtendedBigDecimal::extended_parse(&format!("0e{}", i64::MAX as u64 + 2)),
+            Ok(ExtendedBigDecimal::zero()),
+        );
+        assert_eq!(
+            ExtendedBigDecimal::extended_parse(&format!("-0.0e{}", i64::MAX as u64 + 3)),
+            Ok(ExtendedBigDecimal::MinusZero)
+        );
+        assert_eq!(
+            ExtendedBigDecimal::extended_parse(&format!("0.0000e{}", i64::MIN)),
+            Ok(ExtendedBigDecimal::zero()),
+        );
+        assert_eq!(
+            ExtendedBigDecimal::extended_parse(&format!("-0e{}", i64::MIN + 2)),
+            Ok(ExtendedBigDecimal::MinusZero)
+        );
+
+        /* Invalid numbers */
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse(".")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("e")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse(".e")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("-e")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("+.e")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("e10")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("e-10")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("-e10")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            ExtendedBigDecimal::extended_parse("+e10")
+        );
+    }
+
+    #[test]
+    fn test_hexadecimal() {
+        assert_eq!(Ok(0x123), u64::extended_parse("0x123"));
+        assert_eq!(Ok(0x123), u64::extended_parse("0X123"));
+        assert_eq!(Ok(0x123), u64::extended_parse("+0x123"));
+        assert_eq!(Ok(0xfe), u64::extended_parse("0xfE"));
+        assert_eq!(Ok(-0x123), i64::extended_parse("-0x123"));
+
+        assert_eq!(Ok(0.5), f64::extended_parse("0x.8"));
+        assert_eq!(Ok(0.0625), f64::extended_parse("0x.1"));
+        assert_eq!(Ok(15.007_812_5), f64::extended_parse("0xf.02"));
+        assert_eq!(Ok(16.0), f64::extended_parse("0x0.8p5"));
+        assert_eq!(Ok(0.0625), f64::extended_parse("0x1P-4"));
+
+        // We cannot really check that 'e' is not a valid exponent indicator for hex floats...
+        // but we can check that the number still gets parsed properly: 0x0.8e5 is 0x8e5 / 16**3
+        assert_eq!(Ok(0.555908203125), f64::extended_parse("0x0.8e5"));
+
+        assert!(matches!(f64::extended_parse("0x0.1p"),
+                        Err(ExtendedParserError::PartialMatch(f, "p")) if f == 0.0625));
+        assert!(matches!(f64::extended_parse("0x0.1p-"),
+                        Err(ExtendedParserError::PartialMatch(f, "p-")) if f == 0.0625));
+        assert!(matches!(f64::extended_parse("0x.1p+"),
+                        Err(ExtendedParserError::PartialMatch(f, "p+")) if f == 0.0625));
+        assert!(matches!(f64::extended_parse("0x.1p."),
+                        Err(ExtendedParserError::PartialMatch(f, "p.")) if f == 0.0625));
+
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                BigDecimal::from_str("0.0625").unwrap()
+            )),
+            ExtendedBigDecimal::extended_parse("0x.1")
+        );
+
+        // Precisely parse very large hexadecimal numbers (i.e. with a large division).
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                BigDecimal::from_str("15.999999999999999999999999948301211715435770320536956745627321652136743068695068359375").unwrap()
+            )),
+            ExtendedBigDecimal::extended_parse("0xf.fffffffffffffffffffff")
+        );
+
+        // Test very large exponents (they used to take forever as we kept all digits in the past)
+        // Wolfram Alpha can get us (close to?) these values with a bit of log trickery:
+        // 2**3000000000 = 10**log_10(2**3000000000) = 10**(3000000000 * log_10(2))
+        // TODO: We do lose a little bit of precision, and the last digits are not be correct.
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                // Wolfram Alpha says 9.8162042336235053508313854078782835648991393286913072670026492205522618203568834202759669215027003865... × 10^903089986
+                BigDecimal::from_str("9.816204233623505350831385407878283564899139328691307267002649220552261820356883420275966921514831318e+903089986").unwrap()
+            )),
+            ExtendedBigDecimal::extended_parse("0x1p3000000000")
+        );
+        assert_eq!(
+            Ok(ExtendedBigDecimal::BigDecimal(
+                // Wolfram Alpha says 1.3492131462369983551036088935544888715959511045742395978049631768570509541390540646442193112226520316... × 10^-9030900
+                BigDecimal::from_str("1.349213146236998355103608893554488871595951104574239597804963176857050954139054064644219311222656999e-9030900").unwrap()
+            )),
+            // Couldn't get a answer from Wolfram Alpha for smaller negative exponents
+            ExtendedBigDecimal::extended_parse("0x1p-30000000")
+        );
+
+        // ExtendedBigDecimal overflow/underflow
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("0x1p{}", u32::MAX as u64 + 1)),
+            Err(ExtendedParserError::Overflow(ExtendedBigDecimal::Infinity))
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("-0x100P{}", u32::MAX as u64 + 1)),
+            Err(ExtendedParserError::Overflow(
+                ExtendedBigDecimal::MinusInfinity
+            ))
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("0x1p-{}", u32::MAX as u64 + 1)),
+            Err(ExtendedParserError::Underflow(ebd)) if ebd == ExtendedBigDecimal::zero()
+        ));
+        assert!(matches!(
+            ExtendedBigDecimal::extended_parse(&format!("-0x0.100p-{}", u32::MAX as u64 + 1)),
+            Err(ExtendedParserError::Underflow(
+                ExtendedBigDecimal::MinusZero
+            ))
+        ));
+
+        // Not actually hex numbers, but the prefixes look like it.
+        assert!(matches!(f64::extended_parse("0x"),
+            Err(ExtendedParserError::PartialMatch(f, "x")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("0x."),
+            Err(ExtendedParserError::PartialMatch(f, "x.")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("0xp"),
+            Err(ExtendedParserError::PartialMatch(f, "xp")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("0xp-2"),
+            Err(ExtendedParserError::PartialMatch(f, "xp-2")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("0x.p-2"),
+            Err(ExtendedParserError::PartialMatch(f, "x.p-2")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("0X"),
+            Err(ExtendedParserError::PartialMatch(f, "X")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("-0x"),
+            Err(ExtendedParserError::PartialMatch(f, "x")) if f == -0.0));
+        assert!(matches!(f64::extended_parse("+0x"),
+            Err(ExtendedParserError::PartialMatch(f, "x")) if f == 0.0));
+        assert!(matches!(f64::extended_parse("-0x."),
+            Err(ExtendedParserError::PartialMatch(f, "x.")) if f == -0.0));
+        assert!(matches!(
+            u64::extended_parse("0x"),
+            Err(ExtendedParserError::PartialMatch(0, "x"))
+        ));
+        assert!(matches!(
+            u64::extended_parse("-0x"),
+            Err(ExtendedParserError::PartialMatch(0, "x"))
+        ));
+        assert!(matches!(
+            i64::extended_parse("0x"),
+            Err(ExtendedParserError::PartialMatch(0, "x"))
+        ));
+        assert!(matches!(
+            i64::extended_parse("-0x"),
+            Err(ExtendedParserError::PartialMatch(0, "x"))
+        ));
+    }
+
+    #[test]
+    fn test_octal() {
+        assert_eq!(Ok(0), u64::extended_parse("0"));
+        assert_eq!(Ok(0o123), u64::extended_parse("0123"));
+        assert_eq!(Ok(0o123), u64::extended_parse("+0123"));
+        assert_eq!(Ok(-0o123), i64::extended_parse("-0123"));
+        assert_eq!(Ok(0o123), u64::extended_parse("00123"));
+        assert_eq!(Ok(0), u64::extended_parse("00"));
+        assert!(matches!(
+            u64::extended_parse("008"),
+            Err(ExtendedParserError::PartialMatch(0, "8"))
+        ));
+        assert!(matches!(
+            u64::extended_parse("08"),
+            Err(ExtendedParserError::PartialMatch(0, "8"))
+        ));
+        assert!(matches!(
+            u64::extended_parse("0."),
+            Err(ExtendedParserError::PartialMatch(0, "."))
+        ));
+
+        // No float tests, leading zeros get parsed as decimal anyway.
+    }
+
+    #[test]
+    fn test_binary() {
+        assert_eq!(Ok(0b1011), u64::extended_parse("0b1011"));
+        assert_eq!(Ok(0b1011), u64::extended_parse("0B1011"));
+        assert_eq!(Ok(0b1011), u64::extended_parse("+0b1011"));
+        assert_eq!(Ok(-0b1011), i64::extended_parse("-0b1011"));
+
+        assert!(matches!(
+            u64::extended_parse("0b"),
+            Err(ExtendedParserError::PartialMatch(0, "b"))
+        ));
+        assert!(matches!(
+            u64::extended_parse("0b."),
+            Err(ExtendedParserError::PartialMatch(0, "b."))
+        ));
+        assert!(matches!(
+            u64::extended_parse("-0b"),
+            Err(ExtendedParserError::PartialMatch(0, "b"))
+        ));
+        assert!(matches!(
+            i64::extended_parse("0b"),
+            Err(ExtendedParserError::PartialMatch(0, "b"))
+        ));
+        assert!(matches!(
+            i64::extended_parse("-0b"),
+            Err(ExtendedParserError::PartialMatch(0, "b"))
+        ));
+
+        // Binary not allowed for floats
+        assert!(matches!(
+            f64::extended_parse("0b100"),
+            Err(ExtendedParserError::PartialMatch(0f64, "b100"))
+        ));
+        assert!(matches!(
+            f64::extended_parse("0b100.1"),
+            Err(ExtendedParserError::PartialMatch(0f64, "b100.1"))
+        ));
+
+        assert!(match ExtendedBigDecimal::extended_parse("0b100.1") {
+            Err(ExtendedParserError::PartialMatch(ebd, "b100.1")) =>
+                ebd == ExtendedBigDecimal::zero(),
+            _ => false,
+        });
+
+        assert!(match ExtendedBigDecimal::extended_parse("0b") {
+            Err(ExtendedParserError::PartialMatch(ebd, "b")) => ebd == ExtendedBigDecimal::zero(),
+            _ => false,
+        });
+        assert!(match ExtendedBigDecimal::extended_parse("0b.") {
+            Err(ExtendedParserError::PartialMatch(ebd, "b.")) => ebd == ExtendedBigDecimal::zero(),
+            _ => false,
+        });
+    }
+
+    #[test]
+    fn test_parsing_with_leading_whitespace() {
+        assert_eq!(Ok(1), u64::extended_parse(" 0x1"));
+        assert_eq!(Ok(-2), i64::extended_parse(" -0x2"));
+        assert_eq!(Ok(-3), i64::extended_parse(" \t-0x3"));
+        assert_eq!(Ok(-4), i64::extended_parse(" \n-0x4"));
+        assert_eq!(Ok(-5), i64::extended_parse(" \n\t\u{000d}-0x5"));
+
+        // Ensure that trailing whitespace is still a partial match
+        assert_eq!(
+            Err(ExtendedParserError::PartialMatch(6, " ")),
+            u64::extended_parse("0x6 ")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::PartialMatch(7, "\t")),
+            u64::extended_parse("0x7\t")
+        );
+        assert_eq!(
+            Err(ExtendedParserError::PartialMatch(8, "\n")),
+            u64::extended_parse("0x8\n")
+        );
+
+        // Ensure that unicode non-ascii whitespace is a partial match
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            i64::extended_parse("\u{2029}-0x9")
+        );
+
+        // Ensure that whitespace after the number has "started" is not allowed
+        assert_eq!(
+            Err(ExtendedParserError::NotNumeric),
+            i64::extended_parse("- 0x9")
+        );
+    }
+}
diff --git a/src/uucore/src/lib/parser/parse_glob.rs b/src/uucore/src/lib/features/parser/parse_glob.rs
similarity index 89%
rename from src/uucore/src/lib/parser/parse_glob.rs
rename to src/uucore/src/lib/features/parser/parse_glob.rs
index 9215dd7bf7d..6f7dae24c98 100644
--- a/src/uucore/src/lib/parser/parse_glob.rs
+++ b/src/uucore/src/lib/features/parser/parse_glob.rs
@@ -18,7 +18,11 @@ fn fix_negation(glob: &str) -> String {
     while i + 3 < chars.len() {
         if chars[i] == '[' && chars[i + 1] == '^' {
             match chars[i + 3..].iter().position(|x| *x == ']') {
-                None => (),
+                None => {
+                    // if closing square bracket not found, stop looking for it
+                    // again
+                    break;
+                }
                 Some(j) => {
                     chars[i + 1] = '!';
                     i += j + 4;
@@ -44,7 +48,7 @@ fn fix_negation(glob: &str) -> String {
 ///
 /// ```rust
 /// use std::time::Duration;
-/// use uucore::parse_glob::from_str;
+/// use uucore::parser::parse_glob::from_str;
 /// assert!(!from_str("[^abc]").unwrap().matches("a"));
 /// assert!(from_str("[^abc]").unwrap().matches("x"));
 /// ```
@@ -90,6 +94,11 @@ mod tests {
         assert_eq!(fix_negation("[[]] [^a]"), "[[]] [!a]");
         assert_eq!(fix_negation("[[] [^a]"), "[[] [!a]");
         assert_eq!(fix_negation("[]] [^a]"), "[]] [!a]");
+
+        // test that we don't look for closing square brackets unnecessarily
+        // Verifies issue #5584
+        let chars = "^[".repeat(174_571);
+        assert_eq!(fix_negation(chars.as_str()), chars);
     }
 
     #[test]
diff --git a/src/uucore/src/lib/features/parser/parse_size.rs b/src/uucore/src/lib/features/parser/parse_size.rs
new file mode 100644
index 00000000000..da67a7602c6
--- /dev/null
+++ b/src/uucore/src/lib/features/parser/parse_size.rs
@@ -0,0 +1,766 @@
+// 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.
+// spell-checker:ignore (ToDO) hdsf ghead gtail ACDBK hexdigit
+
+//! Parser for sizes in SI or IEC units (multiples of 1000 or 1024 bytes).
+
+use std::error::Error;
+use std::fmt;
+#[cfg(target_os = "linux")]
+use std::io::BufRead;
+use std::num::{IntErrorKind, ParseIntError};
+
+use crate::display::Quotable;
+
+/// Error arising from trying to compute system memory.
+enum SystemError {
+    IOError,
+    ParseError,
+    NotFound,
+}
+
+impl From<std::io::Error> for SystemError {
+    fn from(_: std::io::Error) -> Self {
+        Self::IOError
+    }
+}
+
+impl From<ParseIntError> for SystemError {
+    fn from(_: ParseIntError) -> Self {
+        Self::ParseError
+    }
+}
+
+/// Get the total number of bytes of physical memory.
+///
+/// The information is read from the `/proc/meminfo` file.
+///
+/// # Errors
+///
+/// If there is a problem reading the file or finding the appropriate
+/// entry in the file.
+#[cfg(target_os = "linux")]
+fn total_physical_memory() -> Result<u128, SystemError> {
+    // On Linux, the `/proc/meminfo` file has a table with information
+    // about memory usage. For example,
+    //
+    //     MemTotal:        7811500 kB
+    //     MemFree:         1487876 kB
+    //     MemAvailable:    3857232 kB
+    //     ...
+    //
+    // We just need to extract the number of `MemTotal`
+    let table = std::fs::read("/proc/meminfo")?;
+    for line in table.lines() {
+        let line = line?;
+        if line.starts_with("MemTotal:") && line.ends_with("kB") {
+            let num_kilobytes: u128 = line[9..line.len() - 2].trim().parse()?;
+            let num_bytes = 1024 * num_kilobytes;
+            return Ok(num_bytes);
+        }
+    }
+    Err(SystemError::NotFound)
+}
+
+/// Get the total number of bytes of physical memory.
+///
+/// TODO Implement this for non-Linux systems.
+#[cfg(not(target_os = "linux"))]
+fn total_physical_memory() -> Result<u128, SystemError> {
+    Err(SystemError::NotFound)
+}
+
+/// Parser for sizes in SI or IEC units (multiples of 1000 or 1024 bytes).
+///
+/// The [`Parser::parse`] function performs the parse.
+#[derive(Default)]
+pub struct Parser<'parser> {
+    /// Whether to allow empty numeric strings.
+    pub no_empty_numeric: bool,
+    /// Whether to treat the suffix "B" as meaning "bytes".
+    pub capital_b_bytes: bool,
+    /// Whether to treat "b" as a "byte count" instead of "block"
+    pub b_byte_count: bool,
+    /// Whitelist for the suffix
+    pub allow_list: Option<&'parser [&'parser str]>,
+    /// Default unit when no suffix is provided
+    pub default_unit: Option<&'parser str>,
+}
+
+enum NumberSystem {
+    Decimal,
+    Octal,
+    Hexadecimal,
+}
+
+impl<'parser> Parser<'parser> {
+    /// Change allow_list of the parser - whitelist for the suffix
+    pub fn with_allow_list(&mut self, allow_list: &'parser [&str]) -> &mut Self {
+        self.allow_list = Some(allow_list);
+        self
+    }
+
+    /// Change default_unit of the parser - when no suffix is provided
+    pub fn with_default_unit(&mut self, default_unit: &'parser str) -> &mut Self {
+        self.default_unit = Some(default_unit);
+        self
+    }
+
+    /// Change b_byte_count of the parser - to treat "b" as a "byte count" instead of "block"
+    pub fn with_b_byte_count(&mut self, value: bool) -> &mut Self {
+        self.b_byte_count = value;
+        self
+    }
+
+    /// Change no_empty_numeric of the parser - to allow empty numeric strings
+    pub fn with_allow_empty_numeric(&mut self, value: bool) -> &mut Self {
+        self.no_empty_numeric = value;
+        self
+    }
+    /// Parse a size string into a number of bytes.
+    ///
+    /// A size string comprises an integer and an optional unit. The unit
+    /// may be K, M, G, T, P, E, Z, Y, R or Q (powers of 1024), or KB, MB,
+    /// etc. (powers of 1000), or b which is 512.
+    /// Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
+    ///
+    /// # Errors
+    ///
+    /// Will return `ParseSizeError` if it's not possible to parse this
+    /// string into a number, e.g. if the string does not begin with a
+    /// numeral, or if the unit is not one of the supported units described
+    /// in the preceding section.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use uucore::parser::parse_size::Parser;
+    /// let parser = Parser {
+    ///     default_unit: Some("M"),
+    ///     ..Default::default()
+    /// };
+    /// assert_eq!(Ok(123 * 1024 * 1024), parser.parse("123M")); // M is 1024^2
+    /// assert_eq!(Ok(123 * 1024 * 1024), parser.parse("123")); // default unit set to "M" on parser instance
+    /// assert_eq!(Ok(9 * 1000), parser.parse("9kB")); // kB is 1000
+    /// assert_eq!(Ok(2 * 1024), parser.parse("2K")); // K is 1024
+    /// assert_eq!(Ok(44251 * 1024), parser.parse("0xACDBK")); // 0xACDB is 44251 in decimal
+    /// ```
+    pub fn parse(&self, size: &str) -> Result<u128, ParseSizeError> {
+        if size.is_empty() {
+            return Err(ParseSizeError::parse_failure(size));
+        }
+
+        let number_system = 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(char::is_ascii_hexdigit))
+                .collect(),
+            _ => size.chars().take_while(char::is_ascii_digit).collect(),
+        };
+        let mut unit: &str = &size[numeric_string.len()..];
+
+        if let Some(default_unit) = self.default_unit {
+            // Check if `unit` is empty then assigns `default_unit` to `unit`
+            if unit.is_empty() {
+                unit = default_unit;
+            }
+        }
+
+        // Check if `b` is a byte count and remove `b`
+        if self.b_byte_count && unit.ends_with('b') {
+            // If `unit` = 'b' then return error
+            if numeric_string.is_empty() {
+                return Err(ParseSizeError::parse_failure(size));
+            }
+            unit = &unit[0..unit.len() - 1];
+        }
+
+        if let Some(allow_list) = self.allow_list {
+            // Check if `unit` appears in `allow_list`, if not return error
+            if !allow_list.contains(&unit) && !unit.is_empty() {
+                if numeric_string.is_empty() {
+                    return Err(ParseSizeError::parse_failure(size));
+                }
+                return Err(ParseSizeError::invalid_suffix(size));
+            }
+        }
+
+        // Special case: for percentage, just compute the given fraction
+        // of the total physical memory on the machine, if possible.
+        if unit == "%" {
+            let number: u128 = Self::parse_number(&numeric_string, 10, size)?;
+            return match total_physical_memory() {
+                Ok(total) => Ok((number / 100) * total),
+                Err(_) => Err(ParseSizeError::PhysicalMem(size.to_string())),
+            };
+        }
+
+        // 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),
+            "b" => (512, 1),
+            "KiB" | "kiB" | "K" | "k" => (1024, 1),
+            "MiB" | "miB" | "M" | "m" => (1024, 2),
+            "GiB" | "giB" | "G" | "g" => (1024, 3),
+            "TiB" | "tiB" | "T" | "t" => (1024, 4),
+            "PiB" | "piB" | "P" | "p" => (1024, 5),
+            "EiB" | "eiB" | "E" | "e" => (1024, 6),
+            "ZiB" | "ziB" | "Z" | "z" => (1024, 7),
+            "YiB" | "yiB" | "Y" | "y" => (1024, 8),
+            "RiB" | "riB" | "R" | "r" => (1024, 9),
+            "QiB" | "qiB" | "Q" | "q" => (1024, 10),
+            "KB" | "kB" => (1000, 1),
+            "MB" | "mB" => (1000, 2),
+            "GB" | "gB" => (1000, 3),
+            "TB" | "tB" => (1000, 4),
+            "PB" | "pB" => (1000, 5),
+            "EB" | "eB" => (1000, 6),
+            "ZB" | "zB" => (1000, 7),
+            "YB" | "yB" => (1000, 8),
+            "RB" | "rB" => (1000, 9),
+            "QB" | "qB" => (1000, 10),
+            _ if numeric_string.is_empty() => return Err(ParseSizeError::parse_failure(size)),
+            _ => return Err(ParseSizeError::invalid_suffix(size)),
+        };
+        let factor = base.pow(exponent);
+
+        // parse string into u128
+        let number: u128 = match number_system {
+            NumberSystem::Decimal => {
+                if numeric_string.is_empty() && !self.no_empty_numeric {
+                    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))
+    }
+
+    /// Explicit u128 alias for `parse()`
+    pub fn parse_u128(&self, size: &str) -> Result<u128, ParseSizeError> {
+        self.parse(size)
+    }
+
+    /// Same as `parse()` but tries to return u64
+    pub fn parse_u64(&self, size: &str) -> Result<u64, ParseSizeError> {
+        self.parse(size).and_then(|num_u128| {
+            u64::try_from(num_u128).map_err(|_| ParseSizeError::size_too_big(size))
+        })
+    }
+
+    /// Same as `parse_u64()`, except returns `u64::MAX` on overflow
+    /// GNU lib/coreutils include similar functionality
+    /// and GNU test suite checks this behavior for some utils (`split` for example)
+    pub fn parse_u64_max(&self, size: &str) -> Result<u64, ParseSizeError> {
+        let result = self.parse_u64(size);
+        match result {
+            Ok(_) => result,
+            Err(error) => {
+                if let ParseSizeError::SizeTooBig(_) = error {
+                    Ok(u64::MAX)
+                } else {
+                    Err(error)
+                }
+            }
+        }
+    }
+
+    /// Same as `parse_u64_max()`, except for u128, i.e. returns `u128::MAX` on overflow
+    pub fn parse_u128_max(&self, size: &str) -> Result<u128, ParseSizeError> {
+        let result = self.parse_u128(size);
+        match result {
+            Ok(_) => result,
+            Err(error) => {
+                if let ParseSizeError::SizeTooBig(_) = error {
+                    Ok(u128::MAX)
+                } else {
+                    Err(error)
+                }
+            }
+        }
+    }
+
+    fn determine_number_system(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(char::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(
+        numeric_string: &str,
+        radix: u32,
+        original_size: &str,
+    ) -> Result<u128, ParseSizeError> {
+        u128::from_str_radix(numeric_string, radix).map_err(|e| match e.kind() {
+            IntErrorKind::PosOverflow => ParseSizeError::size_too_big(original_size),
+            _ => ParseSizeError::ParseFailure(original_size.to_string()),
+        })
+    }
+}
+
+/// Parse a size string into a number of bytes
+/// using Default Parser (no custom settings)
+///
+/// # Examples
+///
+/// ```rust
+/// use uucore::parser::parse_size::parse_size_u128;
+/// assert_eq!(Ok(123), parse_size_u128("123"));
+/// assert_eq!(Ok(9 * 1000), parse_size_u128("9kB")); // kB is 1000
+/// assert_eq!(Ok(2 * 1024), parse_size_u128("2K")); // K is 1024
+/// assert_eq!(Ok(44251 * 1024), parse_size_u128("0xACDBK"));
+/// ```
+pub fn parse_size_u128(size: &str) -> Result<u128, ParseSizeError> {
+    Parser::default().parse(size)
+}
+
+/// Same as `parse_size_u128()`, but for u64
+pub fn parse_size_u64(size: &str) -> Result<u64, ParseSizeError> {
+    Parser::default().parse_u64(size)
+}
+
+/// Same as `parse_size_u64()` - deprecated
+#[deprecated = "Please use parse_size_u64(size: &str) -> Result<u64, ParseSizeError> OR parse_size_u128(size: &str) -> Result<u128, ParseSizeError> instead."]
+pub fn parse_size(size: &str) -> Result<u64, ParseSizeError> {
+    parse_size_u64(size)
+}
+
+/// Same as `parse_size_u64()`, except returns `u64::MAX` on overflow
+/// GNU lib/coreutils include similar functionality
+/// and GNU test suite checks this behavior for some utils
+pub fn parse_size_u64_max(size: &str) -> Result<u64, ParseSizeError> {
+    Parser::default().parse_u64_max(size)
+}
+
+/// Same as `parse_size_u128()`, except returns `u128::MAX` on overflow
+pub fn parse_size_u128_max(size: &str) -> Result<u128, ParseSizeError> {
+    Parser::default().parse_u128_max(size)
+}
+
+/// Error type for parse_size
+#[derive(Debug, PartialEq, Eq)]
+pub enum ParseSizeError {
+    /// Suffix
+    InvalidSuffix(String),
+
+    /// Syntax
+    ParseFailure(String),
+
+    /// Overflow
+    SizeTooBig(String),
+
+    /// Could not determine total physical memory size.
+    PhysicalMem(String),
+}
+
+impl Error for ParseSizeError {
+    fn description(&self) -> &str {
+        match *self {
+            Self::InvalidSuffix(ref s) => s,
+            Self::ParseFailure(ref s) => s,
+            Self::SizeTooBig(ref s) => s,
+            Self::PhysicalMem(ref s) => s,
+        }
+    }
+}
+
+impl fmt::Display for ParseSizeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        let s = match self {
+            Self::InvalidSuffix(s)
+            | Self::ParseFailure(s)
+            | Self::SizeTooBig(s)
+            | Self::PhysicalMem(s) => s,
+        };
+        write!(f, "{s}")
+    }
+}
+
+// FIXME: It's more idiomatic to move the formatting into the Display impl,
+// but there's a lot of downstream code that constructs these errors manually
+// that would be affected
+impl ParseSizeError {
+    fn invalid_suffix(s: &str) -> Self {
+        Self::InvalidSuffix(format!("{}", s.quote()))
+    }
+
+    fn parse_failure(s: &str) -> Self {
+        // stderr on linux (GNU coreutils 8.32) (LC_ALL=C)
+        // has to be handled in the respective uutils because strings differ, e.g.:
+        //
+        // `NUM`
+        // head:     invalid number of bytes: '1fb'
+        // tail:     invalid number of bytes: '1fb'
+        //
+        // `SIZE`
+        // split:    invalid number of bytes: '1fb'
+        // truncate: Invalid number: '1fb'
+        //
+        // `MODE`
+        // stdbuf:   invalid mode '1fb'
+        //
+        // `SIZE`
+        // sort:     invalid suffix in --buffer-size argument '1fb'
+        // sort:     invalid --buffer-size argument 'fb'
+        //
+        // `SIZE`
+        // du:       invalid suffix in --buffer-size argument '1fb'
+        // du:       invalid suffix in --threshold argument '1fb'
+        // du:       invalid --buffer-size argument 'fb'
+        // du:       invalid --threshold argument 'fb'
+        //
+        // `BYTES`
+        // od:       invalid suffix in --read-bytes argument '1fb'
+        // od:       invalid --read-bytes argument  argument 'fb'
+        //                   --skip-bytes
+        //                   --width
+        //                   --strings
+        // etc.
+        Self::ParseFailure(format!("{}", s.quote()))
+    }
+
+    fn size_too_big(s: &str) -> Self {
+        // stderr on linux (GNU coreutils 8.32) (LC_ALL=C)
+        // has to be handled in the respective uutils because strings differ, e.g.:
+        //
+        // head:     invalid number of bytes: '1Y': Value too large for defined data type
+        // tail:     invalid number of bytes: '1Y': Value too large for defined data type
+        // split:    invalid number of bytes: '1Y': Value too large for defined data type
+        // truncate:          Invalid number: '1Y': Value too large for defined data type
+        // stdbuf:               invalid mode '1Y': Value too large for defined data type
+        // sort:     -S argument '1Y' too large
+        // du:       -B argument '1Y' too large
+        // od:       -N argument '1Y' too large
+        // etc.
+        //
+        // stderr on macos (brew - GNU coreutils 8.32) also differs for the same version, e.g.:
+        // ghead:   invalid number of bytes: '1Y': Value too large to be stored in data type
+        // gtail:   invalid number of bytes: '1Y': Value too large to be stored in data type
+        Self::SizeTooBig(format!(
+            "{}: Value too large for defined data type",
+            s.quote()
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn variant_eq(a: &ParseSizeError, b: &ParseSizeError) -> bool {
+        std::mem::discriminant(a) == std::mem::discriminant(b)
+    }
+
+    #[test]
+    fn all_suffixes() {
+        // Units  are  K,M,G,T,P,E,Z,Y,R,Q (powers of 1024) or KB,MB,... (powers of 1000).
+        // Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
+        let suffixes = [
+            ('K', 1u32),
+            ('M', 2u32),
+            ('G', 3u32),
+            ('T', 4u32),
+            ('P', 5u32),
+            ('E', 6u32),
+            ('Z', 7u32),
+            ('Y', 8u32),
+            ('R', 9u32),
+            ('Q', 10u32),
+        ];
+
+        for &(c, exp) in &suffixes {
+            let s = format!("2{c}B"); // KB
+            assert_eq!(Ok(2 * 1000_u128.pow(exp)), parse_size_u128(&s));
+            let s = format!("2{c}"); // K
+            assert_eq!(Ok(2 * 1024_u128.pow(exp)), parse_size_u128(&s));
+            let s = format!("2{c}iB"); // KiB
+            assert_eq!(Ok(2 * 1024_u128.pow(exp)), parse_size_u128(&s));
+            let s = format!("2{}iB", c.to_lowercase()); // kiB
+            assert_eq!(Ok(2 * 1024_u128.pow(exp)), parse_size_u128(&s));
+
+            // suffix only
+            let s = format!("{c}B"); // KB
+            assert_eq!(Ok(1000_u128.pow(exp)), parse_size_u128(&s));
+            let s = format!("{c}"); // K
+            assert_eq!(Ok(1024_u128.pow(exp)), parse_size_u128(&s));
+            let s = format!("{c}iB"); // KiB
+            assert_eq!(Ok(1024_u128.pow(exp)), parse_size_u128(&s));
+            let s = format!("{}iB", c.to_lowercase()); // kiB
+            assert_eq!(Ok(1024_u128.pow(exp)), parse_size_u128(&s));
+        }
+    }
+
+    #[test]
+    fn overflow_x64() {
+        assert!(parse_size_u64("10000000000000000000000").is_err());
+        assert!(parse_size_u64("1000000000T").is_err());
+        assert!(parse_size_u64("100000P").is_err());
+        assert!(parse_size_u64("100E").is_err());
+        assert!(parse_size_u64("1Z").is_err());
+        assert!(parse_size_u64("1Y").is_err());
+        assert!(parse_size_u64("1R").is_err());
+        assert!(parse_size_u64("1Q").is_err());
+
+        assert!(variant_eq(
+            &parse_size_u64("1Z").unwrap_err(),
+            &ParseSizeError::SizeTooBig(String::new())
+        ));
+
+        assert_eq!(
+            ParseSizeError::SizeTooBig("'1Y': Value too large for defined data type".to_string()),
+            parse_size_u64("1Y").unwrap_err()
+        );
+        assert_eq!(
+            ParseSizeError::SizeTooBig("'1R': Value too large for defined data type".to_string()),
+            parse_size_u64("1R").unwrap_err()
+        );
+        assert_eq!(
+            ParseSizeError::SizeTooBig("'1Q': Value too large for defined data type".to_string()),
+            parse_size_u64("1Q").unwrap_err()
+        );
+    }
+
+    #[test]
+    fn overflow_to_max_u64() {
+        assert_eq!(Ok(1_099_511_627_776), parse_size_u64_max("1T"));
+        assert_eq!(Ok(1_125_899_906_842_624), parse_size_u64_max("1P"));
+        assert_eq!(Ok(u64::MAX), parse_size_u64_max("18446744073709551616"));
+        assert_eq!(Ok(u64::MAX), parse_size_u64_max("10000000000000000000000"));
+        assert_eq!(Ok(u64::MAX), parse_size_u64_max("1Y"));
+        assert_eq!(Ok(u64::MAX), parse_size_u64_max("1R"));
+        assert_eq!(Ok(u64::MAX), parse_size_u64_max("1Q"));
+    }
+
+    #[test]
+    fn overflow_to_max_u128() {
+        assert_eq!(
+            Ok(12_379_400_392_853_802_748_991_242_240),
+            parse_size_u128_max("10R")
+        );
+        assert_eq!(
+            Ok(12_676_506_002_282_294_014_967_032_053_760),
+            parse_size_u128_max("10Q")
+        );
+        assert_eq!(Ok(u128::MAX), parse_size_u128_max("1000000000000R"));
+        assert_eq!(Ok(u128::MAX), parse_size_u128_max("1000000000Q"));
+    }
+
+    #[test]
+    fn invalid_suffix() {
+        let test_strings = ["5mib", "1eb", "1H"];
+        for &test_string in &test_strings {
+            assert_eq!(
+                parse_size_u64(test_string).unwrap_err(),
+                ParseSizeError::InvalidSuffix(format!("{}", test_string.quote()))
+            );
+        }
+    }
+
+    #[test]
+    fn invalid_syntax() {
+        let test_strings = ["biB", "-", "+", "", "-1", "∞"];
+        for &test_string in &test_strings {
+            assert_eq!(
+                parse_size_u64(test_string).unwrap_err(),
+                ParseSizeError::ParseFailure(format!("{}", test_string.quote()))
+            );
+        }
+    }
+
+    #[test]
+    fn b_suffix() {
+        assert_eq!(Ok(3 * 512), parse_size_u64("3b")); // b is 512
+    }
+
+    #[test]
+    fn no_suffix() {
+        assert_eq!(Ok(1234), parse_size_u64("1234"));
+        assert_eq!(Ok(0), parse_size_u64("0"));
+        assert_eq!(Ok(5), parse_size_u64("5"));
+        assert_eq!(Ok(999), parse_size_u64("999"));
+    }
+
+    #[test]
+    fn kilobytes_suffix() {
+        assert_eq!(Ok(123 * 1000), parse_size_u64("123KB")); // KB is 1000
+        assert_eq!(Ok(9 * 1000), parse_size_u64("9kB")); // kB is 1000
+        assert_eq!(Ok(2 * 1024), parse_size_u64("2K")); // K is 1024
+        assert_eq!(Ok(0), parse_size_u64("0K"));
+        assert_eq!(Ok(0), parse_size_u64("0KB"));
+        assert_eq!(Ok(1000), parse_size_u64("KB"));
+        assert_eq!(Ok(1024), parse_size_u64("K"));
+        assert_eq!(Ok(2000), parse_size_u64("2kB"));
+        assert_eq!(Ok(4000), parse_size_u64("4KB"));
+    }
+
+    #[test]
+    fn megabytes_suffix() {
+        assert_eq!(Ok(123 * 1024 * 1024), parse_size_u64("123M"));
+        assert_eq!(Ok(123 * 1000 * 1000), parse_size_u64("123MB"));
+        assert_eq!(Ok(1024 * 1024), parse_size_u64("M"));
+        assert_eq!(Ok(1000 * 1000), parse_size_u64("MB"));
+        assert_eq!(Ok(2 * 1_048_576), parse_size_u64("2m"));
+        assert_eq!(Ok(4 * 1_048_576), parse_size_u64("4M"));
+        assert_eq!(Ok(2_000_000), parse_size_u64("2mB"));
+        assert_eq!(Ok(4_000_000), parse_size_u64("4MB"));
+    }
+
+    #[test]
+    fn gigabytes_suffix() {
+        assert_eq!(Ok(1_073_741_824), parse_size_u64("1G"));
+        assert_eq!(Ok(2_000_000_000), parse_size_u64("2GB"));
+    }
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn x64() {
+        assert_eq!(Ok(1_099_511_627_776), parse_size_u64("1T"));
+        assert_eq!(Ok(1_125_899_906_842_624), parse_size_u64("1P"));
+        assert_eq!(Ok(1_152_921_504_606_846_976), parse_size_u64("1E"));
+
+        assert_eq!(Ok(1_180_591_620_717_411_303_424), parse_size_u128("1Z"));
+        assert_eq!(Ok(1_208_925_819_614_629_174_706_176), parse_size_u128("1Y"));
+        assert_eq!(
+            Ok(1_237_940_039_285_380_274_899_124_224),
+            parse_size_u128("1R")
+        );
+        assert_eq!(
+            Ok(1_267_650_600_228_229_401_496_703_205_376),
+            parse_size_u128("1Q")
+        );
+
+        assert_eq!(Ok(2_000_000_000_000), parse_size_u64("2TB"));
+        assert_eq!(Ok(2_000_000_000_000_000), parse_size_u64("2PB"));
+        assert_eq!(Ok(2_000_000_000_000_000_000), parse_size_u64("2EB"));
+
+        assert_eq!(Ok(2_000_000_000_000_000_000_000), parse_size_u128("2ZB"));
+        assert_eq!(
+            Ok(2_000_000_000_000_000_000_000_000),
+            parse_size_u128("2YB")
+        );
+        assert_eq!(
+            Ok(2_000_000_000_000_000_000_000_000_000),
+            parse_size_u128("2RB")
+        );
+        assert_eq!(
+            Ok(2_000_000_000_000_000_000_000_000_000_000),
+            parse_size_u128("2QB")
+        );
+    }
+
+    #[test]
+    fn parse_size_options() {
+        let mut parser = Parser::default();
+
+        parser
+            .with_allow_list(&["k", "K", "G", "MB", "M"])
+            .with_default_unit("K");
+
+        assert_eq!(Ok(1024), parser.parse("1"));
+        assert_eq!(Ok(2 * 1024), parser.parse("2"));
+        assert_eq!(Ok(1000 * 1000), parser.parse("1MB"));
+        assert_eq!(Ok(1024 * 1024), parser.parse("1M"));
+        assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1G"));
+
+        assert!(parser.parse("1T").is_err());
+        assert!(parser.parse("1P").is_err());
+        assert!(parser.parse("1E").is_err());
+
+        parser
+            .with_allow_list(&[
+                "b", "k", "K", "m", "M", "MB", "g", "G", "t", "T", "P", "E", "Z", "Y", "R", "Q",
+            ])
+            .with_default_unit("K")
+            .with_b_byte_count(true);
+
+        assert_eq!(Ok(1024), parser.parse("1"));
+        assert_eq!(Ok(2 * 1024), parser.parse("2"));
+        assert_eq!(Ok(1000 * 1000), parser.parse("1MB"));
+        assert_eq!(Ok(1024 * 1024), parser.parse("1M"));
+        assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1G"));
+        assert_eq!(
+            Ok(1_237_940_039_285_380_274_899_124_224),
+            parser.parse_u128("1R")
+        );
+        assert_eq!(
+            Ok(1_267_650_600_228_229_401_496_703_205_376),
+            parser.parse_u128("1Q")
+        );
+
+        assert_eq!(Ok(1), parser.parse("1b"));
+        assert_eq!(Ok(1024), parser.parse("1024b"));
+        assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1024Mb"));
+
+        assert!(parser.parse("b").is_err());
+        assert!(parser.parse("1B").is_err());
+        assert!(parser.parse("B").is_err());
+    }
+
+    #[test]
+    fn parse_octal_size() {
+        assert_eq!(Ok(63), parse_size_u64("077"));
+        assert_eq!(Ok(528), parse_size_u64("01020"));
+        assert_eq!(Ok(668 * 1024), parse_size_u128("01234K"));
+    }
+
+    #[test]
+    fn parse_hex_size() {
+        assert_eq!(Ok(10), parse_size_u64("0xA"));
+        assert_eq!(Ok(94722), parse_size_u64("0x17202"));
+        assert_eq!(Ok(44251 * 1024), parse_size_u128("0xACDBK"));
+    }
+
+    #[test]
+    #[cfg(target_os = "linux")]
+    fn parse_percent() {
+        assert!(parse_size_u64("0%").is_ok());
+        assert!(parse_size_u64("50%").is_ok());
+        assert!(parse_size_u64("100%").is_ok());
+        assert!(parse_size_u64("100000%").is_ok());
+        assert!(parse_size_u64("-1%").is_err());
+        assert!(parse_size_u64("1.0%").is_err());
+        assert!(parse_size_u64("0x1%").is_err());
+    }
+}
diff --git a/src/uucore/src/lib/features/parser/parse_time.rs b/src/uucore/src/lib/features/parser/parse_time.rs
new file mode 100644
index 00000000000..3ec2e6332ce
--- /dev/null
+++ b/src/uucore/src/lib/features/parser/parse_time.rs
@@ -0,0 +1,282 @@
+// 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.
+
+// spell-checker:ignore (vars) NANOS numstr infinityh INFD nans nanh bigdecimal extendedbigdecimal
+//! Parsing a duration from a string.
+//!
+//! Use the [`from_str`] function to parse a [`Duration`] from a string.
+
+use crate::{
+    display::Quotable,
+    extendedbigdecimal::ExtendedBigDecimal,
+    parser::num_parser::{self, ExtendedParserError, ParseTarget},
+};
+use num_traits::Signed;
+use num_traits::ToPrimitive;
+use num_traits::Zero;
+use std::time::Duration;
+
+/// Parse a duration from a string.
+///
+/// The string may contain only a number, like "123" or "4.5", or it
+/// may contain a number with a unit specifier, like "123s" meaning
+/// one hundred twenty three seconds or "4.5d" meaning four and a half
+/// days. If no unit is specified, the unit is assumed to be seconds.
+///
+/// If `allow_suffixes` is true, the allowed suffixes are
+///
+/// * "s" for seconds,
+/// * "m" for minutes,
+/// * "h" for hours,
+/// * "d" for days.
+///
+/// This function does not overflow if large values are provided. If
+/// overflow would have occurred, [`Duration::MAX`] is returned instead.
+///
+/// If the value is smaller than 1 nanosecond, we return 1 nanosecond.
+///
+/// # Errors
+///
+/// This function returns an error if the input string is empty, the
+/// input is not a valid number, or the unit specifier is invalid or
+/// unknown.
+///
+/// # Examples
+///
+/// ```rust
+/// use std::time::Duration;
+/// use uucore::parser::parse_time::from_str;
+/// assert_eq!(from_str("123", true), Ok(Duration::from_secs(123)));
+/// assert_eq!(from_str("123", false), Ok(Duration::from_secs(123)));
+/// assert_eq!(from_str("2d", true), Ok(Duration::from_secs(60 * 60 * 24 * 2)));
+/// assert!(from_str("2d", false).is_err());
+/// ```
+pub fn from_str(string: &str, allow_suffixes: bool) -> Result<Duration, String> {
+    // TODO: Switch to Duration::NANOSECOND if that ever becomes stable
+    // https://github.com/rust-lang/rust/issues/57391
+    const NANOSECOND_DURATION: Duration = Duration::from_nanos(1);
+
+    let len = string.len();
+    if len == 0 {
+        return Err(format!("invalid time interval {}", string.quote()));
+    }
+    let num = match num_parser::parse(
+        string,
+        ParseTarget::Duration,
+        if allow_suffixes {
+            &[('s', 1), ('m', 60), ('h', 60 * 60), ('d', 60 * 60 * 24)]
+        } else {
+            &[]
+        },
+    ) {
+        Ok(ebd) | Err(ExtendedParserError::Overflow(ebd)) => ebd,
+        Err(ExtendedParserError::Underflow(_)) => return Ok(NANOSECOND_DURATION),
+        _ => {
+            return Err(format!("invalid time interval {}", string.quote()));
+        }
+    };
+
+    // Allow non-negative durations (-0 is fine), and infinity.
+    let num = match num {
+        ExtendedBigDecimal::BigDecimal(bd) if !bd.is_negative() => bd,
+        ExtendedBigDecimal::MinusZero => 0.into(),
+        ExtendedBigDecimal::Infinity => return Ok(Duration::MAX),
+        _ => return Err(format!("invalid time interval {}", string.quote())),
+    };
+
+    // Transform to nanoseconds (9 digits after decimal point)
+    let (nanos_bi, _) = num.with_scale(9).into_bigint_and_scale();
+
+    // If the value is smaller than a nanosecond, just return that.
+    if nanos_bi.is_zero() && !num.is_zero() {
+        return Ok(NANOSECOND_DURATION);
+    }
+
+    const NANOS_PER_SEC: u32 = 1_000_000_000;
+    let whole_secs: u64 = match (&nanos_bi / NANOS_PER_SEC).try_into() {
+        Ok(whole_secs) => whole_secs,
+        Err(_) => return Ok(Duration::MAX),
+    };
+    let nanos: u32 = (&nanos_bi % NANOS_PER_SEC).to_u32().unwrap();
+    Ok(Duration::new(whole_secs, nanos))
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::parser::parse_time::from_str;
+    use std::time::Duration;
+
+    #[test]
+    fn test_no_units() {
+        assert_eq!(from_str("123", true), Ok(Duration::from_secs(123)));
+        assert_eq!(from_str("123", false), Ok(Duration::from_secs(123)));
+    }
+
+    #[test]
+    fn test_units() {
+        assert_eq!(
+            from_str("2d", true),
+            Ok(Duration::from_secs(60 * 60 * 24 * 2))
+        );
+        assert!(from_str("2d", false).is_err());
+    }
+
+    #[test]
+    fn test_overflow() {
+        // u64 seconds overflow (in Duration)
+        assert_eq!(from_str("9223372036854775808d", true), Ok(Duration::MAX));
+        // ExtendedBigDecimal overflow
+        assert_eq!(from_str("1e92233720368547758080", false), Ok(Duration::MAX));
+        assert_eq!(from_str("1e92233720368547758080", false), Ok(Duration::MAX));
+    }
+
+    #[test]
+    fn test_underflow() {
+        // TODO: Switch to Duration::NANOSECOND if that ever becomes stable
+        // https://github.com/rust-lang/rust/issues/57391
+        const NANOSECOND_DURATION: Duration = Duration::from_nanos(1);
+
+        // ExtendedBigDecimal underflow
+        assert_eq!(
+            from_str("1e-92233720368547758080", true),
+            Ok(NANOSECOND_DURATION)
+        );
+        // nanoseconds underflow (in Duration, true)
+        assert_eq!(from_str("0.0000000001", true), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("1e-10", true), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("9e-10", true), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("1e-9", true), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("1.9e-9", true), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("2e-9", true), Ok(Duration::from_nanos(2)));
+
+        // ExtendedBigDecimal underflow
+        assert_eq!(
+            from_str("1e-92233720368547758080", false),
+            Ok(NANOSECOND_DURATION)
+        );
+        // nanoseconds underflow (in Duration, false)
+        assert_eq!(from_str("0.0000000001", false), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("1e-10", false), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("9e-10", false), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("1e-9", false), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("1.9e-9", false), Ok(NANOSECOND_DURATION));
+        assert_eq!(from_str("2e-9", false), Ok(Duration::from_nanos(2)));
+    }
+
+    #[test]
+    fn test_zero() {
+        assert_eq!(from_str("0e-9", true), Ok(Duration::ZERO));
+        assert_eq!(from_str("0e-100", true), Ok(Duration::ZERO));
+        assert_eq!(
+            from_str("0e-92233720368547758080", true),
+            Ok(Duration::ZERO)
+        );
+        assert_eq!(
+            from_str("0.000000000000000000000", true),
+            Ok(Duration::ZERO)
+        );
+
+        assert_eq!(from_str("0e-9", false), Ok(Duration::ZERO));
+        assert_eq!(from_str("0e-100", false), Ok(Duration::ZERO));
+        assert_eq!(
+            from_str("0e-92233720368547758080", false),
+            Ok(Duration::ZERO)
+        );
+        assert_eq!(
+            from_str("0.000000000000000000000", false),
+            Ok(Duration::ZERO)
+        );
+    }
+
+    #[test]
+    fn test_hex_float() {
+        assert_eq!(
+            from_str("0x1.1p-1", true),
+            Ok(Duration::from_secs_f64(0.53125f64))
+        );
+        assert_eq!(
+            from_str("0x1.1p-1", false),
+            Ok(Duration::from_secs_f64(0.53125f64))
+        );
+        assert_eq!(
+            from_str("0x1.1p-1d", true),
+            Ok(Duration::from_secs_f64(0.53125f64 * 3600.0 * 24.0))
+        );
+        assert_eq!(from_str("0xfh", true), Ok(Duration::from_secs(15 * 3600)));
+    }
+
+    #[test]
+    fn test_error_empty() {
+        assert!(from_str("", true).is_err());
+        assert!(from_str("", false).is_err());
+    }
+
+    #[test]
+    fn test_error_invalid_unit() {
+        assert!(from_str("123X", true).is_err());
+        assert!(from_str("123X", false).is_err());
+    }
+
+    #[test]
+    fn test_error_multi_bytes_characters() {
+        assert!(from_str("10€", true).is_err());
+        assert!(from_str("10€", false).is_err());
+    }
+
+    #[test]
+    fn test_error_invalid_magnitude() {
+        assert!(from_str("12abc3s", true).is_err());
+        assert!(from_str("12abc3s", false).is_err());
+    }
+
+    #[test]
+    fn test_error_only_point() {
+        assert!(from_str(".", true).is_err());
+        assert!(from_str(".", false).is_err());
+    }
+
+    #[test]
+    fn test_negative() {
+        assert!(from_str("-1", true).is_err());
+        assert!(from_str("-1", false).is_err());
+    }
+
+    #[test]
+    fn test_infinity() {
+        assert_eq!(from_str("inf", true), Ok(Duration::MAX));
+        assert_eq!(from_str("infinity", true), Ok(Duration::MAX));
+        assert_eq!(from_str("infinityh", true), Ok(Duration::MAX));
+        assert_eq!(from_str("INF", true), Ok(Duration::MAX));
+        assert_eq!(from_str("INFs", true), Ok(Duration::MAX));
+
+        assert_eq!(from_str("inf", false), Ok(Duration::MAX));
+        assert_eq!(from_str("infinity", false), Ok(Duration::MAX));
+        assert_eq!(from_str("INF", false), Ok(Duration::MAX));
+    }
+
+    #[test]
+    fn test_nan() {
+        assert!(from_str("nan", true).is_err());
+        assert!(from_str("nans", true).is_err());
+        assert!(from_str("-nanh", true).is_err());
+        assert!(from_str("NAN", true).is_err());
+        assert!(from_str("-NAN", true).is_err());
+
+        assert!(from_str("nan", false).is_err());
+        assert!(from_str("NAN", false).is_err());
+        assert!(from_str("-NAN", false).is_err());
+    }
+
+    /// Test that capital letters are not allowed in suffixes.
+    #[test]
+    fn test_no_capital_letters() {
+        assert!(from_str("1S", true).is_err());
+        assert!(from_str("1M", true).is_err());
+        assert!(from_str("1H", true).is_err());
+        assert!(from_str("1D", true).is_err());
+        assert!(from_str("INFD", true).is_err());
+    }
+}
diff --git a/src/uucore/src/lib/parser/shortcut_value_parser.rs b/src/uucore/src/lib/features/parser/shortcut_value_parser.rs
similarity index 61%
rename from src/uucore/src/lib/parser/shortcut_value_parser.rs
rename to src/uucore/src/lib/features/parser/shortcut_value_parser.rs
index 49bb2b62b71..5800a91f8a2 100644
--- a/src/uucore/src/lib/parser/shortcut_value_parser.rs
+++ b/src/uucore/src/lib/features/parser/shortcut_value_parser.rs
@@ -2,12 +2,17 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore abcdefgh
+// spell-checker:ignore abcdefgh abef Strs
+
+//! A parser that accepts shortcuts for values.
+//! `ShortcutValueParser` is similar to clap's `PossibleValuesParser`
+
 use clap::{
     builder::{PossibleValue, TypedValueParser},
     error::{ContextKind, ContextValue, ErrorKind},
 };
 
+/// A parser that accepts shortcuts for values.
 #[derive(Clone)]
 pub struct ShortcutValueParser(Vec<PossibleValue>);
 
@@ -17,6 +22,7 @@ pub struct ShortcutValueParser(Vec<PossibleValue>);
 /// Whereas `PossibleValuesParser` only accepts exact matches, `ShortcutValueParser` also accepts
 /// shortcuts as long as they are unambiguous.
 impl ShortcutValueParser {
+    /// Create a new `ShortcutValueParser` from a list of `PossibleValue`.
     pub fn new(values: impl Into<Self>) -> Self {
         values.into()
     }
@@ -26,6 +32,7 @@ impl ShortcutValueParser {
         cmd: &clap::Command,
         arg: Option<&clap::Arg>,
         value: &str,
+        possible_values: &[&PossibleValue],
     ) -> clap::Error {
         let mut err = clap::Error::new(ErrorKind::InvalidValue).with_cmd(cmd);
 
@@ -46,10 +53,38 @@ impl ShortcutValueParser {
             ContextValue::Strings(self.0.iter().map(|x| x.get_name().to_string()).collect()),
         );
 
+        // if `possible_values` is not empty then that means this error is because of an ambiguous value.
+        if !possible_values.is_empty() {
+            add_ambiguous_value_tip(possible_values, &mut err, value);
+        }
         err
     }
 }
 
+/// Adds a suggestion when error is because of ambiguous values based on the provided possible values.
+fn add_ambiguous_value_tip(
+    possible_values: &[&PossibleValue],
+    err: &mut clap::error::Error,
+    value: &str,
+) {
+    let mut formatted_possible_values = String::new();
+    for (i, s) in possible_values.iter().enumerate() {
+        formatted_possible_values.push_str(&format!("'{}'", s.get_name()));
+        if i < possible_values.len() - 2 {
+            formatted_possible_values.push_str(", ");
+        } else if i < possible_values.len() - 1 {
+            formatted_possible_values.push_str(" or ");
+        }
+    }
+    err.insert(
+        ContextKind::Suggested,
+        ContextValue::StyledStrs(vec![format!(
+            "It looks like '{value}' could match several values. Did you mean {formatted_possible_values}?"
+        )
+        .into()]),
+    );
+}
+
 impl TypedValueParser for ShortcutValueParser {
     type Value = String;
 
@@ -66,17 +101,17 @@ impl TypedValueParser for ShortcutValueParser {
         let matched_values: Vec<_> = self
             .0
             .iter()
-            .filter(|x| x.get_name().starts_with(value))
+            .filter(|x| x.get_name_and_aliases().any(|name| name.starts_with(value)))
             .collect();
 
         match matched_values.len() {
-            0 => Err(self.generate_clap_error(cmd, arg, value)),
+            0 => Err(self.generate_clap_error(cmd, arg, value, &[])),
             1 => Ok(matched_values[0].get_name().to_string()),
             _ => {
                 if let Some(direct_match) = matched_values.iter().find(|x| x.get_name() == value) {
                     Ok(direct_match.get_name().to_string())
                 } else {
-                    Err(self.generate_clap_error(cmd, arg, value))
+                    Err(self.generate_clap_error(cmd, arg, value, &matched_values))
                 }
             }
         }
@@ -101,7 +136,7 @@ where
 mod tests {
     use std::ffi::OsStr;
 
-    use clap::{builder::TypedValueParser, error::ErrorKind, Command};
+    use clap::{Command, builder::PossibleValue, builder::TypedValueParser, error::ErrorKind};
 
     use super::ShortcutValueParser;
 
@@ -137,7 +172,10 @@ mod tests {
 
         for ambiguous_value in ambiguous_values {
             let result = parser.parse_ref(&cmd, None, OsStr::new(ambiguous_value));
-            assert_eq!(ErrorKind::InvalidValue, result.unwrap_err().kind());
+            assert_eq!(ErrorKind::InvalidValue, result.as_ref().unwrap_err().kind());
+            assert!(result.unwrap_err().to_string().contains(&format!(
+                "It looks like '{ambiguous_value}' could match several values. Did you mean 'abcd' or 'abef'?"
+            )));
         }
 
         let result = parser.parse_ref(&cmd, None, OsStr::new("abc"));
@@ -163,7 +201,33 @@ mod tests {
         let parser = ShortcutValueParser::new(["abcd"]);
         let cmd = Command::new("cmd");
 
-        let result = parser.parse_ref(&cmd, None, OsStr::from_bytes(&[0xc3 as u8, 0x28 as u8]));
+        let result = parser.parse_ref(&cmd, None, OsStr::from_bytes(&[0xc3, 0x28]));
         assert_eq!(ErrorKind::InvalidUtf8, result.unwrap_err().kind());
     }
+
+    #[test]
+    fn test_ambiguous_word_same_meaning() {
+        let cmd = Command::new("cmd");
+        let parser = ShortcutValueParser::new([
+            PossibleValue::new("atime").alias("access"),
+            "status".into(),
+        ]);
+        // Even though "a" is ambiguous (it might mean "atime" or "access"),
+        // the meaning is uniquely defined, therefore accept it.
+        let atime_values = [
+            // spell-checker:disable-next-line
+            "atime", "atim", "at", "a", "access", "acces", "acce", "acc", "ac",
+        ];
+        // spell-checker:disable-next-line
+        let status_values = ["status", "statu", "stat", "sta", "st", "st"];
+
+        for value in atime_values {
+            let result = parser.parse_ref(&cmd, None, OsStr::new(value));
+            assert_eq!("atime", result.unwrap());
+        }
+        for value in status_values {
+            let result = parser.parse_ref(&cmd, None, OsStr::new(value));
+            assert_eq!("status", result.unwrap());
+        }
+    }
 }
diff --git a/src/uucore/src/lib/features/perms.rs b/src/uucore/src/lib/features/perms.rs
index 5384b52a18f..d044fce81fe 100644
--- a/src/uucore/src/lib/features/perms.rs
+++ b/src/uucore/src/lib/features/perms.rs
@@ -5,17 +5,15 @@
 
 //! Common functions to manage permissions
 
+// spell-checker:ignore (jargon) TOCTOU
+
 use crate::display::Quotable;
-use crate::error::strip_errno;
-use crate::error::UResult;
-use crate::error::USimpleError;
+use crate::error::{UResult, USimpleError, strip_errno};
 pub use crate::features::entries;
-use crate::fs::resolve_relative_path;
 use crate::show_error;
-use clap::Arg;
-use clap::ArgMatches;
-use clap::Command;
-use libc::{self, gid_t, uid_t};
+use clap::{Arg, ArgMatches, Command};
+use libc::{gid_t, uid_t};
+use options::traverse;
 use walkdir::WalkDir;
 
 use std::io::Error as IOError;
@@ -26,7 +24,7 @@ use std::fs::Metadata;
 use std::os::unix::fs::MetadataExt;
 
 use std::os::unix::ffi::OsStrExt;
-use std::path::Path;
+use std::path::{MAIN_SEPARATOR, Path};
 
 /// The various level of verbosity
 #[derive(PartialEq, Eq, Clone, Debug)]
@@ -36,6 +34,7 @@ pub enum VerbosityLevel {
     Verbose,
     Normal,
 }
+
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Verbosity {
     pub groups_only: bool,
@@ -81,21 +80,19 @@ pub fn wrap_chown<P: AsRef<Path>>(
             VerbosityLevel::Silent => (),
             level => {
                 out = format!(
-                    "changing {} of {}: {}",
+                    "changing {} of {}: {e}",
                     if verbosity.groups_only {
                         "group"
                     } else {
                         "ownership"
                     },
                     path.quote(),
-                    e
                 );
                 if level == VerbosityLevel::Verbose {
                     out = if verbosity.groups_only {
                         let gid = meta.gid();
                         format!(
-                            "{}\nfailed to change group of {} from {} to {}",
-                            out,
+                            "{out}\nfailed to change group of {} from {} to {}",
                             path.quote(),
                             entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()),
                             entries::gid2grp(dest_gid).unwrap_or_else(|_| dest_gid.to_string())
@@ -104,8 +101,7 @@ pub fn wrap_chown<P: AsRef<Path>>(
                         let uid = meta.uid();
                         let gid = meta.gid();
                         format!(
-                            "{}\nfailed to change ownership of {} from {}:{} to {}:{}",
-                            out,
+                            "{out}\nfailed to change ownership of {} from {}:{} to {}:{}",
                             path.quote(),
                             entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
                             entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string()),
@@ -192,6 +188,73 @@ pub struct ChownExecutor {
     pub dereference: bool,
 }
 
+#[cfg(test)]
+pub fn check_root(path: &Path, would_recurse_symlink: bool) -> bool {
+    is_root(path, would_recurse_symlink)
+}
+
+/// In the context of chown and chgrp, check whether we are in a "preserve-root" scenario.
+///
+/// In particular, we want to prohibit further traversal only if:
+///     (--preserve-root and -R present) &&
+///     (path canonicalizes to "/") &&
+///     (
+///         (path is a symlink && would traverse/recurse this symlink) ||
+///         (path is not a symlink)
+///     )
+/// The first clause is checked by the caller, the second and third clause is checked here.
+/// The caller has to evaluate -P/-H/-L into 'would_recurse_symlink'.
+/// Recall that canonicalization resolves both relative paths (e.g. "..") and symlinks.
+fn is_root(path: &Path, would_traverse_symlink: bool) -> bool {
+    // The third clause can be evaluated without any syscalls, so we do that first.
+    // If we would_recurse_symlink, then the clause is true no matter whether the path is a symlink
+    // or not. Otherwise, we only need to check here if the path can syntactically be a symlink:
+    if !would_traverse_symlink {
+        // We cannot check path.is_dir() here, as this would resolve symlinks,
+        // which we need to avoid here.
+        // All directory-ish paths match "*/", except ".", "..", "*/.", and "*/..".
+        let path_bytes = path.as_os_str().as_encoded_bytes();
+        let looks_like_dir = path_bytes == [b'.']
+            || path_bytes == [b'.', b'.']
+            || path_bytes.ends_with(&[MAIN_SEPARATOR as u8])
+            || path_bytes.ends_with(&[MAIN_SEPARATOR as u8, b'.'])
+            || path_bytes.ends_with(&[MAIN_SEPARATOR as u8, b'.', b'.']);
+
+        if !looks_like_dir {
+            return false;
+        }
+    }
+
+    // FIXME: TOCTOU bug! canonicalize() runs at a different time than WalkDir's recursion decision.
+    // However, we're forced to make the decision whether to warn about --preserve-root
+    // *before* even attempting to chown the path, let alone doing the stat inside WalkDir.
+    if let Ok(p) = path.canonicalize() {
+        let path_buf = path.to_path_buf();
+        if p.parent().is_none() {
+            if path_buf.as_os_str() == "/" {
+                show_error!("it is dangerous to operate recursively on '/'");
+            } else {
+                show_error!(
+                    "it is dangerous to operate recursively on {} (same as '/')",
+                    path_buf.quote()
+                );
+            }
+            show_error!("use --no-preserve-root to override this failsafe");
+            return true;
+        }
+    }
+
+    false
+}
+
+pub fn get_metadata(file: &Path, follow: bool) -> Result<Metadata, std::io::Error> {
+    if follow {
+        file.metadata()
+    } else {
+        file.symlink_metadata()
+    }
+}
+
 impl ChownExecutor {
     pub fn exec(&self) -> UResult<()> {
         let mut ret = 0;
@@ -207,45 +270,23 @@ impl ChownExecutor {
     #[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,
-            _ => {
-                if self.verbosity.level == VerbosityLevel::Verbose {
-                    println!(
-                        "failed to change ownership of {} to {}",
-                        path.quote(),
-                        self.raw_owner
-                    );
-                }
-                return 1;
+        let Some(meta) = self.obtain_meta(path, self.dereference) else {
+            if self.verbosity.level == VerbosityLevel::Verbose {
+                println!(
+                    "failed to change ownership of {} to {}",
+                    path.quote(),
+                    self.raw_owner
+                );
             }
+            return 1;
         };
 
-        // Prohibit only if:
-        // (--preserve-root and -R present) &&
-        // (
-        //     (argument is not symlink && resolved to be '/') ||
-        //     (argument is symlink && should follow argument && resolved to be '/')
-        // )
-        if self.recursive && self.preserve_root {
-            let may_exist = if self.dereference {
-                path.canonicalize().ok()
-            } else {
-                let real = resolve_relative_path(path);
-                if real.is_dir() {
-                    Some(real.canonicalize().expect("failed to get real path"))
-                } else {
-                    Some(real.into_owned())
-                }
-            };
-
-            if let Some(p) = may_exist {
-                if p.parent().is_none() {
-                    show_error!("it is dangerous to operate recursively on '/'");
-                    show_error!("use --no-preserve-root to override this failsafe");
-                    return 1;
-                }
-            }
+        if self.recursive
+            && self.preserve_root
+            && is_root(path, self.traverse_symlinks != TraverseSymlinks::None)
+        {
+            // Fail-fast, do not attempt to recurse.
+            return 1;
         }
 
         let ret = if self.matched(meta.uid(), meta.gid()) {
@@ -259,13 +300,13 @@ impl ChownExecutor {
             ) {
                 Ok(n) => {
                     if !n.is_empty() {
-                        show_error!("{}", n);
+                        show_error!("{n}");
                     }
                     0
                 }
                 Err(e) => {
                     if self.verbosity.level != VerbosityLevel::Silent {
-                        show_error!("{}", e);
+                        show_error!("{e}");
                     }
                     1
                 }
@@ -316,26 +357,30 @@ impl ChownExecutor {
                             }
                         );
                     } else {
-                        show_error!("{}", e);
+                        show_error!("{e}");
                     }
                     continue;
                 }
                 Ok(entry) => entry,
             };
             let path = entry.path();
-            let meta = match self.obtain_meta(path, self.dereference) {
-                Some(m) => m,
-                _ => {
-                    ret = 1;
-                    if entry.file_type().is_dir() {
-                        // Instruct walkdir to skip this directory to avoid getting another error
-                        // when walkdir tries to query the children of this directory.
-                        iterator.skip_current_dir();
-                    }
-                    continue;
+
+            let Some(meta) = self.obtain_meta(path, self.dereference) else {
+                ret = 1;
+                if entry.file_type().is_dir() {
+                    // Instruct walkdir to skip this directory to avoid getting another error
+                    // when walkdir tries to query the children of this directory.
+                    iterator.skip_current_dir();
                 }
+                continue;
             };
 
+            if self.preserve_root && is_root(path, self.traverse_symlinks == TraverseSymlinks::All)
+            {
+                // Fail-fast, do not recurse further.
+                return 1;
+            }
+
             if !self.matched(meta.uid(), meta.gid()) {
                 self.print_verbose_ownership_retained_as(
                     path,
@@ -355,13 +400,13 @@ impl ChownExecutor {
             ) {
                 Ok(n) => {
                     if !n.is_empty() {
-                        show_error!("{}", n);
+                        show_error!("{n}");
                     }
                     0
                 }
                 Err(e) => {
                     if self.verbosity.level != VerbosityLevel::Silent {
-                        show_error!("{}", e);
+                        show_error!("{e}");
                     }
                     1
                 }
@@ -372,26 +417,18 @@ impl ChownExecutor {
 
     fn obtain_meta<P: AsRef<Path>>(&self, path: P, follow: bool) -> Option<Metadata> {
         let path = path.as_ref();
-        let meta = if follow {
-            path.metadata()
-        } else {
-            path.symlink_metadata()
-        };
-        match meta {
-            Err(e) => {
-                match self.verbosity.level {
-                    VerbosityLevel::Silent => (),
-                    _ => show_error!(
+        get_metadata(path, follow)
+            .inspect_err(|e| {
+                if self.verbosity.level != VerbosityLevel::Silent {
+                    show_error!(
                         "cannot {} {}: {}",
                         if follow { "dereference" } else { "access" },
                         path.quote(),
-                        strip_errno(&e)
-                    ),
+                        strip_errno(e)
+                    );
                 }
-                None
-            }
-            Ok(meta) => Some(meta),
-        }
+            })
+            .ok()
     }
 
     #[inline]
@@ -406,29 +443,21 @@ impl ChownExecutor {
 
     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()),
-                    );
-                }
+            let ownership = match (self.dest_uid, self.dest_gid, gid) {
+                (Some(_), Some(_), Some(gid)) => format!(
+                    "{}:{}",
+                    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()),
-                    );
+                    entries::gid2grp(gid).unwrap_or_else(|_| gid.to_string())
                 }
+                _ => entries::uid2usr(uid).unwrap_or_else(|_| uid.to_string()),
+            };
+            if self.verbosity.groups_only {
+                println!("group of {} retained as {ownership}", path.quote());
+            } else {
+                println!("ownership of {} retained as {ownership}", path.quote());
             }
         }
     }
@@ -471,6 +500,47 @@ pub struct GidUidOwnerFilter {
 }
 type GidUidFilterOwnerParser = fn(&ArgMatches) -> UResult<GidUidOwnerFilter>;
 
+/// Determines symbolic link traversal and recursion settings based on flags.
+/// Returns the updated `dereference` and `traverse_symlinks` values.
+pub fn configure_symlink_and_recursion(
+    matches: &ArgMatches,
+    default_traverse_symlinks: TraverseSymlinks,
+) -> Result<(bool, bool, TraverseSymlinks), Box<dyn crate::error::UError>> {
+    let mut dereference = if matches.get_flag(options::dereference::DEREFERENCE) {
+        Some(true) // Follow symlinks
+    } else if matches.get_flag(options::dereference::NO_DEREFERENCE) {
+        Some(false) // Do not follow symlinks
+    } else {
+        None // Default behavior
+    };
+
+    let mut traverse_symlinks = default_traverse_symlinks;
+    if matches.get_flag("L") {
+        traverse_symlinks = TraverseSymlinks::All
+    } else if matches.get_flag("H") {
+        traverse_symlinks = TraverseSymlinks::First
+    } else if matches.get_flag("P") {
+        traverse_symlinks = TraverseSymlinks::None
+    };
+
+    let recursive = matches.get_flag(options::RECURSIVE);
+    if recursive {
+        if traverse_symlinks == TraverseSymlinks::None {
+            if dereference == Some(true) {
+                return Err(USimpleError::new(
+                    1,
+                    "-R --dereference requires -H or -L".to_string(),
+                ));
+            }
+            dereference = Some(false);
+        }
+    } else {
+        traverse_symlinks = TraverseSymlinks::None;
+    }
+
+    Ok((recursive, dereference.unwrap_or(true), traverse_symlinks))
+}
+
 /// Base implementation for `chgrp` and `chown`.
 ///
 /// An argument called `add_arg_if_not_reference` will be added to `command` if
@@ -526,34 +596,8 @@ pub fn chown_base(
         .unwrap_or_default();
 
     let preserve_root = matches.get_flag(options::preserve_root::PRESERVE);
-
-    let mut dereference = if matches.get_flag(options::dereference::DEREFERENCE) {
-        Some(true)
-    } else if matches.get_flag(options::dereference::NO_DEREFERENCE) {
-        Some(false)
-    } else {
-        None
-    };
-
-    let mut traverse_symlinks = if matches.get_flag(options::traverse::TRAVERSE) {
-        TraverseSymlinks::First
-    } else if matches.get_flag(options::traverse::EVERY) {
-        TraverseSymlinks::All
-    } else {
-        TraverseSymlinks::None
-    };
-
-    let recursive = matches.get_flag(options::RECURSIVE);
-    if recursive {
-        if traverse_symlinks == TraverseSymlinks::None {
-            if dereference == Some(true) {
-                return Err(USimpleError::new(1, "-R --dereference requires -H or -L"));
-            }
-            dereference = Some(false);
-        }
-    } else {
-        traverse_symlinks = TraverseSymlinks::None;
-    }
+    let (recursive, dereference, traverse_symlinks) =
+        configure_symlink_and_recursion(&matches, TraverseSymlinks::None)?;
 
     let verbosity_level = if matches.get_flag(options::verbosity::CHANGES) {
         VerbosityLevel::Changes
@@ -583,10 +627,116 @@ pub fn chown_base(
             level: verbosity_level,
         },
         recursive,
-        dereference: dereference.unwrap_or(true),
+        dereference,
         preserve_root,
         files,
         filter,
     };
     executor.exec()
 }
+
+pub fn common_args() -> Vec<Arg> {
+    vec![
+        Arg::new(traverse::TRAVERSE)
+            .short(traverse::TRAVERSE.chars().next().unwrap())
+            .help("if a command line argument is a symbolic link to a directory, traverse it")
+            .overrides_with_all([traverse::EVERY, traverse::NO_TRAVERSE])
+            .action(clap::ArgAction::SetTrue),
+        Arg::new(traverse::EVERY)
+            .short(traverse::EVERY.chars().next().unwrap())
+            .help("traverse every symbolic link to a directory encountered")
+            .overrides_with_all([traverse::TRAVERSE, traverse::NO_TRAVERSE])
+            .action(clap::ArgAction::SetTrue),
+        Arg::new(traverse::NO_TRAVERSE)
+            .short(traverse::NO_TRAVERSE.chars().next().unwrap())
+            .help("do not traverse any symbolic links (default)")
+            .overrides_with_all([traverse::TRAVERSE, traverse::EVERY])
+            .action(clap::ArgAction::SetTrue),
+        Arg::new(options::dereference::DEREFERENCE)
+            .long(options::dereference::DEREFERENCE)
+            .help(
+                "affect the referent of each symbolic link (this is the default), \
+    rather than the symbolic link itself",
+            )
+            .action(clap::ArgAction::SetTrue),
+        Arg::new(options::dereference::NO_DEREFERENCE)
+            .short('h')
+            .long(options::dereference::NO_DEREFERENCE)
+            .help(
+                "affect symbolic links instead of any referenced file \
+        (useful only on systems that can change the ownership of a symlink)",
+            )
+            .action(clap::ArgAction::SetTrue),
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    // Note this useful idiom: importing names from outer (for mod tests) scope.
+    use super::*;
+    #[cfg(unix)]
+    use std::os::unix;
+    use std::path::{Component, PathBuf};
+    #[cfg(unix)]
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_empty_string() {
+        let path = PathBuf::new();
+        assert_eq!(path.to_str(), Some(""));
+        // The main point to test here is that we don't crash.
+        // The result should be 'false', to avoid unnecessary and confusing warnings.
+        assert!(!is_root(&path, false));
+        assert!(!is_root(&path, true));
+    }
+
+    #[allow(clippy::needless_borrow)]
+    #[cfg(unix)]
+    #[test]
+    fn test_literal_root() {
+        let component = Component::RootDir;
+        let path: &Path = component.as_ref();
+        assert_eq!(
+            path.to_str(),
+            Some("/"),
+            "cfg(unix) but using non-unix path delimiters?!"
+        );
+        // Must return true, this is the main scenario that --preserve-root shall prevent.
+        assert!(is_root(&path, false));
+        assert!(is_root(&path, true));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_symlink_slash() {
+        let temp_dir = tempdir().unwrap();
+        let symlink_path = temp_dir.path().join("symlink");
+        unix::fs::symlink(PathBuf::from("/"), symlink_path).unwrap();
+        let symlink_path_slash = temp_dir.path().join("symlink/");
+        // Must return true, we're about to "accidentally" recurse on "/",
+        // since "symlink/" always counts as an already-entered directory
+        // Output from GNU:
+        //   $ chown --preserve-root -RH --dereference $(id -u) slink-to-root/
+        //   chown: it is dangerous to operate recursively on 'slink-to-root/' (same as '/')
+        //   chown: use --no-preserve-root to override this failsafe
+        //   [$? = 1]
+        //   $ chown --preserve-root -RH --no-dereference $(id -u) slink-to-root/
+        //   chown: it is dangerous to operate recursively on 'slink-to-root/' (same as '/')
+        //   chown: use --no-preserve-root to override this failsafe
+        //   [$? = 1]
+        assert!(is_root(&symlink_path_slash, false));
+        assert!(is_root(&symlink_path_slash, true));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn test_symlink_no_slash() {
+        // This covers both the commandline-argument case and the recursion case.
+        let temp_dir = tempdir().unwrap();
+        let symlink_path = temp_dir.path().join("symlink");
+        unix::fs::symlink(PathBuf::from("/"), &symlink_path).unwrap();
+        // Only return true  we're about to "accidentally" recurse on "/".
+        assert!(!is_root(&symlink_path, false));
+        assert!(is_root(&symlink_path, true));
+    }
+}
diff --git a/src/uucore/src/lib/features/pipes.rs b/src/uucore/src/lib/features/pipes.rs
index 75749f72148..5ac590b7b4a 100644
--- a/src/uucore/src/lib/features/pipes.rs
+++ b/src/uucore/src/lib/features/pipes.rs
@@ -2,13 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-/// Thin pipe-related wrappers around functions from the `nix` crate.
+
+//! Thin pipe-related wrappers around functions from the `nix` crate.
+
 use std::fs::File;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::io::IoSlice;
 #[cfg(any(target_os = "linux", target_os = "android"))]
-use std::os::unix::io::AsRawFd;
-use std::os::unix::io::FromRawFd;
+use std::os::fd::AsFd;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use nix::fcntl::SpliceFFlags;
@@ -21,8 +22,7 @@ pub use nix::{Error, Result};
 /// from the first.
 pub fn pipe() -> Result<(File, File)> {
     let (read, write) = nix::unistd::pipe()?;
-    // SAFETY: The file descriptors do not have other owners.
-    unsafe { Ok((File::from_raw_fd(read), File::from_raw_fd(write))) }
+    Ok((File::from(read), File::from(write)))
 }
 
 /// Less noisy wrapper around [`nix::fcntl::splice`].
@@ -35,15 +35,8 @@ pub fn pipe() -> Result<(File, File)> {
 /// a [`pipe`] and then from the pipe into your target (with `splice_exact`):
 /// this is still very efficient.
 #[cfg(any(target_os = "linux", target_os = "android"))]
-pub fn splice(source: &impl AsRawFd, target: &impl AsRawFd, len: usize) -> Result<usize> {
-    nix::fcntl::splice(
-        source.as_raw_fd(),
-        None,
-        target.as_raw_fd(),
-        None,
-        len,
-        SpliceFFlags::empty(),
-    )
+pub fn splice(source: &impl AsFd, target: &impl AsFd, len: usize) -> Result<usize> {
+    nix::fcntl::splice(source, None, target, None, len, SpliceFFlags::empty())
 }
 
 /// Splice wrapper which fully finishes the write.
@@ -52,7 +45,7 @@ pub fn splice(source: &impl AsRawFd, target: &impl AsRawFd, len: usize) -> Resul
 ///
 /// Panics if `source` runs out of data before `len` bytes have been moved.
 #[cfg(any(target_os = "linux", target_os = "android"))]
-pub fn splice_exact(source: &impl AsRawFd, target: &impl AsRawFd, len: usize) -> Result<()> {
+pub fn splice_exact(source: &impl AsFd, target: &impl AsFd, len: usize) -> Result<()> {
     let mut left = len;
     while left != 0 {
         let written = splice(source, target, left)?;
@@ -66,10 +59,6 @@ pub fn splice_exact(source: &impl AsRawFd, target: &impl AsRawFd, len: usize) ->
 ///
 /// Returns the number of successfully copied bytes.
 #[cfg(any(target_os = "linux", target_os = "android"))]
-pub fn vmsplice(target: &impl AsRawFd, bytes: &[u8]) -> Result<usize> {
-    nix::fcntl::vmsplice(
-        target.as_raw_fd(),
-        &[IoSlice::new(bytes)],
-        SpliceFFlags::empty(),
-    )
+pub fn vmsplice(target: &impl AsFd, bytes: &[u8]) -> Result<usize> {
+    nix::fcntl::vmsplice(target, &[IoSlice::new(bytes)], SpliceFFlags::empty())
 }
diff --git a/src/uucore/src/lib/features/proc_info.rs b/src/uucore/src/lib/features/proc_info.rs
new file mode 100644
index 00000000000..3f5334d1007
--- /dev/null
+++ b/src/uucore/src/lib/features/proc_info.rs
@@ -0,0 +1,515 @@
+// 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.
+
+// spell-checker:ignore exitstatus cmdline kworker pgrep pwait snice procps
+// spell-checker:ignore egid euid gettid ppid
+
+//! Set of functions to manage IDs
+//!
+//! This module provide [`ProcessInformation`] and [`TerminalType`] and corresponding
+//! functions for obtaining process information.
+//!
+//! And also provide [`walk_process`] function to collecting all the information of
+//! processes in current system.
+//!
+//! Utilities that rely on this module:
+//! `pgrep` (TBD)
+//! `pwait` (TBD)
+//! `snice` (TBD)
+//!
+
+// This file is currently flagged as dead code, because it isn't used anywhere
+// in the codebase. It may be useful in the future though, so we decide to keep
+// it.
+// The code was originally written in procps
+// (https://github.com/uutils/procps/blob/main/src/uu/pgrep/src/process.rs)
+// but was eventually moved here.
+// See https://github.com/uutils/coreutils/pull/6932 for discussion.
+#![allow(dead_code)]
+
+use crate::features::tty::Teletype;
+use std::hash::Hash;
+use std::{
+    collections::HashMap,
+    fmt::{self, Display, Formatter},
+    fs, io,
+    path::PathBuf,
+    rc::Rc,
+};
+use walkdir::{DirEntry, WalkDir};
+
+/// State or process
+#[derive(Debug, PartialEq, Eq)]
+pub enum RunState {
+    ///`R`, running
+    Running,
+    ///`S`, sleeping
+    Sleeping,
+    ///`D`, sleeping in an uninterruptible wait
+    UninterruptibleWait,
+    ///`Z`, zombie
+    Zombie,
+    ///`T`, traced or stopped
+    Stopped,
+}
+
+impl Display for RunState {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Running => write!(f, "R"),
+            Self::Sleeping => write!(f, "S"),
+            Self::UninterruptibleWait => write!(f, "D"),
+            Self::Zombie => write!(f, "Z"),
+            Self::Stopped => write!(f, "T"),
+        }
+    }
+}
+
+impl TryFrom<char> for RunState {
+    type Error = io::Error;
+
+    fn try_from(value: char) -> Result<Self, Self::Error> {
+        match value {
+            'R' => Ok(Self::Running),
+            'S' => Ok(Self::Sleeping),
+            'D' => Ok(Self::UninterruptibleWait),
+            'Z' => Ok(Self::Zombie),
+            'T' => Ok(Self::Stopped),
+            _ => Err(io::ErrorKind::InvalidInput.into()),
+        }
+    }
+}
+
+impl TryFrom<&str> for RunState {
+    type Error = io::Error;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        if value.len() != 1 {
+            return Err(io::ErrorKind::InvalidInput.into());
+        }
+
+        Self::try_from(
+            value
+                .chars()
+                .nth(0)
+                .ok_or::<io::Error>(io::ErrorKind::InvalidInput.into())?,
+        )
+    }
+}
+
+impl TryFrom<String> for RunState {
+    type Error = io::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::try_from(value.as_str())
+    }
+}
+
+impl TryFrom<&String> for RunState {
+    type Error = io::Error;
+
+    fn try_from(value: &String) -> Result<Self, Self::Error> {
+        Self::try_from(value.as_str())
+    }
+}
+
+/// Process ID and its information
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct ProcessInformation {
+    pub pid: usize,
+    pub cmdline: String,
+
+    inner_status: String,
+    inner_stat: String,
+
+    /// Processed `/proc/self/status` file
+    cached_status: Option<Rc<HashMap<String, String>>>,
+    /// Processed `/proc/self/stat` file
+    cached_stat: Option<Rc<Vec<String>>>,
+
+    cached_start_time: Option<u64>,
+
+    cached_thread_ids: Option<Rc<Vec<usize>>>,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum UidGid {
+    Uid,
+    Gid,
+}
+
+impl ProcessInformation {
+    /// Try new with pid path such as `/proc/self`
+    ///
+    /// # Error
+    ///
+    /// If the files in path cannot be parsed into [ProcessInformation],
+    /// it almost caused by wrong filesystem structure.
+    ///
+    /// - [The /proc Filesystem](https://docs.kernel.org/filesystems/proc.html#process-specific-subdirectories)
+    pub fn try_new(value: PathBuf) -> Result<Self, io::Error> {
+        let dir_append = |mut path: PathBuf, str: String| {
+            path.push(str);
+            path
+        };
+
+        let value = if value.is_symlink() {
+            fs::read_link(value)?
+        } else {
+            value
+        };
+
+        let pid = {
+            value
+                .iter()
+                .next_back()
+                .ok_or(io::ErrorKind::Other)?
+                .to_str()
+                .ok_or(io::ErrorKind::InvalidData)?
+                .parse::<usize>()
+                .map_err(|_| io::ErrorKind::InvalidData)?
+        };
+        let cmdline = fs::read_to_string(dir_append(value.clone(), "cmdline".into()))?
+            .replace('\0', " ")
+            .trim_end()
+            .into();
+
+        Ok(Self {
+            pid,
+            cmdline,
+            inner_status: fs::read_to_string(dir_append(value.clone(), "status".into()))?,
+            inner_stat: fs::read_to_string(dir_append(value, "stat".into()))?,
+            ..Default::default()
+        })
+    }
+
+    pub fn proc_status(&self) -> &str {
+        &self.inner_status
+    }
+
+    pub fn proc_stat(&self) -> &str {
+        &self.inner_stat
+    }
+
+    /// Collect information from `/proc/<pid>/status` file
+    pub fn status(&mut self) -> Rc<HashMap<String, String>> {
+        if let Some(c) = &self.cached_status {
+            return Rc::clone(c);
+        }
+
+        let result = self
+            .inner_status
+            .lines()
+            .filter_map(|it| it.split_once(':'))
+            .map(|it| (it.0.to_string(), it.1.trim_start().to_string()))
+            .collect::<HashMap<_, _>>();
+
+        let result = Rc::new(result);
+        self.cached_status = Some(Rc::clone(&result));
+        Rc::clone(&result)
+    }
+
+    /// Collect information from `/proc/<pid>/stat` file
+    pub fn stat(&mut self) -> Rc<Vec<String>> {
+        if let Some(c) = &self.cached_stat {
+            return Rc::clone(c);
+        }
+
+        let result: Vec<_> = stat_split(&self.inner_stat);
+
+        let result = Rc::new(result);
+        self.cached_stat = Some(Rc::clone(&result));
+        Rc::clone(&result)
+    }
+
+    /// Fetch start time from [ProcessInformation::cached_stat]
+    ///
+    /// - [The /proc Filesystem: Table 1-4](https://docs.kernel.org/filesystems/proc.html#id10)
+    pub fn start_time(&mut self) -> Result<u64, io::Error> {
+        if let Some(time) = self.cached_start_time {
+            return Ok(time);
+        }
+
+        // Kernel doc: https://docs.kernel.org/filesystems/proc.html#process-specific-subdirectories
+        // Table 1-4
+        let time = self
+            .stat()
+            .get(21)
+            .ok_or(io::ErrorKind::InvalidData)?
+            .parse::<u64>()
+            .map_err(|_| io::ErrorKind::InvalidData)?;
+
+        self.cached_start_time = Some(time);
+
+        Ok(time)
+    }
+
+    pub fn ppid(&mut self) -> Result<u64, io::Error> {
+        // the PPID is the fourth field in /proc/<PID>/stat
+        // (https://www.kernel.org/doc/html/latest/filesystems/proc.html#id10)
+        self.stat()
+            .get(3)
+            .ok_or(io::ErrorKind::InvalidData)?
+            .parse::<u64>()
+            .map_err(|_| io::ErrorKind::InvalidData.into())
+    }
+
+    fn get_uid_or_gid_field(&mut self, field: UidGid, index: usize) -> Result<u32, io::Error> {
+        self.status()
+            .get(&format!("{field:?}"))
+            .ok_or(io::ErrorKind::InvalidData)?
+            .split_whitespace()
+            .nth(index)
+            .ok_or(io::ErrorKind::InvalidData)?
+            .parse::<u32>()
+            .map_err(|_| io::ErrorKind::InvalidData.into())
+    }
+
+    pub fn uid(&mut self) -> Result<u32, io::Error> {
+        self.get_uid_or_gid_field(UidGid::Uid, 0)
+    }
+
+    pub fn euid(&mut self) -> Result<u32, io::Error> {
+        self.get_uid_or_gid_field(UidGid::Uid, 1)
+    }
+
+    pub fn gid(&mut self) -> Result<u32, io::Error> {
+        self.get_uid_or_gid_field(UidGid::Gid, 0)
+    }
+
+    pub fn egid(&mut self) -> Result<u32, io::Error> {
+        self.get_uid_or_gid_field(UidGid::Gid, 1)
+    }
+
+    /// Fetch run state from [ProcessInformation::cached_stat]
+    ///
+    /// - [The /proc Filesystem: Table 1-4](https://docs.kernel.org/filesystems/proc.html#id10)
+    ///
+    /// # Error
+    ///
+    /// If parsing failed, this function will return [io::ErrorKind::InvalidInput]
+    pub fn run_state(&mut self) -> Result<RunState, io::Error> {
+        RunState::try_from(self.stat().get(2).unwrap().as_str())
+    }
+
+    /// This function will scan the `/proc/<pid>/fd` directory
+    ///
+    /// If the process does not belong to any terminal and mismatched permission,
+    /// the result will contain [TerminalType::Unknown].
+    ///
+    /// Otherwise [TerminalType::Unknown] does not appear in the result.
+    pub fn tty(&self) -> Teletype {
+        let path = PathBuf::from(format!("/proc/{}/fd", self.pid));
+
+        let Ok(result) = fs::read_dir(path) else {
+            return Teletype::Unknown;
+        };
+
+        for dir in result.flatten().filter(|it| it.path().is_symlink()) {
+            if let Ok(path) = fs::read_link(dir.path()) {
+                if let Ok(tty) = Teletype::try_from(path) {
+                    return tty;
+                }
+            }
+        }
+
+        Teletype::Unknown
+    }
+
+    pub fn thread_ids(&mut self) -> Rc<Vec<usize>> {
+        if let Some(c) = &self.cached_thread_ids {
+            return Rc::clone(c);
+        }
+
+        let thread_ids_dir = format!("/proc/{}/task", self.pid);
+        let result = Rc::new(
+            WalkDir::new(thread_ids_dir)
+                .min_depth(1)
+                .max_depth(1)
+                .follow_links(false)
+                .into_iter()
+                .flatten()
+                .flat_map(|it| {
+                    it.path()
+                        .file_name()
+                        .and_then(|it| it.to_str())
+                        .and_then(|it| it.parse::<usize>().ok())
+                })
+                .collect::<Vec<_>>(),
+        );
+
+        self.cached_thread_ids = Some(Rc::clone(&result));
+        Rc::clone(&result)
+    }
+}
+impl TryFrom<DirEntry> for ProcessInformation {
+    type Error = io::Error;
+
+    fn try_from(value: DirEntry) -> Result<Self, Self::Error> {
+        let value = value.into_path();
+
+        Self::try_new(value)
+    }
+}
+
+impl Hash for ProcessInformation {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        // Make it faster.
+        self.pid.hash(state);
+        self.inner_status.hash(state);
+        self.inner_stat.hash(state);
+    }
+}
+
+/// Parsing `/proc/self/stat` file.
+///
+/// In some case, the first pair (and the only one pair) will contains whitespace,
+/// so if we want to parse it, we have to write new algorithm.
+///
+/// TODO: If possible, test and use regex to replace this algorithm.
+fn stat_split(stat: &str) -> Vec<String> {
+    let stat = String::from(stat);
+
+    let mut buf = String::with_capacity(stat.len());
+
+    let l = stat.find('(');
+    let r = stat.find(')');
+    let content = if let (Some(l), Some(r)) = (l, r) {
+        let replaced = stat[(l + 1)..r].replace(' ', "$$");
+
+        buf.push_str(&stat[..l]);
+        buf.push_str(&replaced);
+        buf.push_str(&stat[(r + 1)..stat.len()]);
+
+        &buf
+    } else {
+        &stat
+    };
+
+    content
+        .split_whitespace()
+        .map(|it| it.replace("$$", " "))
+        .collect()
+}
+
+/// Iterating pid in current system
+pub fn walk_process() -> impl Iterator<Item = ProcessInformation> {
+    WalkDir::new("/proc/")
+        .max_depth(1)
+        .follow_links(false)
+        .into_iter()
+        .flatten()
+        .filter(|it| it.path().is_dir())
+        .flat_map(ProcessInformation::try_from)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::features::tty::Teletype;
+    use std::{collections::HashSet, str::FromStr};
+
+    #[test]
+    fn test_run_state_conversion() {
+        assert_eq!(RunState::try_from("R").unwrap(), RunState::Running);
+        assert_eq!(RunState::try_from("S").unwrap(), RunState::Sleeping);
+        assert_eq!(
+            RunState::try_from("D").unwrap(),
+            RunState::UninterruptibleWait
+        );
+        assert_eq!(RunState::try_from("T").unwrap(), RunState::Stopped);
+        assert_eq!(RunState::try_from("Z").unwrap(), RunState::Zombie);
+
+        assert!(RunState::try_from("G").is_err());
+        assert!(RunState::try_from("Rg").is_err());
+    }
+
+    fn current_pid() -> usize {
+        // Direct read link of /proc/self.
+        // It's result must be current programs pid.
+        fs::read_link("/proc/self")
+            .unwrap()
+            .to_str()
+            .unwrap()
+            .parse::<usize>()
+            .unwrap()
+    }
+
+    #[test]
+    fn test_walk_pid() {
+        let current_pid = current_pid();
+
+        let find = walk_process().find(|it| it.pid == current_pid);
+
+        assert!(find.is_some());
+    }
+
+    #[test]
+    fn test_pid_entry() {
+        let current_pid = current_pid();
+
+        let pid_entry = ProcessInformation::try_new(
+            PathBuf::from_str(&format!("/proc/{current_pid}")).unwrap(),
+        )
+        .unwrap();
+
+        let result = WalkDir::new(format!("/proc/{current_pid}/fd"))
+            .into_iter()
+            .flatten()
+            .map(DirEntry::into_path)
+            .flat_map(|it| it.read_link())
+            .flat_map(Teletype::try_from)
+            .collect::<HashSet<_>>();
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(
+            pid_entry.tty(),
+            Vec::from_iter(result.into_iter()).first().unwrap().clone()
+        );
+    }
+
+    #[test]
+    fn test_thread_ids() {
+        let main_tid = unsafe { crate::libc::gettid() };
+        std::thread::spawn(move || {
+            let mut pid_entry = ProcessInformation::try_new(
+                PathBuf::from_str(&format!("/proc/{}", current_pid())).unwrap(),
+            )
+            .unwrap();
+            let thread_ids = pid_entry.thread_ids();
+
+            assert!(thread_ids.contains(&(main_tid as usize)));
+
+            let new_thread_tid = unsafe { crate::libc::gettid() };
+            assert!(thread_ids.contains(&(new_thread_tid as usize)));
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_stat_split() {
+        let case = "32 (idle_inject/3) S 2 0 0 0 -1 69238848 0 0 0 0 0 0 0 0 -51 0 1 0 34 0 0 18446744073709551615 0 0 0 0 0 0 0 2147483647 0 0 0 0 17 3 50 1 0 0 0 0 0 0 0 0 0 0 0";
+        assert_eq!(stat_split(case)[1], "idle_inject/3");
+
+        let case = "3508 (sh) S 3478 3478 3478 0 -1 4194304 67 0 0 0 0 0 0 0 20 0 1 0 11911 2961408 238 18446744073709551615 94340156948480 94340157028757 140736274114368 0 0 0 0 4096 65538 1 0 0 17 8 0 0 0 0 0 94340157054704 94340157059616 94340163108864 140736274122780 140736274122976 140736274122976 140736274124784 0";
+        assert_eq!(stat_split(case)[1], "sh");
+
+        let case = "47246 (kworker /10:1-events) I 2 0 0 0 -1 69238880 0 0 0 0 17 29 0 0 20 0 1 0 1396260 0 0 18446744073709551615 0 0 0 0 0 0 0 2147483647 0 0 0 0 17 10 0 0 0 0 0 0 0 0 0 0 0 0 0";
+        assert_eq!(stat_split(case)[1], "kworker /10:1-events");
+    }
+
+    #[test]
+    fn test_uid_gid() {
+        let mut pid_entry = ProcessInformation::try_new(
+            PathBuf::from_str(&format!("/proc/{}", current_pid())).unwrap(),
+        )
+        .unwrap();
+        assert_eq!(pid_entry.uid().unwrap(), crate::process::getuid());
+        assert_eq!(pid_entry.euid().unwrap(), crate::process::geteuid());
+        assert_eq!(pid_entry.gid().unwrap(), crate::process::getgid());
+        assert_eq!(pid_entry.egid().unwrap(), crate::process::getegid());
+    }
+}
diff --git a/src/uucore/src/lib/features/process.rs b/src/uucore/src/lib/features/process.rs
index c7dff1f05ec..4656e7c13ea 100644
--- a/src/uucore/src/lib/features/process.rs
+++ b/src/uucore/src/lib/features/process.rs
@@ -3,12 +3,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (vars) cvar exitstatus
-// spell-checker:ignore (sys/unix) WIFSIGNALED
-
-//! Set of functions to manage IDs
+// spell-checker:ignore (vars) cvar exitstatus cmdline kworker getsid getpid
+// spell-checker:ignore (sys/unix) WIFSIGNALED ESRCH
+// spell-checker:ignore pgrep pwait snice getpgrp
 
 use libc::{gid_t, pid_t, uid_t};
+#[cfg(not(target_os = "redox"))]
+use nix::errno::Errno;
 use std::io;
 use std::process::Child;
 use std::process::ExitStatus;
@@ -22,6 +23,12 @@ pub fn geteuid() -> uid_t {
     unsafe { libc::geteuid() }
 }
 
+/// `getpgrp()` returns the process group ID of the calling process.
+/// It is a trivial wrapper over libc::getpgrp to "hide" the unsafe
+pub fn getpgrp() -> pid_t {
+    unsafe { libc::getpgrp() }
+}
+
 /// `getegid()` returns the effective group ID of the calling process.
 pub fn getegid() -> gid_t {
     unsafe { libc::getegid() }
@@ -37,6 +44,37 @@ pub fn getuid() -> uid_t {
     unsafe { libc::getuid() }
 }
 
+/// `getpid()` returns the pid of the calling process.
+pub fn getpid() -> pid_t {
+    unsafe { libc::getpid() }
+}
+
+/// `getsid()` returns the session ID of the process with process ID pid.
+///
+/// If pid is 0, getsid() returns the session ID of the calling process.
+///
+/// # Error
+///
+/// - [Errno::EPERM] A process with process ID pid exists, but it is not in the same session as the calling process, and the implementation considers this an error.
+/// - [Errno::ESRCH] No process with process ID pid was found.
+///
+///
+/// # Platform
+///
+/// This function only support standard POSIX implementation platform,
+/// so some system such as redox doesn't supported.
+#[cfg(not(target_os = "redox"))]
+pub fn getsid(pid: i32) -> Result<pid_t, Errno> {
+    unsafe {
+        let result = libc::getsid(pid);
+        if Errno::last() == Errno::UnknownErrno {
+            Ok(result)
+        } else {
+            Err(Errno::last())
+        }
+    }
+}
+
 /// Missing methods for Child objects
 pub trait ChildExt {
     /// Send a signal to a Child process.
@@ -100,3 +138,25 @@ impl ChildExt for Child {
         Ok(None)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[cfg(not(target_os = "redox"))]
+    fn test_getsid() {
+        assert_eq!(
+            getsid(getpid()).expect("getsid(getpid)"),
+            // zero is a special value for SID.
+            // https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsid.html
+            getsid(0).expect("getsid(0)")
+        );
+
+        // SID never be 0.
+        assert!(getsid(getpid()).expect("getsid(getpid)") > 0);
+
+        // This might caused tests failure but the probability is low.
+        assert!(getsid(999_999).is_err());
+    }
+}
diff --git a/src/uucore/src/lib/features/quoting_style.rs b/src/uucore/src/lib/features/quoting_style.rs
new file mode 100644
index 00000000000..d9dcd078bf0
--- /dev/null
+++ b/src/uucore/src/lib/features/quoting_style.rs
@@ -0,0 +1,1289 @@
+// 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.
+
+//! Set of functions for escaping names according to different quoting styles.
+
+use std::char::from_digit;
+use std::ffi::{OsStr, OsString};
+use std::fmt;
+
+// These are characters with special meaning in the shell (e.g. bash).
+// The first const contains characters that only have a special meaning when they appear at the beginning of a name.
+const SPECIAL_SHELL_CHARS_START: &[u8] = b"~#";
+// PR#6559 : Remove `]{}` from special shell chars.
+const SPECIAL_SHELL_CHARS: &str = "`$&*()|[;\\'\"<>?! ";
+
+/// The quoting style to use when escaping a name.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum QuotingStyle {
+    /// Escape the name as a shell string.
+    /// Used in, e.g., `ls --quoting-style=shell`.
+    Shell {
+        /// Whether to escape characters in the name.
+        /// True in, e.g., `ls --quoting-style=shell-escape`.
+        escape: bool,
+
+        /// Whether to always quote the name.
+        always_quote: bool,
+
+        /// Whether to show control and non-unicode characters, or replace them with `?`.
+        show_control: bool,
+    },
+
+    /// Escape the name as a C string.
+    /// Used in, e.g., `ls --quote-name`.
+    C {
+        /// The type of quotes to use.
+        quotes: Quotes,
+    },
+
+    /// Do not escape the string.
+    /// Used in, e.g., `ls --literal`.
+    Literal {
+        /// Whether to show control and non-unicode characters, or replace them with `?`.
+        show_control: bool,
+    },
+}
+
+/// The type of quotes to use when escaping a name as a C string.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Quotes {
+    /// Do not use quotes.
+    None,
+
+    /// Use single quotes.
+    Single,
+
+    /// Use double quotes.
+    Double,
+    // TODO: Locale
+}
+
+// This implementation is heavily inspired by the std::char::EscapeDefault implementation
+// in the Rust standard library. This custom implementation is needed because the
+// characters \a, \b, \e, \f & \v are not recognized by Rust.
+struct EscapedChar {
+    state: EscapeState,
+}
+
+enum EscapeState {
+    Done,
+    Char(char),
+    Backslash(char),
+    ForceQuote(char),
+    Octal(EscapeOctal),
+}
+
+/// Bytes we need to present as escaped octal, in the form of `\nnn` per byte.
+/// Only supports characters up to 2 bytes long in UTF-8.
+struct EscapeOctal {
+    c: [u8; 2],
+    state: EscapeOctalState,
+    idx: u8,
+}
+
+enum EscapeOctalState {
+    Done,
+    FirstBackslash,
+    FirstValue,
+    LastBackslash,
+    LastValue,
+}
+
+fn byte_to_octal_digit(byte: u8, idx: u8) -> u8 {
+    (byte >> (idx * 3)) & 0o7
+}
+
+impl Iterator for EscapeOctal {
+    type Item = char;
+
+    fn next(&mut self) -> Option<char> {
+        match self.state {
+            EscapeOctalState::Done => None,
+            EscapeOctalState::FirstBackslash => {
+                self.state = EscapeOctalState::FirstValue;
+                Some('\\')
+            }
+            EscapeOctalState::LastBackslash => {
+                self.state = EscapeOctalState::LastValue;
+                Some('\\')
+            }
+            EscapeOctalState::FirstValue => {
+                let octal_digit = byte_to_octal_digit(self.c[0], self.idx);
+                if self.idx == 0 {
+                    self.state = EscapeOctalState::LastBackslash;
+                    self.idx = 2;
+                } else {
+                    self.idx -= 1;
+                }
+                Some(from_digit(octal_digit.into(), 8).unwrap())
+            }
+            EscapeOctalState::LastValue => {
+                let octal_digit = byte_to_octal_digit(self.c[1], self.idx);
+                if self.idx == 0 {
+                    self.state = EscapeOctalState::Done;
+                } else {
+                    self.idx -= 1;
+                }
+                Some(from_digit(octal_digit.into(), 8).unwrap())
+            }
+        }
+    }
+}
+
+impl EscapeOctal {
+    fn from_char(c: char) -> Self {
+        if c.len_utf8() == 1 {
+            return Self::from_byte(c as u8);
+        }
+
+        let mut buf = [0; 2];
+        let _s = c.encode_utf8(&mut buf);
+        Self {
+            c: buf,
+            idx: 2,
+            state: EscapeOctalState::FirstBackslash,
+        }
+    }
+
+    fn from_byte(b: u8) -> Self {
+        Self {
+            c: [0, b],
+            idx: 2,
+            state: EscapeOctalState::LastBackslash,
+        }
+    }
+}
+
+impl EscapedChar {
+    fn new_literal(c: char) -> Self {
+        Self {
+            state: EscapeState::Char(c),
+        }
+    }
+
+    fn new_octal(b: u8) -> Self {
+        Self {
+            state: EscapeState::Octal(EscapeOctal::from_byte(b)),
+        }
+    }
+
+    fn new_c(c: char, quotes: Quotes, dirname: bool) -> Self {
+        use EscapeState::*;
+        let init_state = match c {
+            '\x07' => Backslash('a'),
+            '\x08' => Backslash('b'),
+            '\t' => Backslash('t'),
+            '\n' => Backslash('n'),
+            '\x0B' => Backslash('v'),
+            '\x0C' => Backslash('f'),
+            '\r' => Backslash('r'),
+            '\\' => Backslash('\\'),
+            '\'' => match quotes {
+                Quotes::Single => Backslash('\''),
+                _ => Char('\''),
+            },
+            '"' => match quotes {
+                Quotes::Double => Backslash('"'),
+                _ => Char('"'),
+            },
+            ' ' if !dirname => match quotes {
+                Quotes::None => Backslash(' '),
+                _ => Char(' '),
+            },
+            ':' if dirname => Backslash(':'),
+            _ if c.is_control() => Octal(EscapeOctal::from_char(c)),
+            _ => Char(c),
+        };
+        Self { state: init_state }
+    }
+
+    fn new_shell(c: char, escape: bool, quotes: Quotes) -> Self {
+        use EscapeState::*;
+        let init_state = match c {
+            _ if !escape && c.is_control() => Char(c),
+            '\x07' => Backslash('a'),
+            '\x08' => Backslash('b'),
+            '\t' => Backslash('t'),
+            '\n' => Backslash('n'),
+            '\x0B' => Backslash('v'),
+            '\x0C' => Backslash('f'),
+            '\r' => Backslash('r'),
+            '\'' => match quotes {
+                Quotes::Single => Backslash('\''),
+                _ => Char('\''),
+            },
+            _ if c.is_control() => Octal(EscapeOctal::from_char(c)),
+            _ if SPECIAL_SHELL_CHARS.contains(c) => ForceQuote(c),
+            _ => Char(c),
+        };
+        Self { state: init_state }
+    }
+
+    fn hide_control(self) -> Self {
+        match self.state {
+            EscapeState::Char(c) if c.is_control() => Self {
+                state: EscapeState::Char('?'),
+            },
+            _ => self,
+        }
+    }
+}
+
+impl Iterator for EscapedChar {
+    type Item = char;
+
+    fn next(&mut self) -> Option<char> {
+        match self.state {
+            EscapeState::Backslash(c) => {
+                self.state = EscapeState::Char(c);
+                Some('\\')
+            }
+            EscapeState::Char(c) | EscapeState::ForceQuote(c) => {
+                self.state = EscapeState::Done;
+                Some(c)
+            }
+            EscapeState::Done => None,
+            EscapeState::Octal(ref mut iter) => iter.next(),
+        }
+    }
+}
+
+/// Check whether `bytes` starts with any byte in `pattern`.
+fn bytes_start_with(bytes: &[u8], pattern: &[u8]) -> bool {
+    !bytes.is_empty() && pattern.contains(&bytes[0])
+}
+
+fn shell_without_escape(name: &[u8], quotes: Quotes, show_control_chars: bool) -> (Vec<u8>, bool) {
+    let mut must_quote = false;
+    let mut escaped_str = Vec::with_capacity(name.len());
+    let mut utf8_buf = vec![0; 4];
+
+    for s in name.utf8_chunks() {
+        for c in s.valid().chars() {
+            let escaped = {
+                let ec = EscapedChar::new_shell(c, false, quotes);
+                if show_control_chars {
+                    ec
+                } else {
+                    ec.hide_control()
+                }
+            };
+
+            match escaped.state {
+                EscapeState::Backslash('\'') => escaped_str.extend_from_slice(b"'\\''"),
+                EscapeState::ForceQuote(x) => {
+                    must_quote = true;
+                    escaped_str.extend_from_slice(x.encode_utf8(&mut utf8_buf).as_bytes());
+                }
+                _ => {
+                    for c in escaped {
+                        escaped_str.extend_from_slice(c.encode_utf8(&mut utf8_buf).as_bytes());
+                    }
+                }
+            }
+        }
+
+        if show_control_chars {
+            escaped_str.extend_from_slice(s.invalid());
+        } else {
+            escaped_str.resize(escaped_str.len() + s.invalid().len(), b'?');
+        }
+    }
+
+    must_quote = must_quote || bytes_start_with(name, SPECIAL_SHELL_CHARS_START);
+    (escaped_str, must_quote)
+}
+
+fn shell_with_escape(name: &[u8], quotes: Quotes) -> (Vec<u8>, bool) {
+    // We need to keep track of whether we are in a dollar expression
+    // because e.g. \b\n is escaped as $'\b\n' and not like $'b'$'n'
+    let mut in_dollar = false;
+    let mut must_quote = false;
+    let mut escaped_str = String::with_capacity(name.len());
+
+    for s in name.utf8_chunks() {
+        for c in s.valid().chars() {
+            let escaped = EscapedChar::new_shell(c, true, quotes);
+            match escaped.state {
+                EscapeState::Char(x) => {
+                    if in_dollar {
+                        escaped_str.push_str("''");
+                        in_dollar = false;
+                    }
+                    escaped_str.push(x);
+                }
+                EscapeState::ForceQuote(x) => {
+                    if in_dollar {
+                        escaped_str.push_str("''");
+                        in_dollar = false;
+                    }
+                    must_quote = true;
+                    escaped_str.push(x);
+                }
+                // Single quotes are not put in dollar expressions, but are escaped
+                // if the string also contains double quotes. In that case, they must
+                // be handled separately.
+                EscapeState::Backslash('\'') => {
+                    must_quote = true;
+                    in_dollar = false;
+                    escaped_str.push_str("'\\''");
+                }
+                _ => {
+                    if !in_dollar {
+                        escaped_str.push_str("'$'");
+                        in_dollar = true;
+                    }
+                    must_quote = true;
+                    for char in escaped {
+                        escaped_str.push(char);
+                    }
+                }
+            }
+        }
+        if !s.invalid().is_empty() {
+            if !in_dollar {
+                escaped_str.push_str("'$'");
+                in_dollar = true;
+            }
+            must_quote = true;
+            let escaped_bytes: String = s
+                .invalid()
+                .iter()
+                .flat_map(|b| EscapedChar::new_octal(*b))
+                .collect();
+            escaped_str.push_str(&escaped_bytes);
+        }
+    }
+    must_quote = must_quote || bytes_start_with(name, SPECIAL_SHELL_CHARS_START);
+    (escaped_str.into(), must_quote)
+}
+
+/// Return a set of characters that implies quoting of the word in
+/// shell-quoting mode.
+fn shell_escaped_char_set(is_dirname: bool) -> &'static [u8] {
+    const ESCAPED_CHARS: &[u8] = b":\"`$\\^\n\t\r=";
+    // the ':' colon character only induce quoting in the
+    // context of ls displaying a directory name before listing its content.
+    // (e.g. with the recursive flag -R)
+    let start_index = if is_dirname { 0 } else { 1 };
+    &ESCAPED_CHARS[start_index..]
+}
+
+/// Escape a name according to the given quoting style.
+///
+/// This inner function provides an additional flag `dirname` which
+/// is meant for ls' directory name display.
+fn escape_name_inner(name: &[u8], style: &QuotingStyle, dirname: bool) -> Vec<u8> {
+    match style {
+        QuotingStyle::Literal { show_control } => {
+            if *show_control {
+                name.to_owned()
+            } else {
+                name.utf8_chunks()
+                    .map(|s| {
+                        let valid: String = s
+                            .valid()
+                            .chars()
+                            .flat_map(|c| EscapedChar::new_literal(c).hide_control())
+                            .collect();
+                        let invalid = "?".repeat(s.invalid().len());
+                        valid + &invalid
+                    })
+                    .collect::<String>()
+                    .into()
+            }
+        }
+        QuotingStyle::C { quotes } => {
+            let escaped_str: String = name
+                .utf8_chunks()
+                .flat_map(|s| {
+                    let valid = s
+                        .valid()
+                        .chars()
+                        .flat_map(|c| EscapedChar::new_c(c, *quotes, dirname));
+                    let invalid = s.invalid().iter().flat_map(|b| EscapedChar::new_octal(*b));
+                    valid.chain(invalid)
+                })
+                .collect::<String>();
+
+            match quotes {
+                Quotes::Single => format!("'{escaped_str}'"),
+                Quotes::Double => format!("\"{escaped_str}\""),
+                Quotes::None => escaped_str,
+            }
+            .into()
+        }
+        QuotingStyle::Shell {
+            escape,
+            always_quote,
+            show_control,
+        } => {
+            let (quotes, must_quote) = if name
+                .iter()
+                .any(|c| shell_escaped_char_set(dirname).contains(c))
+            {
+                (Quotes::Single, true)
+            } else if name.contains(&b'\'') {
+                (Quotes::Double, true)
+            } else if *always_quote || name.is_empty() {
+                (Quotes::Single, true)
+            } else {
+                (Quotes::Single, false)
+            };
+
+            let (escaped_str, contains_quote_chars) = if *escape {
+                shell_with_escape(name, quotes)
+            } else {
+                shell_without_escape(name, quotes, *show_control)
+            };
+
+            if must_quote | contains_quote_chars && quotes != Quotes::None {
+                let mut quoted_str = Vec::<u8>::with_capacity(escaped_str.len() + 2);
+                let quote = if quotes == Quotes::Single {
+                    b'\''
+                } else {
+                    b'"'
+                };
+                quoted_str.push(quote);
+                quoted_str.extend(escaped_str);
+                quoted_str.push(quote);
+                quoted_str
+            } else {
+                escaped_str
+            }
+        }
+    }
+}
+
+/// Escape a filename with respect to the given style.
+pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> OsString {
+    let name = crate::os_str_as_bytes_lossy(name);
+    crate::os_string_from_vec(escape_name_inner(&name, style, false))
+        .expect("all byte sequences should be valid for platform, or already replaced in name")
+}
+
+/// Escape a directory name with respect to the given style.
+/// This is mainly meant to be used for ls' directory name printing and is not
+/// likely to be used elsewhere.
+pub fn escape_dir_name(dir_name: &OsStr, style: &QuotingStyle) -> OsString {
+    let name = crate::os_str_as_bytes_lossy(dir_name);
+    crate::os_string_from_vec(escape_name_inner(&name, style, true))
+        .expect("all byte sequences should be valid for platform, or already replaced in name")
+}
+
+impl fmt::Display for QuotingStyle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::Shell {
+                escape,
+                always_quote,
+                show_control,
+            } => {
+                let mut style = "shell".to_string();
+                if escape {
+                    style.push_str("-escape");
+                }
+                if always_quote {
+                    style.push_str("-always-quote");
+                }
+                if show_control {
+                    style.push_str("-show-control");
+                }
+                f.write_str(&style)
+            }
+            Self::C { .. } => f.write_str("C"),
+            Self::Literal { .. } => f.write_str("literal"),
+        }
+    }
+}
+
+impl fmt::Display for Quotes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::None => f.write_str("None"),
+            Self::Single => f.write_str("Single"),
+            Self::Double => f.write_str("Double"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::quoting_style::{Quotes, QuotingStyle, escape_name_inner};
+
+    // spell-checker:ignore (tests/words) one\'two one'two
+
+    fn get_style(s: &str) -> QuotingStyle {
+        match s {
+            "literal" => QuotingStyle::Literal {
+                show_control: false,
+            },
+            "literal-show" => QuotingStyle::Literal { show_control: true },
+            "escape" => QuotingStyle::C {
+                quotes: Quotes::None,
+            },
+            "c" => QuotingStyle::C {
+                quotes: Quotes::Double,
+            },
+            "shell" => QuotingStyle::Shell {
+                escape: false,
+                always_quote: false,
+                show_control: false,
+            },
+            "shell-show" => QuotingStyle::Shell {
+                escape: false,
+                always_quote: false,
+                show_control: true,
+            },
+            "shell-always" => QuotingStyle::Shell {
+                escape: false,
+                always_quote: true,
+                show_control: false,
+            },
+            "shell-always-show" => QuotingStyle::Shell {
+                escape: false,
+                always_quote: true,
+                show_control: true,
+            },
+            "shell-escape" => QuotingStyle::Shell {
+                escape: true,
+                always_quote: false,
+                show_control: false,
+            },
+            "shell-escape-always" => QuotingStyle::Shell {
+                escape: true,
+                always_quote: true,
+                show_control: false,
+            },
+            _ => panic!("Invalid name!"),
+        }
+    }
+
+    fn check_names_inner<T>(name: &[u8], map: &[(T, &str)]) -> Vec<Vec<u8>> {
+        map.iter()
+            .map(|(_, style)| escape_name_inner(name, &get_style(style), false))
+            .collect()
+    }
+
+    fn check_names(name: &str, map: &[(&str, &str)]) {
+        assert_eq!(
+            map.iter()
+                .map(|(correct, _)| *correct)
+                .collect::<Vec<&str>>(),
+            check_names_inner(name.as_bytes(), map)
+                .iter()
+                .map(|bytes| std::str::from_utf8(bytes)
+                    .expect("valid str goes in, valid str comes out"))
+                .collect::<Vec<&str>>()
+        );
+    }
+
+    fn check_names_raw(name: &[u8], map: &[(&[u8], &str)]) {
+        assert_eq!(
+            map.iter()
+                .map(|(correct, _)| *correct)
+                .collect::<Vec<&[u8]>>(),
+            check_names_inner(name, map)
+        );
+    }
+
+    #[test]
+    fn test_simple_names() {
+        check_names(
+            "one_two",
+            &[
+                ("one_two", "literal"),
+                ("one_two", "literal-show"),
+                ("one_two", "escape"),
+                ("\"one_two\"", "c"),
+                ("one_two", "shell"),
+                ("one_two", "shell-show"),
+                ("'one_two'", "shell-always"),
+                ("'one_two'", "shell-always-show"),
+                ("one_two", "shell-escape"),
+                ("'one_two'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_empty_string() {
+        check_names(
+            "",
+            &[
+                ("", "literal"),
+                ("", "literal-show"),
+                ("", "escape"),
+                ("\"\"", "c"),
+                ("''", "shell"),
+                ("''", "shell-show"),
+                ("''", "shell-always"),
+                ("''", "shell-always-show"),
+                ("''", "shell-escape"),
+                ("''", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_spaces() {
+        check_names(
+            "one two",
+            &[
+                ("one two", "literal"),
+                ("one two", "literal-show"),
+                ("one\\ two", "escape"),
+                ("\"one two\"", "c"),
+                ("'one two'", "shell"),
+                ("'one two'", "shell-show"),
+                ("'one two'", "shell-always"),
+                ("'one two'", "shell-always-show"),
+                ("'one two'", "shell-escape"),
+                ("'one two'", "shell-escape-always"),
+            ],
+        );
+
+        check_names(
+            " one",
+            &[
+                (" one", "literal"),
+                (" one", "literal-show"),
+                ("\\ one", "escape"),
+                ("\" one\"", "c"),
+                ("' one'", "shell"),
+                ("' one'", "shell-show"),
+                ("' one'", "shell-always"),
+                ("' one'", "shell-always-show"),
+                ("' one'", "shell-escape"),
+                ("' one'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_quotes() {
+        // One double quote
+        check_names(
+            "one\"two",
+            &[
+                ("one\"two", "literal"),
+                ("one\"two", "literal-show"),
+                ("one\"two", "escape"),
+                ("\"one\\\"two\"", "c"),
+                ("'one\"two'", "shell"),
+                ("'one\"two'", "shell-show"),
+                ("'one\"two'", "shell-always"),
+                ("'one\"two'", "shell-always-show"),
+                ("'one\"two'", "shell-escape"),
+                ("'one\"two'", "shell-escape-always"),
+            ],
+        );
+
+        // One single quote
+        check_names(
+            "one'two",
+            &[
+                ("one'two", "literal"),
+                ("one'two", "literal-show"),
+                ("one'two", "escape"),
+                ("\"one'two\"", "c"),
+                ("\"one'two\"", "shell"),
+                ("\"one'two\"", "shell-show"),
+                ("\"one'two\"", "shell-always"),
+                ("\"one'two\"", "shell-always-show"),
+                ("\"one'two\"", "shell-escape"),
+                ("\"one'two\"", "shell-escape-always"),
+            ],
+        );
+
+        // One single quote and one double quote
+        check_names(
+            "one'two\"three",
+            &[
+                ("one'two\"three", "literal"),
+                ("one'two\"three", "literal-show"),
+                ("one'two\"three", "escape"),
+                ("\"one'two\\\"three\"", "c"),
+                ("'one'\\''two\"three'", "shell"),
+                ("'one'\\''two\"three'", "shell-show"),
+                ("'one'\\''two\"three'", "shell-always"),
+                ("'one'\\''two\"three'", "shell-always-show"),
+                ("'one'\\''two\"three'", "shell-escape"),
+                ("'one'\\''two\"three'", "shell-escape-always"),
+            ],
+        );
+
+        // Consecutive quotes
+        check_names(
+            "one''two\"\"three",
+            &[
+                ("one''two\"\"three", "literal"),
+                ("one''two\"\"three", "literal-show"),
+                ("one''two\"\"three", "escape"),
+                ("\"one''two\\\"\\\"three\"", "c"),
+                ("'one'\\'''\\''two\"\"three'", "shell"),
+                ("'one'\\'''\\''two\"\"three'", "shell-show"),
+                ("'one'\\'''\\''two\"\"three'", "shell-always"),
+                ("'one'\\'''\\''two\"\"three'", "shell-always-show"),
+                ("'one'\\'''\\''two\"\"three'", "shell-escape"),
+                ("'one'\\'''\\''two\"\"three'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_control_chars() {
+        // A simple newline
+        check_names(
+            "one\ntwo",
+            &[
+                ("one?two", "literal"),
+                ("one\ntwo", "literal-show"),
+                ("one\\ntwo", "escape"),
+                ("\"one\\ntwo\"", "c"),
+                ("'one?two'", "shell"),
+                ("'one\ntwo'", "shell-show"),
+                ("'one?two'", "shell-always"),
+                ("'one\ntwo'", "shell-always-show"),
+                ("'one'$'\\n''two'", "shell-escape"),
+                ("'one'$'\\n''two'", "shell-escape-always"),
+            ],
+        );
+
+        // A control character followed by a special shell character
+        check_names(
+            "one\n&two",
+            &[
+                ("one?&two", "literal"),
+                ("one\n&two", "literal-show"),
+                ("one\\n&two", "escape"),
+                ("\"one\\n&two\"", "c"),
+                ("'one?&two'", "shell"),
+                ("'one\n&two'", "shell-show"),
+                ("'one?&two'", "shell-always"),
+                ("'one\n&two'", "shell-always-show"),
+                ("'one'$'\\n''&two'", "shell-escape"),
+                ("'one'$'\\n''&two'", "shell-escape-always"),
+            ],
+        );
+
+        // The first 16 ASCII control characters. NUL is also included, even though it is of
+        // no importance for file names.
+        check_names(
+            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
+            &[
+                ("????????????????", "literal"),
+                (
+                    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
+                    "literal-show",
+                ),
+                (
+                    "\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017",
+                    "escape",
+                ),
+                (
+                    "\"\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017\"",
+                    "c",
+                ),
+                ("'????????????????'", "shell"),
+                (
+                    "'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F'",
+                    "shell-show",
+                ),
+                ("'????????????????'", "shell-always"),
+                (
+                    "'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F'",
+                    "shell-always-show",
+                ),
+                (
+                    "''$'\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017'",
+                    "shell-escape",
+                ),
+                (
+                    "''$'\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017'",
+                    "shell-escape-always",
+                ),
+            ],
+        );
+
+        // The last 16 ASCII control characters.
+        check_names(
+            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
+            &[
+                ("????????????????", "literal"),
+                (
+                    "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
+                    "literal-show",
+                ),
+                (
+                    "\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037",
+                    "escape",
+                ),
+                (
+                    "\"\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\"",
+                    "c",
+                ),
+                ("????????????????", "shell"),
+                (
+                    "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
+                    "shell-show",
+                ),
+                ("'????????????????'", "shell-always"),
+                (
+                    "'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F'",
+                    "shell-always-show",
+                ),
+                (
+                    "''$'\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037'",
+                    "shell-escape",
+                ),
+                (
+                    "''$'\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037'",
+                    "shell-escape-always",
+                ),
+            ],
+        );
+
+        // DEL
+        check_names(
+            "\x7F",
+            &[
+                ("?", "literal"),
+                ("\x7F", "literal-show"),
+                ("\\177", "escape"),
+                ("\"\\177\"", "c"),
+                ("?", "shell"),
+                ("\x7F", "shell-show"),
+                ("'?'", "shell-always"),
+                ("'\x7F'", "shell-always-show"),
+                ("''$'\\177'", "shell-escape"),
+                ("''$'\\177'", "shell-escape-always"),
+            ],
+        );
+
+        // The first 16 Unicode control characters.
+        let test_str = std::str::from_utf8(b"\xC2\x80\xC2\x81\xC2\x82\xC2\x83\xC2\x84\xC2\x85\xC2\x86\xC2\x87\xC2\x88\xC2\x89\xC2\x8A\xC2\x8B\xC2\x8C\xC2\x8D\xC2\x8E\xC2\x8F").unwrap();
+        check_names(
+            test_str,
+            &[
+                ("????????????????", "literal"),
+                (test_str, "literal-show"),
+                (
+                    "\\302\\200\\302\\201\\302\\202\\302\\203\\302\\204\\302\\205\\302\\206\\302\\207\\302\\210\\302\\211\\302\\212\\302\\213\\302\\214\\302\\215\\302\\216\\302\\217",
+                    "escape",
+                ),
+                (
+                    "\"\\302\\200\\302\\201\\302\\202\\302\\203\\302\\204\\302\\205\\302\\206\\302\\207\\302\\210\\302\\211\\302\\212\\302\\213\\302\\214\\302\\215\\302\\216\\302\\217\"",
+                    "c",
+                ),
+                ("????????????????", "shell"),
+                (test_str, "shell-show"),
+                ("'????????????????'", "shell-always"),
+                (&format!("'{test_str}'"), "shell-always-show"),
+                (
+                    "''$'\\302\\200\\302\\201\\302\\202\\302\\203\\302\\204\\302\\205\\302\\206\\302\\207\\302\\210\\302\\211\\302\\212\\302\\213\\302\\214\\302\\215\\302\\216\\302\\217'",
+                    "shell-escape",
+                ),
+                (
+                    "''$'\\302\\200\\302\\201\\302\\202\\302\\203\\302\\204\\302\\205\\302\\206\\302\\207\\302\\210\\302\\211\\302\\212\\302\\213\\302\\214\\302\\215\\302\\216\\302\\217'",
+                    "shell-escape-always",
+                ),
+            ],
+        );
+
+        // The last 16 Unicode control characters.
+        let test_str = std::str::from_utf8(b"\xC2\x90\xC2\x91\xC2\x92\xC2\x93\xC2\x94\xC2\x95\xC2\x96\xC2\x97\xC2\x98\xC2\x99\xC2\x9A\xC2\x9B\xC2\x9C\xC2\x9D\xC2\x9E\xC2\x9F").unwrap();
+        check_names(
+            test_str,
+            &[
+                ("????????????????", "literal"),
+                (test_str, "literal-show"),
+                (
+                    "\\302\\220\\302\\221\\302\\222\\302\\223\\302\\224\\302\\225\\302\\226\\302\\227\\302\\230\\302\\231\\302\\232\\302\\233\\302\\234\\302\\235\\302\\236\\302\\237",
+                    "escape",
+                ),
+                (
+                    "\"\\302\\220\\302\\221\\302\\222\\302\\223\\302\\224\\302\\225\\302\\226\\302\\227\\302\\230\\302\\231\\302\\232\\302\\233\\302\\234\\302\\235\\302\\236\\302\\237\"",
+                    "c",
+                ),
+                ("????????????????", "shell"),
+                (test_str, "shell-show"),
+                ("'????????????????'", "shell-always"),
+                (&format!("'{test_str}'"), "shell-always-show"),
+                (
+                    "''$'\\302\\220\\302\\221\\302\\222\\302\\223\\302\\224\\302\\225\\302\\226\\302\\227\\302\\230\\302\\231\\302\\232\\302\\233\\302\\234\\302\\235\\302\\236\\302\\237'",
+                    "shell-escape",
+                ),
+                (
+                    "''$'\\302\\220\\302\\221\\302\\222\\302\\223\\302\\224\\302\\225\\302\\226\\302\\227\\302\\230\\302\\231\\302\\232\\302\\233\\302\\234\\302\\235\\302\\236\\302\\237'",
+                    "shell-escape-always",
+                ),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_non_unicode_bytes() {
+        let ascii = b'_';
+        let continuation = b'\xA7';
+        let first2byte = b'\xC2';
+        let first3byte = b'\xE0';
+        let first4byte = b'\xF0';
+        let invalid = b'\xC0';
+
+        // a single byte value invalid outside of additional context in UTF-8
+        check_names_raw(
+            &[continuation],
+            &[
+                (b"?", "literal"),
+                (b"\xA7", "literal-show"),
+                (b"\\247", "escape"),
+                (b"\"\\247\"", "c"),
+                (b"?", "shell"),
+                (b"\xA7", "shell-show"),
+                (b"'?'", "shell-always"),
+                (b"'\xA7'", "shell-always-show"),
+                (b"''$'\\247'", "shell-escape"),
+                (b"''$'\\247'", "shell-escape-always"),
+            ],
+        );
+
+        // ...but the byte becomes valid with appropriate context
+        // (this is just the § character in UTF-8, written as bytes)
+        check_names_raw(
+            &[first2byte, continuation],
+            &[
+                (b"\xC2\xA7", "literal"),
+                (b"\xC2\xA7", "literal-show"),
+                (b"\xC2\xA7", "escape"),
+                (b"\"\xC2\xA7\"", "c"),
+                (b"\xC2\xA7", "shell"),
+                (b"\xC2\xA7", "shell-show"),
+                (b"'\xC2\xA7'", "shell-always"),
+                (b"'\xC2\xA7'", "shell-always-show"),
+                (b"\xC2\xA7", "shell-escape"),
+                (b"'\xC2\xA7'", "shell-escape-always"),
+            ],
+        );
+
+        // mixed with valid characters
+        check_names_raw(
+            &[continuation, ascii],
+            &[
+                (b"?_", "literal"),
+                (b"\xA7_", "literal-show"),
+                (b"\\247_", "escape"),
+                (b"\"\\247_\"", "c"),
+                (b"?_", "shell"),
+                (b"\xA7_", "shell-show"),
+                (b"'?_'", "shell-always"),
+                (b"'\xA7_'", "shell-always-show"),
+                (b"''$'\\247''_'", "shell-escape"),
+                (b"''$'\\247''_'", "shell-escape-always"),
+            ],
+        );
+        check_names_raw(
+            &[ascii, continuation],
+            &[
+                (b"_?", "literal"),
+                (b"_\xA7", "literal-show"),
+                (b"_\\247", "escape"),
+                (b"\"_\\247\"", "c"),
+                (b"_?", "shell"),
+                (b"_\xA7", "shell-show"),
+                (b"'_?'", "shell-always"),
+                (b"'_\xA7'", "shell-always-show"),
+                (b"'_'$'\\247'", "shell-escape"),
+                (b"'_'$'\\247'", "shell-escape-always"),
+            ],
+        );
+        check_names_raw(
+            &[ascii, continuation, ascii],
+            &[
+                (b"_?_", "literal"),
+                (b"_\xA7_", "literal-show"),
+                (b"_\\247_", "escape"),
+                (b"\"_\\247_\"", "c"),
+                (b"_?_", "shell"),
+                (b"_\xA7_", "shell-show"),
+                (b"'_?_'", "shell-always"),
+                (b"'_\xA7_'", "shell-always-show"),
+                (b"'_'$'\\247''_'", "shell-escape"),
+                (b"'_'$'\\247''_'", "shell-escape-always"),
+            ],
+        );
+        check_names_raw(
+            &[continuation, ascii, continuation],
+            &[
+                (b"?_?", "literal"),
+                (b"\xA7_\xA7", "literal-show"),
+                (b"\\247_\\247", "escape"),
+                (b"\"\\247_\\247\"", "c"),
+                (b"?_?", "shell"),
+                (b"\xA7_\xA7", "shell-show"),
+                (b"'?_?'", "shell-always"),
+                (b"'\xA7_\xA7'", "shell-always-show"),
+                (b"''$'\\247''_'$'\\247'", "shell-escape"),
+                (b"''$'\\247''_'$'\\247'", "shell-escape-always"),
+            ],
+        );
+
+        // contiguous invalid bytes
+        check_names_raw(
+            &[
+                ascii,
+                invalid,
+                ascii,
+                continuation,
+                continuation,
+                ascii,
+                continuation,
+                continuation,
+                continuation,
+                ascii,
+                continuation,
+                continuation,
+                continuation,
+                continuation,
+                ascii,
+            ],
+            &[
+                (b"_?_??_???_????_", "literal"),
+                (
+                    b"_\xC0_\xA7\xA7_\xA7\xA7\xA7_\xA7\xA7\xA7\xA7_",
+                    "literal-show",
+                ),
+                (
+                    b"_\\300_\\247\\247_\\247\\247\\247_\\247\\247\\247\\247_",
+                    "escape",
+                ),
+                (
+                    b"\"_\\300_\\247\\247_\\247\\247\\247_\\247\\247\\247\\247_\"",
+                    "c",
+                ),
+                (b"_?_??_???_????_", "shell"),
+                (
+                    b"_\xC0_\xA7\xA7_\xA7\xA7\xA7_\xA7\xA7\xA7\xA7_",
+                    "shell-show",
+                ),
+                (b"'_?_??_???_????_'", "shell-always"),
+                (
+                    b"'_\xC0_\xA7\xA7_\xA7\xA7\xA7_\xA7\xA7\xA7\xA7_'",
+                    "shell-always-show",
+                ),
+                (
+                    b"'_'$'\\300''_'$'\\247\\247''_'$'\\247\\247\\247''_'$'\\247\\247\\247\\247''_'",
+                    "shell-escape",
+                ),
+                (
+                    b"'_'$'\\300''_'$'\\247\\247''_'$'\\247\\247\\247''_'$'\\247\\247\\247\\247''_'",
+                    "shell-escape-always",
+                ),
+            ],
+        );
+
+        // invalid multi-byte sequences that start valid
+        check_names_raw(
+            &[first2byte, ascii],
+            &[
+                (b"?_", "literal"),
+                (b"\xC2_", "literal-show"),
+                (b"\\302_", "escape"),
+                (b"\"\\302_\"", "c"),
+                (b"?_", "shell"),
+                (b"\xC2_", "shell-show"),
+                (b"'?_'", "shell-always"),
+                (b"'\xC2_'", "shell-always-show"),
+                (b"''$'\\302''_'", "shell-escape"),
+                (b"''$'\\302''_'", "shell-escape-always"),
+            ],
+        );
+        check_names_raw(
+            &[first2byte, first2byte, continuation],
+            &[
+                (b"?\xC2\xA7", "literal"),
+                (b"\xC2\xC2\xA7", "literal-show"),
+                (b"\\302\xC2\xA7", "escape"),
+                (b"\"\\302\xC2\xA7\"", "c"),
+                (b"?\xC2\xA7", "shell"),
+                (b"\xC2\xC2\xA7", "shell-show"),
+                (b"'?\xC2\xA7'", "shell-always"),
+                (b"'\xC2\xC2\xA7'", "shell-always-show"),
+                (b"''$'\\302''\xC2\xA7'", "shell-escape"),
+                (b"''$'\\302''\xC2\xA7'", "shell-escape-always"),
+            ],
+        );
+        check_names_raw(
+            &[first3byte, continuation, ascii],
+            &[
+                (b"??_", "literal"),
+                (b"\xE0\xA7_", "literal-show"),
+                (b"\\340\\247_", "escape"),
+                (b"\"\\340\\247_\"", "c"),
+                (b"??_", "shell"),
+                (b"\xE0\xA7_", "shell-show"),
+                (b"'??_'", "shell-always"),
+                (b"'\xE0\xA7_'", "shell-always-show"),
+                (b"''$'\\340\\247''_'", "shell-escape"),
+                (b"''$'\\340\\247''_'", "shell-escape-always"),
+            ],
+        );
+        check_names_raw(
+            &[first4byte, continuation, continuation, ascii],
+            &[
+                (b"???_", "literal"),
+                (b"\xF0\xA7\xA7_", "literal-show"),
+                (b"\\360\\247\\247_", "escape"),
+                (b"\"\\360\\247\\247_\"", "c"),
+                (b"???_", "shell"),
+                (b"\xF0\xA7\xA7_", "shell-show"),
+                (b"'???_'", "shell-always"),
+                (b"'\xF0\xA7\xA7_'", "shell-always-show"),
+                (b"''$'\\360\\247\\247''_'", "shell-escape"),
+                (b"''$'\\360\\247\\247''_'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_question_mark() {
+        // A question mark must force quotes in shell and shell-always, unless
+        // it is in place of a control character (that case is already covered
+        // in other tests)
+        check_names(
+            "one?two",
+            &[
+                ("one?two", "literal"),
+                ("one?two", "literal-show"),
+                ("one?two", "escape"),
+                ("\"one?two\"", "c"),
+                ("'one?two'", "shell"),
+                ("'one?two'", "shell-show"),
+                ("'one?two'", "shell-always"),
+                ("'one?two'", "shell-always-show"),
+                ("'one?two'", "shell-escape"),
+                ("'one?two'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_backslash() {
+        // Escaped in C-style, but not in Shell-style escaping
+        check_names(
+            "one\\two",
+            &[
+                ("one\\two", "literal"),
+                ("one\\two", "literal-show"),
+                ("one\\\\two", "escape"),
+                ("\"one\\\\two\"", "c"),
+                ("'one\\two'", "shell"),
+                ("'one\\two'", "shell-always"),
+                ("'one\\two'", "shell-escape"),
+                ("'one\\two'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_tilde_and_hash() {
+        check_names("~", &[("'~'", "shell"), ("'~'", "shell-escape")]);
+        check_names(
+            "~name",
+            &[("'~name'", "shell"), ("'~name'", "shell-escape")],
+        );
+        check_names(
+            "some~name",
+            &[("some~name", "shell"), ("some~name", "shell-escape")],
+        );
+        check_names("name~", &[("name~", "shell"), ("name~", "shell-escape")]);
+
+        check_names("#", &[("'#'", "shell"), ("'#'", "shell-escape")]);
+        check_names(
+            "#name",
+            &[("'#name'", "shell"), ("'#name'", "shell-escape")],
+        );
+        check_names(
+            "some#name",
+            &[("some#name", "shell"), ("some#name", "shell-escape")],
+        );
+        check_names("name#", &[("name#", "shell"), ("name#", "shell-escape")]);
+    }
+
+    #[test]
+    fn test_special_chars_in_double_quotes() {
+        check_names(
+            "can'$t",
+            &[
+                ("'can'\\''$t'", "shell"),
+                ("'can'\\''$t'", "shell-always"),
+                ("'can'\\''$t'", "shell-escape"),
+                ("'can'\\''$t'", "shell-escape-always"),
+            ],
+        );
+
+        check_names(
+            "can'`t",
+            &[
+                ("'can'\\''`t'", "shell"),
+                ("'can'\\''`t'", "shell-always"),
+                ("'can'\\''`t'", "shell-escape"),
+                ("'can'\\''`t'", "shell-escape-always"),
+            ],
+        );
+
+        check_names(
+            "can'\\t",
+            &[
+                ("'can'\\''\\t'", "shell"),
+                ("'can'\\''\\t'", "shell-always"),
+                ("'can'\\''\\t'", "shell-escape"),
+                ("'can'\\''\\t'", "shell-escape-always"),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_quoting_style_display() {
+        let style = QuotingStyle::Shell {
+            escape: true,
+            always_quote: false,
+            show_control: false,
+        };
+        assert_eq!(format!("{style}"), "shell-escape");
+
+        let style = QuotingStyle::Shell {
+            escape: false,
+            always_quote: true,
+            show_control: false,
+        };
+        assert_eq!(format!("{style}"), "shell-always-quote");
+
+        let style = QuotingStyle::Shell {
+            escape: false,
+            always_quote: false,
+            show_control: true,
+        };
+        assert_eq!(format!("{style}"), "shell-show-control");
+
+        let style = QuotingStyle::C {
+            quotes: Quotes::Double,
+        };
+        assert_eq!(format!("{style}"), "C");
+
+        let style = QuotingStyle::Literal {
+            show_control: false,
+        };
+        assert_eq!(format!("{style}"), "literal");
+    }
+
+    #[test]
+    fn test_quotes_display() {
+        assert_eq!(format!("{}", Quotes::None), "None");
+        assert_eq!(format!("{}", Quotes::Single), "Single");
+        assert_eq!(format!("{}", Quotes::Double), "Double");
+    }
+}
diff --git a/src/uucore/src/lib/features/ranges.rs b/src/uucore/src/lib/features/ranges.rs
index 29f40218363..0797a3bd5ec 100644
--- a/src/uucore/src/lib/features/ranges.rs
+++ b/src/uucore/src/lib/features/ranges.rs
@@ -5,14 +5,20 @@
 
 // spell-checker:ignore (ToDO) inval
 
+//! A module for handling ranges of values.
+
 use std::cmp::max;
 use std::str::FromStr;
 
 use crate::display::Quotable;
 
+/// A range of values
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
 pub struct Range {
+    /// The lower bound of the range
     pub low: usize,
+
+    /// The upper bound of the range
     pub high: usize,
 }
 
@@ -38,6 +44,8 @@ impl FromStr for Range {
         fn parse(s: &str) -> Result<usize, &'static str> {
             match s.parse::<usize>() {
                 Ok(0) => Err("fields and positions are numbered from 1"),
+                // GNU fails when we are at the limit. Match their behavior
+                Ok(n) if n == usize::MAX => Err("byte/character offset is too large"),
                 Ok(n) => Ok(n),
                 Err(_) => Err("failed to parse range"),
             }
@@ -70,19 +78,20 @@ impl FromStr for Range {
 }
 
 impl Range {
+    /// Parse a list of ranges separated by commas and/or spaces
     pub fn from_list(list: &str) -> Result<Vec<Self>, String> {
         let mut ranges = Vec::new();
 
         for item in list.split(&[',', ' ']) {
             let range_item = FromStr::from_str(item)
-                .map_err(|e| format!("range {} was invalid: {}", item.quote(), e))?;
+                .map_err(|e| format!("range {} was invalid: {e}", item.quote()))?;
             ranges.push(range_item);
         }
 
         Ok(Self::merge(ranges))
     }
 
-    /// Merge any overlapping ranges
+    /// Merge any overlapping ranges. Adjacent ranges are *NOT* merged.
     ///
     /// Is guaranteed to return only disjoint ranges in a sorted order.
     fn merge(mut ranges: Vec<Self>) -> Vec<Self> {
@@ -92,10 +101,7 @@ impl Range {
         for i in 0..ranges.len() {
             let j = i + 1;
 
-            // The +1 is a small optimization, because we can merge adjacent Ranges.
-            // For example (1,3) and (4,6), because in the integers, there are no
-            // possible values between 3 and 4, this is equivalent to (1,6).
-            while j < ranges.len() && ranges[j].low <= ranges[i].high + 1 {
+            while j < ranges.len() && ranges[j].low <= ranges[i].high {
                 let j_high = ranges.remove(j).high;
                 ranges[i].high = max(ranges[i].high, j_high);
             }
@@ -104,6 +110,7 @@ impl Range {
     }
 }
 
+/// Calculate the complement of the given ranges.
 pub fn complement(ranges: &[Range]) -> Vec<Range> {
     let mut prev_high = 0;
     let mut complements = Vec::with_capacity(ranges.len() + 1);
@@ -158,7 +165,8 @@ pub fn contain(ranges: &[Range], n: usize) -> bool {
 
 #[cfg(test)]
 mod test {
-    use super::{complement, Range};
+    use super::{Range, complement};
+    use std::str::FromStr;
 
     fn m(a: Vec<Range>, b: &[Range]) {
         assert_eq!(Range::merge(a), b);
@@ -205,8 +213,8 @@ mod test {
             &[r(10, 40), r(50, 60)],
         );
 
-        // Merge adjacent ranges
-        m(vec![r(1, 3), r(4, 6)], &[r(1, 6)]);
+        // Don't merge adjacent ranges
+        m(vec![r(1, 3), r(4, 6)], &[r(1, 3), r(4, 6)]);
     }
 
     #[test]
@@ -229,4 +237,33 @@ mod test {
         // With start and end
         assert_eq!(complement(&[r(1, 4), r(6, usize::MAX - 1)]), vec![r(5, 5)]);
     }
+
+    #[test]
+    fn test_from_str() {
+        assert_eq!(Range::from_str("5"), Ok(Range { low: 5, high: 5 }));
+        assert_eq!(Range::from_str("3-5"), Ok(Range { low: 3, high: 5 }));
+        assert_eq!(
+            Range::from_str("5-3"),
+            Err("high end of range less than low end")
+        );
+        assert_eq!(Range::from_str("-"), Err("invalid range with no endpoint"));
+        assert_eq!(
+            Range::from_str("3-"),
+            Ok(Range {
+                low: 3,
+                high: usize::MAX - 1
+            })
+        );
+        assert_eq!(Range::from_str("-5"), Ok(Range { low: 1, high: 5 }));
+        assert_eq!(
+            Range::from_str("0"),
+            Err("fields and positions are numbered from 1")
+        );
+
+        let max_value = format!("{}", usize::MAX);
+        assert_eq!(
+            Range::from_str(&max_value),
+            Err("byte/character offset is too large")
+        );
+    }
 }
diff --git a/src/uucore/src/lib/features/ringbuffer.rs b/src/uucore/src/lib/features/ringbuffer.rs
index d58c8c498b8..edd83867d6b 100644
--- a/src/uucore/src/lib/features/ringbuffer.rs
+++ b/src/uucore/src/lib/features/ringbuffer.rs
@@ -41,11 +41,15 @@ use std::collections::VecDeque;
 /// [`push_back`]: struct.RingBuffer.html#method.push_back
 /// [`from_iter`]: struct.RingBuffer.html#method.from_iter
 pub struct RingBuffer<T> {
+    /// The data stored in the ring buffer.
     pub data: VecDeque<T>,
+
+    /// The maximum number of elements that the ring buffer can hold.
     size: usize,
 }
 
 impl<T> RingBuffer<T> {
+    /// Create a new ring buffer with a maximum size of `size`.
     pub fn new(size: usize) -> Self {
         Self {
             data: VecDeque::new(),
@@ -53,6 +57,7 @@ impl<T> RingBuffer<T> {
         }
     }
 
+    /// Create a new ring buffer from an iterator.
     pub fn from_iter(iter: impl Iterator<Item = T>, size: usize) -> Self {
         let mut ring_buffer = Self::new(size);
         for value in iter {
diff --git a/src/uucore/src/lib/features/selinux.rs b/src/uucore/src/lib/features/selinux.rs
new file mode 100644
index 00000000000..062d1c16c80
--- /dev/null
+++ b/src/uucore/src/lib/features/selinux.rs
@@ -0,0 +1,629 @@
+// This file is part of the uutils uucore package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Set of functions to manage SELinux security contexts
+
+use std::error::Error;
+use std::path::Path;
+
+use selinux::SecurityContext;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum SeLinuxError {
+    #[error("SELinux is not enabled on this system")]
+    SELinuxNotEnabled,
+
+    #[error("failed to open the file: {0}")]
+    FileOpenFailure(String),
+
+    #[error("failed to retrieve the security context: {0}")]
+    ContextRetrievalFailure(String),
+
+    #[error("failed to set default file creation context to '{0}': {1}")]
+    ContextSetFailure(String, String),
+
+    #[error("failed to set default file creation context to '{0}': {1}")]
+    ContextConversionFailure(String, String),
+}
+
+impl From<SeLinuxError> for i32 {
+    fn from(error: SeLinuxError) -> i32 {
+        match error {
+            SeLinuxError::SELinuxNotEnabled => 1,
+            SeLinuxError::FileOpenFailure(_) => 2,
+            SeLinuxError::ContextRetrievalFailure(_) => 3,
+            SeLinuxError::ContextSetFailure(_, _) => 4,
+            SeLinuxError::ContextConversionFailure(_, _) => 5,
+        }
+    }
+}
+
+/// Checks if SELinux is enabled on the system.
+///
+/// This function verifies whether the kernel has SELinux support enabled.
+pub fn is_selinux_enabled() -> bool {
+    selinux::kernel_support() != selinux::KernelSupport::Unsupported
+}
+
+/// Returns a string describing the error and its causes.
+fn selinux_error_description(mut error: &dyn Error) -> String {
+    let mut description = String::new();
+    while let Some(source) = error.source() {
+        let error_text = source.to_string();
+        // Check if this is an OS error and trim it
+        if let Some(idx) = error_text.find(" (os error ") {
+            description.push_str(&error_text[..idx]);
+        } else {
+            description.push_str(&error_text);
+        }
+        error = source;
+    }
+    description
+}
+
+/// Sets the SELinux security context for the given filesystem path.
+///
+/// If a specific context is provided, it attempts to set this context explicitly.
+/// Otherwise, it applies the default SELinux context for the provided path.
+///
+/// # Arguments
+///
+/// * `path` - Filesystem path on which to set the SELinux context.
+/// * `context` - Optional SELinux context string to explicitly set.
+///
+/// # Errors
+///
+/// Returns an error if:
+/// - SELinux is not enabled on the system.
+/// - The provided context is invalid or cannot be applied.
+/// - The default SELinux context cannot be set.
+///
+/// # Examples
+///
+/// Setting default context:
+/// ```
+/// use std::path::Path;
+/// use uucore::selinux::set_selinux_security_context;
+///
+/// // Set the default SELinux context for a file
+/// let result = set_selinux_security_context(Path::new("/path/to/file"), None);
+/// if let Err(err) = result {
+///     eprintln!("Failed to set default context: {}", err);
+/// }
+/// ```
+///
+/// Setting specific context:
+/// ```
+/// use std::path::Path;
+/// use uucore::selinux::set_selinux_security_context;
+///
+/// // Set a specific SELinux context for a file
+/// let context = String::from("unconfined_u:object_r:user_home_t:s0");
+/// let result = set_selinux_security_context(Path::new("/path/to/file"), Some(&context));
+/// if let Err(err) = result {
+///     eprintln!("Failed to set context: {}", err);
+/// }
+/// ```
+pub fn set_selinux_security_context(
+    path: &Path,
+    context: Option<&String>,
+) -> Result<(), SeLinuxError> {
+    if !is_selinux_enabled() {
+        return Err(SeLinuxError::SELinuxNotEnabled);
+    }
+
+    if let Some(ctx_str) = context {
+        // Create a CString from the provided context string
+        let c_context = std::ffi::CString::new(ctx_str.as_str()).map_err(|e| {
+            SeLinuxError::ContextConversionFailure(
+                ctx_str.to_string(),
+                selinux_error_description(&e),
+            )
+        })?;
+
+        // Convert the CString into an SELinux security context
+        let security_context =
+            selinux::OpaqueSecurityContext::from_c_str(&c_context).map_err(|e| {
+                SeLinuxError::ContextConversionFailure(
+                    ctx_str.to_string(),
+                    selinux_error_description(&e),
+                )
+            })?;
+
+        // Set the provided security context on the specified path
+        SecurityContext::from_c_str(
+            &security_context.to_c_string().map_err(|e| {
+                SeLinuxError::ContextConversionFailure(
+                    ctx_str.to_string(),
+                    selinux_error_description(&e),
+                )
+            })?,
+            false,
+        )
+        .set_for_path(path, false, false)
+        .map_err(|e| {
+            SeLinuxError::ContextSetFailure(ctx_str.to_string(), selinux_error_description(&e))
+        })
+    } else {
+        // If no context provided, set the default SELinux context for the path
+        SecurityContext::set_default_for_path(path).map_err(|e| {
+            SeLinuxError::ContextSetFailure(String::new(), selinux_error_description(&e))
+        })
+    }
+}
+
+/// Gets the SELinux security context for the given filesystem path.
+///
+/// Retrieves the security context of the specified filesystem path if SELinux is enabled
+/// on the system.
+///
+/// # Arguments
+///
+/// * `path` - Filesystem path for which to retrieve the SELinux context.
+///
+/// # Returns
+///
+/// * `Ok(String)` - The SELinux context string if successfully retrieved. Returns an empty
+///   string if no context was found.
+/// * `Err(SeLinuxError)` - An error variant indicating the type of failure:
+///   - `SeLinuxError::SELinuxNotEnabled` - SELinux is not enabled on the system.
+///   - `SeLinuxError::FileOpenFailure` - Failed to open the specified file.
+///   - `SeLinuxError::ContextRetrievalFailure` - Failed to retrieve the security context.
+///   - `SeLinuxError::ContextConversionFailure` - Failed to convert the security context to a string.
+///   - `SeLinuxError::ContextSetFailure` - Failed to set the security context.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// use uucore::selinux::{get_selinux_security_context, SeLinuxError};
+///
+/// // Get the SELinux context for a file
+/// match get_selinux_security_context(Path::new("/path/to/file")) {
+///     Ok(context) => {
+///         if context.is_empty() {
+///             println!("No SELinux context found for the file");
+///         } else {
+///             println!("SELinux context: {}", context);
+///         }
+///     },
+///     Err(SeLinuxError::SELinuxNotEnabled) => println!("SELinux is not enabled on this system"),
+///     Err(SeLinuxError::FileOpenFailure(e)) => println!("Failed to open the file: {}", e),
+///     Err(SeLinuxError::ContextRetrievalFailure(e)) => println!("Failed to retrieve the security context: {}", e),
+///     Err(SeLinuxError::ContextConversionFailure(ctx, e)) => println!("Failed to convert context '{}': {}", ctx, e),
+///     Err(SeLinuxError::ContextSetFailure(ctx, e)) => println!("Failed to set context '{}': {}", ctx, e),
+/// }
+/// ```
+pub fn get_selinux_security_context(path: &Path) -> Result<String, SeLinuxError> {
+    if !is_selinux_enabled() {
+        return Err(SeLinuxError::SELinuxNotEnabled);
+    }
+
+    let f = std::fs::File::open(path)
+        .map_err(|e| SeLinuxError::FileOpenFailure(selinux_error_description(&e)))?;
+
+    // Get the security context of the file
+    let context = match SecurityContext::of_file(&f, false) {
+        Ok(Some(ctx)) => ctx,
+        Ok(None) => return Ok(String::new()), // No context found, return empty string
+        Err(e) => {
+            return Err(SeLinuxError::ContextRetrievalFailure(
+                selinux_error_description(&e),
+            ));
+        }
+    };
+
+    let context_c_string = context.to_c_string().map_err(|e| {
+        SeLinuxError::ContextConversionFailure(String::new(), selinux_error_description(&e))
+    })?;
+
+    if let Some(c_str) = context_c_string {
+        // Convert the C string to a Rust String
+        Ok(c_str.to_string_lossy().to_string())
+    } else {
+        Ok(String::new())
+    }
+}
+
+/// Compares SELinux security contexts of two filesystem paths.
+///
+/// This function retrieves and compares the SELinux security contexts of two paths.
+/// If the contexts differ or an error occurs during retrieval, it returns true.
+///
+/// # Arguments
+///
+/// * `from_path` - Source filesystem path.
+/// * `to_path` - Destination filesystem path.
+///
+/// # Returns
+///
+/// * `true` - If contexts differ, cannot be retrieved, or if SELinux is not enabled.
+/// * `false` - If contexts are the same.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// use uucore::selinux::contexts_differ;
+///
+/// // Check if contexts differ between two files
+/// let differ = contexts_differ(Path::new("/path/to/source"), Path::new("/path/to/destination"));
+/// if differ {
+///     println!("Files have different SELinux contexts");
+/// } else {
+///     println!("Files have the same SELinux context");
+/// }
+/// ```
+pub fn contexts_differ(from_path: &Path, to_path: &Path) -> bool {
+    if !is_selinux_enabled() {
+        return true;
+    }
+
+    // Check if SELinux contexts differ
+    match (
+        selinux::SecurityContext::of_path(from_path, false, false),
+        selinux::SecurityContext::of_path(to_path, false, false),
+    ) {
+        (Ok(Some(from_ctx)), Ok(Some(to_ctx))) => {
+            // Convert contexts to CString and compare
+            match (from_ctx.to_c_string(), to_ctx.to_c_string()) {
+                (Ok(Some(from_c_str)), Ok(Some(to_c_str))) => {
+                    from_c_str.to_string_lossy() != to_c_str.to_string_lossy()
+                }
+                // If contexts couldn't be converted to CString or were None, consider them different
+                _ => true,
+            }
+        }
+        // If either context is None or an error occurred, assume contexts differ
+        _ => true,
+    }
+}
+
+/// Preserves the SELinux security context from one filesystem path to another.
+///
+/// This function copies the security context from the source path to the destination path.
+/// If SELinux is not enabled, or if the source has no context, the function returns success
+/// without making any changes.
+///
+/// # Arguments
+///
+/// * `from_path` - Source filesystem path from which to copy the SELinux context.
+/// * `to_path` - Destination filesystem path to which the context should be applied.
+///
+/// # Returns
+///
+/// * `Ok(())` - If the context was successfully preserved or if SELinux is not enabled.
+/// * `Err(SeLinuxError)` - If an error occurred during context retrieval or application.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// use uucore::selinux::preserve_security_context;
+///
+/// // Preserve the SELinux context from source to destination
+/// match preserve_security_context(Path::new("/path/to/source"), Path::new("/path/to/destination")) {
+///     Ok(_) => println!("Context preserved successfully (or SELinux is not enabled)"),
+///     Err(err) => eprintln!("Failed to preserve context: {}", err),
+/// }
+/// ```
+pub fn preserve_security_context(from_path: &Path, to_path: &Path) -> Result<(), SeLinuxError> {
+    // If SELinux is not enabled, return success without doing anything
+    if !is_selinux_enabled() {
+        return Err(SeLinuxError::SELinuxNotEnabled);
+    }
+
+    // Get context from the source path
+    let context = get_selinux_security_context(from_path)?;
+
+    // If no context was found, just return success (nothing to preserve)
+    if context.is_empty() {
+        return Ok(());
+    }
+
+    // Apply the context to the destination path
+    set_selinux_security_context(to_path, Some(&context))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_selinux_context_setting() {
+        let tmpfile = NamedTempFile::new().expect("Failed to create tempfile");
+        let path = tmpfile.path();
+
+        if !is_selinux_enabled() {
+            let result = set_selinux_security_context(path, None);
+            assert!(result.is_err(), "Expected error when SELinux is disabled");
+            match result.unwrap_err() {
+                SeLinuxError::SELinuxNotEnabled => {
+                    // This is the expected error when SELinux is not enabled
+                }
+                err => panic!("Expected SELinuxNotEnabled error but got: {}", err),
+            }
+            return;
+        }
+
+        let default_result = set_selinux_security_context(path, None);
+        assert!(
+            default_result.is_ok(),
+            "Failed to set default context: {:?}",
+            default_result.err()
+        );
+
+        let context = get_selinux_security_context(path).expect("Failed to get context");
+        assert!(
+            !context.is_empty(),
+            "Expected non-empty context after setting default context"
+        );
+
+        let test_context = String::from("system_u:object_r:tmp_t:s0");
+        let explicit_result = set_selinux_security_context(path, Some(&test_context));
+
+        if explicit_result.is_ok() {
+            let new_context = get_selinux_security_context(path)
+                .expect("Failed to get context after setting explicit context");
+
+            assert!(
+                new_context.contains("tmp_t"),
+                "Expected context to contain 'tmp_t', but got: {}",
+                new_context
+            );
+        } else {
+            println!(
+                "Note: Could not set explicit context {:?}",
+                explicit_result.err()
+            );
+        }
+    }
+    #[test]
+    fn test_invalid_context_string_error() {
+        let tmpfile = NamedTempFile::new().expect("Failed to create tempfile");
+        let path = tmpfile.path();
+        if !is_selinux_enabled() {
+            println!("test skipped: Kernel has no support for SElinux context");
+            return;
+        }
+        // Pass a context string containing a null byte to trigger CString::new error
+        let invalid_context = String::from("invalid\0context");
+        let result = set_selinux_security_context(path, Some(&invalid_context));
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_is_selinux_enabled_runtime_behavior() {
+        let result = is_selinux_enabled();
+
+        match selinux::kernel_support() {
+            selinux::KernelSupport::Unsupported => {
+                assert!(!result, "Expected false when SELinux is not supported");
+            }
+            _ => {
+                assert!(result, "Expected true when SELinux is supported");
+            }
+        }
+    }
+
+    #[test]
+    fn test_get_selinux_security_context() {
+        let tmpfile = NamedTempFile::new().expect("Failed to create tempfile");
+        let path = tmpfile.path();
+        if !is_selinux_enabled() {
+            println!("test skipped: Kernel has no support for SElinux context");
+            return;
+        }
+        std::fs::write(path, b"test content").expect("Failed to write to tempfile");
+
+        let result = get_selinux_security_context(path);
+
+        if result.is_ok() {
+            let context = result.unwrap();
+            println!("Retrieved SELinux context: {}", context);
+
+            assert!(
+                is_selinux_enabled(),
+                "Got a successful context result but SELinux is not enabled"
+            );
+
+            if !context.is_empty() {
+                assert!(
+                    context.contains(':'),
+                    "SELinux context '{}' doesn't match expected format",
+                    context
+                );
+            }
+        } else {
+            let err = result.unwrap_err();
+
+            match err {
+                SeLinuxError::SELinuxNotEnabled => {
+                    assert!(
+                        !is_selinux_enabled(),
+                        "Got SELinuxNotEnabled error, but is_selinux_enabled() returned true"
+                    );
+                }
+                SeLinuxError::ContextRetrievalFailure(e) => {
+                    assert!(
+                        is_selinux_enabled(),
+                        "Got ContextRetrievalFailure when SELinux is not enabled"
+                    );
+                    assert!(!e.is_empty(), "Error message should not be empty");
+                    println!("Context retrieval failure: {}", e);
+                }
+                SeLinuxError::ContextConversionFailure(ctx, e) => {
+                    assert!(
+                        is_selinux_enabled(),
+                        "Got ContextConversionFailure when SELinux is not enabled"
+                    );
+                    assert!(!e.is_empty(), "Error message should not be empty");
+                    println!("Context conversion failure for '{}': {}", ctx, e);
+                }
+                SeLinuxError::ContextSetFailure(ctx, e) => {
+                    assert!(!e.is_empty(), "Error message should not be empty");
+                    println!("Context conversion failure for '{}': {}", ctx, e);
+                }
+                SeLinuxError::FileOpenFailure(e) => {
+                    assert!(
+                        Path::new(path).exists(),
+                        "File open failure occurred despite file being created: {}",
+                        e
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_get_selinux_context_nonexistent_file() {
+        let path = Path::new("/nonexistent/file/that/does/not/exist");
+        if !is_selinux_enabled() {
+            println!("test skipped: Kernel has no support for SElinux context");
+            return;
+        }
+        let result = get_selinux_security_context(path);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_contexts_differ() {
+        let file1 = NamedTempFile::new().expect("Failed to create first tempfile");
+        let file2 = NamedTempFile::new().expect("Failed to create second tempfile");
+        let path1 = file1.path();
+        let path2 = file2.path();
+
+        std::fs::write(path1, b"content for file 1").expect("Failed to write to first tempfile");
+        std::fs::write(path2, b"content for file 2").expect("Failed to write to second tempfile");
+
+        if !is_selinux_enabled() {
+            assert!(
+                contexts_differ(path1, path2),
+                "contexts_differ should return true when SELinux is not enabled"
+            );
+            return;
+        }
+
+        let test_context = String::from("system_u:object_r:tmp_t:s0");
+        let result1 = set_selinux_security_context(path1, Some(&test_context));
+        let result2 = set_selinux_security_context(path2, Some(&test_context));
+
+        if result1.is_ok() && result2.is_ok() {
+            assert!(
+                !contexts_differ(path1, path2),
+                "Contexts should not differ when the same context is set on both files"
+            );
+
+            let different_context = String::from("system_u:object_r:user_tmp_t:s0");
+            if set_selinux_security_context(path2, Some(&different_context)).is_ok() {
+                assert!(
+                    contexts_differ(path1, path2),
+                    "Contexts should differ when different contexts are set"
+                );
+            }
+        } else {
+            println!(
+                "Note: Couldn't set SELinux contexts to test differences. This is expected if the test doesn't have sufficient permissions."
+            );
+            assert!(
+                contexts_differ(path1, path2),
+                "Contexts should differ when different contexts are set"
+            );
+        }
+
+        let nonexistent_path = Path::new("/nonexistent/file/path");
+        assert!(
+            contexts_differ(path1, nonexistent_path),
+            "contexts_differ should return true when one path doesn't exist"
+        );
+    }
+
+    #[test]
+    fn test_preserve_security_context() {
+        let source_file = NamedTempFile::new().expect("Failed to create source tempfile");
+        let dest_file = NamedTempFile::new().expect("Failed to create destination tempfile");
+        let source_path = source_file.path();
+        let dest_path = dest_file.path();
+
+        std::fs::write(source_path, b"source content").expect("Failed to write to source tempfile");
+        std::fs::write(dest_path, b"destination content")
+            .expect("Failed to write to destination tempfile");
+
+        if !is_selinux_enabled() {
+            let result = preserve_security_context(source_path, dest_path);
+            assert!(
+                result.is_err(),
+                "preserve_security_context should fail when SELinux is not enabled"
+            );
+            return;
+        }
+
+        let source_context = String::from("system_u:object_r:tmp_t:s0");
+        let result = set_selinux_security_context(source_path, Some(&source_context));
+
+        if result.is_ok() {
+            let preserve_result = preserve_security_context(source_path, dest_path);
+            assert!(
+                preserve_result.is_ok(),
+                "Failed to preserve context: {:?}",
+                preserve_result.err()
+            );
+
+            assert!(
+                !contexts_differ(source_path, dest_path),
+                "Contexts should be the same after preserving"
+            );
+        } else {
+            println!(
+                "Note: Couldn't set SELinux context on source file to test preservation. This is expected if the test doesn't have sufficient permissions."
+            );
+
+            let preserve_result = preserve_security_context(source_path, dest_path);
+            assert!(preserve_result.is_err());
+        }
+
+        let nonexistent_path = Path::new("/nonexistent/file/path");
+        let result = preserve_security_context(nonexistent_path, dest_path);
+        assert!(
+            result.is_err(),
+            "preserve_security_context should fail when source file doesn't exist"
+        );
+
+        let result = preserve_security_context(source_path, nonexistent_path);
+        assert!(
+            result.is_err(),
+            "preserve_security_context should fail when destination file doesn't exist"
+        );
+    }
+
+    #[test]
+    fn test_preserve_security_context_empty_context() {
+        let source_file = NamedTempFile::new().expect("Failed to create source tempfile");
+        let dest_file = NamedTempFile::new().expect("Failed to create destination tempfile");
+        let source_path = source_file.path();
+        let dest_path = dest_file.path();
+
+        if !is_selinux_enabled() {
+            return;
+        }
+
+        let result = preserve_security_context(source_path, dest_path);
+
+        if let Err(err) = result {
+            match err {
+                SeLinuxError::ContextSetFailure(_, _) => {
+                    println!("Note: Could not set context due to permissions: {}", err);
+                }
+                unexpected => {
+                    panic!("Unexpected error: {}", unexpected);
+                }
+            }
+        }
+    }
+}
diff --git a/src/uucore/src/lib/features/signals.rs b/src/uucore/src/lib/features/signals.rs
index 61482024da0..4e7fe81c9af 100644
--- a/src/uucore/src/lib/features/signals.rs
+++ b/src/uucore/src/lib/features/signals.rs
@@ -3,14 +3,21 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// 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
+// spell-checker:ignore (vars/api) fcntl setrlimit setitimer rubout pollable sysconf
+// spell-checker:ignore (vars/signals) ABRT ALRM CHLD SEGV SIGABRT SIGALRM SIGBUS SIGCHLD SIGCONT SIGDANGER SIGEMT SIGFPE SIGHUP SIGILL SIGINFO SIGINT SIGIO SIGIOT SIGKILL SIGMIGRATE SIGMSG SIGPIPE SIGPRE SIGPROF SIGPWR SIGQUIT SIGSEGV SIGSTOP SIGSYS SIGTALRM SIGTERM SIGTRAP SIGTSTP SIGTHR SIGTTIN SIGTTOU SIGURG SIGUSR SIGVIRT SIGVTALRM SIGWINCH SIGXCPU SIGXFSZ STKFLT PWR THR TSTP TTIN TTOU VIRT VTALRM XCPU XFSZ SIGCLD SIGPOLL SIGWAITING SIGAIOCANCEL SIGLWP SIGFREEZE SIGTHAW SIGCANCEL SIGLOST SIGXRES SIGJVM SIGRTMIN SIGRT SIGRTMAX TALRM AIOCANCEL XRES RTMIN RTMAX
+
+//! This module provides a way to handle signals in a platform-independent way.
+//! It provides a way to convert signal names to their corresponding values and vice versa.
+//! It also provides a way to ignore the SIGINT signal and enable pipe errors.
+
 #[cfg(unix)]
 use nix::errno::Errno;
 #[cfg(unix)]
 use nix::sys::signal::{
-    signal, SigHandler::SigDfl, SigHandler::SigIgn, Signal::SIGINT, Signal::SIGPIPE,
+    SigHandler::SigDfl, SigHandler::SigIgn, Signal::SIGINT, Signal::SIGPIPE, signal,
 };
+
+/// The default signal value.
 pub static DEFAULT_SIGNAL: usize = 15;
 
 /*
@@ -26,7 +33,8 @@ Linux Programmer's Manual
 
 */
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+/// The list of all signals.
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "redox"))]
 pub static ALL_SIGNALS: [&str; 32] = [
     "EXIT", "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "BUS", "FPE", "KILL", "USR1", "SEGV",
     "USR2", "PIPE", "ALRM", "TERM", "STKFLT", "CHLD", "CONT", "STOP", "TSTP", "TTIN", "TTOU",
@@ -178,33 +186,196 @@ pub static ALL_SIGNALS: [&str; 33] = [
     "XCPU", "XFSZ", "VTALRM", "PROF", "WINCH", "INFO", "USR1", "USR2", "THR",
 ];
 
+/*
+     The following signals are defined in Solaris and illumos;
+     (the signals for illumos are the same as Solaris, but illumos still has SIGLWP
+     as well as the alias for SIGLWP (SIGAIOCANCEL)):
+
+     SIGHUP       1       hangup
+     SIGINT       2       interrupt (rubout)
+     SIGQUIT      3       quit (ASCII FS)
+     SIGILL       4       illegal instruction (not reset when caught)
+     SIGTRAP      5       trace trap (not reset when caught)
+     SIGIOT       6       IOT instruction
+     SIGABRT      6       used by abort, replace SIGIOT in the future
+     SIGEMT       7       EMT instruction
+     SIGFPE       8       floating point exception
+     SIGKILL      9       kill (cannot be caught or ignored)
+     SIGBUS       10      bus error
+     SIGSEGV      11      segmentation violation
+     SIGSYS       12      bad argument to system call
+     SIGPIPE      13      write on a pipe with no one to read it
+     SIGALRM      14      alarm clock
+     SIGTERM      15      software termination signal from kill
+     SIGUSR1      16      user defined signal 1
+     SIGUSR2      17      user defined signal 2
+     SIGCLD       18      child status change
+     SIGCHLD      18      child status change alias (POSIX)
+     SIGPWR       19      power-fail restart
+     SIGWINCH     20      window size change
+     SIGURG       21      urgent socket condition
+     SIGPOLL      22      pollable event occurred
+     SIGIO        SIGPOLL socket I/O possible (SIGPOLL alias)
+     SIGSTOP      23      stop (cannot be caught or ignored)
+     SIGTSTP      24      user stop requested from tty
+     SIGCONT      25      stopped process has been continued
+     SIGTTIN      26      background tty read attempted
+     SIGTTOU      27      background tty write attempted
+     SIGVTALRM    28      virtual timer expired
+     SIGPROF      29      profiling timer expired
+     SIGXCPU      30      exceeded cpu limit
+     SIGXFSZ      31      exceeded file size limit
+     SIGWAITING   32      reserved signal no longer used by threading code
+     SIGAIOCANCEL 33      reserved signal no longer used by threading code (formerly SIGLWP)
+     SIGFREEZE    34      special signal used by CPR
+     SIGTHAW      35      special signal used by CPR
+     SIGCANCEL    36      reserved signal for thread cancellation
+     SIGLOST      37      resource lost (eg, record-lock lost)
+     SIGXRES      38      resource control exceeded
+     SIGJVM1      39      reserved signal for Java Virtual Machine
+     SIGJVM2      40      reserved signal for Java Virtual Machine
+     SIGINFO      41      information request
+     SIGRTMIN     ((int)_sysconf(_SC_SIGRT_MIN)) first realtime signal
+     SIGRTMAX     ((int)_sysconf(_SC_SIGRT_MAX)) last realtime signal
+*/
+
+#[cfg(target_os = "solaris")]
+const SIGNALS_SIZE: usize = 46;
+
+#[cfg(target_os = "illumos")]
+const SIGNALS_SIZE: usize = 47;
+
+#[cfg(any(target_os = "solaris", target_os = "illumos"))]
+static ALL_SIGNALS: [&str; SIGNALS_SIZE] = [
+    "HUP",
+    "INT",
+    "QUIT",
+    "ILL",
+    "TRAP",
+    "IOT",
+    "ABRT",
+    "EMT",
+    "FPE",
+    "KILL",
+    "BUS",
+    "SEGV",
+    "SYS",
+    "PIPE",
+    "ALRM",
+    "TERM",
+    "USR1",
+    "USR2",
+    "CLD",
+    "CHLD",
+    "PWR",
+    "WINCH",
+    "URG",
+    "POLL",
+    "IO",
+    "STOP",
+    "TSTP",
+    "CONT",
+    "TTIN",
+    "TTOU",
+    "VTALRM",
+    "PROF",
+    "XCPU",
+    "XFSZ",
+    "WAITING",
+    "AIOCANCEL",
+    #[cfg(target_os = "illumos")]
+    "LWP",
+    "FREEZE",
+    "THAW",
+    "CANCEL",
+    "LOST",
+    "XRES",
+    "JVM1",
+    "JVM2",
+    "INFO",
+    "RTMIN",
+    "RTMAX",
+];
+
+/*
+   The following signals are defined in AIX:
+
+   SIGHUP     hangup, generated when terminal disconnects
+   SIGINT     interrupt, generated from terminal special char
+   SIGQUIT    quit, generated from terminal special char
+   SIGILL     illegal instruction (not reset when caught)
+   SIGTRAP    trace trap (not reset when caught)
+   SIGABRT    abort process
+   SIGEMT     EMT instruction
+   SIGFPE     floating point exception
+   SIGKILL    kill (cannot be caught or ignored)
+   SIGBUS     bus error (specification exception)
+   SIGSEGV    segmentation violation
+   SIGSYS     bad argument to system call
+   SIGPIPE    write on a pipe with no one to read it
+   SIGALRM    alarm clock timeout
+   SIGTERM    software termination signal
+   SIGURG     urgent condition on I/O channel
+   SIGSTOP    stop (cannot be caught or ignored)
+   SIGTSTP    interactive stop
+   SIGCONT    continue (cannot be caught or ignored)
+   SIGCHLD    sent to parent on child stop or exit
+   SIGTTIN    background read attempted from control terminal
+   SIGTTOU    background write attempted to control terminal
+   SIGIO      I/O possible, or completed
+   SIGXCPU    cpu time limit exceeded (see setrlimit())
+   SIGXFSZ    file size limit exceeded (see setrlimit())
+   SIGMSG     input data is in the ring buffer
+   SIGWINCH   window size changed
+   SIGPWR     power-fail restart
+   SIGUSR1    user defined signal 1
+   SIGUSR2    user defined signal 2
+   SIGPROF    profiling time alarm (see setitimer)
+   SIGDANGER  system crash imminent; free up some page space
+   SIGVTALRM  virtual time alarm (see setitimer)
+   SIGMIGRATE migrate process
+   SIGPRE     programming exception
+   SIGVIRT    AIX virtual time alarm
+   SIGTALRM   per-thread alarm clock
+*/
+#[cfg(target_os = "aix")]
+pub static ALL_SIGNALS: [&str; 37] = [
+    "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "EMT", "FPE", "KILL", "BUS", "SEGV", "SYS",
+    "PIPE", "ALRM", "TERM", "URG", "STOP", "TSTP", "CONT", "CHLD", "TTIN", "TTOU", "IO", "XCPU",
+    "XFSZ", "MSG", "WINCH", "PWR", "USR1", "USR2", "PROF", "DANGER", "VTALRM", "MIGRATE", "PRE",
+    "VIRT", "TALRM",
+];
+
+/// Returns the signal number for a given signal name or value.
 pub fn signal_by_name_or_value(signal_name_or_value: &str) -> Option<usize> {
-    if let Ok(value) = signal_name_or_value.parse() {
-        if is_signal(value) {
-            return Some(value);
-        } else {
-            return None;
-        }
+    let signal_name_upcase = signal_name_or_value.to_uppercase();
+    if let Ok(value) = signal_name_upcase.parse() {
+        return if is_signal(value) { Some(value) } else { None };
     }
-    let signal_name = signal_name_or_value.trim_start_matches("SIG");
+    let signal_name = signal_name_upcase.trim_start_matches("SIG");
 
     ALL_SIGNALS.iter().position(|&s| s == signal_name)
 }
 
+/// Returns true if the given number is a valid signal number.
 pub fn is_signal(num: usize) -> bool {
     num < ALL_SIGNALS.len()
 }
 
+/// Returns the signal name for a given signal value.
 pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
     ALL_SIGNALS.get(signal_value).copied()
 }
 
+/// Returns the default signal value.
 #[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(|_| ())
 }
+
+/// Ignores the SIGINT signal.
 #[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.
diff --git a/src/uucore/src/lib/features/sum.rs b/src/uucore/src/lib/features/sum.rs
index e079d7a30e3..fce0fd89e55 100644
--- a/src/uucore/src/lib/features/sum.rs
+++ b/src/uucore/src/lib/features/sum.rs
@@ -27,7 +27,7 @@ pub trait Digest {
     fn reset(&mut self);
     fn output_bits(&self) -> usize;
     fn output_bytes(&self) -> usize {
-        (self.output_bits() + 7) / 8
+        self.output_bits().div_ceil(8)
     }
     fn result_str(&mut self) -> String {
         let mut buf: Vec<u8> = vec![0; self.output_bytes()];
@@ -125,12 +125,12 @@ impl Digest for Sm3 {
 // NOTE: CRC_TABLE_LEN *must* be <= 256 as we cast 0..CRC_TABLE_LEN to u8
 const CRC_TABLE_LEN: usize = 256;
 
-pub struct CRC {
+pub struct Crc {
     state: u32,
     size: usize,
     crc_table: [u32; CRC_TABLE_LEN],
 }
-impl CRC {
+impl Crc {
     fn generate_crc_table() -> [u32; CRC_TABLE_LEN] {
         let mut table = [0; CRC_TABLE_LEN];
 
@@ -166,7 +166,7 @@ impl CRC {
     }
 }
 
-impl Digest for CRC {
+impl Digest for Crc {
     fn new() -> Self {
         Self {
             state: 0,
@@ -207,17 +207,41 @@ impl Digest for CRC {
     }
 }
 
-// This can be replaced with usize::div_ceil once it is stabilized.
-// This implementation approach is optimized for when `b` is a constant,
-// particularly a power of two.
-pub fn div_ceil(a: usize, b: usize) -> usize {
-    (a + b - 1) / b
+pub struct CRC32B(crc32fast::Hasher);
+impl Digest for CRC32B {
+    fn new() -> Self {
+        Self(crc32fast::Hasher::new())
+    }
+
+    fn hash_update(&mut self, input: &[u8]) {
+        self.0.update(input);
+    }
+
+    fn hash_finalize(&mut self, out: &mut [u8]) {
+        let result = self.0.clone().finalize();
+        let slice = result.to_be_bytes();
+        out.copy_from_slice(&slice);
+    }
+
+    fn reset(&mut self) {
+        self.0.reset();
+    }
+
+    fn output_bits(&self) -> usize {
+        32
+    }
+
+    fn result_str(&mut self) -> String {
+        let mut out = [0; 4];
+        self.hash_finalize(&mut out);
+        format!("{}", u32::from_be_bytes(out))
+    }
 }
 
-pub struct BSD {
+pub struct Bsd {
     state: u16,
 }
-impl Digest for BSD {
+impl Digest for Bsd {
     fn new() -> Self {
         Self { state: 0 }
     }
@@ -248,10 +272,10 @@ impl Digest for BSD {
     }
 }
 
-pub struct SYSV {
+pub struct SysV {
     state: u32,
 }
-impl Digest for SYSV {
+impl Digest for SysV {
     fn new() -> Self {
         Self { state: 0 }
     }
@@ -391,7 +415,7 @@ pub struct DigestWriter<'a> {
 }
 
 impl<'a> DigestWriter<'a> {
-    pub fn new(digest: &'a mut Box<dyn Digest>, binary: bool) -> DigestWriter {
+    pub fn new(digest: &'a mut Box<dyn Digest>, binary: bool) -> Self {
         let was_last_character_carriage_return = false;
         DigestWriter {
             digest,
@@ -402,7 +426,7 @@ impl<'a> DigestWriter<'a> {
 
     pub fn finalize(&mut self) -> bool {
         if self.was_last_character_carriage_return {
-            self.digest.hash_update(&[b'\r']);
+            self.digest.hash_update(b"\r");
             true
         } else {
             false
@@ -410,7 +434,7 @@ impl<'a> DigestWriter<'a> {
     }
 }
 
-impl<'a> Write for DigestWriter<'a> {
+impl Write for DigestWriter<'_> {
     #[cfg(not(windows))]
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         self.digest.hash_update(buf);
@@ -433,7 +457,7 @@ impl<'a> Write for DigestWriter<'a> {
         // call to `write()`.
         let n = buf.len();
         if self.was_last_character_carriage_return && n > 0 && buf[0] != b'\n' {
-            self.digest.hash_update(&[b'\r']);
+            self.digest.hash_update(b"\r");
         }
 
         // Next, find all occurrences of "\r\n", inputting the slice
@@ -484,22 +508,23 @@ mod tests {
     fn test_crlf_across_blocks() {
         use std::io::Write;
 
-        use crate::digest::Digest;
-        use crate::digest::DigestWriter;
+        use super::Digest;
+        use super::DigestWriter;
+        use super::Md5;
 
         // Writing "\r" in one call to `write()`, and then "\n" in another.
-        let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
+        let mut digest = Box::new(Md5::new()) as Box<dyn Digest>;
         let mut writer_crlf = DigestWriter::new(&mut digest, false);
-        writer_crlf.write_all(&[b'\r']).unwrap();
-        writer_crlf.write_all(&[b'\n']).unwrap();
-        writer_crlf.hash_finalize();
+        writer_crlf.write_all(b"\r").unwrap();
+        writer_crlf.write_all(b"\n").unwrap();
+        writer_crlf.finalize();
         let result_crlf = digest.result_str();
 
         // We expect "\r\n" to be replaced with "\n" in text mode on Windows.
-        let mut digest = Box::new(md5::Md5::new()) as Box<dyn Digest>;
+        let mut digest = Box::new(Md5::new()) as Box<dyn Digest>;
         let mut writer_lf = DigestWriter::new(&mut digest, false);
-        writer_lf.write_all(&[b'\n']).unwrap();
-        writer_lf.hash_finalize();
+        writer_lf.write_all(b"\n").unwrap();
+        writer_lf.finalize();
         let result_lf = digest.result_str();
 
         assert_eq!(result_crlf, result_lf);
diff --git a/src/uucore/src/lib/features/tokenize/mod.rs b/src/uucore/src/lib/features/tokenize/mod.rs
deleted file mode 100644
index 49611bbca5e..00000000000
--- a/src/uucore/src/lib/features/tokenize/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// 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.
-#[allow(clippy::module_inception)]
-mod num_format;
-pub mod sub;
-pub mod token;
-pub mod unescaped_text;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/format_field.rs b/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
deleted file mode 100644
index 036ee286d25..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/format_field.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! Primitives used by Sub Tokenizer
-//! and num_format modules
-#[derive(Clone)]
-pub enum FieldType {
-    Strf,
-    Floatf,
-    CninetyNineHexFloatf,
-    Scif,
-    Decf,
-    Intf,
-    Charf,
-}
-
-// #[allow(non_camel_case_types)]
-// pub enum FChar {
-// d,
-// e,
-// E,
-// i,
-// f,
-// F,
-// g,
-// G,
-// u,
-// x,
-// X,
-// o
-// }
-//
-
-// a Sub Tokens' fields are stored
-// as a single object so they can be more simply
-// passed by ref to num_format in a Sub method
-#[derive(Clone)]
-pub struct FormatField<'a> {
-    pub min_width: Option<isize>,
-    pub second_field: Option<u32>,
-    pub field_char: &'a char,
-    pub field_type: &'a FieldType,
-    pub orig: &'a String,
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatter.rs b/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
deleted file mode 100644
index 2a3fd1013eb..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatter.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// 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.
-//! Primitives used by num_format and sub_modules.
-//! never dealt with above (e.g. Sub Tokenizer never uses these)
-
-use crate::{display::Quotable, show_error};
-use itertools::{put_back_n, PutBackN};
-use std::str::Chars;
-
-use super::format_field::FormatField;
-
-// contains the rough ingredients to final
-// output for a number, organized together
-// to allow for easy generalization of output manipulation
-// (e.g. max number of digits after decimal)
-#[derive(Default)]
-pub struct FormatPrimitive {
-    pub prefix: Option<String>,
-    pub pre_decimal: Option<String>,
-    pub post_decimal: Option<String>,
-    pub suffix: Option<String>,
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub enum Base {
-    Ten = 10,
-    Hex = 16,
-    Octal = 8,
-}
-
-// information from the beginning of a numeric argument
-// the precedes the beginning of a numeric value
-pub struct InitialPrefix {
-    pub radix_in: Base,
-    pub sign: i8,
-    pub offset: usize,
-}
-
-pub trait Formatter {
-    //  return a FormatPrimitive for
-    // particular field char(s), given the argument
-    // string and prefix information (sign, radix)
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        in_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive>;
-    // return a string from a FormatPrimitive,
-    // given information about the field
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String;
-}
-pub fn get_it_at(offset: usize, str_in: &str) -> PutBackN<Chars> {
-    put_back_n(str_in[offset..].chars())
-}
-
-// TODO: put this somewhere better
-pub fn warn_incomplete_conv(pf_arg: &str) {
-    // important: keep println here not print
-    show_error!("{}: value not completely converted", pf_arg.maybe_quote());
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
deleted file mode 100644
index 7c041fec8c0..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/mod.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-// 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.
-// spell-checker:ignore (ToDO) arrnum arr_num mult basenum bufferval refd vals arrfloat conv intermed addl
-
-pub fn arrnum_int_mult(arr_num: &[u8], basenum: u8, base_ten_int_fact: u8) -> Vec<u8> {
-    let mut carry: u16 = 0;
-    let mut rem: u16;
-    let mut new_amount: u16;
-    let fact: u16 = u16::from(base_ten_int_fact);
-    let base: u16 = u16::from(basenum);
-
-    let mut ret_rev: Vec<u8> = Vec::new();
-    let mut it = arr_num.iter().rev();
-    loop {
-        let i = it.next();
-        match i {
-            Some(u) => {
-                new_amount = (u16::from(*u) * fact) + carry;
-                rem = new_amount % base;
-                carry = (new_amount - rem) / base;
-                ret_rev.push(rem as u8);
-            }
-            None => {
-                while carry != 0 {
-                    rem = carry % base;
-                    carry = (carry - rem) / base;
-                    ret_rev.push(rem as u8);
-                }
-                break;
-            }
-        }
-    }
-    let ret: Vec<u8> = ret_rev.into_iter().rev().collect();
-    ret
-}
-
-#[allow(dead_code)]
-pub struct Remainder<'a> {
-    pub position: usize,
-    pub replace: Vec<u8>,
-    pub arr_num: &'a Vec<u8>,
-}
-
-#[allow(dead_code)]
-pub struct DivOut<'a> {
-    pub quotient: u8,
-    pub remainder: Remainder<'a>,
-}
-
-#[allow(dead_code)]
-pub fn arrnum_int_div_step<'a>(
-    rem_in: &'a Remainder,
-    radix_in: u8,
-    base_ten_int_divisor: u8,
-    after_decimal: bool,
-) -> DivOut<'a> {
-    let mut rem_out = Remainder {
-        position: rem_in.position,
-        replace: Vec::new(),
-        arr_num: rem_in.arr_num,
-    };
-
-    let mut bufferval: u16 = 0;
-    let base: u16 = u16::from(radix_in);
-    let divisor: u16 = u16::from(base_ten_int_divisor);
-    let mut traversed = 0;
-
-    let mut quotient = 0;
-    let refd_vals = &rem_in.arr_num[rem_in.position + rem_in.replace.len()..];
-    let mut it_replace = rem_in.replace.iter();
-    let mut it_f = refd_vals.iter();
-    loop {
-        let u = match it_replace.next() {
-            Some(u_rep) => u16::from(*u_rep),
-            None => match it_f.next() {
-                Some(u_orig) => u16::from(*u_orig),
-                None => {
-                    if !after_decimal {
-                        break;
-                    }
-                    0
-                }
-            },
-        };
-        traversed += 1;
-        bufferval += u;
-        if bufferval > divisor {
-            while bufferval >= divisor {
-                quotient += 1;
-                bufferval -= divisor;
-            }
-            rem_out.replace = if bufferval == 0 {
-                Vec::new()
-            } else {
-                let remainder_as_arrnum = unsigned_to_arrnum(bufferval);
-                base_conv_vec(&remainder_as_arrnum, 10, radix_in)
-            };
-            rem_out.position += 1 + (traversed - rem_out.replace.len());
-            break;
-        } else {
-            bufferval *= base;
-        }
-    }
-    DivOut {
-        quotient,
-        remainder: rem_out,
-    }
-}
-pub fn arrnum_int_add(arrnum: &[u8], basenum: u8, base_ten_int_term: u8) -> Vec<u8> {
-    let mut carry: u16 = u16::from(base_ten_int_term);
-    let mut rem: u16;
-    let mut new_amount: u16;
-    let base: u16 = u16::from(basenum);
-
-    let mut ret_rev: Vec<u8> = Vec::new();
-    let mut it = arrnum.iter().rev();
-    loop {
-        let i = it.next();
-        match i {
-            Some(u) => {
-                new_amount = u16::from(*u) + carry;
-                rem = new_amount % base;
-                carry = (new_amount - rem) / base;
-                ret_rev.push(rem as u8);
-            }
-            None => {
-                while carry != 0 {
-                    rem = carry % base;
-                    carry = (carry - rem) / base;
-                    ret_rev.push(rem as u8);
-                }
-                break;
-            }
-        }
-    }
-    let ret: Vec<u8> = ret_rev.into_iter().rev().collect();
-    ret
-}
-
-pub fn base_conv_vec(src: &[u8], radix_src: u8, radix_dest: u8) -> Vec<u8> {
-    let mut result = vec![0];
-    for i in src {
-        result = arrnum_int_mult(&result, radix_dest, radix_src);
-        result = arrnum_int_add(&result, radix_dest, *i);
-    }
-    result
-}
-
-#[allow(dead_code)]
-pub fn unsigned_to_arrnum(src: u16) -> Vec<u8> {
-    let mut result: Vec<u8> = Vec::new();
-    let mut src_tmp: u16 = src;
-    while src_tmp > 0 {
-        result.push((src_tmp % 10) as u8);
-        src_tmp /= 10;
-    }
-    result.reverse();
-    result
-}
-
-// temporary needs-improvement-function
-pub fn base_conv_float(src: &[u8], radix_src: u8, _radix_dest: u8) -> f64 {
-    // it would require a lot of addl code
-    // to implement this for arbitrary string input.
-    // until then, the below operates as an outline
-    // of how it would work.
-    let mut factor: f64 = 1_f64;
-    let radix_src_float: f64 = f64::from(radix_src);
-    let mut r: f64 = 0_f64;
-    for (i, u) in src.iter().enumerate() {
-        if i > 15 {
-            break;
-        }
-        factor /= radix_src_float;
-        r += factor * f64::from(*u);
-    }
-    r
-}
-
-pub fn str_to_arrnum(src: &str, radix_def_src: &dyn RadixDef) -> Vec<u8> {
-    let mut intermed_in: Vec<u8> = Vec::new();
-    for c in src.chars() {
-        #[allow(clippy::single_match)]
-        match radix_def_src.parse_char(c) {
-            Some(u) => {
-                intermed_in.push(u);
-            }
-            None => {} //todo err msg on incorrect
-        }
-    }
-    intermed_in
-}
-
-pub fn arrnum_to_str(src: &[u8], radix_def_dest: &dyn RadixDef) -> String {
-    let mut str_out = String::new();
-    for u in src {
-        #[allow(clippy::single_match)]
-        match radix_def_dest.format_u8(*u) {
-            Some(c) => {
-                str_out.push(c);
-            }
-            None => {} //todo
-        }
-    }
-    str_out
-}
-
-pub fn base_conv_str(
-    src: &str,
-    radix_def_src: &dyn RadixDef,
-    radix_def_dest: &dyn RadixDef,
-) -> String {
-    let intermed_in: Vec<u8> = str_to_arrnum(src, radix_def_src);
-    let intermed_out = base_conv_vec(
-        &intermed_in,
-        radix_def_src.get_max(),
-        radix_def_dest.get_max(),
-    );
-    arrnum_to_str(&intermed_out, radix_def_dest)
-}
-
-pub trait RadixDef {
-    fn get_max(&self) -> u8;
-    fn parse_char(&self, x: char) -> Option<u8>;
-    fn format_u8(&self, x: u8) -> Option<char>;
-}
-pub struct RadixTen;
-
-const ZERO_ASC: u8 = b'0';
-const UPPER_A_ASC: u8 = b'A';
-const LOWER_A_ASC: u8 = b'a';
-
-impl RadixDef for RadixTen {
-    fn get_max(&self) -> u8 {
-        10
-    }
-    fn parse_char(&self, c: char) -> Option<u8> {
-        match c {
-            '0'..='9' => Some(c as u8 - ZERO_ASC),
-            _ => None,
-        }
-    }
-    fn format_u8(&self, u: u8) -> Option<char> {
-        match u {
-            0..=9 => Some((ZERO_ASC + u) as char),
-            _ => None,
-        }
-    }
-}
-pub struct RadixHex;
-impl RadixDef for RadixHex {
-    fn get_max(&self) -> u8 {
-        16
-    }
-    fn parse_char(&self, c: char) -> Option<u8> {
-        match c {
-            '0'..='9' => Some(c as u8 - ZERO_ASC),
-            'A'..='F' => Some(c as u8 + 10 - UPPER_A_ASC),
-            'a'..='f' => Some(c as u8 + 10 - LOWER_A_ASC),
-            _ => None,
-        }
-    }
-    fn format_u8(&self, u: u8) -> Option<char> {
-        match u {
-            0..=9 => Some((ZERO_ASC + u) as char),
-            10..=15 => Some((UPPER_A_ASC + (u - 10)) as char),
-            _ => None,
-        }
-    }
-}
-
-mod tests;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
deleted file mode 100644
index bf3747e1881..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/base_conv/tests.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-// 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.
-// spell-checker:ignore (ToDO) arrnum mult
-
-#[cfg(test)]
-use super::*;
-
-#[test]
-fn test_arrnum_int_mult() {
-    // (in base 10) 12 * 4 = 48
-    let factor: Vec<u8> = vec![1, 2];
-    let base_num = 10;
-    let base_ten_int_fact: u8 = 4;
-    let should_output: Vec<u8> = vec![4, 8];
-
-    let product = arrnum_int_mult(&factor, base_num, base_ten_int_fact);
-    assert!(product == should_output);
-}
-
-#[test]
-fn test_arrnum_int_non_base_10() {
-    // (in base 3)
-    // 5 * 4 = 20
-    let factor: Vec<u8> = vec![1, 2];
-    let base_num = 3;
-    let base_ten_int_fact: u8 = 4;
-    let should_output: Vec<u8> = vec![2, 0, 2];
-
-    let product = arrnum_int_mult(&factor, base_num, base_ten_int_fact);
-    assert!(product == should_output);
-}
-
-#[test]
-fn test_arrnum_int_div_short_circuit() {
-    // (
-    let arrnum: Vec<u8> = vec![5, 5, 5, 5, 0];
-    let base_num = 10;
-    let base_ten_int_divisor: u8 = 41;
-    let remainder_passed_in = Remainder {
-        position: 1,
-        replace: vec![1, 3],
-        arr_num: &arrnum,
-    };
-
-    // the "replace" should mean the number being divided
-    // is 1350, the first time you can get 41 to go into
-    // 1350, its at 135, where you can get a quotient of
-    // 3 and a remainder of 12;
-
-    let quotient_should_be: u8 = 3;
-    let remainder_position_should_be: usize = 3;
-    let remainder_replace_should_be = vec![1, 2];
-
-    let result = arrnum_int_div_step(&remainder_passed_in, base_num, base_ten_int_divisor, false);
-    assert!(quotient_should_be == result.quotient);
-    assert!(remainder_position_should_be == result.remainder.position);
-    assert!(remainder_replace_should_be == result.remainder.replace);
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
deleted file mode 100644
index 91a854f261e..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/cninetyninehexfloatf.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for %a %F C99 Hex-floating-point subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::base_conv;
-use super::base_conv::RadixDef;
-use super::float_common::{primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct CninetyNineHexFloatf {
-    #[allow(dead_code)]
-    as_num: f64,
-}
-impl CninetyNineHexFloatf {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-impl Formatter for CninetyNineHexFloatf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            Some(second_field as usize),
-            None,
-            true,
-        );
-        let f = get_primitive_hex(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            *field.field_char == 'A',
-        );
-        Some(f)
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
-
-// c99 hex has unique requirements of all floating point subs in pretty much every part of building a primitive, from prefix and suffix to need for base conversion (in all other cases if you don't have decimal you must have decimal, here it's the other way around)
-
-// on the todo list is to have a trait for get_primitive that is implemented by each float formatter and can override a default. when that happens we can take the parts of get_primitive_dec specific to dec and spin them out to their own functions that can be overridden.
-fn get_primitive_hex(
-    initial_prefix: &InitialPrefix,
-    _str_in: &str,
-    _analysis: &FloatAnalysis,
-    _last_dec_place: usize,
-    capitalized: bool,
-) -> FormatPrimitive {
-    let prefix = Some(String::from(if initial_prefix.sign == -1 {
-        "-0x"
-    } else {
-        "0x"
-    }));
-
-    // TODO actual conversion, make sure to get back mantissa.
-    // for hex to hex, it's really just a matter of moving the
-    // decimal point and calculating the mantissa by its initial
-    // position and its moves, with every position counting for
-    // the addition or subtraction of 4 (2**4, because 4 bits in a hex digit)
-    // to the exponent.
-    // decimal's going to be a little more complicated. correct simulation
-    // of glibc will require after-decimal division to a specified precision.
-    // the difficult part of this (arrnum_int_div_step) is already implemented.
-
-    // the hex float name may be a bit misleading in terms of how to go about the
-    // conversion. The best way to do it is to just convert the float number
-    // directly to base 2 and then at the end translate back to hex.
-    let mantissa = 0;
-    let suffix = Some({
-        let ind = if capitalized { "P" } else { "p" };
-        if mantissa >= 0 {
-            format!("{ind}+{mantissa}")
-        } else {
-            format!("{ind}{mantissa}")
-        }
-    });
-    FormatPrimitive {
-        prefix,
-        suffix,
-        ..Default::default()
-    }
-}
-
-#[allow(dead_code)]
-fn to_hex(src: &str, before_decimal: bool) -> String {
-    let radix_ten = base_conv::RadixTen;
-    let radix_hex = base_conv::RadixHex;
-    if before_decimal {
-        base_conv::base_conv_str(src, &radix_ten, &radix_hex)
-    } else {
-        let as_arrnum_ten = base_conv::str_to_arrnum(src, &radix_ten);
-        let s = format!(
-            "{}",
-            base_conv::base_conv_float(&as_arrnum_ten, radix_ten.get_max(), radix_hex.get_max())
-        );
-        if s.len() > 2 {
-            String::from(&s[2..])
-        } else {
-            // zero
-            s
-        }
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
deleted file mode 100644
index 35b981b4fba..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/decf.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! formatter for %g %G decimal subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-const SIGNIFICANT_FIGURES: usize = 6;
-
-// Parse a numeric string as the nearest integer with a given significance.
-// This is a helper function for round().
-// Examples:
-//  round_to_significance("456", 1) == 500
-//  round_to_significance("456", 2) == 460
-//  round_to_significance("456", 9) == 456
-fn round_to_significance(input: &str, significant_figures: usize) -> u32 {
-    if significant_figures < input.len() {
-        // If the input has too many digits, use a float intermediary
-        // to round it before converting to an integer. Otherwise,
-        // converting straight to integer will truncate.
-        // There might be a cleaner way to do this...
-        let digits = &input[..significant_figures + 1];
-        let float_representation = digits.parse::<f32>().unwrap();
-        (float_representation / 10.0).round() as u32
-    } else {
-        input.parse::<u32>().unwrap_or(0)
-    }
-}
-
-// Removing trailing zeroes, expressing the result as an integer where
-// possible. This is a helper function for round().
-fn truncate(mut format: FormatPrimitive) -> FormatPrimitive {
-    if let Some(ref post_dec) = format.post_decimal {
-        let trimmed = post_dec.trim_end_matches('0');
-
-        if trimmed.is_empty() {
-            // If there are no nonzero digits after the decimal point,
-            // use integer formatting by clearing post_decimal and suffix.
-            format.post_decimal = Some(String::new());
-            if format.suffix == Some("e+00".into()) {
-                format.suffix = Some(String::new());
-            }
-        } else if trimmed.len() != post_dec.len() {
-            // Otherwise, update the format to remove only the trailing
-            // zeroes (e.g. "4.50" becomes "4.5", not "4"). If there were
-            // no trailing zeroes, do nothing.
-            format.post_decimal = Some(trimmed.to_owned());
-        }
-    }
-    format
-}
-
-// Round a format to six significant figures and remove trailing zeroes.
-fn round(mut format: FormatPrimitive) -> FormatPrimitive {
-    let mut significant_digits_remaining = SIGNIFICANT_FIGURES;
-
-    // First, take as many significant digits as possible from pre_decimal,
-    if format.pre_decimal.is_some() {
-        let input = format.pre_decimal.as_ref().unwrap();
-        let rounded = round_to_significance(input, significant_digits_remaining);
-        let mut rounded_str = rounded.to_string();
-        significant_digits_remaining -= rounded_str.len();
-
-        // If the pre_decimal has exactly enough significant digits,
-        // round the input to the nearest integer. If the first
-        // post_decimal digit is 5 or higher, round up by incrementing
-        // the pre_decimal number. Otherwise, use the pre_decimal as-is.
-        if significant_digits_remaining == 0 {
-            if let Some(digits) = &format.post_decimal {
-                if digits.chars().next().unwrap_or('0') >= '5' {
-                    let rounded = rounded + 1;
-                    rounded_str = rounded.to_string();
-                }
-            }
-        }
-        format.pre_decimal = Some(rounded_str);
-    }
-
-    // If no significant digits remain, or there's no post_decimal to
-    // round, return the rounded pre_decimal value with no post_decimal.
-    // Otherwise, round the post_decimal to the remaining significance.
-    if significant_digits_remaining == 0 {
-        format.post_decimal = Some(String::new());
-    } else if let Some(input) = format.post_decimal {
-        let leading_zeroes = input.len() - input.trim_start_matches('0').len();
-        let digits = &input[leading_zeroes..];
-
-        // In the post_decimal, leading zeroes are significant. "01.0010"
-        // has one significant digit in pre_decimal, and 3 from post_decimal.
-        let mut post_decimal_str = String::with_capacity(significant_digits_remaining);
-        for _ in 0..leading_zeroes {
-            post_decimal_str.push('0');
-        }
-
-        if leading_zeroes < significant_digits_remaining {
-            // After significant leading zeroes, round the remaining digits
-            // to any remaining significance.
-            let rounded = round_to_significance(digits, significant_digits_remaining);
-            post_decimal_str.push_str(&rounded.to_string());
-        } else if leading_zeroes == significant_digits_remaining
-            && digits.chars().next().unwrap_or('0') >= '5'
-        {
-            // If necessary, round up the post_decimal ("1.000009" should
-            // round to 1.00001, instead of truncating after the last
-            // significant leading zero).
-            post_decimal_str.pop();
-            post_decimal_str.push('1');
-        } else {
-            // If the rounded post_decimal is entirely zeroes, discard
-            // it and use integer formatting instead.
-            post_decimal_str = String::new();
-        }
-
-        format.post_decimal = Some(post_decimal_str);
-    }
-    truncate(format)
-}
-
-// Given an exponent used in scientific notation, return whether the
-// number is small enough to be expressed as a decimal instead. "Small
-// enough" is based only on the number's magnitude, not the length of
-// any string representation.
-fn should_represent_as_decimal(suffix: &Option<String>) -> bool {
-    match suffix {
-        Some(exponent) => {
-            if exponent.chars().nth(1) == Some('-') {
-                exponent < &"e-05".into()
-            } else {
-                exponent < &"e+06".into()
-            }
-        }
-        None => true,
-    }
-}
-
-pub struct Decf;
-
-impl Decf {
-    pub fn new() -> Self {
-        Self
-    }
-}
-impl Formatter for Decf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        // default to scif interpretation so as to not truncate input vals
-        // (that would be displayed in scif) based on relation to decimal place
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            Some(second_field as usize + 1),
-            None,
-            false,
-        );
-        let mut f_dec = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            Some(*field.field_char == 'G'),
-        );
-
-        if should_represent_as_decimal(&f_dec.suffix) {
-            // Use decimal formatting instead of scientific notation
-            // if the input's magnitude is small.
-            f_dec = get_primitive_dec(
-                initial_prefix,
-                &str_in[initial_prefix.offset..],
-                &analysis,
-                second_field as usize,
-                None,
-            );
-        }
-
-        Some(round(f_dec))
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
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
deleted file mode 100644
index 1cf25b32f1e..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/float_common.rs
+++ /dev/null
@@ -1,381 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-use super::super::format_field::FormatField;
-use super::super::formatter::{
-    get_it_at, warn_incomplete_conv, Base, FormatPrimitive, InitialPrefix,
-};
-use super::base_conv;
-use super::base_conv::RadixDef;
-
-// if the memory, copy, and comparison cost of chars
-//  becomes an issue, we can always operate in vec<u8> here
-//  rather than just at de_hex
-
-pub struct FloatAnalysis {
-    pub len_important: usize,
-    // none means no decimal point.
-    pub decimal_pos: Option<usize>,
-    pub follow: Option<char>,
-}
-fn has_enough_digits(
-    hex_input: bool,
-    hex_output: bool,
-    string_position: usize,
-    starting_position: usize,
-    limit: usize,
-) -> bool {
-    // -1s are for rounding
-    if hex_output {
-        if hex_input {
-            (string_position - 1) - starting_position >= limit
-        } else {
-            false //undecidable without converting
-        }
-    } else if hex_input {
-        (((string_position - 1) - starting_position) * 9) / 8 >= limit
-    } else {
-        (string_position - 1) - starting_position >= limit
-    }
-}
-
-impl FloatAnalysis {
-    #[allow(clippy::cognitive_complexity)]
-    pub fn analyze(
-        str_in: &str,
-        initial_prefix: &InitialPrefix,
-        max_sd_opt: Option<usize>,
-        max_after_dec_opt: Option<usize>,
-        hex_output: bool,
-    ) -> Self {
-        // this fn assumes
-        // the input string
-        // has no leading spaces or 0s
-        let str_it = get_it_at(initial_prefix.offset, str_in);
-        let mut ret = Self {
-            len_important: 0,
-            decimal_pos: None,
-            follow: None,
-        };
-        let hex_input = match initial_prefix.radix_in {
-            Base::Hex => true,
-            Base::Ten => false,
-            Base::Octal => {
-                panic!("this should never happen: floats should never receive octal input");
-            }
-        };
-        let mut i = 0;
-        let mut pos_before_first_nonzero_after_decimal: Option<usize> = None;
-        for c in str_it {
-            match c {
-                e @ ('0'..='9' | 'A'..='F' | 'a'..='f') => {
-                    if !hex_input {
-                        match e {
-                            '0'..='9' => {}
-                            _ => {
-                                warn_incomplete_conv(str_in);
-                                break;
-                            }
-                        }
-                    }
-                    if ret.decimal_pos.is_some()
-                        && pos_before_first_nonzero_after_decimal.is_none()
-                        && e != '0'
-                    {
-                        pos_before_first_nonzero_after_decimal = Some(i - 1);
-                    }
-                    if let Some(max_sd) = max_sd_opt {
-                        if i == max_sd {
-                            // follow is used in cases of %g
-                            // where the character right after the last
-                            // sd is considered is rounded affecting
-                            // the previous digit in 1/2 of instances
-                            ret.follow = Some(e);
-                        } else if ret.decimal_pos.is_some() && i > max_sd {
-                            break;
-                        }
-                    }
-                    if let Some(max_after_dec) = max_after_dec_opt {
-                        if let Some(p) = ret.decimal_pos {
-                            if has_enough_digits(hex_input, hex_output, i, p, max_after_dec) {
-                                break;
-                            }
-                        }
-                    } else if let Some(max_sd) = max_sd_opt {
-                        if let Some(p) = pos_before_first_nonzero_after_decimal {
-                            if has_enough_digits(hex_input, hex_output, i, p, max_sd) {
-                                break;
-                            }
-                        }
-                    }
-                }
-                '.' => {
-                    if ret.decimal_pos.is_none() {
-                        ret.decimal_pos = Some(i);
-                    } else {
-                        warn_incomplete_conv(str_in);
-                        break;
-                    }
-                }
-                _ => {
-                    warn_incomplete_conv(str_in);
-                    break;
-                }
-            };
-            i += 1;
-        }
-        ret.len_important = i;
-        ret
-    }
-}
-
-fn de_hex(src: &str, before_decimal: bool) -> String {
-    let radix_ten = base_conv::RadixTen;
-    let radix_hex = base_conv::RadixHex;
-    if before_decimal {
-        base_conv::base_conv_str(src, &radix_hex, &radix_ten)
-    } else {
-        let as_arrnum_hex = base_conv::str_to_arrnum(src, &radix_hex);
-        let s = format!(
-            "{}",
-            base_conv::base_conv_float(&as_arrnum_hex, radix_hex.get_max(), radix_ten.get_max())
-        );
-        if s.len() > 2 {
-            String::from(&s[2..])
-        } else {
-            // zero
-            s
-        }
-    }
-}
-
-// takes a string in,
-// truncates to a position,
-// bumps the last digit up one,
-// and if the digit was nine
-// propagate to the next, etc.
-// If before the decimal and the most
-// significant digit is a 9, it becomes a 1
-fn _round_str_from(in_str: &str, position: usize, before_dec: bool) -> (String, bool) {
-    let mut it = in_str[0..position].chars();
-    let mut rev = String::new();
-    let mut i = position;
-    let mut finished_in_dec = false;
-    while let Some(c) = it.next_back() {
-        i -= 1;
-        match c {
-            '9' => {
-                // If we're before the decimal
-                // and on the most significant digit,
-                // round 9 to 1, else to 0.
-                if before_dec && i == 0 {
-                    rev.push('1');
-                } else {
-                    rev.push('0');
-                }
-            }
-            e => {
-                rev.push(((e as u8) + 1) as char);
-                finished_in_dec = true;
-                break;
-            }
-        }
-    }
-    let mut fwd = String::from(&in_str[0..i]);
-    for ch in rev.chars().rev() {
-        fwd.push(ch);
-    }
-    (fwd, finished_in_dec)
-}
-
-fn round_terminal_digit(
-    before_dec: String,
-    after_dec: String,
-    position: usize,
-) -> (String, String, bool) {
-    if position < after_dec.len() {
-        let digit_at_pos: char;
-        {
-            digit_at_pos = after_dec[position..=position].chars().next().expect("");
-        }
-        if let '5'..='9' = digit_at_pos {
-            let (new_after_dec, finished_in_dec) = _round_str_from(&after_dec, position, false);
-            if finished_in_dec {
-                return (before_dec, new_after_dec, false);
-            } else {
-                let (new_before_dec, _) = _round_str_from(&before_dec, before_dec.len(), true);
-                let mut dec_place_chg = false;
-                let mut before_dec_chars = new_before_dec.chars();
-                if before_dec_chars.next() == Some('1') && before_dec_chars.all(|c| c == '0') {
-                    // If the first digit is a one and remaining are zeros, we have
-                    // rounded to a new decimal place, so the decimal place must be updated.
-                    // Only update decimal place if the before decimal != 0
-                    dec_place_chg = before_dec != "0";
-                }
-                return (new_before_dec, new_after_dec, dec_place_chg);
-            }
-            // TODO
-        }
-    }
-    (before_dec, after_dec, false)
-}
-
-#[allow(clippy::cognitive_complexity)]
-pub fn get_primitive_dec(
-    initial_prefix: &InitialPrefix,
-    str_in: &str,
-    analysis: &FloatAnalysis,
-    last_dec_place: usize,
-    sci_mode: Option<bool>,
-) -> FormatPrimitive {
-    let mut f = FormatPrimitive::default();
-
-    // add negative sign section
-    if initial_prefix.sign == -1 {
-        f.prefix = Some(String::from("-"));
-    }
-
-    // assign the digits before and after the decimal points
-    // to separate slices. If no digits after decimal point,
-    // assign 0
-    let (mut first_segment_raw, second_segment_raw) = match analysis.decimal_pos {
-        Some(pos) => (&str_in[..pos], &str_in[pos + 1..]),
-        None => (str_in, "0"),
-    };
-    if first_segment_raw.is_empty() {
-        first_segment_raw = "0";
-    }
-    // convert to string, de_hexifying if input is in hex   // spell-checker:disable-line
-    let (first_segment, second_segment) = match initial_prefix.radix_in {
-        Base::Hex => (
-            de_hex(first_segment_raw, true),
-            de_hex(second_segment_raw, false),
-        ),
-        _ => (
-            String::from(first_segment_raw),
-            String::from(second_segment_raw),
-        ),
-    };
-    let (pre_dec_unrounded, post_dec_unrounded, mut mantissa) = if sci_mode.is_some() {
-        if first_segment.len() > 1 {
-            let mut post_dec = String::from(&first_segment[1..]);
-            post_dec.push_str(&second_segment);
-            (
-                String::from(&first_segment[0..1]),
-                post_dec,
-                first_segment.len() as isize - 1,
-            )
-        } else {
-            match first_segment
-                .chars()
-                .next()
-                .expect("float_common: no chars in first segment.")
-            {
-                '0' => {
-                    let it = second_segment.chars().enumerate();
-                    let mut m: isize = 0;
-                    let mut pre = String::from("0");
-                    let mut post = String::from("0");
-                    for (i, c) in it {
-                        match c {
-                            '0' => {}
-                            _ => {
-                                m = -((i as isize) + 1);
-                                pre = String::from(&second_segment[i..=i]);
-                                post = String::from(&second_segment[i + 1..]);
-                                break;
-                            }
-                        }
-                    }
-                    (pre, post, m)
-                }
-                _ => (first_segment, second_segment, 0),
-            }
-        }
-    } else {
-        (first_segment, second_segment, 0)
-    };
-
-    let (pre_dec_draft, post_dec_draft, dec_place_chg) =
-        round_terminal_digit(pre_dec_unrounded, post_dec_unrounded, last_dec_place - 1);
-    f.post_decimal = Some(post_dec_draft);
-    if let Some(capitalized) = sci_mode {
-        let si_ind = if capitalized { 'E' } else { 'e' };
-        // Increase the mantissa if we're adding a decimal place
-        if dec_place_chg {
-            mantissa += 1;
-        }
-        f.suffix = Some(if mantissa >= 0 {
-            format!("{si_ind}+{mantissa:02}")
-        } else {
-            // negative sign is considered in format!s
-            // leading zeroes
-            format!("{si_ind}{mantissa:03}")
-        });
-        f.pre_decimal = Some(pre_dec_draft);
-    } else if dec_place_chg {
-        // We've rounded up to a new decimal place so append 0
-        f.pre_decimal = Some(pre_dec_draft + "0");
-    } else {
-        f.pre_decimal = Some(pre_dec_draft);
-    }
-
-    f
-}
-
-pub fn primitive_to_str_common(prim: &FormatPrimitive, field: &FormatField) -> String {
-    let mut final_str = String::new();
-    if let Some(ref prefix) = prim.prefix {
-        final_str.push_str(prefix);
-    }
-    match prim.pre_decimal {
-        Some(ref pre_decimal) => {
-            final_str.push_str(pre_decimal);
-        }
-        None => {
-            panic!(
-                "error, format primitives provided to int, will, incidentally under correct \
-                 behavior, always have a pre_dec value."
-            );
-        }
-    }
-    let decimal_places = field.second_field.unwrap_or(6);
-    match prim.post_decimal {
-        Some(ref post_decimal) => {
-            if !post_decimal.is_empty() && decimal_places > 0 {
-                final_str.push('.');
-                let len_avail = post_decimal.len() as u32;
-
-                if decimal_places >= len_avail {
-                    // println!("dec {}, len avail {}", decimal_places, len_avail);
-                    final_str.push_str(post_decimal);
-
-                    if *field.field_char != 'g' && *field.field_char != 'G' {
-                        let diff = decimal_places - len_avail;
-                        for _ in 0..diff {
-                            final_str.push('0');
-                        }
-                    }
-                } else {
-                    // println!("printing to only {}", decimal_places);
-                    final_str.push_str(&post_decimal[0..decimal_places as usize]);
-                }
-            }
-        }
-        None => {
-            panic!(
-                "error, format primitives provided to int, will, incidentally under correct \
-                 behavior, always have a pre_dec value."
-            );
-        }
-    }
-    if let Some(ref suffix) = prim.suffix {
-        final_str.push_str(suffix);
-    }
-
-    final_str
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
deleted file mode 100644
index 59f2cb4085e..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/floatf.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for %f %F common-notation floating-point subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct Floatf;
-impl Floatf {
-    pub fn new() -> Self {
-        Self
-    }
-}
-impl Formatter for Floatf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            None,
-            Some(second_field as usize),
-            false,
-        );
-        let f = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            None,
-        );
-        Some(f)
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
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
deleted file mode 100644
index 11070113c26..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/intf.rs
+++ /dev/null
@@ -1,286 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-// spell-checker:ignore (ToDO) arrnum
-
-//! formatter for unsigned and signed int subs
-//! unsigned int: %X %x (hex u64) %o (octal u64) %u (base ten u64)
-//! signed int: %i %d (both base ten i64)
-use super::super::format_field::FormatField;
-use super::super::formatter::{
-    get_it_at, warn_incomplete_conv, Base, FormatPrimitive, Formatter, InitialPrefix,
-};
-use std::i64;
-use std::u64;
-
-#[derive(Default)]
-pub struct Intf {
-    _a: u32,
-}
-
-// see the Intf::analyze() function below
-struct IntAnalysis {
-    check_past_max: bool,
-    past_max: bool,
-    is_zero: bool,
-    len_digits: u8,
-}
-
-impl Intf {
-    pub fn new() -> Self {
-        Self::default()
-    }
-    // take a ref to argument string, and basic information
-    // about prefix (offset, radix, sign), and analyze string
-    // to gain the IntAnalysis information above
-    // check_past_max: true if the number *may* be above max,
-    //   but we don't know either way. One of several reasons
-    //   we may have to parse as int.
-    // past_max: true if the object is past max, false if not
-    //  in the future we should probably combine these into an
-    //  Option<bool>
-    // 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
-        // max
-        let mut str_it = get_it_at(initial_prefix.offset, str_in);
-        let max_sd_in = if signed_out {
-            match initial_prefix.radix_in {
-                Base::Ten => 19,
-                Base::Octal => 21,
-                Base::Hex => 16,
-            }
-        } else {
-            match initial_prefix.radix_in {
-                Base::Ten => 20,
-                Base::Octal => 22,
-                Base::Hex => 16,
-            }
-        };
-        let mut ret = IntAnalysis {
-            check_past_max: false,
-            past_max: false,
-            is_zero: false,
-            len_digits: 0,
-        };
-
-        // todo turn this to a while let now that we know
-        // no special behavior on EOI break
-        loop {
-            let c_opt = str_it.next();
-            if let Some(c) = c_opt {
-                match c {
-                    '0'..='9' | 'a'..='f' | 'A'..='F' => {
-                        if ret.len_digits == 0 && c == '0' {
-                            ret.is_zero = true;
-                        } else if ret.is_zero {
-                            ret.is_zero = false;
-                        }
-                        ret.len_digits += 1;
-                        if ret.len_digits == max_sd_in {
-                            if let Some(next_ch) = str_it.next() {
-                                match next_ch {
-                                    '0'..='9' => {
-                                        ret.past_max = true;
-                                    }
-                                    _ => {
-                                        // force conversion
-                                        // to check if its above max.
-                                        // todo: spin out convert
-                                        // into fn, call it here to try
-                                        // read val, on Ok()
-                                        // save val for reuse later
-                                        // that way on same-base in and out
-                                        // we don't needlessly convert int
-                                        // to str, we can just copy it over.
-                                        ret.check_past_max = true;
-                                        str_it.put_back(next_ch);
-                                    }
-                                }
-                                if ret.past_max {
-                                    break;
-                                }
-                            } else {
-                                ret.check_past_max = true;
-                            }
-                        }
-                    }
-                    _ => {
-                        warn_incomplete_conv(str_in);
-                        break;
-                    }
-                }
-            } else {
-                // breaks on EOL
-                break;
-            }
-        }
-        ret
-    }
-    // get a FormatPrimitive of the maximum value for the field char
-    //  and given sign
-    fn get_max(field_char: char, sign: i8) -> FormatPrimitive {
-        let mut fmt_primitive = FormatPrimitive::default();
-        fmt_primitive.pre_decimal = Some(String::from(match field_char {
-            'd' | 'i' => match sign {
-                1 => "9223372036854775807",
-                _ => {
-                    fmt_primitive.prefix = Some(String::from("-"));
-                    "9223372036854775808"
-                }
-            },
-            'x' | 'X' => "ffffffffffffffff",
-            'o' => "1777777777777777777777",
-            /* 'u' | */ _ => "18446744073709551615",
-        }));
-        fmt_primitive
-    }
-    // conv_from_segment contract:
-    // 1. takes
-    // - a string that begins with a non-zero digit, and proceeds
-    //  with zero or more following digits until the end of the string
-    // - a radix to interpret those digits as
-    // - a char that communicates:
-    //     whether to interpret+output the string as an i64 or u64
-    //     what radix to write the parsed number as.
-    // 2. parses it as a rust integral type
-    // 3. outputs FormatPrimitive with:
-    // - if the string falls within bounds:
-    //   number parsed and written in the correct radix
-    // - if the string falls outside bounds:
-    //   for i64 output, the int minimum or int max (depending on sign)
-    //   for u64 output, the u64 max in the output radix
-    fn conv_from_segment(
-        segment: &str,
-        radix_in: Base,
-        field_char: char,
-        sign: i8,
-    ) -> FormatPrimitive {
-        match field_char {
-            'i' | 'd' => match i64::from_str_radix(segment, radix_in as u32) {
-                Ok(i) => {
-                    let mut fmt_prim = FormatPrimitive::default();
-                    if sign == -1 {
-                        fmt_prim.prefix = Some(String::from("-"));
-                    }
-                    fmt_prim.pre_decimal = Some(format!("{i}"));
-                    fmt_prim
-                }
-                Err(_) => Self::get_max(field_char, sign),
-            },
-            _ => match u64::from_str_radix(segment, radix_in as u32) {
-                Ok(u) => {
-                    let mut fmt_prim = FormatPrimitive::default();
-                    let u_f = if sign == -1 { u64::MAX - (u - 1) } else { u };
-                    fmt_prim.pre_decimal = Some(match field_char {
-                        'X' => format!("{u_f:X}"),
-                        'x' => format!("{u_f:x}"),
-                        'o' => format!("{u_f:o}"),
-                        _ => format!("{u_f}"),
-                    });
-                    fmt_prim
-                }
-                Err(_) => Self::get_max(field_char, sign),
-            },
-        }
-    }
-}
-impl Formatter for Intf {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let begin = initial_prefix.offset;
-
-        // get information about the string. see Intf::Analyze
-        // def above.
-        let convert_hints = Self::analyze(
-            str_in,
-            *field.field_char == 'i' || *field.field_char == 'd',
-            initial_prefix,
-        );
-        // We always will have a format primitive to return
-        Some(if convert_hints.len_digits == 0 || convert_hints.is_zero {
-            // if non-digit or end is reached before a non-zero digit
-            FormatPrimitive {
-                pre_decimal: Some(String::from("0")),
-                ..Default::default()
-            }
-        } else if !convert_hints.past_max {
-            // if the number is or may be below the bounds limit
-            let radix_out = match *field.field_char {
-                'd' | 'i' | 'u' => Base::Ten,
-                'x' | 'X' => Base::Hex,
-                /* 'o' | */ _ => Base::Octal,
-            };
-            let radix_mismatch = !radix_out.eq(&initial_prefix.radix_in);
-            let decrease_from_max: bool = initial_prefix.sign == -1 && *field.field_char != 'i';
-            let end = begin + convert_hints.len_digits as usize;
-
-            // convert to int if any one of these is true:
-            // - number of digits in int indicates it may be past max
-            // - we're subtracting from the max
-            // - we're converting the base
-            if convert_hints.check_past_max || decrease_from_max || radix_mismatch {
-                // radix of in and out is the same.
-                let segment = String::from(&str_in[begin..end]);
-                Self::conv_from_segment(
-                    &segment,
-                    initial_prefix.radix_in.clone(),
-                    *field.field_char,
-                    initial_prefix.sign,
-                )
-            } else {
-                // otherwise just do a straight string copy.
-                let mut fmt_prim = FormatPrimitive::default();
-
-                // this is here and not earlier because
-                // zero doesn't get a sign, and conv_from_segment
-                // creates its format primitive separately
-                if initial_prefix.sign == -1 && *field.field_char == 'i' {
-                    fmt_prim.prefix = Some(String::from("-"));
-                }
-                fmt_prim.pre_decimal = Some(String::from(&str_in[begin..end]));
-                fmt_prim
-            }
-        } else {
-            Self::get_max(*field.field_char, initial_prefix.sign)
-        })
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        let mut final_str: String = String::new();
-        if let Some(ref prefix) = prim.prefix {
-            final_str.push_str(prefix);
-        }
-        // integral second fields is zero-padded minimum-width
-        // which gets handled before general minimum-width
-        match prim.pre_decimal {
-            Some(ref pre_decimal) => {
-                if let Some(min) = field.second_field {
-                    let mut i = min;
-                    let len = pre_decimal.len() as u32;
-                    while i > len {
-                        final_str.push('0');
-                        i -= 1;
-                    }
-                }
-                final_str.push_str(pre_decimal);
-            }
-            None => {
-                panic!(
-                    "error, format primitives provided to int, will, incidentally under \
-                     correct behavior, always have a pre_dec value."
-                );
-            }
-        }
-        final_str
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
deleted file mode 100644
index 95908917153..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-mod base_conv;
-pub mod cninetyninehexfloatf;
-pub mod decf;
-mod float_common;
-pub mod floatf;
-pub mod intf;
-pub mod scif;
diff --git a/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs b/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
deleted file mode 100644
index a0dfa86c1c1..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/formatters/scif.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-//! formatter for %e %E scientific notation subs
-use super::super::format_field::FormatField;
-use super::super::formatter::{FormatPrimitive, Formatter, InitialPrefix};
-use super::float_common::{get_primitive_dec, primitive_to_str_common, FloatAnalysis};
-
-#[derive(Default)]
-pub struct Scif;
-
-impl Scif {
-    pub fn new() -> Self {
-        Self
-    }
-}
-impl Formatter for Scif {
-    fn get_primitive(
-        &self,
-        field: &FormatField,
-        initial_prefix: &InitialPrefix,
-        str_in: &str,
-    ) -> Option<FormatPrimitive> {
-        let second_field = field.second_field.unwrap_or(6) + 1;
-        let analysis = FloatAnalysis::analyze(
-            str_in,
-            initial_prefix,
-            Some(second_field as usize + 1),
-            None,
-            false,
-        );
-        let f = get_primitive_dec(
-            initial_prefix,
-            &str_in[initial_prefix.offset..],
-            &analysis,
-            second_field as usize,
-            Some(*field.field_char == 'E'),
-        );
-        Some(f)
-    }
-    fn primitive_to_str(&self, prim: &FormatPrimitive, field: FormatField) -> String {
-        primitive_to_str_common(prim, &field)
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/num_format/mod.rs b/src/uucore/src/lib/features/tokenize/num_format/mod.rs
deleted file mode 100644
index d2ce686ff37..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// 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.
-pub mod format_field;
-mod formatter;
-mod formatters;
-pub mod num_format;
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
deleted file mode 100644
index e9b676a8078..00000000000
--- a/src/uucore/src/lib/features/tokenize/num_format/num_format.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
-
-//! handles creating printed output for numeric substitutions
-
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-use std::env;
-use std::vec::Vec;
-
-use crate::display::Quotable;
-use crate::{show_error, show_warning};
-
-use super::format_field::{FieldType, FormatField};
-use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
-use super::formatters::cninetyninehexfloatf::CninetyNineHexFloatf;
-use super::formatters::decf::Decf;
-use super::formatters::floatf::Floatf;
-use super::formatters::intf::Intf;
-use super::formatters::scif::Scif;
-
-pub fn warn_expected_numeric(pf_arg: &str) {
-    // important: keep println here not print
-    show_error!("{}: expected a numeric value", pf_arg.maybe_quote());
-}
-
-// when character constant arguments have excess characters
-// issue a warning when POSIXLY_CORRECT is not set
-fn warn_char_constant_ign(remaining_bytes: &[u8]) {
-    match env::var("POSIXLY_CORRECT") {
-        Ok(_) => {}
-        Err(e) => {
-            if let env::VarError::NotPresent = e {
-                show_warning!(
-                    "{:?}: character(s) following character \
-                     constant have been ignored",
-                    remaining_bytes
-                );
-            }
-        }
-    }
-}
-
-// this function looks at the first few
-// characters of an argument and returns a value if we can learn
-// a value from that (e.g. no argument? return 0, char constant? ret value)
-fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
-    const C_S_QUOTE: u8 = 39;
-    const C_D_QUOTE: u8 = 34;
-    match str_in_opt {
-        Some(str_in) => {
-            let mut byte_it = str_in.bytes();
-            if let Some(ch) = byte_it.next() {
-                match ch {
-                    C_S_QUOTE | C_D_QUOTE => {
-                        Some(match byte_it.next() {
-                            Some(second_byte) => {
-                                let mut ignored: Vec<u8> = Vec::new();
-                                for cont in byte_it {
-                                    ignored.push(cont);
-                                }
-                                if !ignored.is_empty() {
-                                    warn_char_constant_ign(&ignored);
-                                }
-                                second_byte
-                            }
-                            // no byte after quote
-                            None => {
-                                let so_far = (ch as char).to_string();
-                                warn_expected_numeric(&so_far);
-                                0_u8
-                            }
-                        })
-                    }
-                    // first byte is not quote
-                    _ => None, // no first byte
-                }
-            } else {
-                Some(0_u8)
-            }
-        }
-        None => Some(0),
-    }
-}
-
-// takes a string and returns
-// a sign,
-// 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 {
-        radix_in: Base::Ten,
-        sign: 1,
-        offset: 0,
-    };
-    let mut top_char = str_it.next();
-    // skip spaces and ensure top_char is the first non-space char
-    // (or None if none exists)
-    while let Some(' ') = top_char {
-        ret.offset += 1;
-        top_char = str_it.next();
-    }
-    // parse sign
-    match top_char {
-        Some('+') => {
-            ret.offset += 1;
-            top_char = str_it.next();
-        }
-        Some('-') => {
-            ret.sign = -1;
-            ret.offset += 1;
-            top_char = str_it.next();
-        }
-        _ => {}
-    }
-    // we want to exit with offset being
-    // the index of the first non-zero
-    // digit before the decimal point or
-    // if there is none, the zero before the
-    // decimal point, or, if there is none,
-    // the decimal point.
-
-    // while we are determining the offset
-    // we will ensure as a convention
-    // the offset is always on the first character
-    // that we are yet unsure if it is the
-    // final offset. If the zero could be before
-    // a decimal point we don't move past the zero.
-    let mut is_hex = false;
-    if Some('0') == top_char {
-        if let Some(base) = str_it.next() {
-            // lead zeroes can only exist in
-            // octal and hex base
-            let mut do_clean_lead_zeroes = false;
-            match base {
-                'x' | 'X' => {
-                    is_hex = true;
-                    ret.offset += 2;
-                    ret.radix_in = Base::Hex;
-                    do_clean_lead_zeroes = true;
-                }
-                e @ '0'..='9' => {
-                    ret.offset += 1;
-                    if let FieldType::Intf = *field_type {
-                        ret.radix_in = Base::Octal;
-                    }
-                    if e == '0' {
-                        do_clean_lead_zeroes = true;
-                    }
-                }
-                _ => {}
-            }
-            if do_clean_lead_zeroes {
-                let mut first = true;
-                for ch_zero in str_it {
-                    // see notes on offset above:
-                    // this is why the offset for octal and decimal numbers
-                    // that reach this branch is 1 even though
-                    // they have already eaten the characters '00'
-                    // this is also why when hex encounters its
-                    // first zero it does not move its offset
-                    // forward because it does not know for sure
-                    // that it's current offset (of that zero)
-                    // is not the final offset,
-                    // whereas at that point octal knows its
-                    // current offset is not the final offset.
-                    match ch_zero {
-                        '0' => {
-                            if !(is_hex && first) {
-                                ret.offset += 1;
-                            }
-                        }
-                        // if decimal, keep last zero if one exists
-                        // (it's possible for last zero to
-                        // not exist at this branch if we're in hex input)
-                        '.' => break,
-                        // other digit, etc.
-                        _ => {
-                            if !(is_hex && first) {
-                                ret.offset += 1;
-                            }
-                            break;
-                        }
-                    }
-                    if first {
-                        first = false;
-                    }
-                }
-            }
-        }
-    }
-    ret
-}
-
-// this is the function a Sub's print will delegate to
-// if it is a numeric field, passing the field details
-// and an iterator to the argument
-pub fn num_format(field: &FormatField, in_str_opt: Option<&String>) -> Option<String> {
-    let field_char = field.field_char;
-
-    // num format mainly operates by further delegating to one of
-    // several Formatter structs depending on the field
-    // see formatter.rs for more details
-
-    // to do switch to static dispatch
-    let formatter: Box<dyn Formatter> = match *field.field_type {
-        FieldType::Intf => Box::new(Intf::new()),
-        FieldType::Floatf => Box::new(Floatf::new()),
-        FieldType::CninetyNineHexFloatf => Box::new(CninetyNineHexFloatf::new()),
-        FieldType::Scif => Box::new(Scif::new()),
-        FieldType::Decf => Box::new(Decf::new()),
-        _ => {
-            panic!("asked to do num format with non-num field type");
-        }
-    };
-    let prim_opt=
-        // if we can get an assumed value from looking at the first
-        // few characters, use that value to create the FormatPrimitive
-        if let Some(provided_num) = get_provided(in_str_opt) {
-            let mut tmp = FormatPrimitive::default();
-            match field_char {
-                'u' | 'i' | 'd' => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num}"));
-                },
-                'x' | 'X' => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num:x}"));
-                },
-                'o' => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num:o}"));
-                },
-                'e' | 'E' | 'g' | 'G' => {
-                    let as_str = format!("{provided_num}");
-                    let initial_prefix = get_initial_prefix(
-                        &as_str,
-                        field.field_type
-                    );
-                    tmp=formatter.get_primitive(field, &initial_prefix, &as_str)
-                        .expect("err during default provided num");
-                },
-                _ => {
-                    tmp.pre_decimal = Some(
-                        format!("{provided_num}"));
-                    tmp.post_decimal = Some(String::from("0"));
-                }
-            }
-            Some(tmp)
-        } else {
-            // otherwise we'll interpret the argument as a number
-            // using the appropriate Formatter
-            let in_str = in_str_opt.expect(
-                "please send the devs this message:
-                \n get_provided is failing to ret as Some(0) on no str ");
-            // first get information about the beginning of the
-            // numeric argument that would be useful for
-            // any formatter (int or float)
-            let initial_prefix = get_initial_prefix(
-                in_str,
-                field.field_type
-            );
-            // then get the FormatPrimitive from the Formatter
-            formatter.get_primitive(field, &initial_prefix, in_str)
-        };
-    // if we have a formatPrimitive, print its results
-    // according to the field-char appropriate Formatter
-    prim_opt.map(|prim| formatter.primitive_to_str(&prim, field.clone()))
-}
diff --git a/src/uucore/src/lib/features/tokenize/sub.rs b/src/uucore/src/lib/features/tokenize/sub.rs
deleted file mode 100644
index 447616ae6a6..00000000000
--- a/src/uucore/src/lib/features/tokenize/sub.rs
+++ /dev/null
@@ -1,456 +0,0 @@
-// 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.
-// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
-
-//! Sub is a token that represents a
-//! segment of the format string that is a substitution
-//! it is created by Sub's implementation of the Tokenizer trait
-//! Subs which have numeric field chars make use of the num_format
-//! submodule
-use crate::error::{UError, UResult};
-use itertools::{put_back_n, PutBackN};
-use std::error::Error;
-use std::fmt::Display;
-use std::io::Write;
-use std::iter::Peekable;
-use std::process::exit;
-use std::slice::Iter;
-use std::str::Chars;
-// use std::collections::HashSet;
-
-use super::num_format::format_field::{FieldType, FormatField};
-use super::num_format::num_format;
-use super::token;
-use super::unescaped_text::UnescapedText;
-
-const EXIT_ERR: i32 = 1;
-
-#[derive(Debug)]
-pub enum SubError {
-    InvalidSpec(String),
-}
-
-impl Display for SubError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match self {
-            Self::InvalidSpec(s) => write!(f, "%{s}: invalid conversion specification"),
-        }
-    }
-}
-
-impl Error for SubError {}
-
-impl UError for SubError {}
-
-fn convert_asterisk_arg_int(asterisk_arg: &str) -> isize {
-    // this is a costly way to parse the
-    // args used for asterisk values into integers
-    // from various bases. Actually doing it correctly
-    // (going through the pipeline to intf, but returning
-    // the integer instead of writing it to string and then
-    // back) is on the refactoring TODO
-    let field_type = FieldType::Intf;
-    let field_char = 'i';
-    let field_info = FormatField {
-        min_width: Some(0),
-        second_field: Some(0),
-        orig: &asterisk_arg.to_string(),
-        field_type: &field_type,
-        field_char: &field_char,
-    };
-    num_format::num_format(&field_info, Some(&asterisk_arg.to_string()))
-        .unwrap()
-        .parse::<isize>()
-        .unwrap()
-}
-
-pub enum CanAsterisk<T> {
-    Fixed(T),
-    Asterisk,
-}
-
-// Sub is a tokenizer which creates tokens
-// for substitution segments of a format string
-pub struct Sub {
-    min_width: CanAsterisk<Option<isize>>,
-    second_field: CanAsterisk<Option<u32>>,
-    field_char: char,
-    field_type: FieldType,
-    orig: String,
-    prefix_char: char,
-}
-impl Sub {
-    pub fn new(
-        min_width: CanAsterisk<Option<isize>>,
-        second_field: CanAsterisk<Option<u32>>,
-        field_char: char,
-        orig: String,
-        prefix_char: char,
-    ) -> Self {
-        // for more dry printing, field characters are grouped
-        // in initialization of token.
-        let field_type = match field_char {
-            's' | 'b' => FieldType::Strf,
-            'd' | 'i' | 'u' | 'o' | 'x' | 'X' => FieldType::Intf,
-            'f' | 'F' => FieldType::Floatf,
-            'a' | 'A' => FieldType::CninetyNineHexFloatf,
-            'e' | 'E' => FieldType::Scif,
-            'g' | 'G' => FieldType::Decf,
-            'c' => FieldType::Charf,
-            _ => {
-                // should be unreachable.
-                println!("Invalid field type");
-                exit(EXIT_ERR);
-            }
-        };
-        Self {
-            min_width,
-            second_field,
-            field_char,
-            field_type,
-            orig,
-            prefix_char,
-        }
-    }
-}
-
-#[derive(Default)]
-pub(crate) struct SubParser {
-    min_width_tmp: Option<String>,
-    min_width_is_asterisk: bool,
-    past_decimal: bool,
-    second_field_tmp: Option<String>,
-    second_field_is_asterisk: bool,
-    specifiers_found: bool,
-    field_char: Option<char>,
-    text_so_far: String,
-}
-
-impl SubParser {
-    fn new() -> Self {
-        Self::default()
-    }
-    pub(crate) fn from_it<W>(
-        writer: &mut W,
-        it: &mut PutBackN<Chars>,
-        args: &mut Peekable<Iter<String>>,
-    ) -> UResult<Option<token::Token>>
-    where
-        W: Write,
-    {
-        let mut parser = Self::new();
-        if parser.sub_vals_retrieved(it)? {
-            let t = Self::build_token(parser);
-            t.write(writer, args);
-            Ok(Some(t))
-        } else {
-            Ok(None)
-        }
-    }
-    fn build_token(parser: Self) -> token::Token {
-        // not a self method so as to allow move of sub-parser vals.
-        // return new Sub struct as token
-        let prefix_char = match &parser.min_width_tmp {
-            Some(width) if width.starts_with('0') => '0',
-            _ => ' ',
-        };
-
-        token::Token::Sub(Sub::new(
-            if parser.min_width_is_asterisk {
-                CanAsterisk::Asterisk
-            } else {
-                CanAsterisk::Fixed(
-                    parser
-                        .min_width_tmp
-                        .map(|x| x.parse::<isize>().unwrap_or(1)),
-                )
-            },
-            if parser.second_field_is_asterisk {
-                CanAsterisk::Asterisk
-            } else {
-                CanAsterisk::Fixed(parser.second_field_tmp.map(|x| x.parse::<u32>().unwrap()))
-            },
-            parser.field_char.unwrap(),
-            parser.text_so_far,
-            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);
-        }
-        // this fn in particular is much longer than it needs to be
-        // .could get a lot
-        // of code savings just by cleaning it up. shouldn't use a regex
-        // though, as we want to mimic the original behavior of printing
-        // the field as interpreted up until the error in the field.
-
-        let mut legal_fields = [
-            // 'a', 'A', //c99 hex float implementation not yet complete
-            'b', 'c', 'd', 'e', 'E', 'f', 'F', 'g', 'G', 'i', 'o', 's', 'u', 'x', 'X',
-        ];
-        let mut specifiers = ['h', 'j', 'l', 'L', 't', 'z'];
-        legal_fields.sort_unstable();
-        specifiers.sort_unstable();
-
-        // divide substitution from %([0-9]+)?(.[0-9+])?([a-zA-Z])
-        // into min_width, second_field, field_char
-        for ch in it {
-            self.text_so_far.push(ch);
-            match ch {
-                '-' | '*' | '0'..='9' => {
-                    if self.past_decimal {
-                        // second field should never have a
-                        // negative value
-                        if self.second_field_is_asterisk || ch == '-' || self.specifiers_found {
-                            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                        }
-                        if self.second_field_tmp.is_none() {
-                            self.second_field_tmp = Some(String::new());
-                        }
-                        match self.second_field_tmp.as_mut() {
-                            Some(x) => {
-                                if ch == '*' && !x.is_empty() {
-                                    return Err(
-                                        SubError::InvalidSpec(self.text_so_far.clone()).into()
-                                    );
-                                }
-                                if ch == '*' {
-                                    self.second_field_is_asterisk = true;
-                                }
-                                x.push(ch);
-                            }
-                            None => {
-                                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 {
-                        return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                    } else {
-                        self.past_decimal = true;
-                    }
-                }
-                x if legal_fields.binary_search(&x).is_ok() => {
-                    self.field_char = Some(ch);
-                    self.text_so_far.push(ch);
-                    break;
-                }
-                x if specifiers.binary_search(&x).is_ok() => {
-                    if !self.past_decimal {
-                        self.past_decimal = true;
-                    }
-                    if !self.specifiers_found {
-                        self.specifiers_found = true;
-                    }
-                }
-                _ => {
-                    return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-                }
-            }
-        }
-        if self.field_char.is_none() {
-            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-        }
-        let field_char_retrieved = self.field_char.unwrap();
-        if self.past_decimal && self.second_field_tmp.is_none() {
-            self.second_field_tmp = Some(String::from("0"));
-        }
-        self.validate_field_params(field_char_retrieved)?;
-        // if the dot is provided without a second field
-        // printf interprets it as 0.
-        if let Some(x) = self.second_field_tmp.as_mut() {
-            if x.is_empty() {
-                self.min_width_tmp = Some(String::from("0"));
-            }
-        }
-
-        Ok(true)
-    }
-    fn successfully_eat_prefix(
-        it: &mut PutBackN<Chars>,
-        text_so_far: &mut String,
-    ) -> UResult<bool> {
-        // get next two chars,
-        // if they're '%%' we're not tokenizing it
-        // else put chars back
-        let preface = it.next();
-        let n_ch = it.next();
-        if preface == Some('%') && n_ch != Some('%') {
-            match n_ch {
-                Some(x) => {
-                    it.put_back(x);
-                    Ok(true)
-                }
-                None => {
-                    text_so_far.push('%');
-                    Err(SubError::InvalidSpec(text_so_far.clone()).into())
-                }
-            }
-        } else {
-            if let Some(x) = n_ch {
-                it.put_back(x);
-            };
-            if let Some(x) = preface {
-                it.put_back(x);
-            };
-            Ok(false)
-        }
-    }
-    fn validate_field_params(&self, field_char: char) -> UResult<()> {
-        // check for illegal combinations here when possible vs
-        // on each application so we check less per application
-        // to do: move these checks to Sub::new
-        if (field_char == 's' && self.min_width_tmp == Some(String::from("0")))
-            || (field_char == 'c'
-                && (self.min_width_tmp == Some(String::from("0")) || self.past_decimal))
-            || (field_char == 'b'
-                && (self.min_width_tmp.is_some()
-                    || self.past_decimal
-                    || self.second_field_tmp.is_some()))
-        {
-            // invalid string substitution
-            // to do: include information about an invalid
-            // string substitution
-            return Err(SubError::InvalidSpec(self.text_so_far.clone()).into());
-        }
-        Ok(())
-    }
-}
-
-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,
-    {
-        let field = FormatField {
-            min_width: match self.min_width {
-                CanAsterisk::Fixed(x) => x,
-                CanAsterisk::Asterisk => {
-                    match pf_args_it.next() {
-                        // temporary, use intf.rs instead
-                        Some(x) => Some(convert_asterisk_arg_int(x)),
-                        None => Some(0),
-                    }
-                }
-            },
-            second_field: match self.second_field {
-                CanAsterisk::Fixed(x) => x,
-                CanAsterisk::Asterisk => {
-                    match pf_args_it.next() {
-                        // temporary, use intf.rs instead
-                        Some(x) => {
-                            let result = convert_asterisk_arg_int(x);
-                            if result < 0 {
-                                None
-                            } else {
-                                Some(result as u32)
-                            }
-                        }
-                        None => Some(0),
-                    }
-                }
-            },
-            field_char: &self.field_char,
-            field_type: &self.field_type,
-            orig: &self.orig,
-        };
-        let pf_arg = pf_args_it.next();
-
-        // minimum width is handled independently of actual
-        // field char
-        let pre_min_width_opt: Option<String> = match *field.field_type {
-            // if %s just return arg
-            // if %b use UnescapedText module's unescape-fn
-            // if %c return first char of arg
-            FieldType::Strf | FieldType::Charf => {
-                match pf_arg {
-                    Some(arg_string) => {
-                        match *field.field_char {
-                            's' => Some(match field.second_field {
-                                Some(max) => String::from(&arg_string[..max as usize]),
-                                None => arg_string.clone(),
-                            }),
-                            'b' => {
-                                let mut a_it = put_back_n(arg_string.chars());
-                                UnescapedText::from_it_core(writer, &mut a_it, true);
-                                None
-                            }
-                            // for 'c': get iter of string vals,
-                            // get opt<char> of first val
-                            // and map it to opt<String>
-                            /* 'c' | */
-                            _ => arg_string.chars().next().map(|x| x.to_string()),
-                        }
-                    }
-                    None => None,
-                }
-            }
-            _ => {
-                // non string/char fields are delegated to num_format
-                num_format::num_format(&field, pf_arg)
-            }
-        };
-        if let Some(pre_min_width) = pre_min_width_opt {
-            // if have a string, print it, ensuring minimum width is met.
-            write!(
-                writer,
-                "{}",
-                match field.min_width {
-                    Some(min_width) => {
-                        let diff: isize = min_width.abs() - pre_min_width.len() as isize;
-                        if diff > 0 {
-                            let mut final_str = String::new();
-                            // definitely more efficient ways
-                            //  to do this.
-                            let pad_before = min_width > 0;
-                            if !pad_before {
-                                final_str.push_str(&pre_min_width);
-                            }
-                            for _ in 0..diff {
-                                final_str.push(self.prefix_char);
-                            }
-                            if pad_before {
-                                final_str.push_str(&pre_min_width);
-                            }
-                            final_str
-                        } else {
-                            pre_min_width
-                        }
-                    }
-                    None => pre_min_width,
-                }
-            )
-            .ok();
-        }
-    }
-}
diff --git a/src/uucore/src/lib/features/tokenize/token.rs b/src/uucore/src/lib/features/tokenize/token.rs
deleted file mode 100644
index c4f7bd6accc..00000000000
--- a/src/uucore/src/lib/features/tokenize/token.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-//! Traits and enums dealing with Tokenization of printf Format String
-use std::io::Write;
-use std::iter::Peekable;
-use std::slice::Iter;
-
-use crate::features::tokenize::sub::Sub;
-use crate::features::tokenize::unescaped_text::UnescapedText;
-
-// A token object is an object that can print the expected output
-// of a contiguous segment of the format string, and
-// requires at most 1 argument
-pub enum Token {
-    Sub(Sub),
-    UnescapedText(UnescapedText),
-}
-
-impl Token {
-    pub(crate) fn write<W>(&self, writer: &mut W, args: &mut Peekable<Iter<String>>)
-    where
-        W: Write,
-    {
-        match self {
-            Self::Sub(sub) => sub.write(writer, args),
-            Self::UnescapedText(unescaped_text) => unescaped_text.write(writer),
-        }
-    }
-}
-
-// A tokenizer object is an object that takes an iterator
-// at a position in a format string, and sees whether
-// it can return a token of a type it knows how to produce
-// if so, return the token, move the iterator past the
-// format string text the token represents, and if an
-// argument is used move the argument iter forward one
-
-// creating token of a format string segment should also cause
-// printing of that token's value. Essentially tokenizing
-// a whole format string will print the format string and consume
-// a number of arguments equal to the number of argument-using tokens
diff --git a/src/uucore/src/lib/features/tokenize/unescaped_text.rs b/src/uucore/src/lib/features/tokenize/unescaped_text.rs
deleted file mode 100644
index 8ec6fd57618..00000000000
--- a/src/uucore/src/lib/features/tokenize/unescaped_text.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-// 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.
-//! UnescapedText is a tokenizer impl
-//! for tokenizing character literals,
-//! and escaped character literals (of allowed escapes),
-//! into an unescaped text byte array
-
-// spell-checker:ignore (ToDO) retval hexchars octals printf's bvec vals coreutil addchar eval bytecode bslice
-
-use itertools::PutBackN;
-use std::char::from_u32;
-use std::io::Write;
-use std::process::exit;
-use std::str::Chars;
-
-use super::token;
-
-const EXIT_OK: i32 = 0;
-const EXIT_ERR: i32 = 1;
-
-// by default stdout only flushes
-// to console when a newline is passed.
-macro_rules! write_and_flush {
-    ($writer:expr, $($args:tt)+) => ({
-        write!($writer, "{}", $($args)+).ok();
-        $writer.flush().ok();
-    })
-}
-
-fn flush_bytes<W>(writer: &mut W, bslice: &[u8])
-where
-    W: Write,
-{
-    writer.write_all(bslice).ok();
-    writer.flush().ok();
-}
-
-#[derive(Default)]
-pub struct UnescapedText(Vec<u8>);
-impl UnescapedText {
-    fn new() -> Self {
-        Self::default()
-    }
-    // take an iterator to the format string
-    // consume between min and max chars
-    // and return it as a base-X number
-    fn base_to_u32(min_chars: u8, max_chars: u8, base: u32, it: &mut PutBackN<Chars>) -> u32 {
-        let mut retval: u32 = 0;
-        let mut found = 0;
-        while found < max_chars {
-            // if end of input break
-            let nc = it.next();
-            match nc {
-                Some(digit) => {
-                    // if end of hexchars break
-                    match digit.to_digit(base) {
-                        Some(d) => {
-                            found += 1;
-                            retval *= base;
-                            retval += d;
-                        }
-                        None => {
-                            it.put_back(digit);
-                            break;
-                        }
-                    }
-                }
-                None => {
-                    break;
-                }
-            }
-        }
-        if found < min_chars {
-            // only ever expected for hex
-            println!("missing hexadecimal number in escape"); //todo stderr
-            exit(EXIT_ERR);
-        }
-        retval
-    }
-    // validates against valid
-    // IEC 10646 vals - these values
-    // are pinned against the more popular
-    // printf so as to not disrupt when
-    // dropped-in as a replacement.
-    fn validate_iec(val: u32, eight_word: bool) {
-        let mut preface = 'u';
-        let leading_zeros = if eight_word {
-            preface = 'U';
-            8
-        } else {
-            4
-        };
-        let err_msg = format!("invalid universal character name {preface}{val:0leading_zeros$x}");
-        if (val < 159 && (val != 36 && val != 64 && val != 96)) || (val > 55296 && val < 57343) {
-            println!("{err_msg}"); //todo stderr
-            exit(EXIT_ERR);
-        }
-    }
-    // pass an iterator that succeeds an '/',
-    // and process the remaining character
-    // adding the unescaped bytes
-    // to the passed byte_vec
-    // in subs_mode change octal behavior
-    fn handle_escaped<W>(
-        writer: &mut W,
-        byte_vec: &mut Vec<u8>,
-        it: &mut PutBackN<Chars>,
-        subs_mode: bool,
-    ) where
-        W: Write,
-    {
-        let ch = it.next().unwrap_or('\\');
-        match ch {
-            '0'..='9' | 'x' => {
-                let min_len = 1;
-                let mut max_len = 2;
-                let mut base = 16;
-                let ignore = false;
-                match ch {
-                    'x' => {}
-                    e @ '0'..='9' => {
-                        max_len = 3;
-                        base = 8;
-                        // in practice, gnu coreutils printf
-                        // interprets octals without a
-                        // leading zero in %b
-                        // but it only skips leading zeros
-                        // in %b mode.
-                        // if we ever want to match gnu coreutil
-                        // printf's docs instead of its behavior
-                        // we'd set this to true.
-                        // if subs_mode && e != '0'
-                        //  { ignore = true; }
-                        if !subs_mode || e != '0' {
-                            it.put_back(ch);
-                        }
-                    }
-                    _ => {}
-                }
-                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);
-                }
-            }
-            e => {
-                // only for hex and octal
-                // is byte encoding specified.
-                // otherwise, why not leave the door open
-                // for other encodings unless it turns out
-                // a bottleneck.
-                let mut s = String::new();
-                let ch = match e {
-                    '\\' => '\\',
-                    '"' => '"',
-                    'n' => '\n',
-                    'r' => '\r',
-                    't' => '\t',
-                    // bell
-                    'a' => '\x07',
-                    // backspace
-                    'b' => '\x08',
-                    // vertical tab
-                    'v' => '\x0B',
-                    // form feed
-                    'f' => '\x0C',
-                    // escape character
-                    'e' => '\x1B',
-                    'c' => exit(EXIT_OK),
-                    'u' | 'U' => {
-                        let len = match e {
-                            'u' => 4,
-                            /* 'U' | */ _ => 8,
-                        };
-                        let val = Self::base_to_u32(len, len, 16, it);
-                        Self::validate_iec(val, false);
-                        if let Some(c) = from_u32(val) {
-                            c
-                        } else {
-                            '-'
-                        }
-                    }
-                    _ => {
-                        s.push('\\');
-                        ch
-                    }
-                };
-                s.push(ch);
-                write_and_flush!(writer, &s);
-                byte_vec.extend(s.bytes());
-            }
-        };
-    }
-
-    // take an iterator to a string,
-    // 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>,
-        subs_mode: bool,
-    ) -> Option<token::Token>
-    where
-        W: Write,
-    {
-        let mut addchar = false;
-        let mut new_text = Self::new();
-        let mut tmp_str = String::new();
-        {
-            let new_vec: &mut Vec<u8> = &mut (new_text.0);
-            while let Some(ch) = it.next() {
-                if !addchar {
-                    addchar = true;
-                }
-                match ch {
-                    x if x != '\\' && x != '%' => {
-                        // lazy branch eval
-                        // remember this fn could be called
-                        // many times in a single exec through %b
-                        write_and_flush!(writer, ch);
-                        tmp_str.push(ch);
-                    }
-                    '\\' => {
-                        // the literal may be a literal bytecode
-                        // and not valid utf-8. Str only supports
-                        // valid utf-8.
-                        // if we find the unnecessary drain
-                        // on non hex or octal escapes is costly
-                        // then we can make it faster/more complex
-                        // with as-necessary draining.
-                        if !tmp_str.is_empty() {
-                            new_vec.extend(tmp_str.bytes());
-                            tmp_str = String::new();
-                        }
-                        Self::handle_escaped(writer, new_vec, it, subs_mode);
-                    }
-                    x if x == '%' && !subs_mode => {
-                        if let Some(follow) = it.next() {
-                            if follow == '%' {
-                                write_and_flush!(writer, ch);
-                                tmp_str.push(ch);
-                            } else {
-                                it.put_back(follow);
-                                it.put_back(ch);
-                                break;
-                            }
-                        } else {
-                            it.put_back(ch);
-                            break;
-                        }
-                    }
-                    _ => {
-                        write_and_flush!(writer, ch);
-                        tmp_str.push(ch);
-                    }
-                }
-            }
-            if !tmp_str.is_empty() {
-                new_vec.extend(tmp_str.bytes());
-            }
-        }
-        if addchar {
-            Some(token::Token::UnescapedText(new_text))
-        } else {
-            None
-        }
-    }
-}
-impl UnescapedText {
-    pub(crate) fn write<W>(&self, writer: &mut W)
-    where
-        W: Write,
-    {
-        flush_bytes(writer, &self.0[..]);
-    }
-}
diff --git a/src/uucore/src/lib/features/tty.rs b/src/uucore/src/lib/features/tty.rs
new file mode 100644
index 00000000000..221ee442d63
--- /dev/null
+++ b/src/uucore/src/lib/features/tty.rs
@@ -0,0 +1,127 @@
+// 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.
+
+//! Set of functions to parsing TTY
+use std::{
+    fmt::{self, Display, Formatter},
+    path::PathBuf,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Teletype {
+    Tty(u64),
+    TtyS(u64),
+    Pts(u64),
+    Unknown,
+}
+
+impl Display for Teletype {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Tty(id) => write!(f, "/dev/tty{id}"),
+            Self::TtyS(id) => write!(f, "/dev/ttyS{id}"),
+            Self::Pts(id) => write!(f, "/dev/pts/{id}"),
+            Self::Unknown => write!(f, "?"),
+        }
+    }
+}
+
+impl TryFrom<String> for Teletype {
+    type Error = ();
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::try_from(value.as_str())
+    }
+}
+
+impl TryFrom<&str> for Teletype {
+    type Error = ();
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        if value == "?" {
+            return Ok(Self::Unknown);
+        }
+
+        Self::try_from(PathBuf::from(value))
+    }
+}
+
+impl TryFrom<PathBuf> for Teletype {
+    type Error = ();
+
+    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
+        // Three case: /dev/pts/* , /dev/ttyS**, /dev/tty**
+
+        let mut iter = value.iter();
+        // Case 1
+
+        // Considering this format: **/**/pts/<num>
+        if let (Some(_), Some(num)) = (iter.find(|it| *it == "pts"), iter.next()) {
+            return num
+                .to_str()
+                .ok_or(())?
+                .parse::<u64>()
+                .map_err(|_| ())
+                .map(Teletype::Pts);
+        };
+
+        // Considering this format: **/**/ttyS** then **/**/tty**
+        let path = value.to_str().ok_or(())?;
+
+        let f = |prefix: &str| {
+            value
+                .iter()
+                .next_back()?
+                .to_str()?
+                .strip_prefix(prefix)?
+                .parse::<u64>()
+                .ok()
+        };
+
+        if path.contains("ttyS") {
+            // Case 2
+            f("ttyS").ok_or(()).map(Teletype::TtyS)
+        } else if path.contains("tty") {
+            // Case 3
+            f("tty").ok_or(()).map(Teletype::Tty)
+        } else {
+            Err(())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tty_from() {
+        assert_eq!(Teletype::try_from("?").unwrap(), Teletype::Unknown);
+        assert_eq!(Teletype::try_from("/dev/tty1").unwrap(), Teletype::Tty(1));
+        assert_eq!(Teletype::try_from("/dev/tty10").unwrap(), Teletype::Tty(10));
+        assert_eq!(Teletype::try_from("/dev/pts/1").unwrap(), Teletype::Pts(1));
+        assert_eq!(
+            Teletype::try_from("/dev/pts/10").unwrap(),
+            Teletype::Pts(10)
+        );
+        assert_eq!(Teletype::try_from("/dev/ttyS1").unwrap(), Teletype::TtyS(1));
+        assert_eq!(
+            Teletype::try_from("/dev/ttyS10").unwrap(),
+            Teletype::TtyS(10)
+        );
+        assert_eq!(Teletype::try_from("ttyS10").unwrap(), Teletype::TtyS(10));
+
+        assert!(Teletype::try_from("value").is_err());
+        assert!(Teletype::try_from("TtyS10").is_err());
+    }
+
+    #[test]
+    fn test_terminal_type_display() {
+        assert_eq!(Teletype::Pts(10).to_string(), "/dev/pts/10");
+        assert_eq!(Teletype::Tty(10).to_string(), "/dev/tty10");
+        assert_eq!(Teletype::TtyS(10).to_string(), "/dev/ttyS10");
+        assert_eq!(Teletype::Unknown.to_string(), "?");
+    }
+}
diff --git a/src/uucore/src/lib/features/update_control.rs b/src/uucore/src/lib/features/update_control.rs
index bd429251452..d7c4b4f167e 100644
--- a/src/uucore/src/lib/features/update_control.rs
+++ b/src/uucore/src/lib/features/update_control.rs
@@ -39,7 +39,7 @@
 //!     let update_mode = update_control::determine_update_mode(&matches);
 //!
 //!     // handle cases
-//!     if update_mode == UpdateMode::ReplaceIfOlder {
+//!     if update_mode == UpdateMode::IfOlder {
 //!         // do
 //!     } else {
 //!         unreachable!()
@@ -48,30 +48,37 @@
 //! ```
 use clap::ArgMatches;
 
-// Available update mode
-#[derive(Clone, Debug, Eq, PartialEq)]
+/// Available update mode
+#[derive(Clone, Debug, Eq, PartialEq, Default)]
 pub enum UpdateMode {
-    // --update=`all`, ``
-    ReplaceAll,
-    // --update=`none`
-    ReplaceNone,
-    // --update=`older`
-    // -u
-    ReplaceIfOlder,
+    /// --update=`all`, ``
+    #[default]
+    All,
+    /// --update=`none`
+    None,
+
+    /// --update=`older`
+    /// -u
+    IfOlder,
+    NoneFail,
 }
 
 pub mod arguments {
+    //! Pre-defined arguments for update functionality.
+    use crate::parser::shortcut_value_parser::ShortcutValueParser;
     use clap::ArgAction;
 
+    /// `--update` argument
     pub static OPT_UPDATE: &str = "update";
+    /// `-u` argument
     pub static OPT_UPDATE_NO_ARG: &str = "u";
 
-    // `--update` argument, defaults to `older` if no values are provided
+    /// `--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"])
+            .value_parser(ShortcutValueParser::new(["none", "all", "older","none-fail"]))
             .num_args(0..=1)
             .default_missing_value("older")
             .require_equals(true)
@@ -79,7 +86,7 @@ pub mod arguments {
             .action(clap::ArgAction::Set)
     }
 
-    // `-u` argument
+    /// `-u` argument
     pub fn update_no_args() -> clap::Arg {
         clap::Arg::new(OPT_UPDATE_NO_ARG)
             .short('u')
@@ -117,21 +124,22 @@ pub mod arguments {
 ///         ]);
 ///
 ///     let update_mode = update_control::determine_update_mode(&matches);
-///     assert_eq!(update_mode, UpdateMode::ReplaceAll)
+///     assert_eq!(update_mode, UpdateMode::All)
 /// }
 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,
+            "all" => UpdateMode::All,
+            "none" => UpdateMode::None,
+            "older" => UpdateMode::IfOlder,
+            "none-fail" => UpdateMode::NoneFail,
             _ => 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
+        UpdateMode::IfOlder
     } else {
         // no option was present
-        UpdateMode::ReplaceAll
+        UpdateMode::All
     }
 }
diff --git a/src/uucore/src/lib/features/uptime.rs b/src/uucore/src/lib/features/uptime.rs
new file mode 100644
index 00000000000..91fa9dd7de9
--- /dev/null
+++ b/src/uucore/src/lib/features/uptime.rs
@@ -0,0 +1,375 @@
+// 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.
+
+// spell-checker:ignore gettime BOOTTIME clockid boottime nusers loadavg getloadavg
+
+//! Provides functions to get system uptime, number of users and load average.
+
+// The code was originally written in uu_uptime
+// (https://github.com/uutils/coreutils/blob/main/src/uu/uptime/src/uptime.rs)
+// but was eventually moved here.
+// See https://github.com/uutils/coreutils/pull/7289 for discussion.
+
+use crate::error::{UError, UResult};
+use chrono::Local;
+use libc::time_t;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum UptimeError {
+    #[error("could not retrieve system uptime")]
+    SystemUptime,
+    #[error("could not retrieve system load average")]
+    SystemLoadavg,
+    #[error("Windows does not have an equivalent to the load average on Unix-like systems")]
+    WindowsLoadavg,
+    #[error("boot time larger than current time")]
+    BootTime,
+}
+
+impl UError for UptimeError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+/// Returns the formatted time string, e.g. "12:34:56"
+pub fn get_formatted_time() -> String {
+    Local::now().time().format("%H:%M:%S").to_string()
+}
+
+/// Get the system uptime
+///
+/// # Arguments
+///
+/// boot_time: Option<time_t> - Manually specify the boot time, or None to try to get it from the system.
+///
+/// # Returns
+///
+/// Returns a UResult with the uptime in seconds if successful, otherwise an UptimeError.
+#[cfg(target_os = "openbsd")]
+pub fn get_uptime(_boot_time: Option<time_t>) -> UResult<i64> {
+    use libc::CLOCK_BOOTTIME;
+    use libc::clock_gettime;
+
+    use libc::c_int;
+    use libc::timespec;
+
+    let mut tp: timespec = timespec {
+        tv_sec: 0,
+        tv_nsec: 0,
+    };
+    let raw_tp = &mut tp as *mut timespec;
+
+    // OpenBSD prototype: clock_gettime(clk_id: ::clockid_t, tp: *mut ::timespec) -> ::c_int;
+    let ret: c_int = unsafe { clock_gettime(CLOCK_BOOTTIME, raw_tp) };
+
+    if ret == 0 {
+        #[cfg(target_pointer_width = "64")]
+        let uptime: i64 = tp.tv_sec;
+        #[cfg(not(target_pointer_width = "64"))]
+        let uptime: i64 = tp.tv_sec.into();
+
+        Ok(uptime)
+    } else {
+        Err(UptimeError::SystemUptime)
+    }
+}
+
+/// Get the system uptime
+///
+/// # Arguments
+///
+/// boot_time: Option<time_t> - Manually specify the boot time, or None to try to get it from the system.
+///
+/// # Returns
+///
+/// Returns a UResult with the uptime in seconds if successful, otherwise an UptimeError.
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
+pub fn get_uptime(boot_time: Option<time_t>) -> UResult<i64> {
+    use crate::utmpx::Utmpx;
+    use libc::BOOT_TIME;
+    use std::fs::File;
+    use std::io::Read;
+
+    let mut proc_uptime_s = String::new();
+
+    let proc_uptime = File::open("/proc/uptime")
+        .ok()
+        .and_then(|mut f| f.read_to_string(&mut proc_uptime_s).ok())
+        .and_then(|_| proc_uptime_s.split_whitespace().next())
+        .and_then(|s| s.split('.').next().unwrap_or("0").parse::<i64>().ok());
+
+    if let Some(uptime) = proc_uptime {
+        return Ok(uptime);
+    }
+
+    let boot_time = boot_time.or_else(|| {
+        let records = Utmpx::iter_all_records();
+        for line in records {
+            match line.record_type() {
+                BOOT_TIME => {
+                    let dt = line.login_time();
+                    if dt.unix_timestamp() > 0 {
+                        return Some(dt.unix_timestamp() as time_t);
+                    }
+                }
+                _ => continue,
+            }
+        }
+        None
+    });
+
+    if let Some(t) = boot_time {
+        let now = Local::now().timestamp();
+        #[cfg(target_pointer_width = "64")]
+        let boottime: i64 = t;
+        #[cfg(not(target_pointer_width = "64"))]
+        let boottime: i64 = t.into();
+        if now < boottime {
+            Err(UptimeError::BootTime)?;
+        }
+        return Ok(now - boottime);
+    }
+
+    Err(UptimeError::SystemUptime)?
+}
+
+/// Get the system uptime
+///
+/// # Arguments
+///
+/// boot_time will be ignored, pass None.
+///
+/// # Returns
+///
+/// Returns a UResult with the uptime in seconds if successful, otherwise an UptimeError.
+#[cfg(windows)]
+pub fn get_uptime(_boot_time: Option<time_t>) -> UResult<i64> {
+    use windows_sys::Win32::System::SystemInformation::GetTickCount;
+    // SAFETY: always return u32
+    let uptime = unsafe { GetTickCount() };
+    Ok(uptime as i64 / 1000)
+}
+
+/// Get the system uptime in a human-readable format
+///
+/// # Arguments
+///
+/// boot_time: Option<time_t> - Manually specify the boot time, or None to try to get it from the system.
+///
+/// # Returns
+///
+/// Returns a UResult with the uptime in a human-readable format(e.g. "1 day, 3:45") if successful, otherwise an UptimeError.
+#[inline]
+pub fn get_formatted_uptime(boot_time: Option<time_t>) -> UResult<String> {
+    let up_secs = get_uptime(boot_time)?;
+
+    if up_secs < 0 {
+        Err(UptimeError::SystemUptime)?;
+    }
+    let up_days = up_secs / 86400;
+    let up_hours = (up_secs - (up_days * 86400)) / 3600;
+    let up_mins = (up_secs - (up_days * 86400) - (up_hours * 3600)) / 60;
+    match up_days.cmp(&1) {
+        std::cmp::Ordering::Equal => Ok(format!("{up_days:1} day, {up_hours:2}:{up_mins:02}")),
+        std::cmp::Ordering::Greater => Ok(format!("{up_days:1} days {up_hours:2}:{up_mins:02}")),
+        _ => Ok(format!("{up_hours:2}:{up_mins:02}")),
+    }
+}
+
+/// Get the number of users currently logged in
+///
+/// # Returns
+///
+/// Returns the number of users currently logged in if successful, otherwise 0.
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
+// see: https://gitlab.com/procps-ng/procps/-/blob/4740a0efa79cade867cfc7b32955fe0f75bf5173/library/uptime.c#L63-L115
+pub fn get_nusers() -> usize {
+    use crate::utmpx::Utmpx;
+    use libc::USER_PROCESS;
+
+    let mut num_user = 0;
+    Utmpx::iter_all_records().for_each(|ut| {
+        if ut.record_type() == USER_PROCESS {
+            num_user += 1;
+        }
+    });
+    num_user
+}
+
+/// Get the number of users currently logged in
+///
+/// # Returns
+///
+/// Returns the number of users currently logged in if successful, otherwise 0
+#[cfg(target_os = "openbsd")]
+pub fn get_nusers(file: &str) -> usize {
+    use utmp_classic::{UtmpEntry, parse_from_path};
+
+    let mut nusers = 0;
+
+    let entries = match parse_from_path(file) {
+        Some(e) => e,
+        None => return 0,
+    };
+
+    for entry in entries {
+        if let UtmpEntry::UTMP {
+            line: _,
+            user,
+            host: _,
+            time: _,
+        } = entry
+        {
+            if !user.is_empty() {
+                nusers += 1;
+            }
+        }
+    }
+    nusers
+}
+
+/// Get the number of users currently logged in
+///
+/// # Returns
+///
+/// Returns the number of users currently logged in if successful, otherwise 0
+#[cfg(target_os = "windows")]
+pub fn get_nusers() -> usize {
+    use std::ptr;
+    use windows_sys::Win32::System::RemoteDesktop::*;
+
+    let mut num_user = 0;
+
+    // SAFETY: WTS_CURRENT_SERVER_HANDLE is a valid handle
+    unsafe {
+        let mut session_info_ptr = ptr::null_mut();
+        let mut session_count = 0;
+
+        let result = WTSEnumerateSessionsW(
+            WTS_CURRENT_SERVER_HANDLE,
+            0,
+            1,
+            &mut session_info_ptr,
+            &mut session_count,
+        );
+        if result == 0 {
+            return 0;
+        }
+
+        let sessions = std::slice::from_raw_parts(session_info_ptr, session_count as usize);
+
+        for session in sessions {
+            let mut buffer: *mut u16 = ptr::null_mut();
+            let mut bytes_returned = 0;
+
+            let result = WTSQuerySessionInformationW(
+                WTS_CURRENT_SERVER_HANDLE,
+                session.SessionId,
+                5,
+                &mut buffer,
+                &mut bytes_returned,
+            );
+            if result == 0 || buffer.is_null() {
+                continue;
+            }
+
+            let username = if !buffer.is_null() {
+                let cstr = std::ffi::CStr::from_ptr(buffer as *const i8);
+                cstr.to_string_lossy().to_string()
+            } else {
+                String::new()
+            };
+            if !username.is_empty() {
+                num_user += 1;
+            }
+
+            WTSFreeMemory(buffer as _);
+        }
+
+        WTSFreeMemory(session_info_ptr as _);
+    }
+
+    num_user
+}
+
+/// Format the number of users to a human-readable string
+///
+/// # Returns
+///
+/// e.g. "0 user", "1 user", "2 users"
+#[inline]
+pub fn format_nusers(nusers: usize) -> String {
+    match nusers {
+        0 => "0 user".to_string(),
+        1 => "1 user".to_string(),
+        _ => format!("{nusers} users"),
+    }
+}
+
+/// Get the number of users currently logged in in a human-readable format
+///
+/// # Returns
+///
+/// e.g. "0 user", "1 user", "2 users"
+#[inline]
+pub fn get_formatted_nusers() -> String {
+    #[cfg(not(target_os = "openbsd"))]
+    return format_nusers(get_nusers());
+
+    #[cfg(target_os = "openbsd")]
+    format_nusers(get_nusers("/var/run/utmp"))
+}
+
+/// Get the system load average
+///
+/// # Returns
+///
+/// Returns a UResult with the load average if successful, otherwise an UptimeError.
+/// The load average is a tuple of three floating point numbers representing the 1-minute, 5-minute, and 15-minute load averages.
+#[cfg(unix)]
+pub fn get_loadavg() -> UResult<(f64, f64, f64)> {
+    use crate::libc::c_double;
+    use libc::getloadavg;
+
+    let mut avg: [c_double; 3] = [0.0; 3];
+    // SAFETY: checked whether it returns -1
+    let loads: i32 = unsafe { getloadavg(avg.as_mut_ptr(), 3) };
+
+    if loads == -1 {
+        Err(UptimeError::SystemLoadavg)?
+    } else {
+        Ok((avg[0], avg[1], avg[2]))
+    }
+}
+
+/// Get the system load average
+/// Windows does not have an equivalent to the load average on Unix-like systems.
+///
+/// # Returns
+///
+/// Returns a UResult with an UptimeError.
+#[cfg(windows)]
+pub fn get_loadavg() -> UResult<(f64, f64, f64)> {
+    Err(UptimeError::WindowsLoadavg)?
+}
+
+/// Get the system load average in a human-readable format
+///
+/// # Returns
+///
+/// Returns a UResult with the load average in a human-readable format if successful, otherwise an UptimeError.
+/// e.g. "load average: 0.00, 0.00, 0.00"
+#[inline]
+pub fn get_formatted_loadavg() -> UResult<String> {
+    let loadavg = get_loadavg()?;
+    Ok(format!(
+        "load average: {:.2}, {:.2}, {:.2}",
+        loadavg.0, loadavg.1, loadavg.2
+    ))
+}
diff --git a/src/uucore/src/lib/features/utmpx.rs b/src/uucore/src/lib/features/utmpx.rs
index 1b6ecbcf5c8..1dba4e16e16 100644
--- a/src/uucore/src/lib/features/utmpx.rs
+++ b/src/uucore/src/lib/features/utmpx.rs
@@ -40,11 +40,19 @@ use std::ptr;
 use std::sync::{Mutex, MutexGuard};
 
 pub use self::ut::*;
+
+// See the FAQ at https://wiki.musl-libc.org/faq#Q:-Why-is-the-utmp/wtmp-functionality-only-implemented-as-stubs?
+// Musl implements only stubs for the utmp functions, and the libc crate issues a deprecation warning about this.
+// However, calling these stubs is the correct approach to maintain consistent behavior with GNU coreutils.
+#[cfg_attr(target_env = "musl", allow(deprecated))]
 pub use libc::endutxent;
+#[cfg_attr(target_env = "musl", allow(deprecated))]
 pub use libc::getutxent;
+#[cfg_attr(target_env = "musl", allow(deprecated))]
 pub use libc::setutxent;
 use libc::utmpx;
 #[cfg(any(target_vendor = "apple", target_os = "linux", target_os = "netbsd"))]
+#[cfg_attr(target_env = "musl", allow(deprecated))]
 pub use libc::utmpxname;
 
 /// # Safety
@@ -54,8 +62,6 @@ pub unsafe extern "C" fn utmpxname(_file: *const libc::c_char) -> libc::c_int {
     0
 }
 
-use once_cell::sync::Lazy;
-
 use crate::*; // import macros from `../../macros.rs`
 
 // In case the c_char array doesn't end with NULL
@@ -72,9 +78,21 @@ macro_rules! chars2string {
 mod ut {
     pub static DEFAULT_FILE: &str = "/var/run/utmp";
 
+    #[cfg(not(target_env = "musl"))]
     pub use libc::__UT_HOSTSIZE as UT_HOSTSIZE;
+    #[cfg(target_env = "musl")]
+    pub use libc::UT_HOSTSIZE;
+
+    #[cfg(not(target_env = "musl"))]
     pub use libc::__UT_LINESIZE as UT_LINESIZE;
+    #[cfg(target_env = "musl")]
+    pub use libc::UT_LINESIZE;
+
+    #[cfg(not(target_env = "musl"))]
     pub use libc::__UT_NAMESIZE as UT_NAMESIZE;
+    #[cfg(target_env = "musl")]
+    pub use libc::UT_NAMESIZE;
+
     pub const UT_IDSIZE: usize = 4;
 
     pub use libc::ACCOUNTING;
@@ -156,6 +174,7 @@ mod ut {
     pub use libc::USER_PROCESS;
 }
 
+/// A login record
 pub struct Utmpx {
     inner: utmpx,
 }
@@ -191,7 +210,8 @@ impl Utmpx {
         let ts_nanos: i128 = (1_000_000_000_i64 * self.inner.ut_tv.tv_sec as i64
             + 1_000_i64 * self.inner.ut_tv.tv_usec as i64)
             .into();
-        let local_offset = time::OffsetDateTime::now_local().unwrap().offset();
+        let local_offset =
+            time::OffsetDateTime::now_local().map_or_else(|_| time::UtcOffset::UTC, |v| v.offset());
         time::OffsetDateTime::from_unix_timestamp_nanos(ts_nanos)
             .unwrap()
             .to_offset(local_offset)
@@ -214,6 +234,7 @@ impl Utmpx {
     pub fn into_inner(self) -> utmpx {
         self.inner
     }
+    /// check if the record is a user process
     pub fn is_user_process(&self) -> bool {
         !self.user().is_empty() && self.record_type() == USER_PROCESS
     }
@@ -225,7 +246,7 @@ impl Utmpx {
         let (hostname, display) = host.split_once(':').unwrap_or((&host, ""));
 
         if !hostname.is_empty() {
-            use dns_lookup::{getaddrinfo, AddrInfoHints};
+            use dns_lookup::{AddrInfoHints, getaddrinfo};
 
             const AI_CANONNAME: i32 = 0x2;
             let hints = AddrInfoHints {
@@ -265,6 +286,7 @@ impl Utmpx {
             // This can technically fail, and it would be nice to detect that,
             // but it doesn't return anything so we'd have to do nasty things
             // with errno.
+            #[cfg_attr(target_env = "musl", allow(deprecated))]
             setutxent();
         }
         iter
@@ -289,7 +311,9 @@ impl Utmpx {
             // is specified, no warning or anything.
             // So this function is pretty crazy and we don't try to detect errors.
             // Not much we can do besides pray.
+            #[cfg_attr(target_env = "musl", allow(deprecated))]
             utmpxname(path.as_ptr());
+            #[cfg_attr(target_env = "musl", allow(deprecated))]
             setutxent();
         }
         iter
@@ -303,7 +327,7 @@ impl Utmpx {
 // I believe the only technical memory unsafety that could happen is a data
 // race while copying the data out of the pointer returned by getutxent(), but
 // ordinary race conditions are also very much possible.
-static LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+static LOCK: LazyLock<Mutex<()>> = LazyLock::new(|| Mutex::new(()));
 
 /// Iterator of login records
 pub struct UtmpxIter {
@@ -329,6 +353,7 @@ impl Iterator for UtmpxIter {
     type Item = Utmpx;
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
+            #[cfg_attr(target_env = "musl", allow(deprecated))]
             let res = getutxent();
             if res.is_null() {
                 None
@@ -348,6 +373,7 @@ impl Iterator for UtmpxIter {
 impl Drop for UtmpxIter {
     fn drop(&mut self) {
         unsafe {
+            #[cfg_attr(target_env = "musl", allow(deprecated))]
             endutxent();
         }
     }
diff --git a/src/uucore/src/lib/mods/version_cmp.rs b/src/uucore/src/lib/features/version_cmp.rs
similarity index 98%
rename from src/uucore/src/lib/mods/version_cmp.rs
rename to src/uucore/src/lib/features/version_cmp.rs
index d881a73a183..492313d1b74 100644
--- a/src/uucore/src/lib/mods/version_cmp.rs
+++ b/src/uucore/src/lib/features/version_cmp.rs
@@ -2,6 +2,9 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+
+//! Compare two version strings.
+
 use std::cmp::Ordering;
 
 /// Compares the non-digit parts of a version.
@@ -19,10 +22,10 @@ fn version_non_digit_cmp(a: &str, b: &str) -> Ordering {
             (None, Some(_)) => return Ordering::Less,
             (Some(_), None) => return Ordering::Greater,
             (Some(c1), Some(c2)) if c1.is_ascii_alphabetic() && !c2.is_ascii_alphabetic() => {
-                return Ordering::Less
+                return Ordering::Less;
             }
             (Some(c1), Some(c2)) if !c1.is_ascii_alphabetic() && c2.is_ascii_alphabetic() => {
-                return Ordering::Greater
+                return Ordering::Greater;
             }
             (Some(c1), Some(c2)) => return c1.cmp(&c2),
         }
@@ -58,6 +61,7 @@ fn remove_file_ending(a: &str) -> &str {
     }
 }
 
+/// Compare two version strings.
 pub fn version_cmp(mut a: &str, mut b: &str) -> Ordering {
     let str_cmp = a.cmp(b);
     if str_cmp == Ordering::Equal {
@@ -170,12 +174,12 @@ mod tests {
         );
 
         // Shortened names
-        assert_eq!(version_cmp("world", "wo"), Ordering::Greater,);
+        assert_eq!(version_cmp("world", "wo"), Ordering::Greater);
 
-        assert_eq!(version_cmp("hello10wo", "hello10world"), Ordering::Less,);
+        assert_eq!(version_cmp("hello10wo", "hello10world"), Ordering::Less);
 
         // Simple names
-        assert_eq!(version_cmp("world", "hello"), Ordering::Greater,);
+        assert_eq!(version_cmp("world", "hello"), Ordering::Greater);
 
         assert_eq!(version_cmp("hello", "world"), Ordering::Less);
 
diff --git a/src/uucore/src/lib/lib.rs b/src/uucore/src/lib/lib.rs
index 5b9f4ae1266..b1a9363f728 100644
--- a/src/uucore/src/lib/lib.rs
+++ b/src/uucore/src/lib/lib.rs
@@ -2,7 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// library ~ (core/bundler file)
+//! library ~ (core/bundler file)
+// #![deny(missing_docs)] //TODO: enable this
+//
+// spell-checker:ignore sigaction SIGBUS SIGSEGV extendedbigdecimal
 
 // * feature-gated external crates (re-shared as public internal modules)
 #[cfg(feature = "libc")]
@@ -15,38 +18,47 @@ pub extern crate windows_sys;
 mod features; // feature-gated code modules
 mod macros; // crate macros (macro_rules-type; exported to `crate::...`)
 mod mods; // core cross-platform modules
-mod parser; // string parsing modules
 
 pub use uucore_procs::*;
 
 // * cross-platform modules
 pub use crate::mods::display;
 pub use crate::mods::error;
+#[cfg(feature = "fs")]
+pub use crate::mods::io;
 pub use crate::mods::line_ending;
+pub use crate::mods::locale;
 pub use crate::mods::os;
 pub use crate::mods::panic;
-pub use crate::mods::quoting_style;
-pub use crate::mods::version_cmp;
-
-// * string parsing modules
-pub use crate::parser::parse_glob;
-pub use crate::parser::parse_size;
-pub use crate::parser::parse_time;
-pub use crate::parser::shortcut_value_parser;
+pub use crate::mods::posix;
 
 // * feature-gated modules
 #[cfg(feature = "backup-control")]
 pub use crate::features::backup_control;
+#[cfg(feature = "buf-copy")]
+pub use crate::features::buf_copy;
+#[cfg(feature = "checksum")]
+pub use crate::features::checksum;
+#[cfg(feature = "colors")]
+pub use crate::features::colors;
+#[cfg(feature = "custom-tz-fmt")]
+pub use crate::features::custom_tz_fmt;
 #[cfg(feature = "encoding")]
 pub use crate::features::encoding;
+#[cfg(feature = "extendedbigdecimal")]
+pub use crate::features::extendedbigdecimal;
+#[cfg(feature = "fast-inc")]
+pub use crate::features::fast_inc;
+#[cfg(feature = "format")]
+pub use crate::features::format;
 #[cfg(feature = "fs")]
 pub use crate::features::fs;
-#[cfg(feature = "fsext")]
-pub use crate::features::fsext;
 #[cfg(feature = "lines")]
 pub use crate::features::lines;
-#[cfg(feature = "memo")]
-pub use crate::features::memo;
+#[cfg(feature = "parser")]
+pub use crate::features::parser;
+#[cfg(feature = "quoting-style")]
+pub use crate::features::quoting_style;
 #[cfg(feature = "ranges")]
 pub use crate::features::ranges;
 #[cfg(feature = "ringbuffer")]
@@ -55,6 +67,10 @@ pub use crate::features::ringbuffer;
 pub use crate::features::sum;
 #[cfg(feature = "update-control")]
 pub use crate::features::update_control;
+#[cfg(feature = "uptime")]
+pub use crate::features::uptime;
+#[cfg(feature = "version-cmp")]
+pub use crate::features::version_cmp;
 
 // * (platform-specific) feature-gated modules
 // ** non-windows (i.e. Unix + Fuchsia)
@@ -65,7 +81,7 @@ pub use crate::features::mode;
 pub use crate::features::entries;
 #[cfg(all(unix, feature = "perms"))]
 pub use crate::features::perms;
-#[cfg(all(unix, feature = "pipes"))]
+#[cfg(all(unix, any(feature = "pipes", feature = "buf-copy")))]
 pub use crate::features::pipes;
 #[cfg(all(unix, feature = "process"))]
 pub use crate::features::process;
@@ -75,8 +91,8 @@ pub use crate::features::signals;
     unix,
     not(target_os = "android"),
     not(target_os = "fuchsia"),
+    not(target_os = "openbsd"),
     not(target_os = "redox"),
-    not(target_env = "musl"),
     feature = "utmpx"
 ))]
 pub use crate::features::utmpx;
@@ -84,12 +100,50 @@ pub use crate::features::utmpx;
 #[cfg(all(windows, feature = "wide"))]
 pub use crate::features::wide;
 
-//## core functions
+#[cfg(feature = "fsext")]
+pub use crate::features::fsext;
 
-use std::ffi::OsString;
-use std::sync::atomic::Ordering;
+#[cfg(all(unix, feature = "fsxattr"))]
+pub use crate::features::fsxattr;
 
-use once_cell::sync::Lazy;
+#[cfg(all(target_os = "linux", feature = "selinux"))]
+pub use crate::features::selinux;
+
+//## core functions
+
+#[cfg(unix)]
+use nix::errno::Errno;
+#[cfg(unix)]
+use nix::sys::signal::{
+    SaFlags, SigAction, SigHandler::SigDfl, SigSet, Signal::SIGBUS, Signal::SIGSEGV, sigaction,
+};
+use std::borrow::Cow;
+use std::ffi::{OsStr, OsString};
+use std::io::{BufRead, BufReader};
+use std::iter;
+#[cfg(unix)]
+use std::os::unix::ffi::{OsStrExt, OsStringExt};
+use std::str;
+use std::sync::{LazyLock, atomic::Ordering};
+
+/// Disables the custom signal handlers installed by Rust for stack-overflow handling. With those custom signal handlers processes ignore the first SIGBUS and SIGSEGV signal they receive.
+/// See <https://github.com/rust-lang/rust/blob/8ac1525e091d3db28e67adcbbd6db1e1deaa37fb/src/libstd/sys/unix/stack_overflow.rs#L71-L92> for details.
+#[cfg(unix)]
+pub fn disable_rust_signal_handlers() -> Result<(), Errno> {
+    unsafe {
+        sigaction(
+            SIGSEGV,
+            &SigAction::new(SigDfl, SaFlags::empty(), SigSet::all()),
+        )
+    }?;
+    unsafe {
+        sigaction(
+            SIGBUS,
+            &SigAction::new(SigDfl, SaFlags::empty(), SigSet::all()),
+        )
+    }?;
+    Ok(())
+}
 
 /// Execute utility code for `util`.
 ///
@@ -100,14 +154,39 @@ macro_rules! bin {
     ($util:ident) => {
         pub fn main() {
             use std::io::Write;
-            uucore::panic::mute_sigpipe_panic(); // suppress extraneous error output for SIGPIPE failures/panics
-            let code = $util::uumain(uucore::args_os()); // execute utility code
-            std::io::stdout().flush().expect("could not flush stdout"); // (defensively) flush stdout for utility prior to exit; see <https://github.com/rust-lang/rust/issues/23818>
+            // suppress extraneous error output for SIGPIPE failures/panics
+            uucore::panic::mute_sigpipe_panic();
+            // execute utility code
+            let code = $util::uumain(uucore::args_os());
+            // (defensively) flush stdout for utility prior to exit; see <https://github.com/rust-lang/rust/issues/23818>
+            if let Err(e) = std::io::stdout().flush() {
+                eprintln!("Error flushing stdout: {e}");
+            }
+
             std::process::exit(code);
         }
     };
 }
 
+/// Generate the version string for clap.
+///
+/// The generated string has the format `(<project name>) <version>`, for
+/// example: "(uutils coreutils) 0.30.0". clap will then prefix it with the util name.
+///
+/// To use this macro, you have to add `PROJECT_NAME_FOR_VERSION_STRING = "<project name>"` to the
+/// `[env]` section in `.cargo/config.toml`.
+#[macro_export]
+macro_rules! crate_version {
+    () => {
+        concat!(
+            "(",
+            env!("PROJECT_NAME_FOR_VERSION_STRING"),
+            ") ",
+            env!("CARGO_PKG_VERSION")
+        )
+    };
+}
+
 /// Generate the usage string for clap.
 ///
 /// This function does two things. It indents all but the first line to align
@@ -120,19 +199,23 @@ pub fn format_usage(s: &str) -> String {
     s.replace("{}", crate::execution_phrase())
 }
 
+/// Used to check if the utility is the second argument.
+/// Used to check if we were called as a multicall binary (`coreutils <utility>`)
 pub fn get_utility_is_second_arg() -> bool {
     crate::macros::UTILITY_IS_SECOND_ARG.load(Ordering::SeqCst)
 }
 
+/// Change the value of `UTILITY_IS_SECOND_ARG` to true
+/// Used to specify that the utility is the second argument.
 pub fn set_utility_is_second_arg() {
     crate::macros::UTILITY_IS_SECOND_ARG.store(true, Ordering::SeqCst);
 }
 
 // args_os() can be expensive to call, it copies all of argv before iterating.
 // So if we want only the first arg or so it's overkill. We cache it.
-static ARGV: Lazy<Vec<OsString>> = Lazy::new(|| wild::args_os().collect());
+static ARGV: LazyLock<Vec<OsString>> = LazyLock::new(|| wild::args_os().collect());
 
-static UTIL_NAME: Lazy<String> = Lazy::new(|| {
+static UTIL_NAME: LazyLock<String> = LazyLock::new(|| {
     let base_index = usize::from(get_utility_is_second_arg());
     let is_man = usize::from(ARGV[base_index].eq("manpage"));
     let argv_index = base_index + is_man;
@@ -145,7 +228,7 @@ pub fn util_name() -> &'static str {
     &UTIL_NAME
 }
 
-static EXECUTION_PHRASE: Lazy<String> = Lazy::new(|| {
+static EXECUTION_PHRASE: LazyLock<String> = LazyLock::new(|| {
     if get_utility_is_second_arg() {
         ARGV.iter()
             .take(2)
@@ -162,6 +245,10 @@ pub fn execution_phrase() -> &'static str {
     &EXECUTION_PHRASE
 }
 
+/// Args contains arguments passed to the utility.
+/// It is a trait that extends `Iterator<Item = OsString>`.
+/// It provides utility functions to collect the arguments into a `Vec<String>`.
+/// The collected `Vec<String>` can be lossy or ignore invalid encoding.
 pub trait Args: Iterator<Item = OsString> + Sized {
     /// Collects the iterator into a `Vec<String>`, lossily converting the `OsString`s to `Strings`.
     fn collect_lossy(self) -> Vec<String> {
@@ -176,6 +263,8 @@ pub trait Args: Iterator<Item = OsString> + Sized {
 
 impl<T: Iterator<Item = OsString> + Sized> Args for T {}
 
+/// Returns an iterator over the command line arguments as `OsString`s.
+/// args_os() can be expensive to call
 pub fn args_os() -> impl Iterator<Item = OsString> {
     ARGV.iter().cloned()
 }
@@ -189,6 +278,107 @@ pub fn read_yes() -> bool {
     }
 }
 
+/// Converts an `OsStr` to a UTF-8 `&[u8]`.
+///
+/// This always succeeds on unix platforms,
+/// and fails on other platforms if the string can't be coerced to UTF-8.
+pub fn os_str_as_bytes(os_string: &OsStr) -> mods::error::UResult<&[u8]> {
+    #[cfg(unix)]
+    let bytes = os_string.as_bytes();
+
+    #[cfg(not(unix))]
+    let bytes = os_string
+        .to_str()
+        .ok_or_else(|| {
+            mods::error::UUsageError::new(1, "invalid UTF-8 was detected in one or more arguments")
+        })?
+        .as_bytes();
+
+    Ok(bytes)
+}
+
+/// Performs a potentially lossy conversion from `OsStr` to UTF-8 bytes.
+///
+/// This is always lossless on unix platforms,
+/// and wraps [`OsStr::to_string_lossy`] on non-unix platforms.
+pub fn os_str_as_bytes_lossy(os_string: &OsStr) -> Cow<[u8]> {
+    #[cfg(unix)]
+    let bytes = Cow::from(os_string.as_bytes());
+
+    #[cfg(not(unix))]
+    let bytes = match os_string.to_string_lossy() {
+        Cow::Borrowed(slice) => Cow::from(slice.as_bytes()),
+        Cow::Owned(owned) => Cow::from(owned.into_bytes()),
+    };
+
+    bytes
+}
+
+/// Converts a `&[u8]` to an `&OsStr`,
+/// or parses it as UTF-8 into an [`OsString`] on non-unix platforms.
+///
+/// This always succeeds on unix platforms,
+/// and fails on other platforms if the bytes can't be parsed as UTF-8.
+pub fn os_str_from_bytes(bytes: &[u8]) -> mods::error::UResult<Cow<'_, OsStr>> {
+    #[cfg(unix)]
+    let os_str = Cow::Borrowed(OsStr::from_bytes(bytes));
+    #[cfg(not(unix))]
+    let os_str = Cow::Owned(OsString::from(str::from_utf8(bytes).map_err(|_| {
+        mods::error::UUsageError::new(1, "Unable to transform bytes into OsStr")
+    })?));
+
+    Ok(os_str)
+}
+
+/// Converts a `Vec<u8>` into an `OsString`, parsing as UTF-8 on non-unix platforms.
+///
+/// This always succeeds on unix platforms,
+/// and fails on other platforms if the bytes can't be parsed as UTF-8.
+pub fn os_string_from_vec(vec: Vec<u8>) -> mods::error::UResult<OsString> {
+    #[cfg(unix)]
+    let s = OsString::from_vec(vec);
+    #[cfg(not(unix))]
+    let s = OsString::from(String::from_utf8(vec).map_err(|_| {
+        mods::error::UUsageError::new(1, "invalid UTF-8 was detected in one or more arguments")
+    })?);
+
+    Ok(s)
+}
+
+/// Equivalent to `std::BufRead::lines` which outputs each line as a `Vec<u8>`,
+/// which avoids panicking on non UTF-8 input.
+pub fn read_byte_lines<R: std::io::Read>(
+    mut buf_reader: BufReader<R>,
+) -> impl Iterator<Item = Vec<u8>> {
+    iter::from_fn(move || {
+        let mut buf = Vec::with_capacity(256);
+        let size = buf_reader.read_until(b'\n', &mut buf).ok()?;
+
+        if size == 0 {
+            return None;
+        }
+
+        // Trim (\r)\n
+        if buf.ends_with(b"\n") {
+            buf.pop();
+            if buf.ends_with(b"\r") {
+                buf.pop();
+            }
+        }
+
+        Some(buf)
+    })
+}
+
+/// Equivalent to `std::BufRead::lines` which outputs each line as an `OsString`
+/// This won't panic on non UTF-8 characters on Unix,
+/// but it still will on Windows.
+pub fn read_os_string_lines<R: std::io::Read>(
+    buf_reader: BufReader<R>,
+) -> impl Iterator<Item = OsString> {
+    read_byte_lines(buf_reader).map(|byte_line| os_string_from_vec(byte_line).expect("UTF-8 error"))
+}
+
 /// Prompt the user with a formatted string and returns `true` if they reply `'y'` or `'Y'`
 ///
 /// This macro functions accepts the same syntax as `format!`. The prompt is written to
@@ -199,7 +389,7 @@ pub fn read_yes() -> bool {
 /// ```
 /// use uucore::prompt_yes;
 /// let file = "foo.rs";
-/// prompt_yes!("Do you want to delete '{}'?", file);
+/// prompt_yes!("Do you want to delete '{file}'?");
 /// ```
 /// will print something like below to `stderr` (with `util_name` substituted by the actual
 /// util name) and will wait for user input.
@@ -213,7 +403,10 @@ macro_rules! prompt_yes(
         eprint!("{}: ", uucore::util_name());
         eprint!($($args)+);
         eprint!(" ");
-        uucore::crash_if_err!(1, std::io::stderr().flush());
+        let res = std::io::stderr().flush().map_err(|err| {
+            $crate::error::USimpleError::new(1, err.to_string())
+        });
+        uucore::show_if_err!(res);
         uucore::read_yes()
     })
 );
diff --git a/src/uucore/src/lib/macros.rs b/src/uucore/src/lib/macros.rs
index ad86d530828..068c06519dc 100644
--- a/src/uucore/src/lib/macros.rs
+++ b/src/uucore/src/lib/macros.rs
@@ -3,8 +3,6 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// TODO fix broken links
-#![allow(rustdoc::broken_intra_doc_links)]
 //! Macros for the uucore utilities.
 //!
 //! This module bundles all macros used across the uucore utilities. These
@@ -22,18 +20,16 @@
 //! fully qualified name like this:
 //!
 //! ```no_run
-//! use uucore::{show, crash};
+//! use uucore::show;
 //! ```
 //!
 //! Here's an overview of the macros sorted by purpose
 //!
 //! - Print errors
-//!   - From types implementing [`crate::error::UError`]: [`show!`],
-//!     [`show_if_err!`]
-//!   - From custom messages: [`show_error!`]
-//! - Print warnings: [`show_warning!`]
-//! - Terminate util execution
-//!   - Crash program: [`crash!`], [`crash_if_err!`]
+//!   - From types implementing [`crate::error::UError`]: [`crate::show!`],
+//!     [`crate::show_if_err!`]
+//!   - From custom messages: [`crate::show_error!`]
+//! - Print warnings: [`crate::show_warning!`]
 
 // spell-checker:ignore sourcepath targetpath rustdoc
 
@@ -91,16 +87,18 @@ pub static UTILITY_IS_SECOND_ARG: AtomicBool = AtomicBool::new(false);
 #[macro_export]
 macro_rules! show(
     ($err:expr) => ({
+        #[allow(unused_imports)]
+        use $crate::error::UError;
         let e = $err;
         $crate::error::set_exit_code(e.code());
-        eprintln!("{}: {}", $crate::util_name(), e);
+        eprintln!("{}: {e}", $crate::util_name());
     })
 );
 
 /// Display an error and set global exit code in error case.
 ///
-/// Wraps around [`show!`] and takes a [`crate::error::UResult`] instead of a
-/// [`crate::error::UError`] type. This macro invokes [`show!`] if the
+/// Wraps around [`crate::show!`] and takes a [`crate::error::UResult`] instead of a
+/// [`crate::error::UError`] type. This macro invokes [`crate::show!`] if the
 /// [`crate::error::UResult`] is an `Err`-variant. This can be invoked directly
 /// on the result of a function call, like in the `install` utility:
 ///
@@ -131,7 +129,7 @@ macro_rules! show(
 macro_rules! show_if_err(
     ($res:expr) => ({
         if let Err(e) = $res {
-            show!(e);
+            $crate::show!(e);
         }
     })
 );
@@ -181,56 +179,11 @@ macro_rules! show_warning(
     })
 );
 
-/// Display an error and [`std::process::exit`]
-///
-/// Displays the provided error message using [`show_error!`], then invokes
-/// [`std::process::exit`] with the provided exit code.
-///
-/// # Examples
-///
-/// ```should_panic
-/// # #[macro_use]
-/// # extern crate uucore;
-/// # fn main() {
-/// // outputs <name>: Couldn't apply foo to bar
-/// // and terminates execution
-/// crash!(1, "Couldn't apply {} to {}", "foo", "bar");
-/// # }
-/// ```
+/// Print a warning message to stderr, prepending the utility name.
 #[macro_export]
-macro_rules! crash(
-    ($exit_code:expr, $($args:tt)+) => ({
-        $crate::show_error!($($args)+);
-        std::process::exit($exit_code);
+macro_rules! show_warning_caps(
+    ($($args:tt)+) => ({
+        eprint!("{}: WARNING: ", $crate::util_name());
+        eprintln!($($args)+);
     })
 );
-
-/// Unwrap a [`std::result::Result`], crashing instead of panicking.
-///
-/// If the result is an `Ok`-variant, returns the value contained inside. If it
-/// is an `Err`-variant, invokes [`crash!`] with the formatted error instead.
-///
-/// # Examples
-///
-/// ```should_panic
-/// # #[macro_use]
-/// # extern crate uucore;
-/// # fn main() {
-/// let is_ok: Result<u32, &str> = Ok(1);
-/// // Does nothing
-/// crash_if_err!(1, is_ok);
-///
-/// let is_err: Result<u32, &str> = Err("This didn't work...");
-/// // Calls `crash!`
-/// crash_if_err!(1, is_err);
-/// # }
-/// ```
-#[macro_export]
-macro_rules! crash_if_err(
-    ($exit_code:expr, $exp:expr) => (
-        match $exp {
-            Ok(m) => m,
-            Err(f) => $crate::crash!($exit_code, "{}", f),
-        }
-    )
-);
diff --git a/src/uucore/src/lib/mods.rs b/src/uucore/src/lib/mods.rs
index caa8fcb9290..7af54ff5a6a 100644
--- a/src/uucore/src/lib/mods.rs
+++ b/src/uucore/src/lib/mods.rs
@@ -6,9 +6,10 @@
 
 pub mod display;
 pub mod error;
+#[cfg(feature = "fs")]
+pub mod io;
 pub mod line_ending;
+pub mod locale;
 pub mod os;
 pub mod panic;
-pub mod version_cmp;
-// dir and vdir also need access to the quoting_style module
-pub mod quoting_style;
+pub mod posix;
diff --git a/src/uucore/src/lib/mods/display.rs b/src/uucore/src/lib/mods/display.rs
index db92c488727..78ffe7a4f7e 100644
--- a/src/uucore/src/lib/mods/display.rs
+++ b/src/uucore/src/lib/mods/display.rs
@@ -2,29 +2,31 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-/// Utilities for printing paths, with special attention paid to special
-/// characters and invalid unicode.
-///
-/// For displaying paths in informational messages use `Quotable::quote`. This
-/// will wrap quotes around the filename and add the necessary escapes to make
-/// it copy/paste-able into a shell.
-///
-/// For writing raw paths to stdout when the output should not be quoted or escaped,
-/// use `println_verbatim`. This will preserve invalid unicode.
-///
-/// # Examples
-/// ```
-/// use std::path::Path;
-/// use uucore::display::{Quotable, println_verbatim};
-///
-/// let path = Path::new("foo/bar.baz");
-///
-/// println!("Found file {}", path.quote()); // Prints "Found file 'foo/bar.baz'"
-/// println_verbatim(path)?; // Prints "foo/bar.baz"
-/// # Ok::<(), std::io::Error>(())
-/// ```
+//! Utilities for printing paths, with special attention paid to special
+//! characters and invalid unicode.
+//!
+//! For displaying paths in informational messages use `Quotable::quote`. This
+//! will wrap quotes around the filename and add the necessary escapes to make
+//! it copy/paste-able into a shell.
+//!
+//! For writing raw paths to stdout when the output should not be quoted or escaped,
+//! use `println_verbatim`. This will preserve invalid unicode.
+//!
+//! # Examples
+//! ```rust
+//! use std::path::Path;
+//! use uucore::display::{Quotable, println_verbatim};
+//!
+//! let path = Path::new("foo/bar.baz");
+//!
+//! println!("Found file {}", path.quote()); // Prints "Found file 'foo/bar.baz'"
+//! println_verbatim(path)?; // Prints "foo/bar.baz"
+//! # Ok::<(), std::io::Error>(())
+//! ```
+
 use std::ffi::OsStr;
-use std::io::{self, Write as IoWrite};
+use std::fs::File;
+use std::io::{self, BufWriter, Stdout, StdoutLock, Write as IoWrite};
 
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
@@ -41,33 +43,77 @@ pub use os_display::{Quotable, Quoted};
 /// output is likely to be captured, like `pwd` and `basename`. For informational output
 /// use `Quotable::quote`.
 ///
-/// FIXME: This is lossy on Windows. It could probably be implemented using some low-level
-/// API that takes UTF-16, without going through io::Write. This is not a big priority
+/// FIXME: Invalid Unicode will produce an error on Windows. That could be fixed by
+/// using low-level library calls and bypassing `io::Write`. This is not a big priority
 /// because broken filenames are much rarer on Windows than on Unix.
 pub fn println_verbatim<S: AsRef<OsStr>>(text: S) -> io::Result<()> {
-    let stdout = io::stdout();
-    let mut stdout = stdout.lock();
-    #[cfg(any(unix, target_os = "wasi"))]
-    {
-        stdout.write_all(text.as_ref().as_bytes())?;
-        stdout.write_all(b"\n")?;
-    }
-    #[cfg(not(any(unix, target_os = "wasi")))]
-    {
-        writeln!(stdout, "{}", std::path::Path::new(text.as_ref()).display())?;
-    }
+    let mut stdout = io::stdout().lock();
+    stdout.write_all_os(text.as_ref())?;
+    stdout.write_all(b"\n")?;
     Ok(())
 }
 
 /// Like `println_verbatim`, without the trailing newline.
 pub fn print_verbatim<S: AsRef<OsStr>>(text: S) -> io::Result<()> {
-    let mut stdout = io::stdout();
-    #[cfg(any(unix, target_os = "wasi"))]
-    {
-        stdout.write_all(text.as_ref().as_bytes())
+    io::stdout().write_all_os(text.as_ref())
+}
+
+/// [`io::Write`], but for OS strings.
+///
+/// On Unix this works straightforwardly.
+///
+/// On Windows this currently returns an error if the OS string is not valid Unicode.
+/// This may in the future change to allow those strings to be written to consoles.
+pub trait OsWrite: io::Write {
+    /// Write the entire OS string into this writer.
+    ///
+    /// # Errors
+    ///
+    /// An error is returned if the underlying I/O operation fails.
+    ///
+    /// On Windows, if the OS string is not valid Unicode, an error of kind
+    /// [`io::ErrorKind::InvalidData`] is returned.
+    fn write_all_os(&mut self, buf: &OsStr) -> io::Result<()> {
+        #[cfg(any(unix, target_os = "wasi"))]
+        {
+            self.write_all(buf.as_bytes())
+        }
+
+        #[cfg(not(any(unix, target_os = "wasi")))]
+        {
+            // It's possible to write a better OsWrite impl for Windows consoles (e.g. Stdout)
+            // as those are fundamentally 16-bit. If the OS string is invalid then it can be
+            // encoded to 16-bit and written using raw windows_sys calls. But this is quite involved
+            // (see `sys/pal/windows/stdio.rs` in the stdlib) and the value-add is small.
+            //
+            // There's no way to write invalid OS strings to Windows files, as those are 8-bit.
+
+            match buf.to_str() {
+                Some(text) => self.write_all(text.as_bytes()),
+                // We could output replacement characters instead, but the
+                // stdlib errors when sending invalid UTF-8 to the console,
+                // so let's follow that.
+                None => Err(io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    "OS string cannot be converted to bytes",
+                )),
+            }
+        }
     }
-    #[cfg(not(any(unix, target_os = "wasi")))]
-    {
-        write!(stdout, "{}", std::path::Path::new(text.as_ref()).display())
+}
+
+// We do not have a blanket impl for all Write because a smarter Windows impl should
+// be able to make use of AsRawHandle. Please keep this in mind when adding new impls.
+impl OsWrite for File {}
+impl OsWrite for Stdout {}
+impl OsWrite for StdoutLock<'_> {}
+// A future smarter Windows implementation can first flush the BufWriter before
+// doing a raw write.
+impl<W: OsWrite> OsWrite for BufWriter<W> {}
+
+impl OsWrite for Box<dyn OsWrite> {
+    fn write_all_os(&mut self, buf: &OsStr) -> io::Result<()> {
+        let this: &mut dyn OsWrite = self;
+        this.write_all_os(buf)
     }
 }
diff --git a/src/uucore/src/lib/mods/error.rs b/src/uucore/src/lib/mods/error.rs
index 82644ae8a50..0b88e389b65 100644
--- a/src/uucore/src/lib/mods/error.rs
+++ b/src/uucore/src/lib/mods/error.rs
@@ -2,8 +2,6 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// TODO fix broken links
-#![allow(rustdoc::broken_intra_doc_links)]
 //! All utils return exit with an exit code. Usually, the following scheme is used:
 //! * `0`: succeeded
 //! * `1`: minor problems
@@ -31,9 +29,9 @@
 //! * When `Ok` is returned, the code set with [`set_exit_code`] is used as exit code. If
 //!   [`set_exit_code`] was not used, then `0` is used.
 //! * When `Err` is returned, the code corresponding with the error is used as exit code and the
-//! error message is displayed.
+//!   error message is displayed.
 //!
-//! Additionally, the errors can be displayed manually with the [`show`] and [`show_if_err`] macros:
+//! Additionally, the errors can be displayed manually with the [`crate::show`] and [`crate::show_if_err`] macros:
 //! ```ignore
 //! let res = Err(USimpleError::new(1, "Error!!"));
 //! show_if_err!(res);
@@ -43,7 +41,7 @@
 //! }
 //! ```
 //!
-//! **Note**: The [`show`] and [`show_if_err`] macros set the exit code of the program using
+//! **Note**: The [`crate::show`] and [`crate::show_if_err`] macros set the exit code of the program using
 //! [`set_exit_code`]. See the documentation on that function for more information.
 //!
 //! # Guidelines
@@ -56,7 +54,6 @@
 
 // spell-checker:ignore uioerror rustdoc
 
-use clap;
 use std::{
     error::Error,
     fmt::{Display, Formatter},
@@ -288,11 +285,15 @@ where
 /// ```
 #[derive(Debug)]
 pub struct USimpleError {
+    /// Exit code of the error.
     pub code: i32,
+
+    /// Error message.
     pub message: String,
 }
 
 impl USimpleError {
+    /// Create a new `USimpleError` with a given exit code and message.
     #[allow(clippy::new_ret_no_self)]
     pub fn new<S: Into<String>>(code: i32, message: S) -> Box<dyn UError> {
         Box::new(Self {
@@ -316,14 +317,19 @@ impl UError for USimpleError {
     }
 }
 
+/// Wrapper type around [`std::io::Error`].
 #[derive(Debug)]
 pub struct UUsageError {
+    /// Exit code of the error.
     pub code: i32,
+
+    /// Error message.
     pub message: String,
 }
 
 impl UUsageError {
     #[allow(clippy::new_ret_no_self)]
+    /// Create a new `UUsageError` with a given exit code and message.
     pub fn new<S: Into<String>>(code: i32, message: S) -> Box<dyn UError> {
         Box::new(Self {
             code,
@@ -384,6 +390,7 @@ pub struct UIoError {
 
 impl UIoError {
     #[allow(clippy::new_ret_no_self)]
+    /// Create a new `UIoError` with a given exit code and message.
     pub fn new<S: Into<String>>(kind: std::io::ErrorKind, context: S) -> Box<dyn UError> {
         Box::new(Self {
             context: Some(context.into()),
@@ -460,13 +467,14 @@ pub fn strip_errno(err: &std::io::Error) -> String {
 /// Enables the conversion from [`std::io::Error`] to [`UError`] and from [`std::io::Result`] to
 /// [`UResult`].
 pub trait FromIo<T> {
+    /// Map the error context of an [`std::io::Error`] or [`std::io::Result`] to a custom error
     fn map_err_context(self, context: impl FnOnce() -> String) -> T;
 }
 
 impl FromIo<Box<UIoError>> for std::io::Error {
     fn map_err_context(self, context: impl FnOnce() -> String) -> Box<UIoError> {
         Box::new(UIoError {
-            context: Some((context)()),
+            context: Some(context()),
             inner: self,
         })
     }
@@ -481,7 +489,7 @@ impl<T> FromIo<UResult<T>> for std::io::Result<T> {
 impl FromIo<Box<UIoError>> for std::io::ErrorKind {
     fn map_err_context(self, context: impl FnOnce() -> String) -> Box<UIoError> {
         Box::new(UIoError {
-            context: Some((context)()),
+            context: Some(context()),
             inner: std::io::Error::new(self, ""),
         })
     }
@@ -522,7 +530,7 @@ 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| {
             Box::new(UIoError {
-                context: Some((context)()),
+                context: Some(context()),
                 inner: std::io::Error::from_raw_os_error(e as i32),
             }) as Box<dyn UError>
         })
@@ -533,7 +541,7 @@ impl<T> FromIo<UResult<T>> for Result<T, nix::Error> {
 impl<T> FromIo<UResult<T>> for nix::Error {
     fn map_err_context(self, context: impl FnOnce() -> String) -> UResult<T> {
         Err(Box::new(UIoError {
-            context: Some((context)()),
+            context: Some(context()),
             inner: std::io::Error::from_raw_os_error(self as i32),
         }) as Box<dyn UError>)
     }
@@ -587,9 +595,9 @@ impl From<nix::Error> for Box<dyn UError> {
 /// let other_uio_err = uio_error!(io_err, "Error code: {}", 2);
 ///
 /// // prints "fix me please!: Permission denied"
-/// println!("{}", uio_err);
+/// println!("{uio_err}");
 /// // prints "Error code: 2: Permission denied"
-/// println!("{}", other_uio_err);
+/// println!("{other_uio_err}");
 /// ```
 ///
 /// The [`std::fmt::Display`] impl of [`UIoError`] will then ensure that an
@@ -611,7 +619,7 @@ impl From<nix::Error> for Box<dyn UError> {
 /// let other_uio_err = uio_error!(io_err, "");
 ///
 /// // prints: ": Permission denied"
-/// println!("{}", other_uio_err);
+/// println!("{other_uio_err}");
 /// ```
 //#[macro_use]
 #[macro_export]
@@ -643,6 +651,7 @@ pub struct ExitCode(pub i32);
 
 impl ExitCode {
     #[allow(clippy::new_ret_no_self)]
+    /// Create a new `ExitCode` with a given exit code.
     pub fn new(code: i32) -> Box<dyn UError> {
         Box::new(Self(code))
     }
@@ -695,6 +704,7 @@ pub struct ClapErrorWrapper {
 
 /// Extension trait for `clap::Error` to adjust the exit code.
 pub trait UClapError<T> {
+    /// Set the exit code for the program if `uumain` returns `Ok(())`.
     fn with_exit_code(self, code: i32) -> T;
 }
 
diff --git a/src/uucore/src/lib/mods/io.rs b/src/uucore/src/lib/mods/io.rs
new file mode 100644
index 00000000000..c83c3d98744
--- /dev/null
+++ b/src/uucore/src/lib/mods/io.rs
@@ -0,0 +1,98 @@
+// 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.
+
+//! Encapsulates differences between OSs regarding the access to
+//! file handles / descriptors.
+//! This is useful when dealing with lower level stdin/stdout access.
+//!
+//! In detail:
+//! On unix like OSs, file _descriptors_ are used in this context.
+//! On windows OSs, file _handles_ are used.
+//!
+//! Even though they are distinct classes, they share common functionality.
+//! Access to this common functionality is provided in `OwnedFileDescriptorOrHandle`.
+
+#[cfg(not(windows))]
+use std::os::fd::{AsFd, OwnedFd};
+#[cfg(windows)]
+use std::os::windows::io::{AsHandle, OwnedHandle};
+use std::{
+    fs::{File, OpenOptions},
+    io,
+    path::Path,
+    process::Stdio,
+};
+
+#[cfg(windows)]
+type NativeType = OwnedHandle;
+#[cfg(not(windows))]
+type NativeType = OwnedFd;
+
+/// abstraction wrapper for native file handle / file descriptor
+pub struct OwnedFileDescriptorOrHandle {
+    fx: NativeType,
+}
+
+impl OwnedFileDescriptorOrHandle {
+    /// create from underlying native type
+    pub fn new(x: NativeType) -> Self {
+        Self { fx: x }
+    }
+
+    /// create by opening a file
+    pub fn open_file(options: &OpenOptions, path: &Path) -> io::Result<Self> {
+        let f = options.open(path)?;
+        Self::from(f)
+    }
+
+    /// conversion from borrowed native type
+    ///
+    /// e.g. `std::io::stdout()`, `std::fs::File`, ...
+    #[cfg(windows)]
+    pub fn from<T: AsHandle>(t: T) -> io::Result<Self> {
+        Ok(Self {
+            fx: t.as_handle().try_clone_to_owned()?,
+        })
+    }
+
+    /// conversion from borrowed native type
+    ///
+    /// e.g. `std::io::stdout()`, `std::fs::File`, ...
+    #[cfg(not(windows))]
+    pub fn from<T: AsFd>(t: T) -> io::Result<Self> {
+        Ok(Self {
+            fx: t.as_fd().try_clone_to_owned()?,
+        })
+    }
+
+    /// instantiates a corresponding `File`
+    pub fn into_file(self) -> File {
+        File::from(self.fx)
+    }
+
+    /// instantiates a corresponding `Stdio`
+    pub fn into_stdio(self) -> Stdio {
+        Stdio::from(self.fx)
+    }
+
+    /// clones self. useful when needing another
+    /// owned reference to same file
+    pub fn try_clone(&self) -> io::Result<Self> {
+        self.fx.try_clone().map(Self::new)
+    }
+
+    /// provides native type to be used with
+    /// OS specific functions without abstraction
+    pub fn as_raw(&self) -> &NativeType {
+        &self.fx
+    }
+}
+
+/// instantiates a corresponding `Stdio`
+impl From<OwnedFileDescriptorOrHandle> for Stdio {
+    fn from(value: OwnedFileDescriptorOrHandle) -> Self {
+        value.into_stdio()
+    }
+}
diff --git a/src/uucore/src/lib/mods/line_ending.rs b/src/uucore/src/lib/mods/line_ending.rs
index 6fe608e7d9e..b7fefe97ebb 100644
--- a/src/uucore/src/lib/mods/line_ending.rs
+++ b/src/uucore/src/lib/mods/line_ending.rs
@@ -19,7 +19,10 @@ use std::fmt::Display;
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub enum LineEnding {
     #[default]
+    /// Newline character (`\n`)
     Newline = b'\n',
+
+    /// Null character (`\0`)
     Nul = 0,
 }
 
diff --git a/src/uucore/src/lib/mods/locale.rs b/src/uucore/src/lib/mods/locale.rs
new file mode 100644
index 00000000000..858c0508922
--- /dev/null
+++ b/src/uucore/src/lib/mods/locale.rs
@@ -0,0 +1,1041 @@
+// 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.
+// spell-checker:disable
+
+use crate::error::UError;
+use fluent::{FluentArgs, FluentBundle, FluentResource};
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+use std::sync::OnceLock;
+use thiserror::Error;
+use unic_langid::LanguageIdentifier;
+
+#[derive(Error, Debug)]
+pub enum LocalizationError {
+    #[error("I/O error loading '{path}': {source}")]
+    Io {
+        source: std::io::Error,
+        path: PathBuf,
+    },
+    #[error("Parse error: {0}")]
+    Parse(String),
+    #[error("Bundle error: {0}")]
+    Bundle(String),
+    #[error("Locales directory not found: {0}")]
+    LocalesDirNotFound(String),
+    #[error("Path resolution error: {0}")]
+    PathResolution(String),
+}
+
+impl From<std::io::Error> for LocalizationError {
+    fn from(error: std::io::Error) -> Self {
+        LocalizationError::Io {
+            source: error,
+            path: PathBuf::from("<unknown>"),
+        }
+    }
+}
+
+// Add a generic way to convert LocalizationError to UError
+impl UError for LocalizationError {
+    fn code(&self) -> i32 {
+        1
+    }
+}
+
+pub const DEFAULT_LOCALE: &str = "en-US";
+
+// A struct to handle localization with optional English fallback
+struct Localizer {
+    primary_bundle: FluentBundle<FluentResource>,
+    fallback_bundle: Option<FluentBundle<FluentResource>>,
+}
+
+impl Localizer {
+    fn new(primary_bundle: FluentBundle<FluentResource>) -> Self {
+        Self {
+            primary_bundle,
+            fallback_bundle: None,
+        }
+    }
+
+    fn with_fallback(mut self, fallback_bundle: FluentBundle<FluentResource>) -> Self {
+        self.fallback_bundle = Some(fallback_bundle);
+        self
+    }
+
+    fn format(&self, id: &str, args: Option<&FluentArgs>) -> String {
+        // Try primary bundle first
+        if let Some(message) = self.primary_bundle.get_message(id).and_then(|m| m.value()) {
+            let mut errs = Vec::new();
+            return self
+                .primary_bundle
+                .format_pattern(message, args, &mut errs)
+                .to_string();
+        }
+
+        // Fall back to English bundle if available
+        if let Some(ref fallback) = self.fallback_bundle {
+            if let Some(message) = fallback.get_message(id).and_then(|m| m.value()) {
+                let mut errs = Vec::new();
+                return fallback
+                    .format_pattern(message, args, &mut errs)
+                    .to_string();
+            }
+        }
+
+        // Return the key ID if not found anywhere
+        id.to_string()
+    }
+}
+
+// Global localizer stored in thread-local OnceLock
+thread_local! {
+    static LOCALIZER: OnceLock<Localizer> = const { OnceLock::new() };
+}
+
+// Initialize localization with a specific locale and config
+fn init_localization(
+    locale: &LanguageIdentifier,
+    locales_dir: &Path,
+) -> Result<(), LocalizationError> {
+    let en_locale = LanguageIdentifier::from_str(DEFAULT_LOCALE)
+        .expect("Default locale should always be valid");
+
+    let english_bundle = create_bundle(&en_locale, locales_dir)?;
+    let loc = if locale == &en_locale {
+        // If requesting English, just use English as primary (no fallback needed)
+        Localizer::new(english_bundle)
+    } else {
+        // Try to load the requested locale
+        if let Ok(primary_bundle) = create_bundle(locale, locales_dir) {
+            // Successfully loaded requested locale, load English as fallback
+            Localizer::new(primary_bundle).with_fallback(english_bundle)
+        } else {
+            // Failed to load requested locale, just use English as primary
+            Localizer::new(english_bundle)
+        }
+    };
+
+    LOCALIZER.with(|lock| {
+        lock.set(loc)
+            .map_err(|_| LocalizationError::Bundle("Localizer already initialized".into()))
+    })?;
+    Ok(())
+}
+
+// Create a bundle for a specific locale
+fn create_bundle(
+    locale: &LanguageIdentifier,
+    locales_dir: &Path,
+) -> Result<FluentBundle<FluentResource>, LocalizationError> {
+    let locale_path = locales_dir.join(format!("{locale}.ftl"));
+
+    let ftl_file = fs::read_to_string(&locale_path).map_err(|e| LocalizationError::Io {
+        source: e,
+        path: locale_path.clone(),
+    })?;
+
+    let resource = FluentResource::try_new(ftl_file).map_err(|_| {
+        LocalizationError::Parse(format!(
+            "Failed to parse localization resource for {}: {}",
+            locale,
+            locale_path.display()
+        ))
+    })?;
+
+    let mut bundle = FluentBundle::new(vec![locale.clone()]);
+
+    bundle.add_resource(resource).map_err(|errs| {
+        LocalizationError::Bundle(format!(
+            "Failed to add resource to bundle for {}: {:?}",
+            locale, errs
+        ))
+    })?;
+
+    Ok(bundle)
+}
+
+fn get_message_internal(id: &str, args: Option<FluentArgs>) -> String {
+    LOCALIZER.with(|lock| {
+        lock.get()
+            .map(|loc| loc.format(id, args.as_ref()))
+            .unwrap_or_else(|| id.to_string()) // Return the key ID if localizer not initialized
+    })
+}
+
+/// Retrieves a localized message by its identifier.
+///
+/// Looks up a message with the given ID in the current locale bundle and returns
+/// the localized text. If the message ID is not found in the current locale,
+/// it will fall back to English. If the message is not found in English either,
+/// returns the message ID itself.
+///
+/// # Arguments
+///
+/// * `id` - The message identifier in the Fluent resources
+///
+/// # Returns
+///
+/// A `String` containing the localized message, or the message ID if not found
+///
+/// # Examples
+///
+/// ```
+/// use uucore::locale::get_message;
+///
+/// // Get a localized greeting (from .ftl files)
+/// let greeting = get_message("greeting");
+/// println!("{}", greeting);
+/// ```
+pub fn get_message(id: &str) -> String {
+    get_message_internal(id, None)
+}
+
+/// Retrieves a localized message with variable substitution.
+///
+/// Looks up a message with the given ID in the current locale bundle,
+/// substitutes variables from the provided arguments map, and returns the
+/// localized text. If the message ID is not found in the current locale,
+/// it will fall back to English. If the message is not found in English either,
+/// returns the message ID itself.
+///
+/// # Arguments
+///
+/// * `id` - The message identifier in the Fluent resources
+/// * `ftl_args` - Key-value pairs for variable substitution in the message
+///
+/// # Returns
+///
+/// A `String` containing the localized message with variable substitution, or the message ID if not found
+///
+/// # Examples
+///
+/// ```
+/// use uucore::locale::get_message_with_args;
+/// use std::collections::HashMap;
+///
+/// // For a Fluent message like: "Hello, { $name }! You have { $count } notifications."
+/// let mut args = HashMap::new();
+/// args.insert("name".to_string(), "Alice".to_string());
+/// args.insert("count".to_string(), "3".to_string());
+///
+/// let message = get_message_with_args("notification", args);
+/// println!("{}", message);
+/// ```
+pub fn get_message_with_args(id: &str, ftl_args: HashMap<String, String>) -> String {
+    let mut args = FluentArgs::new();
+
+    for (key, value) in ftl_args {
+        // Try to parse as number first for proper pluralization support
+        if let Ok(num_val) = value.parse::<i64>() {
+            args.set(key, num_val);
+        } else if let Ok(float_val) = value.parse::<f64>() {
+            args.set(key, float_val);
+        } else {
+            // Keep as string if not a number
+            args.set(key, value);
+        }
+    }
+
+    get_message_internal(id, Some(args))
+}
+
+// Function to detect system locale from environment variables
+fn detect_system_locale() -> Result<LanguageIdentifier, LocalizationError> {
+    let locale_str = std::env::var("LANG")
+        .unwrap_or_else(|_| DEFAULT_LOCALE.to_string())
+        .split('.')
+        .next()
+        .unwrap_or(DEFAULT_LOCALE)
+        .to_string();
+
+    LanguageIdentifier::from_str(&locale_str)
+        .map_err(|_| LocalizationError::Parse(format!("Failed to parse locale: {}", locale_str)))
+}
+
+/// Sets up localization using the system locale with English fallback.
+///
+/// This function initializes the localization system based on the system's locale
+/// preferences (via the LANG environment variable) or falls back to English
+/// if the system locale cannot be determined or the locale file doesn't exist.
+/// English is always loaded as a fallback.
+///
+/// # Arguments
+///
+/// * `p` - Path to the directory containing localization (.ftl) files
+///
+/// # Returns
+///
+/// * `Ok(())` if initialization succeeds
+/// * `Err(LocalizationError)` if initialization fails
+///
+/// # Errors
+///
+/// Returns a `LocalizationError` if:
+/// * The en-US.ftl file cannot be read (English is required)
+/// * The files contain invalid Fluent syntax
+/// * The bundle cannot be initialized properly
+///
+/// # Examples
+///
+/// ```
+/// use uucore::locale::setup_localization;
+///
+/// // Initialize localization using files in the "locales" directory
+/// // Make sure you have at least an "en-US.ftl" file in this directory
+/// // Other locale files like "fr-FR.ftl" are optional
+/// match setup_localization("./locales") {
+///     Ok(_) => println!("Localization initialized successfully"),
+///     Err(e) => eprintln!("Failed to initialize localization: {}", e),
+/// }
+/// ```
+pub fn setup_localization(p: &str) -> Result<(), LocalizationError> {
+    let locale = detect_system_locale().unwrap_or_else(|_| {
+        LanguageIdentifier::from_str(DEFAULT_LOCALE).expect("Default locale should always be valid")
+    });
+
+    let locales_dir = get_locales_dir(p)?;
+    init_localization(&locale, &locales_dir)
+}
+
+/// Helper function to get the locales directory based on the build configuration
+fn get_locales_dir(p: &str) -> Result<PathBuf, LocalizationError> {
+    #[cfg(debug_assertions)]
+    {
+        // During development, use the project's locales directory
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+        // from uucore path, load the locales directory from the program directory
+        let dev_path = PathBuf::from(manifest_dir)
+            .join("../uu")
+            .join(p)
+            .join("locales");
+
+        if dev_path.exists() {
+            return Ok(dev_path);
+        }
+
+        // Fallback for development if the expected path doesn't exist
+        let fallback_dev_path = PathBuf::from(manifest_dir).join(p);
+        if fallback_dev_path.exists() {
+            return Ok(fallback_dev_path);
+        }
+
+        Err(LocalizationError::LocalesDirNotFound(format!(
+            "Development locales directory not found at {} or {}",
+            dev_path.display(),
+            fallback_dev_path.display()
+        )))
+    }
+
+    #[cfg(not(debug_assertions))]
+    {
+        use std::env;
+        // In release builds, look relative to executable
+        let exe_path = env::current_exe().map_err(|e| {
+            LocalizationError::PathResolution(format!("Failed to get executable path: {}", e))
+        })?;
+
+        let exe_dir = exe_path.parent().ok_or_else(|| {
+            LocalizationError::PathResolution("Failed to get executable directory".to_string())
+        })?;
+
+        // Try the coreutils-style path first
+        let coreutils_path = exe_dir.join("locales").join(p);
+        if coreutils_path.exists() {
+            return Ok(coreutils_path);
+        }
+
+        // Fallback to just the parameter as a relative path
+        let fallback_path = exe_dir.join(p);
+        if fallback_path.exists() {
+            return Ok(fallback_path);
+        }
+
+        return Err(LocalizationError::LocalesDirNotFound(format!(
+            "Release locales directory not found at {} or {}",
+            coreutils_path.display(),
+            fallback_path.display()
+        )));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+    use std::env;
+    use std::fs;
+    use std::path::PathBuf;
+    use tempfile::TempDir;
+
+    // Helper function to create a temporary directory with test locale files
+    fn create_test_locales_dir() -> TempDir {
+        let temp_dir = TempDir::new().expect("Failed to create temp directory");
+
+        // Create en-US.ftl
+        let en_content = r#"
+greeting = Hello, world!
+welcome = Welcome, { $name }!
+count-items = You have { $count ->
+    [one] { $count } item
+   *[other] { $count } items
+}
+missing-in-other = This message only exists in English
+"#;
+
+        // Create fr-FR.ftl
+        let fr_content = r#"
+greeting = Bonjour, le monde!
+welcome = Bienvenue, { $name }!
+count-items = Vous avez { $count ->
+    [one] { $count } élément
+   *[other] { $count } éléments
+}
+"#;
+
+        // Create ja-JP.ftl (Japanese)
+        let ja_content = r#"
+greeting = �ん����世界�
+welcome = よ����{ $name }�ん�
+count-items = { $count }個�アイテム��り��
+"#;
+
+        // Create ar-SA.ftl (Arabic - Right-to-Left)
+        let ar_content = r#"
+greeting = أهلاً بالعالم�
+welcome = أهلاً وسهلاً، { $name }�
+count-items = لديك { $count ->
+    [zero] لا عناصر
+    [one] عنصر واحد
+    [two] عنصران
+    [few] { $count } عناصر
+   *[other] { $count } عنصر
+}
+"#;
+
+        // Create es-ES.ftl with invalid syntax
+        let es_invalid_content = r#"
+greeting = Hola, mundo!
+invalid-syntax = This is { $missing
+"#;
+
+        fs::write(temp_dir.path().join("en-US.ftl"), en_content)
+            .expect("Failed to write en-US.ftl");
+        fs::write(temp_dir.path().join("fr-FR.ftl"), fr_content)
+            .expect("Failed to write fr-FR.ftl");
+        fs::write(temp_dir.path().join("ja-JP.ftl"), ja_content)
+            .expect("Failed to write ja-JP.ftl");
+        fs::write(temp_dir.path().join("ar-SA.ftl"), ar_content)
+            .expect("Failed to write ar-SA.ftl");
+        fs::write(temp_dir.path().join("es-ES.ftl"), es_invalid_content)
+            .expect("Failed to write es-ES.ftl");
+
+        temp_dir
+    }
+
+    #[test]
+    fn test_localization_error_from_io_error() {
+        let io_error = std::io::Error::new(std::io::ErrorKind::NotFound, "File not found");
+        let loc_error = LocalizationError::from(io_error);
+
+        match loc_error {
+            LocalizationError::Io { source: _, path } => {
+                assert_eq!(path, PathBuf::from("<unknown>"));
+            }
+            _ => panic!("Expected IO error variant"),
+        }
+    }
+
+    #[test]
+    fn test_localization_error_uerror_impl() {
+        let error = LocalizationError::Parse("test error".to_string());
+        assert_eq!(error.code(), 1);
+    }
+
+    #[test]
+    fn test_create_bundle_success() {
+        let temp_dir = create_test_locales_dir();
+        let locale = LanguageIdentifier::from_str("en-US").unwrap();
+
+        let result = create_bundle(&locale, temp_dir.path());
+        assert!(result.is_ok());
+
+        let bundle = result.unwrap();
+        assert!(bundle.get_message("greeting").is_some());
+    }
+
+    #[test]
+    fn test_create_bundle_file_not_found() {
+        let temp_dir = TempDir::new().unwrap();
+        let locale = LanguageIdentifier::from_str("de-DE").unwrap();
+
+        let result = create_bundle(&locale, temp_dir.path());
+        assert!(result.is_err());
+
+        if let Err(LocalizationError::Io { source: _, path }) = result {
+            assert!(path.to_string_lossy().contains("de-DE.ftl"));
+        } else {
+            panic!("Expected IO error");
+        }
+    }
+
+    #[test]
+    fn test_create_bundle_invalid_syntax() {
+        let temp_dir = create_test_locales_dir();
+        let locale = LanguageIdentifier::from_str("es-ES").unwrap();
+
+        let result = create_bundle(&locale, temp_dir.path());
+        assert!(result.is_err());
+
+        if let Err(LocalizationError::Parse(_)) = result {
+            // Expected parse error
+        } else {
+            panic!("Expected parse error");
+        }
+    }
+
+    #[test]
+    fn test_localizer_format_primary_bundle() {
+        let temp_dir = create_test_locales_dir();
+        let en_bundle = create_bundle(
+            &LanguageIdentifier::from_str("en-US").unwrap(),
+            temp_dir.path(),
+        )
+        .unwrap();
+
+        let localizer = Localizer::new(en_bundle);
+        let result = localizer.format("greeting", None);
+        assert_eq!(result, "Hello, world!");
+    }
+
+    #[test]
+    fn test_localizer_format_with_args() {
+        let temp_dir = create_test_locales_dir();
+        let en_bundle = create_bundle(
+            &LanguageIdentifier::from_str("en-US").unwrap(),
+            temp_dir.path(),
+        )
+        .unwrap();
+
+        let localizer = Localizer::new(en_bundle);
+        let mut args = FluentArgs::new();
+        args.set("name", "Alice");
+
+        let result = localizer.format("welcome", Some(&args));
+        assert_eq!(result, "Welcome, \u{2068}Alice\u{2069}!");
+    }
+
+    #[test]
+    fn test_localizer_fallback_to_english() {
+        let temp_dir = create_test_locales_dir();
+        let fr_bundle = create_bundle(
+            &LanguageIdentifier::from_str("fr-FR").unwrap(),
+            temp_dir.path(),
+        )
+        .unwrap();
+        let en_bundle = create_bundle(
+            &LanguageIdentifier::from_str("en-US").unwrap(),
+            temp_dir.path(),
+        )
+        .unwrap();
+
+        let localizer = Localizer::new(fr_bundle).with_fallback(en_bundle);
+
+        // This message exists in French
+        let result1 = localizer.format("greeting", None);
+        assert_eq!(result1, "Bonjour, le monde!");
+
+        // This message only exists in English, should fallback
+        let result2 = localizer.format("missing-in-other", None);
+        assert_eq!(result2, "This message only exists in English");
+    }
+
+    #[test]
+    fn test_localizer_format_message_not_found() {
+        let temp_dir = create_test_locales_dir();
+        let en_bundle = create_bundle(
+            &LanguageIdentifier::from_str("en-US").unwrap(),
+            temp_dir.path(),
+        )
+        .unwrap();
+
+        let localizer = Localizer::new(en_bundle);
+        let result = localizer.format("nonexistent-message", None);
+        assert_eq!(result, "nonexistent-message");
+    }
+
+    #[test]
+    fn test_init_localization_english_only() {
+        // Run in a separate thread to avoid conflicts with other tests
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("en-US").unwrap();
+
+            let result = init_localization(&locale, temp_dir.path());
+            assert!(result.is_ok());
+
+            // Test that we can get messages
+            let message = get_message("greeting");
+            assert_eq!(message, "Hello, world!");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_init_localization_with_fallback() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("fr-FR").unwrap();
+
+            let result = init_localization(&locale, temp_dir.path());
+            assert!(result.is_ok());
+
+            // Test French message
+            let message1 = get_message("greeting");
+            assert_eq!(message1, "Bonjour, le monde!");
+
+            // Test fallback to English
+            let message2 = get_message("missing-in-other");
+            assert_eq!(message2, "This message only exists in English");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_init_localization_invalid_locale_falls_back_to_english() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("de-DE").unwrap(); // No German file
+
+            let result = init_localization(&locale, temp_dir.path());
+            assert!(result.is_ok());
+
+            // Should use English as primary since German failed to load
+            let message = get_message("greeting");
+            assert_eq!(message, "Hello, world!");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_init_localization_already_initialized() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("en-US").unwrap();
+
+            // Initialize once
+            let result1 = init_localization(&locale, temp_dir.path());
+            assert!(result1.is_ok());
+
+            // Try to initialize again - should fail
+            let result2 = init_localization(&locale, temp_dir.path());
+            assert!(result2.is_err());
+
+            match result2 {
+                Err(LocalizationError::Bundle(msg)) => {
+                    assert!(msg.contains("already initialized"));
+                }
+                _ => panic!("Expected Bundle error"),
+            }
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_get_message() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("fr-FR").unwrap();
+
+            init_localization(&locale, temp_dir.path()).unwrap();
+
+            let message = get_message("greeting");
+            assert_eq!(message, "Bonjour, le monde!");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_get_message_not_initialized() {
+        std::thread::spawn(|| {
+            let message = get_message("greeting");
+            assert_eq!(message, "greeting"); // Should return the ID itself
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_get_message_with_args() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("en-US").unwrap();
+
+            init_localization(&locale, temp_dir.path()).unwrap();
+
+            let mut args = HashMap::new();
+            args.insert("name".to_string(), "Bob".to_string());
+
+            let message = get_message_with_args("welcome", args);
+            assert_eq!(message, "Welcome, \u{2068}Bob\u{2069}!");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_get_message_with_args_pluralization() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("en-US").unwrap();
+
+            init_localization(&locale, temp_dir.path()).unwrap();
+
+            // Test singular
+            let mut args1 = HashMap::new();
+            args1.insert("count".to_string(), "1".to_string());
+            let message1 = get_message_with_args("count-items", args1);
+            assert_eq!(message1, "You have \u{2068}\u{2068}1\u{2069} item\u{2069}");
+
+            // Test plural
+            let mut args2 = HashMap::new();
+            args2.insert("count".to_string(), "5".to_string());
+            let message2 = get_message_with_args("count-items", args2);
+            assert_eq!(message2, "You have \u{2068}\u{2068}5\u{2069} items\u{2069}");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_detect_system_locale_from_lang_env() {
+        // Save current LANG value
+        let original_lang = env::var("LANG").ok();
+
+        // Test with a valid locale
+        unsafe {
+            env::set_var("LANG", "fr-FR.UTF-8");
+        }
+        let result = detect_system_locale();
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), "fr-FR");
+
+        // Test with locale without encoding
+        unsafe {
+            env::set_var("LANG", "es-ES");
+        }
+        let result = detect_system_locale();
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), "es-ES");
+
+        // Restore original LANG value
+        match original_lang {
+            Some(val) => unsafe {
+                env::set_var("LANG", val);
+            },
+            None => unsafe {
+                env::remove_var("LANG");
+            },
+        }
+    }
+
+    #[test]
+    fn test_detect_system_locale_no_lang_env() {
+        // Save current LANG value
+        let original_lang = env::var("LANG").ok();
+
+        // Remove LANG environment variable
+        unsafe {
+            env::remove_var("LANG");
+        }
+
+        let result = detect_system_locale();
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap().to_string(), "en-US");
+
+        // Restore original LANG value
+        match original_lang {
+            Some(val) => unsafe {
+                env::set_var("LANG", val);
+            },
+            None => {} // Was already unset
+        }
+    }
+
+    #[test]
+    fn test_setup_localization_success() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+
+            // Save current LANG value
+            let original_lang = env::var("LANG").ok();
+            unsafe {
+                env::set_var("LANG", "fr-FR.UTF-8");
+            }
+
+            let result = setup_localization(temp_dir.path().to_str().unwrap());
+            assert!(result.is_ok());
+
+            // Test that French is loaded
+            let message = get_message("greeting");
+            assert_eq!(message, "Bonjour, le monde!");
+
+            // Restore original LANG value
+            match original_lang {
+                Some(val) => unsafe {
+                    env::set_var("LANG", val);
+                },
+                None => unsafe {
+                    env::remove_var("LANG");
+                },
+            }
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_setup_localization_falls_back_to_english() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+
+            // Save current LANG value
+            let original_lang = env::var("LANG").ok();
+            unsafe {
+                env::set_var("LANG", "de-DE.UTF-8");
+            } // German file doesn't exist
+
+            let result = setup_localization(temp_dir.path().to_str().unwrap());
+            assert!(result.is_ok());
+
+            // Should fall back to English
+            let message = get_message("greeting");
+            assert_eq!(message, "Hello, world!");
+
+            // Restore original LANG value
+            match original_lang {
+                Some(val) => unsafe {
+                    env::set_var("LANG", val);
+                },
+                None => unsafe {
+                    env::remove_var("LANG");
+                },
+            }
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_setup_localization_missing_english_file() {
+        std::thread::spawn(|| {
+            let temp_dir = TempDir::new().unwrap(); // Empty directory
+
+            let result = setup_localization(temp_dir.path().to_str().unwrap());
+            assert!(result.is_err());
+
+            match result {
+                Err(LocalizationError::Io { source: _, path }) => {
+                    assert!(path.to_string_lossy().contains("en-US.ftl"));
+                }
+                _ => panic!("Expected IO error for missing English file"),
+            }
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_thread_local_isolation() {
+        use std::thread;
+
+        let temp_dir = create_test_locales_dir();
+
+        // Initialize in main thread with French
+        let temp_path_main = temp_dir.path().to_path_buf();
+        let main_handle = thread::spawn(move || {
+            let locale = LanguageIdentifier::from_str("fr-FR").unwrap();
+            init_localization(&locale, &temp_path_main).unwrap();
+            let main_message = get_message("greeting");
+            assert_eq!(main_message, "Bonjour, le monde!");
+        });
+        main_handle.join().unwrap();
+
+        // Test in a different thread - should not be initialized
+        let temp_path = temp_dir.path().to_path_buf();
+        let handle = thread::spawn(move || {
+            // This thread should have its own uninitialized LOCALIZER
+            let thread_message = get_message("greeting");
+            assert_eq!(thread_message, "greeting"); // Returns ID since not initialized
+
+            // Initialize in this thread with English
+            let en_locale = LanguageIdentifier::from_str("en-US").unwrap();
+            init_localization(&en_locale, &temp_path).unwrap();
+            let thread_message_after_init = get_message("greeting");
+            assert_eq!(thread_message_after_init, "Hello, world!");
+        });
+
+        handle.join().unwrap();
+
+        // Test another thread to verify French doesn't persist across threads
+        let final_handle = thread::spawn(move || {
+            // Should be uninitialized again
+            let final_message = get_message("greeting");
+            assert_eq!(final_message, "greeting");
+        });
+        final_handle.join().unwrap();
+    }
+
+    #[test]
+    fn test_japanese_localization() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("ja-JP").unwrap();
+
+            let result = init_localization(&locale, temp_dir.path());
+            assert!(result.is_ok());
+
+            // Test Japanese greeting
+            let message = get_message("greeting");
+            assert_eq!(message, "�ん����世界�");
+
+            // Test Japanese with arguments
+            let mut args = HashMap::new();
+            args.insert("name".to_string(), "田中".to_string());
+            let welcome = get_message_with_args("welcome", args);
+            assert_eq!(welcome, "よ����\u{2068}田中\u{2069}�ん�");
+
+            // Test Japanese count (no pluralization)
+            let mut count_args = HashMap::new();
+            count_args.insert("count".to_string(), "5".to_string());
+            let count_message = get_message_with_args("count-items", count_args);
+            assert_eq!(count_message, "\u{2068}5\u{2069}個�アイテム��り��");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_arabic_localization() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("ar-SA").unwrap();
+
+            let result = init_localization(&locale, temp_dir.path());
+            assert!(result.is_ok());
+
+            // Test Arabic greeting (RTL text)
+            let message = get_message("greeting");
+            assert_eq!(message, "أهلاً بالعالم�");
+
+            // Test Arabic with arguments
+            let mut args = HashMap::new();
+            args.insert("name".to_string(), "أحمد".to_string());
+            let welcome = get_message_with_args("welcome", args);
+            assert_eq!(welcome, "أهلاً وسهلاً، \u{2068}أحمد\u{2069}�");
+
+            // Test Arabic pluralization (zero case)
+            let mut args_zero = HashMap::new();
+            args_zero.insert("count".to_string(), "0".to_string());
+            let message_zero = get_message_with_args("count-items", args_zero);
+            assert_eq!(message_zero, "لديك \u{2068}لا عناصر\u{2069}");
+
+            // Test Arabic pluralization (one case)
+            let mut args_one = HashMap::new();
+            args_one.insert("count".to_string(), "1".to_string());
+            let message_one = get_message_with_args("count-items", args_one);
+            assert_eq!(message_one, "لديك \u{2068}عنصر واحد\u{2069}");
+
+            // Test Arabic pluralization (two case)
+            let mut args_two = HashMap::new();
+            args_two.insert("count".to_string(), "2".to_string());
+            let message_two = get_message_with_args("count-items", args_two);
+            assert_eq!(message_two, "لديك \u{2068}عنصران\u{2069}");
+
+            // Test Arabic pluralization (few case - 3-10)
+            let mut args_few = HashMap::new();
+            args_few.insert("count".to_string(), "5".to_string());
+            let message_few = get_message_with_args("count-items", args_few);
+            assert_eq!(message_few, "لديك \u{2068}\u{2068}5\u{2069} عناصر\u{2069}");
+
+            // Test Arabic pluralization (other case - 11+)
+            let mut args_many = HashMap::new();
+            args_many.insert("count".to_string(), "15".to_string());
+            let message_many = get_message_with_args("count-items", args_many);
+            assert_eq!(message_many, "لديك \u{2068}\u{2068}15\u{2069} عنصر\u{2069}");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_mixed_script_fallback() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("ar-SA").unwrap();
+
+            let result = init_localization(&locale, temp_dir.path());
+            assert!(result.is_ok());
+
+            // Test Arabic message exists
+            let arabic_message = get_message("greeting");
+            assert_eq!(arabic_message, "أهلاً بالعالم�");
+
+            // Test fallback to English for missing message
+            let fallback_message = get_message("missing-in-other");
+            assert_eq!(fallback_message, "This message only exists in English");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_unicode_directional_isolation() {
+        std::thread::spawn(|| {
+            let temp_dir = create_test_locales_dir();
+            let locale = LanguageIdentifier::from_str("ar-SA").unwrap();
+
+            init_localization(&locale, temp_dir.path()).unwrap();
+
+            // Test that Latin script names are properly isolated in RTL context
+            let mut args = HashMap::new();
+            args.insert("name".to_string(), "John Smith".to_string());
+            let message = get_message_with_args("welcome", args);
+
+            // The Latin name should be wrapped in directional isolate characters
+            assert!(message.contains("\u{2068}John Smith\u{2069}"));
+            assert_eq!(message, "أهلاً وسهلاً، \u{2068}John Smith\u{2069}�");
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_error_display() {
+        let io_error = LocalizationError::Io {
+            source: std::io::Error::new(std::io::ErrorKind::NotFound, "File not found"),
+            path: PathBuf::from("/test/path.ftl"),
+        };
+        let error_string = format!("{}", io_error);
+        assert!(error_string.contains("I/O error loading"));
+        assert!(error_string.contains("/test/path.ftl"));
+
+        let parse_error = LocalizationError::Parse("Syntax error".to_string());
+        let parse_string = format!("{}", parse_error);
+        assert!(parse_string.contains("Parse error: Syntax error"));
+
+        let bundle_error = LocalizationError::Bundle("Bundle creation failed".to_string());
+        let bundle_string = format!("{}", bundle_error);
+        assert!(bundle_string.contains("Bundle error: Bundle creation failed"));
+    }
+}
diff --git a/src/uucore/src/lib/mods/os.rs b/src/uucore/src/lib/mods/os.rs
index 55bf844b533..9c96bd7a0ce 100644
--- a/src/uucore/src/lib/mods/os.rs
+++ b/src/uucore/src/lib/mods/os.rs
@@ -2,11 +2,12 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-/// Test if the program is running under WSL
-// ref: <https://github.com/microsoft/WSL/issues/4555> @@ <https://archive.is/dP0bz>
-
 // spell-checker:ignore (path) osrelease
 
+//! Test if the program is running under WSL
+//! ref: <https://github.com/microsoft/WSL/issues/4555> @@ <https://archive.is/dP0bz>
+
+/// Test if the program is running under WSL version 1
 pub fn is_wsl_1() -> bool {
     #[cfg(target_os = "linux")]
     {
@@ -23,6 +24,7 @@ pub fn is_wsl_1() -> bool {
     false
 }
 
+/// Test if the program is running under WSL version 2
 pub fn is_wsl_2() -> bool {
     #[cfg(target_os = "linux")]
     {
diff --git a/src/uucore/src/lib/mods/panic.rs b/src/uucore/src/lib/mods/panic.rs
index f42b29581e9..8c170b3c8cd 100644
--- a/src/uucore/src/lib/mods/panic.rs
+++ b/src/uucore/src/lib/mods/panic.rs
@@ -13,11 +13,10 @@
 //! $ seq inf | head -n 1
 //! ```
 //!
-use std::panic;
-use std::panic::PanicInfo;
+use std::panic::{self, PanicHookInfo};
 
 /// Decide whether a panic was caused by a broken pipe (SIGPIPE) error.
-fn is_broken_pipe(info: &PanicInfo) -> bool {
+fn is_broken_pipe(info: &PanicHookInfo) -> bool {
     if let Some(res) = info.payload().downcast_ref::<String>() {
         if res.contains("BrokenPipe") || res.contains("Broken pipe") {
             return true;
diff --git a/src/uucore/src/lib/mods/posix.rs b/src/uucore/src/lib/mods/posix.rs
new file mode 100644
index 00000000000..47bdd7692c2
--- /dev/null
+++ b/src/uucore/src/lib/mods/posix.rs
@@ -0,0 +1,55 @@
+// 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.
+// spell-checker:ignore (vars)
+//! Iterate over lines, including the line ending character(s).
+//!
+//! This module provides the [`posix_version`] function, that returns
+//! Some(usize) if the `_POSIX2_VERSION` environment variable is defined
+//! and has value that can be parsed.
+//! Otherwise returns None, so the calling utility would assume default behavior.
+//!
+//! NOTE: GNU (as of v9.4) recognizes three distinct values for POSIX version
+//!
+//! Utilities that rely on this module:
+//! `sort` (TBD)
+//! `tail` (TBD)
+//! `touch` (TBD)
+//! `uniq`
+//!
+use std::env;
+
+/// '199209' for POSIX 1003.2-1992, which would define Obsolete mode
+pub const OBSOLETE: usize = 199_209;
+
+/// '200112' for POSIX 1003.1-2001, which is the minimum version for Traditional mode
+pub const TRADITIONAL: usize = 200_112;
+
+/// '200809' for POSIX 1003.1-2008, which is the minimum version for Modern mode
+pub const MODERN: usize = 200_809;
+
+/// Returns the value of the `_POSIX2_VERSION` environment variable if it is defined
+pub fn posix_version() -> Option<usize> {
+    env::var("_POSIX2_VERSION")
+        .ok()
+        .and_then(|v| v.parse::<usize>().ok())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::posix::*;
+
+    #[test]
+    fn test_posix_version() {
+        // default
+        assert_eq!(posix_version(), None);
+        // set specific version
+        unsafe { env::set_var("_POSIX2_VERSION", OBSOLETE.to_string()) };
+        assert_eq!(posix_version(), Some(OBSOLETE));
+        unsafe { env::set_var("_POSIX2_VERSION", TRADITIONAL.to_string()) };
+        assert_eq!(posix_version(), Some(TRADITIONAL));
+        unsafe { env::set_var("_POSIX2_VERSION", MODERN.to_string()) };
+        assert_eq!(posix_version(), Some(MODERN));
+    }
+}
diff --git a/src/uucore/src/lib/mods/quoting_style.rs b/src/uucore/src/lib/mods/quoting_style.rs
deleted file mode 100644
index 1b9a76aae22..00000000000
--- a/src/uucore/src/lib/mods/quoting_style.rs
+++ /dev/null
@@ -1,735 +0,0 @@
-// 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.
-use std::char::from_digit;
-use std::ffi::OsStr;
-
-// These are characters with special meaning in the shell (e.g. bash).
-// The first const contains characters that only have a special meaning when they appear at the beginning of a name.
-const SPECIAL_SHELL_CHARS_START: &[char] = &['~', '#'];
-const SPECIAL_SHELL_CHARS: &str = "`$&*()|[]{};\\'\"<>?! ";
-
-pub enum QuotingStyle {
-    Shell {
-        escape: bool,
-        always_quote: bool,
-        show_control: bool,
-    },
-    C {
-        quotes: Quotes,
-    },
-    Literal {
-        show_control: bool,
-    },
-}
-
-#[derive(Clone, Copy)]
-pub enum Quotes {
-    None,
-    Single,
-    Double,
-    // TODO: Locale
-}
-
-// This implementation is heavily inspired by the std::char::EscapeDefault implementation
-// in the Rust standard library. This custom implementation is needed because the
-// characters \a, \b, \e, \f & \v are not recognized by Rust.
-struct EscapedChar {
-    state: EscapeState,
-}
-
-enum EscapeState {
-    Done,
-    Char(char),
-    Backslash(char),
-    ForceQuote(char),
-    Octal(EscapeOctal),
-}
-
-struct EscapeOctal {
-    c: char,
-    state: EscapeOctalState,
-    idx: usize,
-}
-
-enum EscapeOctalState {
-    Done,
-    Backslash,
-    Value,
-}
-
-impl Iterator for EscapeOctal {
-    type Item = char;
-
-    fn next(&mut self) -> Option<char> {
-        match self.state {
-            EscapeOctalState::Done => None,
-            EscapeOctalState::Backslash => {
-                self.state = EscapeOctalState::Value;
-                Some('\\')
-            }
-            EscapeOctalState::Value => {
-                let octal_digit = ((self.c as u32) >> (self.idx * 3)) & 0o7;
-                if self.idx == 0 {
-                    self.state = EscapeOctalState::Done;
-                } else {
-                    self.idx -= 1;
-                }
-                Some(from_digit(octal_digit, 8).unwrap())
-            }
-        }
-    }
-}
-
-impl EscapeOctal {
-    fn from(c: char) -> Self {
-        Self {
-            c,
-            idx: 2,
-            state: EscapeOctalState::Backslash,
-        }
-    }
-}
-
-impl EscapedChar {
-    fn new_literal(c: char) -> Self {
-        Self {
-            state: EscapeState::Char(c),
-        }
-    }
-
-    fn new_c(c: char, quotes: Quotes) -> Self {
-        use EscapeState::*;
-        let init_state = match c {
-            '\x07' => Backslash('a'),
-            '\x08' => Backslash('b'),
-            '\t' => Backslash('t'),
-            '\n' => Backslash('n'),
-            '\x0B' => Backslash('v'),
-            '\x0C' => Backslash('f'),
-            '\r' => Backslash('r'),
-            '\\' => Backslash('\\'),
-            '\'' => match quotes {
-                Quotes::Single => Backslash('\''),
-                _ => Char('\''),
-            },
-            '"' => match quotes {
-                Quotes::Double => Backslash('"'),
-                _ => Char('"'),
-            },
-            ' ' => match quotes {
-                Quotes::None => Backslash(' '),
-                _ => Char(' '),
-            },
-            _ if c.is_ascii_control() => Octal(EscapeOctal::from(c)),
-            _ => Char(c),
-        };
-        Self { state: init_state }
-    }
-
-    fn new_shell(c: char, escape: bool, quotes: Quotes) -> Self {
-        use EscapeState::*;
-        let init_state = match c {
-            _ if !escape && c.is_control() => Char(c),
-            '\x07' => Backslash('a'),
-            '\x08' => Backslash('b'),
-            '\t' => Backslash('t'),
-            '\n' => Backslash('n'),
-            '\x0B' => Backslash('v'),
-            '\x0C' => Backslash('f'),
-            '\r' => Backslash('r'),
-            '\x00'..='\x1F' | '\x7F' => Octal(EscapeOctal::from(c)),
-            '\'' => match quotes {
-                Quotes::Single => Backslash('\''),
-                _ => Char('\''),
-            },
-            _ if SPECIAL_SHELL_CHARS.contains(c) => ForceQuote(c),
-            _ => Char(c),
-        };
-        Self { state: init_state }
-    }
-
-    fn hide_control(self) -> Self {
-        match self.state {
-            EscapeState::Char(c) if c.is_control() => Self {
-                state: EscapeState::Char('?'),
-            },
-            _ => self,
-        }
-    }
-}
-
-impl Iterator for EscapedChar {
-    type Item = char;
-
-    fn next(&mut self) -> Option<char> {
-        match self.state {
-            EscapeState::Backslash(c) => {
-                self.state = EscapeState::Char(c);
-                Some('\\')
-            }
-            EscapeState::Char(c) | EscapeState::ForceQuote(c) => {
-                self.state = EscapeState::Done;
-                Some(c)
-            }
-            EscapeState::Done => None,
-            EscapeState::Octal(ref mut iter) => iter.next(),
-        }
-    }
-}
-
-fn shell_without_escape(name: &str, quotes: Quotes, show_control_chars: bool) -> (String, bool) {
-    let mut must_quote = false;
-    let mut escaped_str = String::with_capacity(name.len());
-
-    for c in name.chars() {
-        let escaped = {
-            let ec = EscapedChar::new_shell(c, false, quotes);
-            if show_control_chars {
-                ec
-            } else {
-                ec.hide_control()
-            }
-        };
-
-        match escaped.state {
-            EscapeState::Backslash('\'') => escaped_str.push_str("'\\''"),
-            EscapeState::ForceQuote(x) => {
-                must_quote = true;
-                escaped_str.push(x);
-            }
-            _ => {
-                for char in escaped {
-                    escaped_str.push(char);
-                }
-            }
-        }
-    }
-
-    must_quote = must_quote || name.starts_with(SPECIAL_SHELL_CHARS_START);
-    (escaped_str, must_quote)
-}
-
-fn shell_with_escape(name: &str, quotes: Quotes) -> (String, bool) {
-    // We need to keep track of whether we are in a dollar expression
-    // because e.g. \b\n is escaped as $'\b\n' and not like $'b'$'n'
-    let mut in_dollar = false;
-    let mut must_quote = false;
-    let mut escaped_str = String::with_capacity(name.len());
-
-    for c in name.chars() {
-        let escaped = EscapedChar::new_shell(c, true, quotes);
-        match escaped.state {
-            EscapeState::Char(x) => {
-                if in_dollar {
-                    escaped_str.push_str("''");
-                    in_dollar = false;
-                }
-                escaped_str.push(x);
-            }
-            EscapeState::ForceQuote(x) => {
-                if in_dollar {
-                    escaped_str.push_str("''");
-                    in_dollar = false;
-                }
-                must_quote = true;
-                escaped_str.push(x);
-            }
-            // Single quotes are not put in dollar expressions, but are escaped
-            // if the string also contains double quotes. In that case, they must
-            // be handled separately.
-            EscapeState::Backslash('\'') => {
-                must_quote = true;
-                in_dollar = false;
-                escaped_str.push_str("'\\''");
-            }
-            _ => {
-                if !in_dollar {
-                    escaped_str.push_str("'$'");
-                    in_dollar = true;
-                }
-                must_quote = true;
-                for char in escaped {
-                    escaped_str.push(char);
-                }
-            }
-        }
-    }
-    must_quote = must_quote || name.starts_with(SPECIAL_SHELL_CHARS_START);
-    (escaped_str, must_quote)
-}
-
-pub fn escape_name(name: &OsStr, style: &QuotingStyle) -> String {
-    match style {
-        QuotingStyle::Literal { 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()
-            }
-        }
-        QuotingStyle::C { quotes } => {
-            let escaped_str: String = name
-                .to_string_lossy()
-                .chars()
-                .flat_map(|c| EscapedChar::new_c(c, *quotes))
-                .collect();
-
-            match quotes {
-                Quotes::Single => format!("'{escaped_str}'"),
-                Quotes::Double => format!("\"{escaped_str}\""),
-                Quotes::None => escaped_str,
-            }
-        }
-        QuotingStyle::Shell {
-            escape,
-            always_quote,
-            show_control,
-        } => {
-            let name = name.to_string_lossy();
-            let (quotes, must_quote) = if name.contains(&['"', '`', '$', '\\'][..]) {
-                (Quotes::Single, true)
-            } else if name.contains('\'') {
-                (Quotes::Double, true)
-            } else if *always_quote {
-                (Quotes::Single, true)
-            } else {
-                (Quotes::Single, false)
-            };
-
-            let (escaped_str, contains_quote_chars) = if *escape {
-                shell_with_escape(&name, quotes)
-            } else {
-                shell_without_escape(&name, quotes, *show_control)
-            };
-
-            match (must_quote | contains_quote_chars, quotes) {
-                (true, Quotes::Single) => format!("'{escaped_str}'"),
-                (true, Quotes::Double) => format!("\"{escaped_str}\""),
-                _ => escaped_str,
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::quoting_style::{escape_name, Quotes, QuotingStyle};
-
-    // spell-checker:ignore (tests/words) one\'two one'two
-
-    fn get_style(s: &str) -> QuotingStyle {
-        match s {
-            "literal" => QuotingStyle::Literal {
-                show_control: false,
-            },
-            "literal-show" => QuotingStyle::Literal { show_control: true },
-            "escape" => QuotingStyle::C {
-                quotes: Quotes::None,
-            },
-            "c" => QuotingStyle::C {
-                quotes: Quotes::Double,
-            },
-            "shell" => QuotingStyle::Shell {
-                escape: false,
-                always_quote: false,
-                show_control: false,
-            },
-            "shell-show" => QuotingStyle::Shell {
-                escape: false,
-                always_quote: false,
-                show_control: true,
-            },
-            "shell-always" => QuotingStyle::Shell {
-                escape: false,
-                always_quote: true,
-                show_control: false,
-            },
-            "shell-always-show" => QuotingStyle::Shell {
-                escape: false,
-                always_quote: true,
-                show_control: true,
-            },
-            "shell-escape" => QuotingStyle::Shell {
-                escape: true,
-                always_quote: false,
-                show_control: false,
-            },
-            "shell-escape-always" => QuotingStyle::Shell {
-                escape: true,
-                always_quote: true,
-                show_control: false,
-            },
-            _ => panic!("Invalid name!"),
-        }
-    }
-
-    fn check_names(name: &str, map: &[(&str, &str)]) {
-        assert_eq!(
-            map.iter()
-                .map(|(_, style)| escape_name(name.as_ref(), &get_style(style)))
-                .collect::<Vec<String>>(),
-            map.iter()
-                .map(|(correct, _)| correct.to_string())
-                .collect::<Vec<String>>()
-        );
-    }
-
-    #[test]
-    fn test_simple_names() {
-        check_names(
-            "one_two",
-            &[
-                ("one_two", "literal"),
-                ("one_two", "literal-show"),
-                ("one_two", "escape"),
-                ("\"one_two\"", "c"),
-                ("one_two", "shell"),
-                ("one_two", "shell-show"),
-                ("\'one_two\'", "shell-always"),
-                ("\'one_two\'", "shell-always-show"),
-                ("one_two", "shell-escape"),
-                ("\'one_two\'", "shell-escape-always"),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_spaces() {
-        check_names(
-            "one two",
-            &[
-                ("one two", "literal"),
-                ("one two", "literal-show"),
-                ("one\\ two", "escape"),
-                ("\"one two\"", "c"),
-                ("\'one two\'", "shell"),
-                ("\'one two\'", "shell-show"),
-                ("\'one two\'", "shell-always"),
-                ("\'one two\'", "shell-always-show"),
-                ("\'one two\'", "shell-escape"),
-                ("\'one two\'", "shell-escape-always"),
-            ],
-        );
-
-        check_names(
-            " one",
-            &[
-                (" one", "literal"),
-                (" one", "literal-show"),
-                ("\\ one", "escape"),
-                ("\" one\"", "c"),
-                ("' one'", "shell"),
-                ("' one'", "shell-show"),
-                ("' one'", "shell-always"),
-                ("' one'", "shell-always-show"),
-                ("' one'", "shell-escape"),
-                ("' one'", "shell-escape-always"),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_quotes() {
-        // One double quote
-        check_names(
-            "one\"two",
-            &[
-                ("one\"two", "literal"),
-                ("one\"two", "literal-show"),
-                ("one\"two", "escape"),
-                ("\"one\\\"two\"", "c"),
-                ("'one\"two'", "shell"),
-                ("'one\"two'", "shell-show"),
-                ("'one\"two'", "shell-always"),
-                ("'one\"two'", "shell-always-show"),
-                ("'one\"two'", "shell-escape"),
-                ("'one\"two'", "shell-escape-always"),
-            ],
-        );
-
-        // One single quote
-        check_names(
-            "one\'two",
-            &[
-                ("one'two", "literal"),
-                ("one'two", "literal-show"),
-                ("one'two", "escape"),
-                ("\"one'two\"", "c"),
-                ("\"one'two\"", "shell"),
-                ("\"one'two\"", "shell-show"),
-                ("\"one'two\"", "shell-always"),
-                ("\"one'two\"", "shell-always-show"),
-                ("\"one'two\"", "shell-escape"),
-                ("\"one'two\"", "shell-escape-always"),
-            ],
-        );
-
-        // One single quote and one double quote
-        check_names(
-            "one'two\"three",
-            &[
-                ("one'two\"three", "literal"),
-                ("one'two\"three", "literal-show"),
-                ("one'two\"three", "escape"),
-                ("\"one'two\\\"three\"", "c"),
-                ("'one'\\''two\"three'", "shell"),
-                ("'one'\\''two\"three'", "shell-show"),
-                ("'one'\\''two\"three'", "shell-always"),
-                ("'one'\\''two\"three'", "shell-always-show"),
-                ("'one'\\''two\"three'", "shell-escape"),
-                ("'one'\\''two\"three'", "shell-escape-always"),
-            ],
-        );
-
-        // Consecutive quotes
-        check_names(
-            "one''two\"\"three",
-            &[
-                ("one''two\"\"three", "literal"),
-                ("one''two\"\"three", "literal-show"),
-                ("one''two\"\"three", "escape"),
-                ("\"one''two\\\"\\\"three\"", "c"),
-                ("'one'\\'''\\''two\"\"three'", "shell"),
-                ("'one'\\'''\\''two\"\"three'", "shell-show"),
-                ("'one'\\'''\\''two\"\"three'", "shell-always"),
-                ("'one'\\'''\\''two\"\"three'", "shell-always-show"),
-                ("'one'\\'''\\''two\"\"three'", "shell-escape"),
-                ("'one'\\'''\\''two\"\"three'", "shell-escape-always"),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_control_chars() {
-        // A simple newline
-        check_names(
-            "one\ntwo",
-            &[
-                ("one?two", "literal"),
-                ("one\ntwo", "literal-show"),
-                ("one\\ntwo", "escape"),
-                ("\"one\\ntwo\"", "c"),
-                ("one?two", "shell"),
-                ("one\ntwo", "shell-show"),
-                ("'one?two'", "shell-always"),
-                ("'one\ntwo'", "shell-always-show"),
-                ("'one'$'\\n''two'", "shell-escape"),
-                ("'one'$'\\n''two'", "shell-escape-always"),
-            ],
-        );
-
-        // A control character followed by a special shell character
-        check_names(
-            "one\n&two",
-            &[
-                ("one?&two", "literal"),
-                ("one\n&two", "literal-show"),
-                ("one\\n&two", "escape"),
-                ("\"one\\n&two\"", "c"),
-                ("'one?&two'", "shell"),
-                ("'one\n&two'", "shell-show"),
-                ("'one?&two'", "shell-always"),
-                ("'one\n&two'", "shell-always-show"),
-                ("'one'$'\\n''&two'", "shell-escape"),
-                ("'one'$'\\n''&two'", "shell-escape-always"),
-            ],
-        );
-
-        // The first 16 control characters. NUL is also included, even though it is of
-        // no importance for file names.
-        check_names(
-            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
-            &[
-                ("????????????????", "literal"),
-                (
-                    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
-                    "literal-show",
-                ),
-                (
-                    "\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017",
-                    "escape",
-                ),
-                (
-                    "\"\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017\"",
-                    "c",
-                ),
-                ("????????????????", "shell"),
-                (
-                    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F",
-                    "shell-show",
-                ),
-                ("'????????????????'", "shell-always"),
-                (
-                    "'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F'",
-                    "shell-always-show",
-                ),
-                (
-                    "''$'\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017'",
-                    "shell-escape",
-                ),
-                (
-                    "''$'\\000\\001\\002\\003\\004\\005\\006\\a\\b\\t\\n\\v\\f\\r\\016\\017'",
-                    "shell-escape-always",
-                ),
-            ],
-        );
-
-        // The last 16 control characters.
-        check_names(
-            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
-            &[
-                ("????????????????", "literal"),
-                (
-                    "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
-                    "literal-show",
-                ),
-                (
-                    "\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037",
-                    "escape",
-                ),
-                (
-                    "\"\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\"",
-                    "c",
-                ),
-                ("????????????????", "shell"),
-                (
-                    "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
-                    "shell-show",
-                ),
-                ("'????????????????'", "shell-always"),
-                (
-                    "'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F'",
-                    "shell-always-show",
-                ),
-                (
-                    "''$'\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037'",
-                    "shell-escape",
-                ),
-                (
-                    "''$'\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037'",
-                    "shell-escape-always",
-                ),
-            ],
-        );
-
-        // DEL
-        check_names(
-            "\x7F",
-            &[
-                ("?", "literal"),
-                ("\x7F", "literal-show"),
-                ("\\177", "escape"),
-                ("\"\\177\"", "c"),
-                ("?", "shell"),
-                ("\x7F", "shell-show"),
-                ("'?'", "shell-always"),
-                ("'\x7F'", "shell-always-show"),
-                ("''$'\\177'", "shell-escape"),
-                ("''$'\\177'", "shell-escape-always"),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_question_mark() {
-        // A question mark must force quotes in shell and shell-always, unless
-        // it is in place of a control character (that case is already covered
-        // in other tests)
-        check_names(
-            "one?two",
-            &[
-                ("one?two", "literal"),
-                ("one?two", "literal-show"),
-                ("one?two", "escape"),
-                ("\"one?two\"", "c"),
-                ("'one?two'", "shell"),
-                ("'one?two'", "shell-show"),
-                ("'one?two'", "shell-always"),
-                ("'one?two'", "shell-always-show"),
-                ("'one?two'", "shell-escape"),
-                ("'one?two'", "shell-escape-always"),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_backslash() {
-        // Escaped in C-style, but not in Shell-style escaping
-        check_names(
-            "one\\two",
-            &[
-                ("one\\two", "literal"),
-                ("one\\two", "literal-show"),
-                ("one\\\\two", "escape"),
-                ("\"one\\\\two\"", "c"),
-                ("'one\\two'", "shell"),
-                ("\'one\\two\'", "shell-always"),
-                ("'one\\two'", "shell-escape"),
-                ("'one\\two'", "shell-escape-always"),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_tilde_and_hash() {
-        check_names("~", &[("'~'", "shell"), ("'~'", "shell-escape")]);
-        check_names(
-            "~name",
-            &[("'~name'", "shell"), ("'~name'", "shell-escape")],
-        );
-        check_names(
-            "some~name",
-            &[("some~name", "shell"), ("some~name", "shell-escape")],
-        );
-        check_names("name~", &[("name~", "shell"), ("name~", "shell-escape")]);
-
-        check_names("#", &[("'#'", "shell"), ("'#'", "shell-escape")]);
-        check_names(
-            "#name",
-            &[("'#name'", "shell"), ("'#name'", "shell-escape")],
-        );
-        check_names(
-            "some#name",
-            &[("some#name", "shell"), ("some#name", "shell-escape")],
-        );
-        check_names("name#", &[("name#", "shell"), ("name#", "shell-escape")]);
-    }
-
-    #[test]
-    fn test_special_chars_in_double_quotes() {
-        check_names(
-            "can'$t",
-            &[
-                ("'can'\\''$t'", "shell"),
-                ("'can'\\''$t'", "shell-always"),
-                ("'can'\\''$t'", "shell-escape"),
-                ("'can'\\''$t'", "shell-escape-always"),
-            ],
-        );
-
-        check_names(
-            "can'`t",
-            &[
-                ("'can'\\''`t'", "shell"),
-                ("'can'\\''`t'", "shell-always"),
-                ("'can'\\''`t'", "shell-escape"),
-                ("'can'\\''`t'", "shell-escape-always"),
-            ],
-        );
-
-        check_names(
-            "can'\\t",
-            &[
-                ("'can'\\''\\t'", "shell"),
-                ("'can'\\''\\t'", "shell-always"),
-                ("'can'\\''\\t'", "shell-escape"),
-                ("'can'\\''\\t'", "shell-escape-always"),
-            ],
-        );
-    }
-}
diff --git a/src/uucore/src/lib/parser/parse_size.rs b/src/uucore/src/lib/parser/parse_size.rs
deleted file mode 100644
index 5f64afcd8a5..00000000000
--- a/src/uucore/src/lib/parser/parse_size.rs
+++ /dev/null
@@ -1,525 +0,0 @@
-// 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.
-
-// spell-checker:ignore (ToDO) hdsf ghead gtail ACDBK hexdigit
-
-use std::error::Error;
-use std::fmt;
-
-use crate::display::Quotable;
-
-/// Parser for sizes in SI or IEC units (multiples of 1000 or 1024 bytes).
-///
-/// The [`Parser::parse`] function performs the parse.
-#[derive(Default)]
-pub struct Parser<'parser> {
-    /// Whether to treat the suffix "B" as meaning "bytes".
-    pub capital_b_bytes: bool,
-    /// Whether to treat "b" as a "byte count" instead of "block"
-    pub b_byte_count: bool,
-    /// Whitelist for the suffix
-    pub allow_list: Option<&'parser [&'parser str]>,
-    /// Default unit when no suffix is provided
-    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);
-        self
-    }
-
-    pub fn with_default_unit(&mut self, default_unit: &'parser str) -> &mut Self {
-        self.default_unit = Some(default_unit);
-        self
-    }
-
-    pub fn with_b_byte_count(&mut self, value: bool) -> &mut Self {
-        self.b_byte_count = value;
-        self
-    }
-
-    /// Parse a size string into a number of bytes.
-    ///
-    /// A size string comprises an integer and an optional unit. The unit
-    /// may be K, M, G, T, P, E, Z or Y (powers of 1024), or KB, MB,
-    /// etc. (powers of 1000), or b which is 512.
-    /// Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
-    ///
-    /// # Errors
-    ///
-    /// Will return `ParseSizeError` if it's not possible to parse this
-    /// string into a number, e.g. if the string does not begin with a
-    /// numeral, or if the unit is not one of the supported units described
-    /// in the preceding section.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use uucore::parse_size::parse_size;
-    /// 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));
-        }
-
-        let number_system = 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 {
-            // Check if `unit` is empty then assigns `default_unit` to `unit`
-            if unit.is_empty() {
-                unit = default_unit;
-            }
-        }
-
-        // Check if `b` is a byte count and remove `b`
-        if self.b_byte_count && unit.ends_with('b') {
-            // If `unit` = 'b' then return error
-            if numeric_string.is_empty() {
-                return Err(ParseSizeError::parse_failure(size));
-            }
-            unit = &unit[0..unit.len() - 1];
-        }
-
-        if let Some(allow_list) = self.allow_list {
-            // Check if `unit` appears in `allow_list`, if not return error
-            if !allow_list.contains(&unit) && !unit.is_empty() {
-                if numeric_string.is_empty() {
-                    return Err(ParseSizeError::parse_failure(size));
-                }
-                return Err(ParseSizeError::invalid_suffix(size));
-            }
-        }
-
-        // 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),
-            "b" => (512, 1),
-            "KiB" | "kiB" | "K" | "k" => (1024, 1),
-            "MiB" | "miB" | "M" | "m" => (1024, 2),
-            "GiB" | "giB" | "G" | "g" => (1024, 3),
-            "TiB" | "tiB" | "T" | "t" => (1024, 4),
-            "PiB" | "piB" | "P" | "p" => (1024, 5),
-            "EiB" | "eiB" | "E" | "e" => (1024, 6),
-            "ZiB" | "ziB" | "Z" | "z" => (1024, 7),
-            "YiB" | "yiB" | "Y" | "y" => (1024, 8),
-            "KB" | "kB" => (1000, 1),
-            "MB" | "mB" => (1000, 2),
-            "GB" | "gB" => (1000, 3),
-            "TB" | "tB" => (1000, 4),
-            "PB" | "pB" => (1000, 5),
-            "EB" | "eB" => (1000, 6),
-            "ZB" | "zB" => (1000, 7),
-            "YB" | "yB" => (1000, 8),
-            _ if numeric_string.is_empty() => return Err(ParseSizeError::parse_failure(size)),
-            _ => return Err(ParseSizeError::invalid_suffix(size)),
-        };
-        let factor = match u64::try_from(base.pow(exponent)) {
-            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(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(
-        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.
-///
-/// A size string comprises an integer and an optional unit. The unit
-/// may be K, M, G, T, P, E, Z or Y (powers of 1024), or KB, MB,
-/// etc. (powers of 1000), or b which is 512.
-/// Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
-///
-/// # Errors
-///
-/// Will return `ParseSizeError` if it's not possible to parse this
-/// string into a number, e.g. if the string does not begin with a
-/// numeral, or if the unit is not one of the supported units described
-/// in the preceding section.
-///
-/// # Examples
-///
-/// ```rust
-/// use uucore::parse_size::parse_size;
-/// 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
-/// ```
-pub fn parse_size(size: &str) -> Result<u64, ParseSizeError> {
-    Parser::default().parse(size)
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum ParseSizeError {
-    InvalidSuffix(String), // Suffix
-    ParseFailure(String),  // Syntax
-    SizeTooBig(String),    // Overflow
-}
-
-impl Error for ParseSizeError {
-    fn description(&self) -> &str {
-        match *self {
-            Self::InvalidSuffix(ref s) => s,
-            Self::ParseFailure(ref s) => s,
-            Self::SizeTooBig(ref s) => s,
-        }
-    }
-}
-
-impl fmt::Display for ParseSizeError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        let s = match self {
-            Self::InvalidSuffix(s) | Self::ParseFailure(s) | Self::SizeTooBig(s) => s,
-        };
-        write!(f, "{s}")
-    }
-}
-
-// FIXME: It's more idiomatic to move the formatting into the Display impl,
-// but there's a lot of downstream code that constructs these errors manually
-// that would be affected
-impl ParseSizeError {
-    fn invalid_suffix(s: &str) -> Self {
-        Self::InvalidSuffix(format!("{}", s.quote()))
-    }
-
-    fn parse_failure(s: &str) -> Self {
-        // stderr on linux (GNU coreutils 8.32) (LC_ALL=C)
-        // has to be handled in the respective uutils because strings differ, e.g.:
-        //
-        // `NUM`
-        // head:     invalid number of bytes: '1fb'
-        // tail:     invalid number of bytes: '1fb'
-        //
-        // `SIZE`
-        // split:    invalid number of bytes: '1fb'
-        // truncate: Invalid number: '1fb'
-        //
-        // `MODE`
-        // stdbuf:   invalid mode '1fb'
-        //
-        // `SIZE`
-        // sort:     invalid suffix in --buffer-size argument '1fb'
-        // sort:     invalid --buffer-size argument 'fb'
-        //
-        // `SIZE`
-        // du:       invalid suffix in --buffer-size argument '1fb'
-        // du:       invalid suffix in --threshold argument '1fb'
-        // du:       invalid --buffer-size argument 'fb'
-        // du:       invalid --threshold argument 'fb'
-        //
-        // `BYTES`
-        // od:       invalid suffix in --read-bytes argument '1fb'
-        // od:       invalid --read-bytes argument  argument 'fb'
-        //                   --skip-bytes
-        //                   --width
-        //                   --strings
-        // etc.
-        Self::ParseFailure(format!("{}", s.quote()))
-    }
-
-    fn size_too_big(s: &str) -> Self {
-        // stderr on linux (GNU coreutils 8.32) (LC_ALL=C)
-        // has to be handled in the respective uutils because strings differ, e.g.:
-        //
-        // head:     invalid number of bytes: '1Y': Value too large for defined data type
-        // tail:     invalid number of bytes: '1Y': Value too large for defined data type
-        // split:    invalid number of bytes: '1Y': Value too large for defined data type
-        // truncate:          Invalid number: '1Y': Value too large for defined data type
-        // stdbuf:               invalid mode '1Y': Value too large for defined data type
-        // sort:     -S argument '1Y' too large
-        // du:       -B argument '1Y' too large
-        // od:       -N argument '1Y' too large
-        // etc.
-        //
-        // stderr on macos (brew - GNU coreutils 8.32) also differs for the same version, e.g.:
-        // ghead:   invalid number of bytes: '1Y': Value too large to be stored in data type
-        // gtail:   invalid number of bytes: '1Y': Value too large to be stored in data type
-        Self::SizeTooBig(format!(
-            "{}: Value too large for defined data type",
-            s.quote()
-        ))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn variant_eq(a: &ParseSizeError, b: &ParseSizeError) -> bool {
-        std::mem::discriminant(a) == std::mem::discriminant(b)
-    }
-
-    #[test]
-    fn all_suffixes() {
-        // Units  are  K,M,G,T,P,E,Z,Y (powers of 1024) or KB,MB,... (powers of 1000).
-        // Binary prefixes can be used, too: KiB=K, MiB=M, and so on.
-        let suffixes = [
-            ('K', 1u32),
-            ('M', 2u32),
-            ('G', 3u32),
-            ('T', 4u32),
-            ('P', 5u32),
-            ('E', 6u32),
-            // The following will always result ParseSizeError::SizeTooBig as they cannot fit in u64
-            // ('Z', 7u32),
-            // ('Y', 8u32),
-        ];
-
-        for &(c, exp) in &suffixes {
-            let s = format!("2{c}B"); // KB
-            assert_eq!(Ok((2 * (1000_u128).pow(exp)) as u64), parse_size(&s));
-            let s = format!("2{c}"); // K
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
-            let s = format!("2{c}iB"); // KiB
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
-            let s = format!("2{}iB", c.to_lowercase()); // kiB
-            assert_eq!(Ok((2 * (1024_u128).pow(exp)) as u64), parse_size(&s));
-
-            // suffix only
-            let s = format!("{c}B"); // KB
-            assert_eq!(Ok(((1000_u128).pow(exp)) as u64), parse_size(&s));
-            let s = format!("{c}"); // K
-            assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
-            let s = format!("{c}iB"); // KiB
-            assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
-            let s = format!("{}iB", c.to_lowercase()); // kiB
-            assert_eq!(Ok(((1024_u128).pow(exp)) as u64), parse_size(&s));
-        }
-    }
-
-    #[test]
-    #[cfg(not(target_pointer_width = "128"))]
-    fn overflow_x64() {
-        assert!(parse_size("10000000000000000000000").is_err());
-        assert!(parse_size("1000000000T").is_err());
-        assert!(parse_size("100000P").is_err());
-        assert!(parse_size("100E").is_err());
-        assert!(parse_size("1Z").is_err());
-        assert!(parse_size("1Y").is_err());
-
-        assert!(variant_eq(
-            &parse_size("1Z").unwrap_err(),
-            &ParseSizeError::SizeTooBig(String::new())
-        ));
-
-        assert_eq!(
-            ParseSizeError::SizeTooBig("'1Y': Value too large for defined data type".to_string()),
-            parse_size("1Y").unwrap_err()
-        );
-    }
-
-    #[test]
-    fn invalid_suffix() {
-        let test_strings = ["5mib", "1eb", "1H"];
-        for &test_string in &test_strings {
-            assert_eq!(
-                parse_size(test_string).unwrap_err(),
-                ParseSizeError::InvalidSuffix(format!("{}", test_string.quote()))
-            );
-        }
-    }
-
-    #[test]
-    fn invalid_syntax() {
-        let test_strings = ["biB", "-", "+", "", "-1", "∞"];
-        for &test_string in &test_strings {
-            assert_eq!(
-                parse_size(test_string).unwrap_err(),
-                ParseSizeError::ParseFailure(format!("{}", test_string.quote()))
-            );
-        }
-    }
-
-    #[test]
-    fn b_suffix() {
-        assert_eq!(Ok(3 * 512), parse_size("3b")); // b is 512
-    }
-
-    #[test]
-    fn no_suffix() {
-        assert_eq!(Ok(1234), parse_size("1234"));
-        assert_eq!(Ok(0), parse_size("0"));
-        assert_eq!(Ok(5), parse_size("5"));
-        assert_eq!(Ok(999), parse_size("999"));
-    }
-
-    #[test]
-    fn kilobytes_suffix() {
-        assert_eq!(Ok(123 * 1000), parse_size("123KB")); // KB is 1000
-        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(0), parse_size("0K"));
-        assert_eq!(Ok(0), parse_size("0KB"));
-        assert_eq!(Ok(1000), parse_size("KB"));
-        assert_eq!(Ok(1024), parse_size("K"));
-        assert_eq!(Ok(2000), parse_size("2kB"));
-        assert_eq!(Ok(4000), parse_size("4KB"));
-    }
-
-    #[test]
-    fn megabytes_suffix() {
-        assert_eq!(Ok(123 * 1024 * 1024), parse_size("123M"));
-        assert_eq!(Ok(123 * 1000 * 1000), parse_size("123MB"));
-        assert_eq!(Ok(1024 * 1024), parse_size("M"));
-        assert_eq!(Ok(1000 * 1000), parse_size("MB"));
-        assert_eq!(Ok(2 * 1_048_576), parse_size("2m"));
-        assert_eq!(Ok(4 * 1_048_576), parse_size("4M"));
-        assert_eq!(Ok(2_000_000), parse_size("2mB"));
-        assert_eq!(Ok(4_000_000), parse_size("4MB"));
-    }
-
-    #[test]
-    fn gigabytes_suffix() {
-        assert_eq!(Ok(1_073_741_824), parse_size("1G"));
-        assert_eq!(Ok(2_000_000_000), parse_size("2GB"));
-    }
-
-    #[test]
-    #[cfg(target_pointer_width = "64")]
-    fn x64() {
-        assert_eq!(Ok(1_099_511_627_776), parse_size("1T"));
-        assert_eq!(Ok(1_125_899_906_842_624), parse_size("1P"));
-        assert_eq!(Ok(1_152_921_504_606_846_976), parse_size("1E"));
-        assert_eq!(Ok(2_000_000_000_000), parse_size("2TB"));
-        assert_eq!(Ok(2_000_000_000_000_000), parse_size("2PB"));
-        assert_eq!(Ok(2_000_000_000_000_000_000), parse_size("2EB"));
-    }
-
-    #[test]
-    fn parse_size_options() {
-        let mut parser = Parser::default();
-
-        parser
-            .with_allow_list(&["k", "K", "G", "MB", "M"])
-            .with_default_unit("K");
-
-        assert_eq!(Ok(1024), parser.parse("1"));
-        assert_eq!(Ok(2 * 1024), parser.parse("2"));
-        assert_eq!(Ok(1000 * 1000), parser.parse("1MB"));
-        assert_eq!(Ok(1024 * 1024), parser.parse("1M"));
-        assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1G"));
-
-        assert!(parser.parse("1T").is_err());
-        assert!(parser.parse("1P").is_err());
-        assert!(parser.parse("1E").is_err());
-
-        parser
-            .with_allow_list(&[
-                "b", "k", "K", "m", "M", "MB", "g", "G", "t", "T", "P", "E", "Z", "Y",
-            ])
-            .with_default_unit("K")
-            .with_b_byte_count(true);
-
-        assert_eq!(Ok(1024), parser.parse("1"));
-        assert_eq!(Ok(2 * 1024), parser.parse("2"));
-        assert_eq!(Ok(1000 * 1000), parser.parse("1MB"));
-        assert_eq!(Ok(1024 * 1024), parser.parse("1M"));
-        assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1G"));
-
-        assert_eq!(Ok(1), parser.parse("1b"));
-        assert_eq!(Ok(1024), parser.parse("1024b"));
-        assert_eq!(Ok(1024 * 1024 * 1024), parser.parse("1024Mb"));
-
-        assert!(parser.parse("b").is_err());
-        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/src/lib/parser/parse_time.rs b/src/uucore/src/lib/parser/parse_time.rs
deleted file mode 100644
index 727ee28b1bf..00000000000
--- a/src/uucore/src/lib/parser/parse_time.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-// 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.
-
-// spell-checker:ignore (vars) NANOS numstr
-//! Parsing a duration from a string.
-//!
-//! Use the [`from_str`] function to parse a [`Duration`] from a string.
-
-use std::time::Duration;
-
-use crate::display::Quotable;
-
-/// Parse a duration from a string.
-///
-/// The string may contain only a number, like "123" or "4.5", or it
-/// may contain a number with a unit specifier, like "123s" meaning
-/// one hundred twenty three seconds or "4.5d" meaning four and a half
-/// days. If no unit is specified, the unit is assumed to be seconds.
-///
-/// The only allowed suffixes are
-///
-/// * "s" for seconds,
-/// * "m" for minutes,
-/// * "h" for hours,
-/// * "d" for days.
-///
-/// This function uses [`Duration::saturating_mul`] to compute the
-/// number of seconds, so it does not overflow. If overflow would have
-/// occurred, [`Duration::MAX`] is returned instead.
-///
-/// # Errors
-///
-/// This function returns an error if the input string is empty, the
-/// input is not a valid number, or the unit specifier is invalid or
-/// unknown.
-///
-/// # Examples
-///
-/// ```rust
-/// use std::time::Duration;
-/// use uucore::parse_time::from_str;
-/// assert_eq!(from_str("123"), Ok(Duration::from_secs(123)));
-/// assert_eq!(from_str("2d"), Ok(Duration::from_secs(60 * 60 * 24 * 2)));
-/// ```
-pub fn from_str(string: &str) -> Result<Duration, String> {
-    let len = string.len();
-    if len == 0 {
-        return Err("empty string".to_owned());
-    }
-    let slice = match string.get(..len - 1) {
-        Some(s) => s,
-        None => return Err(format!("invalid time interval {}", string.quote())),
-    };
-    let (numstr, times) = match string.chars().next_back().unwrap() {
-        's' => (slice, 1),
-        'm' => (slice, 60),
-        'h' => (slice, 60 * 60),
-        'd' => (slice, 60 * 60 * 24),
-        val if !val.is_alphabetic() => (string, 1),
-        _ => {
-            if string == "inf" || string == "infinity" {
-                ("inf", 1)
-            } else {
-                return Err(format!("invalid time interval {}", string.quote()));
-            }
-        }
-    };
-    let num = numstr
-        .parse::<f64>()
-        .map_err(|e| format!("invalid time interval {}: {}", string.quote(), e))?;
-
-    if num < 0. {
-        return Err(format!("invalid time interval {}", string.quote()));
-    }
-
-    const NANOS_PER_SEC: u32 = 1_000_000_000;
-    let whole_secs = num.trunc();
-    let nanos = (num.fract() * (NANOS_PER_SEC as f64)).trunc();
-    let duration = Duration::new(whole_secs as u64, nanos as u32);
-    Ok(duration.saturating_mul(times))
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::parse_time::from_str;
-    use std::time::Duration;
-
-    #[test]
-    fn test_no_units() {
-        assert_eq!(from_str("123"), Ok(Duration::from_secs(123)));
-    }
-
-    #[test]
-    fn test_units() {
-        assert_eq!(from_str("2d"), Ok(Duration::from_secs(60 * 60 * 24 * 2)));
-    }
-
-    #[test]
-    fn test_saturating_mul() {
-        assert_eq!(from_str("9223372036854775808d"), Ok(Duration::MAX));
-    }
-
-    #[test]
-    fn test_error_empty() {
-        assert!(from_str("").is_err());
-    }
-
-    #[test]
-    fn test_error_invalid_unit() {
-        assert!(from_str("123X").is_err());
-    }
-
-    #[test]
-    fn test_error_multi_bytes_characters() {
-        assert!(from_str("10€").is_err());
-    }
-
-    #[test]
-    fn test_error_invalid_magnitude() {
-        assert!(from_str("12abc3s").is_err());
-    }
-
-    #[test]
-    fn test_negative() {
-        assert!(from_str("-1").is_err());
-    }
-
-    /// Test that capital letters are not allowed in suffixes.
-    #[test]
-    fn test_no_capital_letters() {
-        assert!(from_str("1S").is_err());
-        assert!(from_str("1M").is_err());
-        assert!(from_str("1H").is_err());
-        assert!(from_str("1D").is_err());
-    }
-}
diff --git a/src/uucore_procs/Cargo.toml b/src/uucore_procs/Cargo.toml
index 1ad4023f9b1..8d0fb09bb1e 100644
--- a/src/uucore_procs/Cargo.toml
+++ b/src/uucore_procs/Cargo.toml
@@ -1,22 +1,21 @@
 # spell-checker:ignore uuhelp
 [package]
 name = "uucore_procs"
-version = "0.0.21"
-authors = ["Roy Ivy III <rivy.dev@gmail.com>"]
-license = "MIT"
 description = "uutils ~ 'uucore' proc-macros"
-
-homepage = "https://github.com/uutils/coreutils"
+authors = ["Roy Ivy III <rivy.dev@gmail.com>"]
 repository = "https://github.com/uutils/coreutils/tree/main/src/uucore_procs"
 # readme = "README.md"
 keywords = ["cross-platform", "proc-macros", "uucore", "uutils"]
 # categories = ["os"]
-edition = "2021"
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+version.workspace = true
 
 [lib]
 proc-macro = true
 
 [dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-uuhelp_parser = { path = "../uuhelp_parser", version = "0.0.21" }
+proc-macro2 = "1.0.81"
+quote = "1.0.36"
+uuhelp_parser = { path = "../uuhelp_parser", version = "0.1.0" }
diff --git a/src/uucore_procs/src/lib.rs b/src/uucore_procs/src/lib.rs
index cbe915936d3..51741dd9eb4 100644
--- a/src/uucore_procs/src/lib.rs
+++ b/src/uucore_procs/src/lib.rs
@@ -3,7 +3,10 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 //
-// spell-checker:ignore backticks uuhelp
+// spell-checker:ignore backticks uuhelp SIGSEGV
+
+//! A collection of procedural macros for uutils.
+#![deny(missing_docs)]
 
 use std::{fs::File, io::Read, path::PathBuf};
 
@@ -14,6 +17,7 @@ use quote::quote;
 //* 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>
 
+/// A procedural macro to define the main function of a uutils binary.
 #[proc_macro_attribute]
 pub fn main(_args: TokenStream, stream: TokenStream) -> TokenStream {
     let stream = proc_macro2::TokenStream::from(stream);
@@ -21,13 +25,17 @@ pub fn main(_args: TokenStream, stream: TokenStream) -> TokenStream {
     let new = quote!(
         pub fn uumain(args: impl uucore::Args) -> i32 {
             #stream
+
+            // disable rust signal handlers (otherwise processes don't dump core after e.g. one SIGSEGV)
+            #[cfg(unix)]
+            uucore::disable_rust_signal_handlers().expect("Disabling rust signal handlers failed");
             let result = uumain(args);
             match result {
                 Ok(()) => uucore::error::get_exit_code(),
                 Err(e) => {
-                    let s = format!("{}", e);
+                    let s = format!("{e}");
                     if s != "" {
-                        uucore::show_error!("{}", s);
+                        uucore::show_error!("{s}");
                     }
                     if e.usage() {
                         eprintln!("Try '{} --help' for more information.", uucore::execution_phrase());
@@ -63,6 +71,10 @@ 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 = uuhelp_parser::parse_about(&read_help(&filename));
+    assert!(
+        !text.is_empty(),
+        "About text not found! Make sure the markdown format is correct"
+    );
     TokenTree::Literal(Literal::string(&text)).into()
 }
 
@@ -77,6 +89,10 @@ 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 = uuhelp_parser::parse_usage(&read_help(&filename));
+    assert!(
+        !text.is_empty(),
+        "Usage text not found! Make sure the markdown format is correct"
+    );
     TokenTree::Literal(Literal::string(&text)).into()
 }
 
diff --git a/src/uuhelp_parser/Cargo.toml b/src/uuhelp_parser/Cargo.toml
index fdff271b053..32d4768d6c3 100644
--- a/src/uuhelp_parser/Cargo.toml
+++ b/src/uuhelp_parser/Cargo.toml
@@ -1,7 +1,9 @@
 # spell-checker:ignore uuhelp
 [package]
 name = "uuhelp_parser"
-version = "0.0.21"
-edition = "2021"
-license = "MIT"
 description = "A collection of functions to parse the markdown code of help files"
+repository = "https://github.com/uutils/coreutils/tree/main/src/uuhelp_parser"
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+version.workspace = true
diff --git a/src/uuhelp_parser/LICENSE b/src/uuhelp_parser/LICENSE
new file mode 120000
index 00000000000..30cff7403da
--- /dev/null
+++ b/src/uuhelp_parser/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/src/uuhelp_parser/src/lib.rs b/src/uuhelp_parser/src/lib.rs
index 8faa4e6ce4d..0e0907f8a54 100644
--- a/src/uuhelp_parser/src/lib.rs
+++ b/src/uuhelp_parser/src/lib.rs
@@ -2,6 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+#![deny(missing_docs)]
 
 //! A collection of functions to parse the markdown code of help files.
 //!
@@ -61,8 +62,7 @@ pub fn parse_usage(content: &str) -> String {
                 "{}\n".to_string()
             }
         })
-        .collect::<Vec<_>>()
-        .join("")
+        .collect::<String>()
         .trim()
         .to_string()
 }
@@ -73,7 +73,7 @@ pub fn parse_usage(content: &str) -> String {
 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)
+            .is_some_and(|l| l.trim().to_lowercase() == section)
     }
 
     let section = &section.to_lowercase();
diff --git a/tests/benches/factor/Cargo.toml b/tests/benches/factor/Cargo.toml
index 26900e78a91..066a8b52ff4 100644
--- a/tests/benches/factor/Cargo.toml
+++ b/tests/benches/factor/Cargo.toml
@@ -5,7 +5,7 @@ authors = ["nicoo <nicoo@debian.org>"]
 license = "MIT"
 description = "Benchmarks for the uu_factor integer factorization tool"
 homepage = "https://github.com/uutils/coreutils"
-edition = "2021"
+edition = "2024"
 
 [workspace]
 
@@ -17,10 +17,10 @@ array-init = "2.0.0"
 criterion = "0.3"
 rand = "0.8"
 rand_chacha = "0.3.1"
+num-bigint = "0.4.4"
+num-prime = "0.4.4"
+num-traits = "0.2.18"
 
-[[bench]]
-name = "gcd"
-harness = false
 
 [[bench]]
 name = "table"
diff --git a/tests/benches/factor/benches/gcd.rs b/tests/benches/factor/benches/gcd.rs
deleted file mode 100644
index 61545145f98..00000000000
--- a/tests/benches/factor/benches/gcd.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-// 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.
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use uu_factor::numeric;
-
-fn gcd(c: &mut Criterion) {
-    let inputs = {
-        // Deterministic RNG; use an explicitly-named RNG to guarantee stability
-        use rand::{RngCore, SeedableRng};
-        use rand_chacha::ChaCha8Rng;
-        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()))
-    };
-
-    let mut group = c.benchmark_group("gcd");
-    for (n, m) in inputs.take(10) {
-        group.bench_with_input(
-            BenchmarkId::from_parameter(format!("{}_{}", n, m)),
-            &(n, m),
-            |b, &(n, m)| {
-                b.iter(|| numeric::gcd(n, m));
-            },
-        );
-    }
-    group.finish();
-}
-
-criterion_group!(benches, gcd);
-criterion_main!(benches);
diff --git a/tests/benches/factor/benches/table.rs b/tests/benches/factor/benches/table.rs
index f666d72d510..504b7e8e382 100644
--- a/tests/benches/factor/benches/table.rs
+++ b/tests/benches/factor/benches/table.rs
@@ -2,9 +2,11 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+
+// spell-checker:ignore funcs
+
 use array_init::array_init;
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
-use uu_factor::{table::*, Factors};
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 
 fn table(c: &mut Criterion) {
     #[cfg(target_os = "linux")]
@@ -25,22 +27,11 @@ fn table(c: &mut Criterion) {
     let mut group = c.benchmark_group("table");
     group.throughput(Throughput::Elements(INPUT_SIZE as _));
     for a in inputs.take(10) {
-        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;
-                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());
-                }
-            });
-        });
+        let a_str = format!("{a:?}");
         group.bench_with_input(BenchmarkId::new("factor", &a_str), &a, |b, &a| {
             b.iter(|| {
-                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);
+                for n in a {
+                    let _r = num_prime::nt_funcs::factors(n, None);
                 }
             });
         });
@@ -55,17 +46,16 @@ fn check_personality() {
     const PERSONALITY_PATH: &str = "/proc/self/personality";
 
     let p_string = fs::read_to_string(PERSONALITY_PATH)
-        .unwrap_or_else(|_| panic!("Couldn't read '{}'", PERSONALITY_PATH))
+        .unwrap_or_else(|_| panic!("Couldn't read '{PERSONALITY_PATH}'"))
         .strip_suffix('\n')
         .unwrap()
         .to_owned();
 
     let personality = u64::from_str_radix(&p_string, 16)
-        .unwrap_or_else(|_| panic!("Expected a hex value for personality, got '{:?}'", p_string));
+        .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.",
-            personality
+            "WARNING: Benchmarking with ASLR enabled (personality is {personality:x}), results might not be reproducible."
         );
     }
 }
diff --git a/tests/by-util/test_arch.rs b/tests/by-util/test_arch.rs
index daf4e32f52b..99a0cb9e841 100644
--- a/tests/by-util/test_arch.rs
+++ b/tests/by-util/test_arch.rs
@@ -2,7 +2,9 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_arch() {
@@ -19,5 +21,14 @@ fn test_arch_help() {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_arch_output_is_not_empty() {
+    let result = new_ucmd!().succeeds();
+    assert!(
+        !result.stdout_str().trim().is_empty(),
+        "arch output was empty"
+    );
 }
diff --git a/tests/by-util/test_base32.rs b/tests/by-util/test_base32.rs
index 8bb5bda5415..af5df848e21 100644
--- a/tests/by-util/test_base32.rs
+++ b/tests/by-util/test_base32.rs
@@ -4,7 +4,9 @@
 // file that was distributed with this source code.
 //
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_encode() {
@@ -22,6 +24,26 @@ fn test_encode() {
         .stdout_only("JBSWY3DPFQQFO33SNRSCC===\n"); // spell-checker:disable-line
 }
 
+#[test]
+fn test_encode_repeat_flags_later_wrap_10() {
+    let input = "Hello, World!\n";
+    new_ucmd!()
+        .args(&["-ii", "-w17", "-w10"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("JBSWY3DPFQ\nQFO33SNRSC\nCCQ=\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_encode_repeat_flags_later_wrap_17() {
+    let input = "Hello, World!\n";
+    new_ucmd!()
+        .args(&["-ii", "-w10", "-w17"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("JBSWY3DPFQQFO33SN\nRSCCCQ=\n"); // spell-checker:disable-line
+}
+
 #[test]
 fn test_base32_encode_file() {
     new_ucmd!()
@@ -32,7 +54,7 @@ fn test_base32_encode_file() {
 
 #[test]
 fn test_decode() {
-    for decode_param in ["-d", "--decode", "--dec"] {
+    for decode_param in ["-d", "--decode", "--dec", "-D"] {
         let input = "JBSWY3DPFQQFO33SNRSCC===\n"; // spell-checker:disable-line
         new_ucmd!()
             .arg(decode_param)
@@ -42,6 +64,16 @@ fn test_decode() {
     }
 }
 
+#[test]
+fn test_decode_repeat_flags() {
+    let input = "JBSWY3DPFQQFO33SNRSCC===\n"; // spell-checker:disable-line
+    new_ucmd!()
+        .args(&["-didiw80", "--wrap=17", "--wrap", "8"]) // spell-checker:disable-line
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("Hello, World!");
+}
+
 #[test]
 fn test_garbage() {
     let input = "aGVsbG8sIHdvcmxkIQ==\0"; // spell-checker:disable-line
diff --git a/tests/by-util/test_base64.rs b/tests/by-util/test_base64.rs
index b46507faeff..ba0e3adaf40 100644
--- a/tests/by-util/test_base64.rs
+++ b/tests/by-util/test_base64.rs
@@ -2,7 +2,9 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_encode() {
@@ -20,6 +22,48 @@ fn test_encode() {
         .stdout_only("aGVsbG8sIHdvcmxkIQ==\n"); // spell-checker:disable-line
 }
 
+#[test]
+fn test_encode_repeat_flags_later_wrap_10() {
+    let input = "hello, world!";
+    new_ucmd!()
+        .args(&["-ii", "-w15", "-w10"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("aGVsbG8sIH\ndvcmxkIQ==\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_encode_repeat_flags_later_wrap_15() {
+    let input = "hello, world!";
+    new_ucmd!()
+        .args(&["-ii", "-w10", "-w15"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("aGVsbG8sIHdvcmx\nkIQ==\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_decode_short() {
+    let input = "aQ";
+    new_ucmd!()
+        .args(&["--decode"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("i");
+}
+
+#[test]
+fn test_multi_lines() {
+    let input = ["aQ\n\n\n", "a\nQ==\n\n\n"];
+    for i in input {
+        new_ucmd!()
+            .args(&["--decode"])
+            .pipe_in(i)
+            .succeeds()
+            .stdout_only("i");
+    }
+}
+
 #[test]
 fn test_base64_encode_file() {
     new_ucmd!()
@@ -30,7 +74,7 @@ fn test_base64_encode_file() {
 
 #[test]
 fn test_decode() {
-    for decode_param in ["-d", "--decode", "--dec"] {
+    for decode_param in ["-d", "--decode", "--dec", "-D"] {
         let input = "aGVsbG8sIHdvcmxkIQ=="; // spell-checker:disable-line
         new_ucmd!()
             .arg(decode_param)
@@ -40,6 +84,16 @@ fn test_decode() {
     }
 }
 
+#[test]
+fn test_decode_repeat_flags() {
+    let input = "aGVsbG8sIHdvcmxkIQ==\n"; // spell-checker:disable-line
+    new_ucmd!()
+        .args(&["-didiw80", "--wrap=17", "--wrap", "8"]) // spell-checker:disable-line
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("hello, world!");
+}
+
 #[test]
 fn test_garbage() {
     let input = "aGVsbG8sIHdvcmxkIQ==\0"; // spell-checker:disable-line
@@ -75,6 +129,17 @@ fn test_wrap() {
             // spell-checker:disable-next-line
             .stdout_only("VGhlIHF1aWNrIGJyb3du\nIGZveCBqdW1wcyBvdmVy\nIHRoZSBsYXp5IGRvZy4=\n");
     }
+    let input = "hello, world";
+    new_ucmd!()
+        .args(&["--wrap", "0"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("aGVsbG8sIHdvcmxk"); // spell-checker:disable-line
+    new_ucmd!()
+        .args(&["--wrap", "30"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only("aGVsbG8sIHdvcmxk\n"); // spell-checker:disable-line
 }
 
 #[test]
@@ -116,3 +181,77 @@ fn test_base64_file_not_found() {
         .fails()
         .stderr_only("base64: a.txt: No such file or directory\n");
 }
+
+#[test]
+fn test_no_repeated_trailing_newline() {
+    new_ucmd!()
+        .args(&["--wrap", "10", "--", "-"])
+        .pipe_in("The quick brown fox jumps over the lazy dog.")
+        .succeeds()
+        .stdout_only(
+            // cSpell:disable
+            "\
+VGhlIHF1aW
+NrIGJyb3du
+IGZveCBqdW
+1wcyBvdmVy
+IHRoZSBsYX
+p5IGRvZy4=
+",
+            // cSpell:enable
+        );
+}
+
+#[test]
+fn test_wrap_default() {
+    const PIPE_IN: &str = "The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.";
+
+    new_ucmd!()
+        .args(&["--", "-"])
+        .pipe_in(PIPE_IN)
+        .succeeds()
+        .stdout_only(
+            // cSpell:disable
+            "\
+VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4gVGhlIHF1aWNrIGJy
+b3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4gVGhlIHF1aWNrIGJyb3duIGZveCBqdW1w
+cyBvdmVyIHRoZSBsYXp5IGRvZy4=
+",
+            // cSpell:enable
+        );
+}
+
+// Prevent regression to:
+//
+// � coreutils manpage base64 | rg --fixed-strings -- 'base32'
+// The data are encoded as described for the base32 alphabet in RFC 4648.
+// to the bytes of the formal base32 alphabet. Use \-\-ignore\-garbage
+// The data are encoded as described for the base32 alphabet in RFC 4648.
+// to the bytes of the formal base32 alphabet. Use \-\-ignore\-garbage
+#[test]
+fn test_manpage() {
+    use std::process::{Command, Stdio};
+
+    let test_scenario = TestScenario::new("");
+
+    let child = Command::new(&test_scenario.bin_path)
+        .arg("manpage")
+        .arg("base64")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+    let output = child.wait_with_output().unwrap();
+
+    assert_eq!(output.status.code().unwrap(), 0);
+
+    assert!(output.stderr.is_empty());
+
+    let stdout_str = std::str::from_utf8(&output.stdout).unwrap();
+
+    assert!(stdout_str.contains("base64 alphabet"));
+
+    assert!(!stdout_str.to_ascii_lowercase().contains("base32"));
+}
diff --git a/tests/by-util/test_basename.rs b/tests/by-util/test_basename.rs
index 73b44ff7522..e9c44dbe278 100644
--- a/tests/by-util/test_basename.rs
+++ b/tests/by-util/test_basename.rs
@@ -2,11 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) reallylongexecutable
+// spell-checker:ignore (words) reallylongexecutable nbaz
 
-use crate::common::util::TestScenario;
 #[cfg(any(unix, target_os = "redox"))]
 use std::ffi::OsStr;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_help() {
@@ -22,12 +24,14 @@ fn test_help() {
 #[test]
 fn test_version() {
     for version_flg in ["-V", "--version"] {
-        assert!(new_ucmd!()
-            .arg(version_flg)
-            .succeeds()
-            .no_stderr()
-            .stdout_str()
-            .starts_with("basename"));
+        assert!(
+            new_ucmd!()
+                .arg(version_flg)
+                .succeeds()
+                .no_stderr()
+                .stdout_str()
+                .starts_with("basename")
+        );
     }
 }
 
@@ -70,7 +74,7 @@ fn test_multiple_param() {
         new_ucmd!()
             .args(&[multiple_param, path, path])
             .succeeds()
-            .stdout_only("baz\nbaz\n"); // spell-checker:disable-line
+            .stdout_only("baz\nbaz\n");
     }
 }
 
@@ -81,7 +85,7 @@ fn test_suffix_param() {
         new_ucmd!()
             .args(&[suffix_param, ".exe", path, path])
             .succeeds()
-            .stdout_only("baz\nbaz\n"); // spell-checker:disable-line
+            .stdout_only("baz\nbaz\n");
     }
 }
 
@@ -97,12 +101,14 @@ fn test_zero_param() {
 }
 
 fn expect_error(input: &[&str]) {
-    assert!(!new_ucmd!()
-        .args(input)
-        .fails()
-        .no_stdout()
-        .stderr_str()
-        .is_empty());
+    assert!(
+        !new_ucmd!()
+            .args(input)
+            .fails()
+            .no_stdout()
+            .stderr_str()
+            .is_empty()
+    );
 }
 
 #[test]
@@ -192,12 +198,75 @@ fn test_simple_format() {
     new_ucmd!().args(&["a-z", "-z"]).succeeds().stdout_is("a\n");
     new_ucmd!()
         .args(&["a", "b", "c"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("extra operand 'c'");
 }
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_repeated_multiple() {
+    new_ucmd!()
+        .args(&["-aa", "-a", "foo"])
+        .succeeds()
+        .stdout_is("foo\n");
+}
+
+#[test]
+fn test_repeated_multiple_many() {
+    new_ucmd!()
+        .args(&["-aa", "-a", "1/foo", "q/bar", "x/y/baz"])
+        .succeeds()
+        .stdout_is("foo\nbar\nbaz\n");
+}
+
+#[test]
+fn test_repeated_suffix_last() {
+    new_ucmd!()
+        .args(&["-s", ".h", "-s", ".c", "foo.c"])
+        .succeeds()
+        .stdout_is("foo\n");
+}
+
+#[test]
+fn test_repeated_suffix_not_first() {
+    new_ucmd!()
+        .args(&["-s", ".h", "-s", ".c", "foo.h"])
+        .succeeds()
+        .stdout_is("foo.h\n");
+}
+
+#[test]
+fn test_repeated_suffix_multiple() {
+    new_ucmd!()
+        .args(&["-as", ".h", "-a", "-s", ".c", "foo.c", "bar.c", "bar.h"])
+        .succeeds()
+        .stdout_is("foo\nbar\nbar.h\n");
+}
+
+#[test]
+fn test_repeated_zero() {
+    new_ucmd!()
+        .args(&["-zz", "-z", "foo/bar"])
+        .succeeds()
+        .stdout_is("bar\0");
+}
+
+#[test]
+fn test_zero_does_not_imply_multiple() {
+    new_ucmd!()
+        .args(&["-z", "foo.c", "c"])
+        .succeeds()
+        .stdout_is("foo.\0");
+}
+
+#[test]
+fn test_suffix_implies_multiple() {
+    new_ucmd!()
+        .args(&["-s", ".c", "foo.c", "o.c"])
+        .succeeds()
+        .stdout_is("foo\no\n");
 }
diff --git a/tests/by-util/test_basenc.rs b/tests/by-util/test_basenc.rs
index 6c71b63f79c..438fea6ccfc 100644
--- a/tests/by-util/test_basenc.rs
+++ b/tests/by-util/test_basenc.rs
@@ -2,19 +2,273 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker: ignore (encodings) lsbf msbf
+
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
-fn test_z85_not_padded() {
+fn test_z85_not_padded_decode() {
     // The z85 crate deviates from the standard in some cases; we have to catch those
     new_ucmd!()
         .args(&["--z85", "-d"])
         .pipe_in("##########")
         .fails()
         .stderr_only("basenc: error: invalid input\n");
+}
+
+#[test]
+fn test_z85_not_padded_encode() {
+    // The z85 crate deviates from the standard in some cases; we have to catch those
     new_ucmd!()
         .args(&["--z85"])
         .pipe_in("123")
         .fails()
         .stderr_only("basenc: error: invalid input (length must be multiple of 4 characters)\n");
 }
+
+#[test]
+fn test_invalid_input() {
+    let error_message = if cfg!(windows) {
+        "basenc: .: Permission denied\n"
+    } else {
+        "basenc: read error: Is a directory\n"
+    };
+    new_ucmd!()
+        .args(&["--base32", "."])
+        .fails()
+        .stderr_only(error_message);
+}
+
+#[test]
+fn test_base64() {
+    new_ucmd!()
+        .arg("--base64")
+        .pipe_in("to>be?")
+        .succeeds()
+        .stdout_only("dG8+YmU/\n");
+}
+
+#[test]
+fn test_base64_decode() {
+    new_ucmd!()
+        .args(&["--base64", "-d"])
+        .pipe_in("dG8+YmU/")
+        .succeeds()
+        .stdout_only("to>be?");
+}
+
+#[test]
+fn test_base64url() {
+    new_ucmd!()
+        .arg("--base64url")
+        .pipe_in("to>be?")
+        .succeeds()
+        .stdout_only("dG8-YmU_\n");
+}
+
+#[test]
+fn test_base64url_decode() {
+    new_ucmd!()
+        .args(&["--base64url", "-d"])
+        .pipe_in("dG8-YmU_")
+        .succeeds()
+        .stdout_only("to>be?");
+}
+
+#[test]
+fn test_base32() {
+    new_ucmd!()
+        .arg("--base32")
+        .pipe_in("nice>base?")
+        .succeeds()
+        .stdout_only("NZUWGZJ6MJQXGZJ7\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_base32_decode() {
+    new_ucmd!()
+        .args(&["--base32", "-d"])
+        .pipe_in("NZUWGZJ6MJQXGZJ7") // spell-checker:disable-line
+        .succeeds()
+        .stdout_only("nice>base?");
+}
+
+#[test]
+fn test_base32hex() {
+    new_ucmd!()
+        .arg("--base32hex")
+        .pipe_in("nice>base?")
+        .succeeds()
+        .stdout_only("DPKM6P9UC9GN6P9V\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_base32hex_decode() {
+    new_ucmd!()
+        .args(&["--base32hex", "-d"])
+        .pipe_in("DPKM6P9UC9GN6P9V") // spell-checker:disable-line
+        .succeeds()
+        .stdout_only("nice>base?");
+}
+
+#[test]
+fn test_base16() {
+    new_ucmd!()
+        .arg("--base16")
+        .pipe_in("Hello, World!")
+        .succeeds()
+        .stdout_only("48656C6C6F2C20576F726C6421\n");
+}
+
+#[test]
+fn test_base16_decode() {
+    new_ucmd!()
+        .args(&["--base16", "-d"])
+        .pipe_in("48656C6C6F2C20576F726C6421")
+        .succeeds()
+        .stdout_only("Hello, World!");
+}
+
+#[test]
+fn test_base16_decode_lowercase() {
+    new_ucmd!()
+        .args(&["--base16", "-d"])
+        .pipe_in("48656c6c6f2c20576f726c6421")
+        .succeeds()
+        .stdout_only("Hello, World!");
+}
+
+#[test]
+fn test_base16_decode_and_ignore_garbage_lowercase() {
+    new_ucmd!()
+        .args(&["--base16", "-d", "-i"])
+        .pipe_in("48656c6c6f2c20576f726c6421")
+        .succeeds()
+        .stdout_only("Hello, World!");
+}
+
+#[test]
+fn test_base2msbf() {
+    new_ucmd!()
+        .arg("--base2msbf")
+        .pipe_in("msbf")
+        .succeeds()
+        .stdout_only("01101101011100110110001001100110\n");
+}
+
+#[test]
+fn test_base2msbf_decode() {
+    new_ucmd!()
+        .args(&["--base2msbf", "-d"])
+        .pipe_in("01101101011100110110001001100110")
+        .succeeds()
+        .stdout_only("msbf");
+}
+
+#[test]
+fn test_base2lsbf() {
+    new_ucmd!()
+        .arg("--base2lsbf")
+        .pipe_in("lsbf")
+        .succeeds()
+        .stdout_only("00110110110011100100011001100110\n");
+}
+
+#[test]
+fn test_base2lsbf_decode() {
+    new_ucmd!()
+        .args(&["--base2lsbf", "-d"])
+        .pipe_in("00110110110011100100011001100110")
+        .succeeds()
+        .stdout_only("lsbf");
+}
+
+#[test]
+fn test_choose_last_encoding_z85() {
+    new_ucmd!()
+        .args(&[
+            "--base2lsbf",
+            "--base2msbf",
+            "--base16",
+            "--base32hex",
+            "--base64url",
+            "--base32",
+            "--base64",
+            "--z85",
+        ])
+        .pipe_in("Hello, World")
+        .succeeds()
+        .stdout_only("nm=QNz.92jz/PV8\n");
+}
+
+#[test]
+fn test_choose_last_encoding_base64() {
+    new_ucmd!()
+        .args(&[
+            "--base2msbf",
+            "--base2lsbf",
+            "--base64url",
+            "--base32hex",
+            "--base32",
+            "--base16",
+            "--z85",
+            "--base64",
+        ])
+        .pipe_in("Hello, World!")
+        .succeeds()
+        .stdout_only("SGVsbG8sIFdvcmxkIQ==\n"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_choose_last_encoding_base2lsbf() {
+    new_ucmd!()
+        .args(&[
+            "--base64url",
+            "--base16",
+            "--base2msbf",
+            "--base32",
+            "--base64",
+            "--z85",
+            "--base32hex",
+            "--base2lsbf",
+        ])
+        .pipe_in("lsbf")
+        .succeeds()
+        .stdout_only("00110110110011100100011001100110\n");
+}
+
+#[test]
+fn test_base32_decode_repeated() {
+    new_ucmd!()
+        .args(&[
+            "--ignore",
+            "--wrap=80",
+            "--base32hex",
+            "--z85",
+            "--ignore",
+            "--decode",
+            "--z85",
+            "--base32",
+            "-w",
+            "10",
+        ])
+        .pipe_in("NZUWGZJ6MJQXGZJ7") // spell-checker:disable-line
+        .succeeds()
+        .stdout_only("nice>base?");
+}
+
+// The restriction that input length has to be divisible by 4 only applies to data being encoded with Z85, not to the
+// decoding of Z85-encoded data
+#[test]
+fn test_z85_length_check() {
+    new_ucmd!()
+        .args(&["--decode", "--z85"])
+        // Input has length 10, not divisible by 4
+        // spell-checker:disable-next-line
+        .pipe_in("f!$Kwh8WxM")
+        .succeeds()
+        .stdout_only("12345678");
+}
diff --git a/tests/by-util/test_cat.rs b/tests/by-util/test_cat.rs
index 27f40356de5..926befe72ff 100644
--- a/tests/by-util/test_cat.rs
+++ b/tests/by-util/test_cat.rs
@@ -2,16 +2,20 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore NOFILE
+// spell-checker:ignore NOFILE nonewline cmdline
 
-#[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;
+#[cfg(unix)]
+use std::fs::File;
 use std::fs::OpenOptions;
-#[cfg(not(windows))]
 use std::process::Stdio;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+#[cfg(not(windows))]
+use uutests::util::vec_of_size;
+use uutests::util_name;
 
 #[test]
 fn test_output_simple() {
@@ -23,7 +27,6 @@ fn test_output_simple() {
 
 #[test]
 fn test_no_options() {
-    // spell-checker:disable-next-line
     for fixture in ["empty.txt", "alpha.txt", "nonewline.txt"] {
         // Give fixture through command line file argument
         new_ucmd!()
@@ -97,7 +100,9 @@ fn test_fifo_symlink() {
 }
 
 #[test]
-#[cfg(any(target_os = "linux", target_os = "android"))]
+// TODO(#7542): Re-enable on Android once we figure out why setting limit is broken.
+// #[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(target_os = "linux")]
 fn test_closes_file_descriptors() {
     // Each file creates a pipe, which has two file descriptors.
     // If they are not closed then five is certainly too many.
@@ -175,6 +180,7 @@ fn test_piped_to_dev_full() {
             s.ucmd()
                 .set_stdout(dev_full)
                 .pipe_in_fixture("alpha.txt")
+                .ignore_stdin_write_error()
                 .fails()
                 .stderr_contains("No space left on device");
         }
@@ -195,7 +201,6 @@ fn test_directory() {
 fn test_directory_and_file() {
     let s = TestScenario::new(util_name!());
     s.fixtures.mkdir("test_directory2");
-    // spell-checker:disable-next-line
     for fixture in ["empty.txt", "alpha.txt", "nonewline.txt"] {
         s.ucmd()
             .args(&["test_directory2", fixture])
@@ -218,12 +223,13 @@ fn test_three_directories_and_file_and_stdin() {
             "alpha.txt",
             "-",
             "file_which_does_not_exist.txt",
-            "nonewline.txt", // spell-checker:disable-line
+            "nonewline.txt",
             "test_directory3/test_directory5",
             "test_directory3/../test_directory3/test_directory5",
             "test_directory3",
         ])
         .pipe_in("stdout bytes")
+        .ignore_stdin_write_error()
         .fails()
         .stderr_is_fixture("three_directories_and_file_and_stdin.stderr.expected")
         .stdout_is(
@@ -253,6 +259,28 @@ fn test_output_multi_files_print_all_chars() {
     // spell-checker:enable
 }
 
+#[test]
+fn test_output_multi_files_print_all_chars_repeated() {
+    // spell-checker:disable
+    new_ucmd!()
+        .args(&["alpha.txt", "256.txt", "-A", "-n", "-A", "-n"])
+        .succeeds()
+        .stdout_only(
+            "     1\tabcde$\n     2\tfghij$\n     3\tklmno$\n     4\tpqrst$\n     \
+             5\tuvwxyz$\n     6\t^@^A^B^C^D^E^F^G^H^I$\n     \
+             7\t^K^L^M^N^O^P^Q^R^S^T^U^V^W^X^Y^Z^[^\\^]^^^_ \
+             !\"#$%&\'()*+,-./0123456789:;\
+             <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~^?M-^@M-^AM-^\
+             BM-^CM-^DM-^EM-^FM-^GM-^HM-^IM-^JM-^KM-^LM-^MM-^NM-^OM-^PM-^QM-^RM-^SM-^TM-^UM-^V\
+             M-^WM-^XM-^YM-^ZM-^[M-^\\M-^]M-^^M-^_M- \
+             M-!M-\"M-#M-$M-%M-&M-\'M-(M-)M-*M-+M-,M--M-.M-/M-0M-1M-2M-3M-4M-5M-6M-7M-8M-9M-:\
+             M-;M-<M-=M->M-?M-@M-AM-BM-CM-DM-EM-FM-GM-HM-IM-JM-KM-LM-MM-NM-OM-PM-QM-RM-SM-TM-U\
+             M-VM-WM-XM-YM-ZM-[M-\\M-]M-^M-_M-`M-aM-bM-cM-dM-eM-fM-gM-hM-iM-jM-kM-lM-mM-nM-oM-\
+             pM-qM-rM-sM-tM-uM-vM-wM-xM-yM-zM-{M-|M-}M-~M-^?",
+        );
+    // spell-checker:enable
+}
+
 #[test]
 fn test_numbered_lines_no_trailing_newline() {
     // spell-checker:disable
@@ -266,9 +294,18 @@ fn test_numbered_lines_no_trailing_newline() {
     // spell-checker:enable
 }
 
+#[test]
+fn test_numbered_lines_with_crlf() {
+    new_ucmd!()
+        .args(&["-n"])
+        .pipe_in("Hello\r\nWorld")
+        .succeeds()
+        .stdout_only("     1\tHello\r\n     2\tWorld");
+}
+
 #[test]
 fn test_stdin_show_nonprinting() {
-    for same_param in ["-v", "--show-nonprinting", "--show-non"] {
+    for same_param in ["-v", "-vv", "--show-nonprinting", "--show-non"] {
         new_ucmd!()
             .args(&[same_param])
             .pipe_in("\t\0\n")
@@ -279,7 +316,7 @@ fn test_stdin_show_nonprinting() {
 
 #[test]
 fn test_stdin_show_tabs() {
-    for same_param in ["-T", "--show-tabs", "--show-ta"] {
+    for same_param in ["-T", "-TT", "--show-tabs", "--show-ta"] {
         new_ucmd!()
             .args(&[same_param])
             .pipe_in("\t\0\n")
@@ -290,7 +327,7 @@ fn test_stdin_show_tabs() {
 
 #[test]
 fn test_stdin_show_ends() {
-    for same_param in ["-E", "--show-ends", "--show-e"] {
+    for same_param in ["-E", "-EE", "--show-ends", "--show-e"] {
         new_ucmd!()
             .args(&[same_param, "-"])
             .pipe_in("\t\0\n\t")
@@ -300,7 +337,7 @@ fn test_stdin_show_ends() {
 }
 
 #[test]
-fn squeeze_all_files() {
+fn test_squeeze_all_files() {
     // empty lines at the end of a file are "squeezed" together with empty lines at the beginning
     let (at, mut ucmd) = at_and_ucmd!();
     at.write("input1", "a\n\n");
@@ -310,6 +347,17 @@ fn squeeze_all_files() {
         .stdout_only("a\n\nb");
 }
 
+#[test]
+fn test_squeeze_all_files_repeated() {
+    // empty lines at the end of a file are "squeezed" together with empty lines at the beginning
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("input1", "a\n\n");
+    at.write("input2", "\n\nb");
+    ucmd.args(&["-s", "input1", "input2", "-s"])
+        .succeeds()
+        .stdout_only("a\n\nb");
+}
+
 #[test]
 fn test_show_ends_crlf() {
     new_ucmd!()
@@ -339,6 +387,15 @@ fn test_stdin_nonprinting_and_endofline() {
         .stdout_only("\t^@$\n");
 }
 
+#[test]
+fn test_stdin_nonprinting_and_endofline_repeated() {
+    new_ucmd!()
+        .args(&["-ee", "-e"])
+        .pipe_in("\t\0\n")
+        .succeeds()
+        .stdout_only("\t^@$\n");
+}
+
 #[test]
 fn test_stdin_nonprinting_and_tabs() {
     new_ucmd!()
@@ -348,6 +405,24 @@ fn test_stdin_nonprinting_and_tabs() {
         .stdout_only("^I^@\n");
 }
 
+#[test]
+fn test_stdin_nonprinting_and_tabs_repeated() {
+    new_ucmd!()
+        .args(&["-tt", "-t"])
+        .pipe_in("\t\0\n")
+        .succeeds()
+        .stdout_only("^I^@\n");
+}
+
+#[test]
+fn test_stdin_tabs_no_newline() {
+    new_ucmd!()
+        .args(&["-T"])
+        .pipe_in("\ta")
+        .succeeds()
+        .stdout_only("^Ia");
+}
+
 #[test]
 fn test_stdin_squeeze_blank() {
     for same_param in ["-s", "--squeeze-blank", "--squeeze"] {
@@ -362,7 +437,7 @@ fn test_stdin_squeeze_blank() {
 #[test]
 fn test_stdin_number_non_blank() {
     // spell-checker:disable-next-line
-    for same_param in ["-b", "--number-nonblank", "--number-non"] {
+    for same_param in ["-b", "-bb", "--number-nonblank", "--number-non"] {
         new_ucmd!()
             .arg(same_param)
             .arg("-")
@@ -384,6 +459,15 @@ fn test_non_blank_overrides_number() {
     }
 }
 
+#[test]
+fn test_non_blank_overrides_number_even_when_present() {
+    new_ucmd!()
+        .args(&["-n", "-b", "-n"])
+        .pipe_in("\na\nb\n\n\nc")
+        .succeeds()
+        .stdout_only("\n     1\ta\n     2\tb\n\n\n     3\tc");
+}
+
 #[test]
 fn test_squeeze_blank_before_numbering() {
     for same_param in ["-s", "--squeeze-blank"] {
@@ -425,7 +509,7 @@ fn test_dev_random() {
 }
 
 /// Reading from /dev/full should return an infinite amount of zero bytes.
-/// Wikipedia says there is support on Linux, FreeBSD, and NetBSD.
+/// Wikipedia says there is support on Linux, FreeBSD, and `NetBSD`.
 #[test]
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 fn test_dev_full() {
@@ -460,6 +544,21 @@ fn test_dev_full_show_all() {
     proc.kill();
 }
 
+// For some reason splice() on first of those files fails, resulting in
+// fallback inside `write_fast`, the other splice succeeds, in effect
+// without additional flush output gets reversed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_write_fast_fallthrough_uses_flush() {
+    const PROC_INIT_CMDLINE: &str = "/proc/1/cmdline";
+    let cmdline = std::fs::read_to_string(PROC_INIT_CMDLINE).unwrap();
+
+    new_ucmd!()
+        .args(&[PROC_INIT_CMDLINE, "alpha.txt"])
+        .succeeds()
+        .stdout_only(format!("{cmdline}abcde\nfghij\nklmno\npqrst\nuvwxyz\n")); // spell-checker:disable-line
+}
+
 #[test]
 #[cfg(unix)]
 #[ignore]
@@ -503,7 +602,6 @@ fn test_write_to_self_empty() {
 
     let file = OpenOptions::new()
         .create_new(true)
-        .write(true)
         .append(true)
         .open(&file_path)
         .unwrap();
@@ -519,7 +617,6 @@ fn test_write_to_self() {
 
     let file = OpenOptions::new()
         .create_new(true)
-        .write(true)
         .append(true)
         .open(file_path)
         .unwrap();
@@ -531,8 +628,7 @@ fn test_write_to_self() {
         .arg("first_file")
         .arg("first_file")
         .arg("second_file")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only("cat: first_file: input file is output file\ncat: first_file: input file is output file\n");
 
     assert_eq!(
@@ -540,3 +636,83 @@ fn test_write_to_self() {
         "first_file_content.second_file_content."
     );
 }
+
+#[test]
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
+fn test_error_loop() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.symlink_file("2", "1");
+    at.symlink_file("3", "2");
+    at.symlink_file("1", "3");
+    ucmd.arg("1")
+        .fails()
+        .stderr_is("cat: 1: Too many levels of symbolic links\n");
+}
+
+#[test]
+fn test_u_ignored() {
+    for same_param in ["-u", "-uu"] {
+        new_ucmd!()
+            .arg(same_param)
+            .pipe_in("hello")
+            .succeeds()
+            .stdout_only("hello");
+    }
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_appending_same_input_output() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.write("foo", "content");
+    let foo_file = at.plus_as_string("foo");
+
+    let file_read = File::open(&foo_file).unwrap();
+    let file_write = OpenOptions::new().append(true).open(&foo_file).unwrap();
+
+    ucmd.set_stdin(file_read);
+    ucmd.set_stdout(file_write);
+
+    ucmd.fails()
+        .no_stdout()
+        .stderr_contains("input file is output file");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_uchild_when_no_capture_reading_from_infinite_source() {
+    use regex::Regex;
+
+    let ts = TestScenario::new("cat");
+
+    let expected_stdout = b"\0".repeat(12345);
+    let mut child = ts
+        .ucmd()
+        .set_stdin(Stdio::from(File::open("/dev/zero").unwrap()))
+        .set_stdout(Stdio::piped())
+        .run_no_wait();
+
+    child
+        .make_assertion()
+        .with_exact_output(12345, 0)
+        .stdout_only_bytes(expected_stdout);
+
+    child
+        .kill()
+        .make_assertion()
+        .with_current_output()
+        .stdout_matches(&Regex::new("[\0].*").unwrap())
+        .no_stderr();
+}
+
+#[test]
+fn test_child_when_pipe_in() {
+    let ts = TestScenario::new("cat");
+    let mut child = ts.ucmd().set_stdin(Stdio::piped()).run_no_wait();
+    child.pipe_in("content");
+    child.wait().unwrap().stdout_only("content").success();
+
+    ts.ucmd().pipe_in("content").run().stdout_is("content");
+}
diff --git a/tests/by-util/test_chcon.rs b/tests/by-util/test_chcon.rs
index 71405e451d0..8c2ce9d1415 100644
--- a/tests/by-util/test_chcon.rs
+++ b/tests/by-util/test_chcon.rs
@@ -3,14 +3,17 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore (jargon) xattributes
-
+#![allow(clippy::missing_errors_doc, clippy::similar_names)]
 #![cfg(feature = "feat_selinux")]
 
 use std::ffi::CString;
 use std::path::Path;
 use std::{io, iter, str};
 
-use crate::common::util::*;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn version() {
@@ -88,6 +91,33 @@ fn valid_context_on_valid_symlink() {
     assert_eq!(get_file_context(dir.plus("a.tmp")).unwrap(), a_context);
 }
 
+#[test]
+fn valid_context_on_valid_symlink_override_dereference() {
+    let (dir, mut cmd) = at_and_ucmd!();
+    dir.touch("a.tmp");
+    dir.symlink_file("a.tmp", "la.tmp");
+
+    let a_context = get_file_context(dir.plus("a.tmp")).unwrap();
+    let la_context = get_file_context(dir.plus("la.tmp")).unwrap();
+    let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+    assert_ne!(a_context.as_deref(), Some(new_a_context));
+    assert_ne!(la_context.as_deref(), Some(new_a_context));
+
+    cmd.args(&[
+        "--verbose",
+        "--no-dereference",
+        "--dereference",
+        new_a_context,
+    ])
+    .arg(dir.plus("la.tmp"))
+    .succeeds();
+    assert_eq!(
+        get_file_context(dir.plus("a.tmp")).unwrap().as_deref(),
+        Some(new_a_context)
+    );
+    assert_eq!(get_file_context(dir.plus("la.tmp")).unwrap(), la_context);
+}
+
 #[test]
 fn valid_context_on_broken_symlink() {
     let (dir, mut cmd) = at_and_ucmd!();
@@ -104,6 +134,29 @@ fn valid_context_on_broken_symlink() {
     );
 }
 
+#[test]
+fn valid_context_on_broken_symlink_after_deref() {
+    let (dir, mut cmd) = at_and_ucmd!();
+    dir.symlink_file("a.tmp", "la.tmp");
+
+    let la_context = get_file_context(dir.plus("la.tmp")).unwrap();
+    let new_la_context = "guest_u:object_r:etc_t:s0:c42";
+    assert_ne!(la_context.as_deref(), Some(new_la_context));
+
+    cmd.args(&[
+        "--verbose",
+        "--dereference",
+        "--no-dereference",
+        new_la_context,
+    ])
+    .arg(dir.plus("la.tmp"))
+    .succeeds();
+    assert_eq!(
+        get_file_context(dir.plus("la.tmp")).unwrap().as_deref(),
+        Some(new_la_context)
+    );
+}
+
 #[test]
 fn valid_context_with_prior_xattributes() {
     let (dir, mut cmd) = at_and_ucmd!();
@@ -324,6 +377,30 @@ fn user_change() {
     );
 }
 
+#[test]
+fn user_change_repeated() {
+    let (dir, mut cmd) = at_and_ucmd!();
+
+    dir.touch("a.tmp");
+    let a_context = get_file_context(dir.plus("a.tmp")).unwrap();
+    let new_a_context = if let Some(a_context) = a_context {
+        let mut components: Vec<_> = a_context.split(':').collect();
+        components[0] = "guest_u";
+        components.join(":")
+    } else {
+        set_file_context(dir.plus("a.tmp"), "unconfined_u:object_r:user_tmp_t:s0").unwrap();
+        String::from("guest_u:object_r:user_tmp_t:s0")
+    };
+
+    cmd.args(&["--verbose", "--user=wrong", "--user=guest_u"])
+        .arg(dir.plus("a.tmp"))
+        .succeeds();
+    assert_eq!(
+        get_file_context(dir.plus("a.tmp")).unwrap(),
+        Some(new_a_context)
+    );
+}
+
 #[test]
 fn role_change() {
     let (dir, mut cmd) = at_and_ucmd!();
@@ -421,11 +498,105 @@ fn valid_reference() {
     );
 }
 
+#[test]
+fn valid_reference_repeat_flags() {
+    let (dir, mut cmd) = at_and_ucmd!();
+
+    dir.touch("a.tmp");
+    let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+    set_file_context(dir.plus("a.tmp"), new_a_context).unwrap();
+
+    dir.touch("b.tmp");
+    let b_context = get_file_context(dir.plus("b.tmp")).unwrap();
+    assert_ne!(b_context.as_deref(), Some(new_a_context));
+
+    cmd.arg("--verbose")
+        .arg("-vvRRHHLLPP") // spell-checker:disable-line
+        .arg("--no-preserve-root")
+        .arg("--no-preserve-root")
+        .arg("--preserve-root")
+        .arg("--preserve-root")
+        .arg("--dereference")
+        .arg("--dereference")
+        .arg("--no-dereference")
+        .arg("--no-dereference")
+        .arg(format!("--reference={}", dir.plus_as_string("a.tmp")))
+        .arg(dir.plus("b.tmp"))
+        .succeeds();
+    assert_eq!(
+        get_file_context(dir.plus("b.tmp")).unwrap().as_deref(),
+        Some(new_a_context)
+    );
+}
+
+#[test]
+#[ignore = "issue #7443"]
+fn valid_reference_repeated_reference() {
+    let (dir, mut cmd) = at_and_ucmd!();
+
+    dir.touch("a.tmp");
+    let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+    set_file_context(dir.plus("a.tmp"), new_a_context).unwrap();
+
+    dir.touch("wrong.tmp");
+    let new_wrong_context = "guest_u:object_r:etc_t:s42:c0";
+    set_file_context(dir.plus("wrong.tmp"), new_wrong_context).unwrap();
+
+    dir.touch("b.tmp");
+    let b_context = get_file_context(dir.plus("b.tmp")).unwrap();
+    assert_ne!(b_context.as_deref(), Some(new_a_context));
+
+    cmd.arg("--verbose")
+        .arg(format!("--reference={}", dir.plus_as_string("wrong.tmp")))
+        .arg(format!("--reference={}", dir.plus_as_string("a.tmp")))
+        .arg(dir.plus("b.tmp"))
+        .succeeds();
+    assert_eq!(
+        get_file_context(dir.plus("b.tmp")).unwrap().as_deref(),
+        Some(new_a_context)
+    );
+    assert_eq!(
+        get_file_context(dir.plus("wrong.tmp")).unwrap().as_deref(),
+        Some(new_wrong_context)
+    );
+}
+
+#[test]
+fn valid_reference_multi() {
+    let (dir, mut cmd) = at_and_ucmd!();
+
+    dir.touch("a.tmp");
+    let new_a_context = "guest_u:object_r:etc_t:s0:c42";
+    set_file_context(dir.plus("a.tmp"), new_a_context).unwrap();
+
+    dir.touch("b1.tmp");
+    let b1_context = get_file_context(dir.plus("b1.tmp")).unwrap();
+    assert_ne!(b1_context.as_deref(), Some(new_a_context));
+
+    dir.touch("b2.tmp");
+    let b2_context = get_file_context(dir.plus("b2.tmp")).unwrap();
+    assert_ne!(b2_context.as_deref(), Some(new_a_context));
+
+    cmd.arg("--verbose")
+        .arg(format!("--reference={}", dir.plus_as_string("a.tmp")))
+        .arg(dir.plus("b1.tmp"))
+        .arg(dir.plus("b2.tmp"))
+        .succeeds();
+    assert_eq!(
+        get_file_context(dir.plus("b1.tmp")).unwrap().as_deref(),
+        Some(new_a_context)
+    );
+    assert_eq!(
+        get_file_context(dir.plus("b2.tmp")).unwrap().as_deref(),
+        Some(new_a_context)
+    );
+}
+
 fn get_file_context(path: impl AsRef<Path>) -> Result<Option<String>, selinux::errors::Error> {
     let path = path.as_ref();
     match selinux::SecurityContext::of_path(path, false, false) {
         Err(r) => {
-            println!("get_file_context failed: '{}': {}.", path.display(), &r);
+            println!("get_file_context failed: '{}': {r}.", path.display());
             Err(r)
         }
 
@@ -444,7 +615,7 @@ fn get_file_context(path: impl AsRef<Path>) -> Result<Option<String>, selinux::e
                 .next()
                 .unwrap_or_default();
             let context = String::from_utf8(bytes.into()).unwrap_or_default();
-            println!("get_file_context: '{}' => '{}'.", context, path.display());
+            println!("get_file_context: '{context}' => '{}'.", path.display());
             Ok(Some(context))
         }
     }
@@ -461,13 +632,11 @@ fn set_file_context(path: impl AsRef<Path>, context: &str) -> Result<(), selinux
         selinux::SecurityContext::from_c_str(&c_context, false).set_for_path(path, false, false);
     if let Err(r) = &r {
         println!(
-            "set_file_context failed: '{}' => '{}': {}.",
-            context,
+            "set_file_context failed: '{context}' => '{}': {r}.",
             path.display(),
-            r
         );
     } else {
-        println!("set_file_context: '{}' => '{}'.", context, path.display());
+        println!("set_file_context: '{context}' => '{}'.", path.display());
     }
     r
 }
diff --git a/tests/by-util/test_chgrp.rs b/tests/by-util/test_chgrp.rs
index 07966b67b33..e50d2a19d2e 100644
--- a/tests/by-util/test_chgrp.rs
+++ b/tests/by-util/test_chgrp.rs
@@ -4,8 +4,11 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (words) nosuchgroup groupname
 
-use crate::common::util::TestScenario;
 use uucore::process::getegid;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_option() {
@@ -14,7 +17,7 @@ fn test_invalid_option() {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 static DIR: &str = "/dev";
@@ -56,7 +59,7 @@ fn test_invalid_group() {
 }
 
 #[test]
-fn test_1() {
+fn test_error_1() {
     if getegid() != 0 {
         new_ucmd!().arg("bin").arg(DIR).fails().stderr_contains(
             // linux fails with "Operation not permitted (os error 1)"
@@ -85,18 +88,28 @@ fn test_fail_silently() {
 #[test]
 fn test_preserve_root() {
     // It's weird that on OS X, `realpath /etc/..` returns '/private'
+    new_ucmd!()
+        .arg("--preserve-root")
+        .arg("-R")
+        .arg("bin")
+        .arg("/")
+        .fails()
+        .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe\n");
     for d in [
-        "/",
         "/////dev///../../../../",
         "../../../../../../../../../../../../../../",
         "./../../../../../../../../../../../../../../",
     ] {
+        let expected_error = format!(
+            "chgrp: it is dangerous to operate recursively on '{d}' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n",
+        );
         new_ucmd!()
             .arg("--preserve-root")
             .arg("-R")
-            .arg("bin").arg(d)
+            .arg("bin")
+            .arg(d)
             .fails()
-            .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe\n");
+            .stderr_is(expected_error);
     }
 }
 
@@ -105,17 +118,21 @@ fn test_preserve_root_symlink() {
     let file = "test_chgrp_symlink2root";
     for d in [
         "/",
+        "//",
+        "///",
         "////dev//../../../../",
         "..//../../..//../..//../../../../../../../../",
         ".//../../../../../../..//../../../../../../../",
     ] {
         let (at, mut ucmd) = at_and_ucmd!();
         at.symlink_file(d, file);
+        let expected_error = "chgrp: it is dangerous to operate recursively on 'test_chgrp_symlink2root' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n";
         ucmd.arg("--preserve-root")
             .arg("-HR")
-            .arg("bin").arg(file)
+            .arg("bin")
+            .arg(file)
             .fails()
-            .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe\n");
+            .stderr_is(expected_error);
     }
 
     let (at, mut ucmd) = at_and_ucmd!();
@@ -124,7 +141,7 @@ fn test_preserve_root_symlink() {
         .arg("-HR")
         .arg("bin").arg(format!(".//{file}/..//..//../../"))
         .fails()
-        .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe\n");
+        .stderr_is("chgrp: it is dangerous to operate recursively on './/test_chgrp_symlink2root/..//..//../../' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.symlink_file("/", "__root__");
@@ -132,7 +149,47 @@ fn test_preserve_root_symlink() {
         .arg("-R")
         .arg("bin").arg("__root__/.")
         .fails()
-        .stderr_is("chgrp: it is dangerous to operate recursively on '/'\nchgrp: use --no-preserve-root to override this failsafe\n");
+        .stderr_is("chgrp: it is dangerous to operate recursively on '__root__/.' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+}
+
+#[test]
+fn test_preserve_root_symlink_cwd_root() {
+    new_ucmd!()
+        .current_dir("/")
+        .arg("--preserve-root")
+        .arg("-R")
+        .arg("bin").arg(".")
+        .fails()
+        .stderr_is("chgrp: it is dangerous to operate recursively on '.' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+    new_ucmd!()
+        .current_dir("/")
+        .arg("--preserve-root")
+        .arg("-R")
+        .arg("bin").arg("/.")
+        .fails()
+        .stderr_is("chgrp: it is dangerous to operate recursively on '/.' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+    new_ucmd!()
+        .current_dir("/")
+        .arg("--preserve-root")
+        .arg("-R")
+        .arg("bin").arg("..")
+        .fails()
+        .stderr_is("chgrp: it is dangerous to operate recursively on '..' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+    new_ucmd!()
+        .current_dir("/")
+        .arg("--preserve-root")
+        .arg("-R")
+        .arg("bin").arg("/..")
+        .fails()
+        .stderr_is("chgrp: it is dangerous to operate recursively on '/..' (same as '/')\nchgrp: use --no-preserve-root to override this failsafe\n");
+    new_ucmd!()
+        .current_dir("/")
+        .arg("--preserve-root")
+        .arg("-R")
+        .arg("bin")
+        .arg("...")
+        .fails()
+        .stderr_is("chgrp: cannot access '...': No such file or directory\n");
 }
 
 #[test]
@@ -332,8 +389,14 @@ fn test_traverse_symlinks() {
             .arg("dir3/file")
             .succeeds();
 
-        assert!(at.plus("dir2/file").metadata().unwrap().gid() == first_group.as_raw());
-        assert!(at.plus("dir3/file").metadata().unwrap().gid() == first_group.as_raw());
+        assert_eq!(
+            at.plus("dir2/file").metadata().unwrap().gid(),
+            first_group.as_raw()
+        );
+        assert_eq!(
+            at.plus("dir3/file").metadata().unwrap().gid(),
+            first_group.as_raw()
+        );
 
         ucmd.arg("-R")
             .args(args)
@@ -361,3 +424,179 @@ fn test_traverse_symlinks() {
         );
     }
 }
+
+#[test]
+#[cfg(not(target_vendor = "apple"))]
+fn test_from_option() {
+    use std::os::unix::fs::MetadataExt;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let groups = nix::unistd::getgroups().unwrap();
+    // Skip test if we don't have at least two different groups to work with
+    if groups.len() < 2 {
+        return;
+    }
+    let (first_group, second_group) = (groups[0], groups[1]);
+
+    at.touch("test_file");
+    scene
+        .ucmd()
+        .arg(first_group.to_string())
+        .arg("test_file")
+        .succeeds();
+
+    // Test successful group change with --from
+    scene
+        .ucmd()
+        .arg("--from")
+        .arg(first_group.to_string())
+        .arg(second_group.to_string())
+        .arg("test_file")
+        .succeeds()
+        .no_stderr();
+
+    // Verify the group was changed
+    let new_gid = at.plus("test_file").metadata().unwrap().gid();
+    assert_eq!(new_gid, second_group.as_raw());
+
+    scene
+        .ucmd()
+        .arg("--from")
+        .arg(first_group.to_string())
+        .arg(first_group.to_string())
+        .arg("test_file")
+        .succeeds()
+        .no_stderr();
+
+    let unchanged_gid = at.plus("test_file").metadata().unwrap().gid();
+    assert_eq!(unchanged_gid, second_group.as_raw());
+}
+
+#[test]
+#[cfg(not(any(target_os = "android", target_os = "macos")))]
+fn test_from_with_invalid_group() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("test_file");
+    #[cfg(not(target_os = "android"))]
+    let err_msg = "chgrp: invalid user: 'nonexistent_group'\n";
+    #[cfg(target_os = "android")]
+    let err_msg = "chgrp: invalid user: 'staff'\n";
+
+    ucmd.arg("--from")
+        .arg("nonexistent_group")
+        .arg("staff")
+        .arg("test_file")
+        .fails()
+        .stderr_is(err_msg);
+}
+
+#[test]
+#[cfg(not(target_vendor = "apple"))]
+fn test_verbosity_messages() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let groups = nix::unistd::getgroups().unwrap();
+    // Skip test if we don't have at least one group to work with
+    if groups.is_empty() {
+        return;
+    }
+
+    at.touch("ref_file");
+    at.touch("target_file");
+
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--reference=ref_file")
+        .arg("target_file")
+        .succeeds()
+        .stderr_contains("group of 'target_file' retained as ");
+}
+
+#[test]
+#[cfg(not(target_vendor = "apple"))]
+fn test_from_with_reference() {
+    use std::os::unix::fs::MetadataExt;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let groups = nix::unistd::getgroups().unwrap();
+    if groups.len() < 2 {
+        return;
+    }
+    let (first_group, second_group) = (groups[0], groups[1]);
+
+    at.touch("ref_file");
+    at.touch("test_file");
+
+    scene
+        .ucmd()
+        .arg(first_group.to_string())
+        .arg("test_file")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg(second_group.to_string())
+        .arg("ref_file")
+        .succeeds();
+
+    // Test --from with --reference
+    scene
+        .ucmd()
+        .arg("--from")
+        .arg(first_group.to_string())
+        .arg("--reference=ref_file")
+        .arg("test_file")
+        .succeeds()
+        .no_stderr();
+
+    let new_gid = at.plus("test_file").metadata().unwrap().gid();
+    let ref_gid = at.plus("ref_file").metadata().unwrap().gid();
+    assert_eq!(new_gid, ref_gid);
+}
+
+#[test]
+#[cfg(not(target_vendor = "apple"))]
+fn test_numeric_group_formats() {
+    use std::os::unix::fs::MetadataExt;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let groups = nix::unistd::getgroups().unwrap();
+    if groups.len() < 2 {
+        return;
+    }
+    let (first_group, second_group) = (groups[0], groups[1]);
+
+    at.touch("test_file");
+
+    scene
+        .ucmd()
+        .arg(first_group.to_string())
+        .arg("test_file")
+        .succeeds();
+
+    // Test :gid format in --from
+    scene
+        .ucmd()
+        .arg(format!("--from=:{}", first_group.as_raw()))
+        .arg(second_group.to_string())
+        .arg("test_file")
+        .succeeds()
+        .no_stderr();
+
+    let new_gid = at.plus("test_file").metadata().unwrap().gid();
+    assert_eq!(new_gid, second_group.as_raw());
+
+    // Test :gid format in target group
+    scene
+        .ucmd()
+        .arg(format!("--from={}", second_group.as_raw()))
+        .arg(format!(":{}", first_group.as_raw()))
+        .arg("test_file")
+        .succeeds()
+        .no_stderr();
+
+    let final_gid = at.plus("test_file").metadata().unwrap().gid();
+    assert_eq!(final_gid, first_group.as_raw());
+}
diff --git a/tests/by-util/test_chmod.rs b/tests/by-util/test_chmod.rs
index be730a8c0ad..8386c4d32f7 100644
--- a/tests/by-util/test_chmod.rs
+++ b/tests/by-util/test_chmod.rs
@@ -2,23 +2,24 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::{AtPath, TestScenario, UCommand};
-use once_cell::sync::Lazy;
-use std::fs::{metadata, set_permissions, OpenOptions, Permissions};
+
+use std::fs::{OpenOptions, Permissions, metadata, set_permissions};
 use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
-use std::sync::Mutex;
+use uutests::at_and_ucmd;
+use uutests::util::{AtPath, TestScenario, UCommand};
 
-use libc::umask;
+use uutests::new_ucmd;
+use uutests::util_name;
 
 static TEST_FILE: &str = "file";
 static REFERENCE_FILE: &str = "reference";
 static REFERENCE_PERMS: u32 = 0o247;
-static UMASK_MUTEX: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
 
 struct TestCase {
     args: Vec<&'static str>,
     before: u32,
     after: u32,
+    umask: Option<libc::mode_t>,
 }
 
 fn make_file(file: &str, mode: u32) {
@@ -36,15 +37,18 @@ fn make_file(file: &str, mode: u32) {
 fn run_single_test(test: &TestCase, at: &AtPath, mut ucmd: UCommand) {
     make_file(&at.plus_as_string(TEST_FILE), test.before);
     let perms = at.metadata(TEST_FILE).permissions().mode();
-    if perms != test.before {
-        panic!(
-            "{}: expected: {:o} got: {:o}",
-            "setting permissions on test files before actual test run failed", test.after, perms
-        );
-    }
+
+    assert_eq!(
+        perms, test.before,
+        "{}: expected: {:o} got: {perms:o}",
+        "setting permissions on test files before actual test run failed", test.after
+    );
 
     for arg in &test.args {
         ucmd.arg(arg);
+        if let Some(umask) = test.umask {
+            ucmd.umask(umask);
+        }
     }
     let r = ucmd.run();
     if !r.succeeded() {
@@ -53,9 +57,11 @@ fn run_single_test(test: &TestCase, at: &AtPath, mut ucmd: UCommand) {
     }
 
     let perms = at.metadata(TEST_FILE).permissions().mode();
-    if perms != test.after {
-        panic!("{}: expected: {:o} got: {:o}", ucmd, test.after, perms);
-    }
+    assert_eq!(
+        perms, test.after,
+        "{ucmd}: expected: {:o} got: {perms:o}",
+        test.after
+    );
 }
 
 fn run_tests(tests: Vec<TestCase>) {
@@ -73,46 +79,55 @@ fn test_chmod_octal() {
             args: vec!["0700", TEST_FILE],
             before: 0o100000,
             after: 0o100700,
+            umask: None,
         },
         TestCase {
             args: vec!["0070", TEST_FILE],
             before: 0o100000,
             after: 0o100070,
+            umask: None,
         },
         TestCase {
             args: vec!["0007", TEST_FILE],
             before: 0o100000,
             after: 0o100007,
+            umask: None,
         },
         TestCase {
             args: vec!["-0700", TEST_FILE],
             before: 0o100700,
             after: 0o100000,
+            umask: None,
         },
         TestCase {
             args: vec!["-0070", TEST_FILE],
             before: 0o100060,
             after: 0o100000,
+            umask: None,
         },
         TestCase {
             args: vec!["-0007", TEST_FILE],
             before: 0o100001,
             after: 0o100000,
+            umask: None,
         },
         TestCase {
             args: vec!["+0100", TEST_FILE],
             before: 0o100600,
             after: 0o100700,
+            umask: None,
         },
         TestCase {
             args: vec!["+0020", TEST_FILE],
             before: 0o100050,
             after: 0o100070,
+            umask: None,
         },
         TestCase {
             args: vec!["+0004", TEST_FILE],
             before: 0o100003,
             after: 0o100007,
+            umask: None,
         },
     ];
     run_tests(tests);
@@ -120,109 +135,144 @@ fn test_chmod_octal() {
 
 #[test]
 #[allow(clippy::unreadable_literal)]
+#[allow(clippy::too_many_lines)]
 // spell-checker:disable-next-line
 fn test_chmod_ugoa() {
-    let _guard = UMASK_MUTEX.lock();
-
-    let last = unsafe { umask(0) };
     let tests = vec![
         TestCase {
             args: vec!["u=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100700,
+            umask: Some(0),
         },
         TestCase {
             args: vec!["g=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100070,
+            umask: Some(0),
         },
         TestCase {
             args: vec!["o=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100007,
+            umask: Some(0),
         },
         TestCase {
             args: vec!["a=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100777,
+            umask: Some(0),
         },
         TestCase {
             args: vec!["-r", TEST_FILE],
             before: 0o100777,
             after: 0o100333,
+            umask: Some(0),
         },
         TestCase {
             args: vec!["-w", TEST_FILE],
             before: 0o100777,
             after: 0o100555,
+            umask: Some(0),
         },
         TestCase {
             args: vec!["-x", TEST_FILE],
             before: 0o100777,
             after: 0o100666,
+            umask: Some(0),
         },
     ];
     run_tests(tests);
 
-    unsafe {
-        umask(0o022);
-    }
     let tests = vec![
         TestCase {
             args: vec!["u=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100700,
+            umask: Some(0o022),
         },
         TestCase {
             args: vec!["g=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100070,
+            umask: Some(0o022),
         },
         TestCase {
             args: vec!["o=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100007,
+            umask: Some(0o022),
         },
         TestCase {
             args: vec!["a=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100777,
+            umask: Some(0o022),
         },
         TestCase {
             args: vec!["+rw", TEST_FILE],
             before: 0o100000,
             after: 0o100644,
+            umask: Some(0o022),
         },
         TestCase {
             args: vec!["=rwx", TEST_FILE],
             before: 0o100000,
             after: 0o100755,
+            umask: Some(0o022),
         },
         TestCase {
             args: vec!["-x", TEST_FILE],
             before: 0o100777,
             after: 0o100666,
+            umask: Some(0o022),
         },
     ];
     run_tests(tests);
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+// TODO fix android, it has 0777
+// We should force for the umask on startup
+fn test_chmod_umask_expected() {
+    let current_umask = uucore::mode::get_umask();
+    assert_eq!(
+        current_umask, 0o022,
+        "Unexpected umask value: expected 022 (octal), but got {current_umask:03o}. Please adjust the test environment.",
+    );
+}
+
+fn get_expected_symlink_permissions() -> u32 {
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    {
+        0o120_777
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "android")))]
+    {
+        0o120_755
+    }
+}
 
+#[test]
+fn test_chmod_error_permissions() {
     // check that we print an error if umask prevents us from removing a permission
     let (at, mut ucmd) = at_and_ucmd!();
+
     at.touch("file");
     set_permissions(at.plus("file"), Permissions::from_mode(0o777)).unwrap();
+
     ucmd.args(&["-w", "file"])
-        .fails()
-        .code_is(1)
-        // spell-checker:disable-next-line
-        .stderr_is("chmod: file: new permissions are r-xrwxrwx, not r-xr-xr-x\n");
+        .umask(0o022)
+        .fails_with_code(1)
+        .stderr_is(
+            // spell-checker:disable-next-line
+            "chmod: file: new permissions are r-xrwxrwx, not r-xr-xr-x\n",
+        );
     assert_eq!(
         metadata(at.plus("file")).unwrap().permissions().mode(),
-        0o100577
+        0o100_577
     );
-
-    unsafe {
-        umask(last);
-    }
 }
 
 #[test]
@@ -233,26 +283,31 @@ fn test_chmod_ugo_copy() {
             args: vec!["u=g", TEST_FILE],
             before: 0o100070,
             after: 0o100770,
+            umask: None,
         },
         TestCase {
             args: vec!["g=o", TEST_FILE],
             before: 0o100005,
             after: 0o100055,
+            umask: None,
         },
         TestCase {
             args: vec!["o=u", TEST_FILE],
             before: 0o100200,
             after: 0o100202,
+            umask: None,
         },
         TestCase {
             args: vec!["u-g", TEST_FILE],
             before: 0o100710,
             after: 0o100610,
+            umask: None,
         },
         TestCase {
             args: vec!["u+g", TEST_FILE],
             before: 0o100250,
             after: 0o100750,
+            umask: None,
         },
     ];
     run_tests(tests);
@@ -261,33 +316,30 @@ fn test_chmod_ugo_copy() {
 #[test]
 #[allow(clippy::unreadable_literal)]
 fn test_chmod_many_options() {
-    let _guard = UMASK_MUTEX.lock();
-
-    let original_umask = unsafe { umask(0) };
     let tests = vec![TestCase {
         args: vec!["-r,a+w", TEST_FILE],
         before: 0o100444,
         after: 0o100222,
+        umask: Some(0),
     }];
     run_tests(tests);
-    unsafe {
-        umask(original_umask);
-    }
 }
 
 #[test]
 #[allow(clippy::unreadable_literal)]
 fn test_chmod_reference_file() {
-    let tests = vec![
+    let tests = [
         TestCase {
             args: vec!["--reference", REFERENCE_FILE, TEST_FILE],
             before: 0o100070,
             after: 0o100247,
+            umask: None,
         },
         TestCase {
             args: vec!["a-w", "--reference", REFERENCE_FILE, TEST_FILE],
             before: 0o100070,
             after: 0o100247,
+            umask: None,
         },
     ];
     let (at, ucmd) = at_and_ucmd!();
@@ -318,14 +370,16 @@ fn test_permission_denied() {
 #[test]
 #[allow(clippy::unreadable_literal)]
 fn test_chmod_recursive() {
-    let _guard = UMASK_MUTEX.lock();
-
-    let original_umask = unsafe { umask(0) };
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("a");
     at.mkdir("a/b");
     at.mkdir("a/b/c");
     at.mkdir("z");
+
+    // create expected permissions by removing read bits and write bits to the current perms
+    let a_perms_expected = (at.metadata("a").permissions().mode() & !0o444) | 0o222;
+    let z_perms_expected = (at.metadata("z").permissions().mode() & !0o444) | 0o222;
+
     make_file(&at.plus_as_string("a/a"), 0o100444);
     make_file(&at.plus_as_string("a/b/b"), 0o100444);
     make_file(&at.plus_as_string("a/b/c/c"), 0o100444);
@@ -338,6 +392,7 @@ fn test_chmod_recursive() {
         .arg("-r,a+w")
         .arg("a")
         .arg("z")
+        .umask(0)
         .fails()
         .stderr_is("chmod: Permission denied\n");
 
@@ -346,12 +401,8 @@ fn test_chmod_recursive() {
     assert_eq!(at.metadata("a/b/b").permissions().mode(), 0o100444);
     assert_eq!(at.metadata("a/b/c/c").permissions().mode(), 0o100444);
     println!("mode {:o}", at.metadata("a").permissions().mode());
-    assert_eq!(at.metadata("a").permissions().mode(), 0o40333);
-    assert_eq!(at.metadata("z").permissions().mode(), 0o40333);
-
-    unsafe {
-        umask(original_umask);
-    }
+    assert_eq!(at.metadata("a").permissions().mode(), a_perms_expected);
+    assert_eq!(at.metadata("z").permissions().mode(), z_perms_expected);
 }
 
 #[test]
@@ -388,9 +439,8 @@ fn test_chmod_non_existing_file_silent() {
         .arg("--quiet")
         .arg("-r,a+w")
         .arg("does-not-exist")
-        .fails()
-        .no_stderr()
-        .code_is(1);
+        .fails_with_code(1)
+        .no_stderr();
 }
 
 #[test]
@@ -400,7 +450,7 @@ fn test_chmod_preserve_root() {
         .arg("--preserve-root")
         .arg("755")
         .arg("/")
-        .fails()
+        .fails_with_code(1)
         .stderr_contains("chmod: it is dangerous to operate recursively on '/'");
 }
 
@@ -424,8 +474,7 @@ fn test_chmod_symlink_non_existing_file() {
         .arg("755")
         .arg("-v")
         .arg(test_symlink)
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_contains(expected_stdout)
         .stderr_contains(expected_stderr);
 
@@ -436,8 +485,7 @@ fn test_chmod_symlink_non_existing_file() {
         .arg("-v")
         .arg("-f")
         .arg(test_symlink)
-        .run()
-        .code_is(1)
+        .fails_with_code(1)
         .no_stderr()
         .stdout_contains(expected_stdout);
 
@@ -447,8 +495,7 @@ fn test_chmod_symlink_non_existing_file() {
         .ucmd()
         .arg("755")
         .arg(test_symlink)
-        .run()
-        .code_is(1)
+        .fails_with_code(1)
         .no_stdout()
         .stderr_contains(expected_stderr);
 }
@@ -531,14 +578,13 @@ fn test_chmod_keep_setgid() {
 fn test_no_operands() {
     new_ucmd!()
         .arg("777")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .usage_error("missing operand");
 }
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -550,6 +596,7 @@ fn test_mode_after_dash_dash() {
             args: vec!["--", "-r", TEST_FILE],
             before: 0o100_777,
             after: 0o100_333,
+            umask: None,
         },
         &at,
         ucmd,
@@ -569,9 +616,8 @@ fn test_chmod_file_after_non_existing_file() {
         .arg("u+x")
         .arg("does-not-exist")
         .arg(TEST_FILE)
-        .fails()
-        .stderr_contains("chmod: cannot access 'does-not-exist': No such file or directory")
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_contains("chmod: cannot access 'does-not-exist': No such file or directory");
 
     assert_eq!(at.metadata(TEST_FILE).permissions().mode(), 0o100_764);
 
@@ -581,9 +627,8 @@ fn test_chmod_file_after_non_existing_file() {
         .arg("--q")
         .arg("does-not-exist")
         .arg("file2")
-        .fails()
-        .no_stderr()
-        .code_is(1);
+        .fails_with_code(1)
+        .no_stderr();
     assert_eq!(at.metadata("file2").permissions().mode(), 0o100_764);
 }
 
@@ -614,13 +659,15 @@ fn test_chmod_file_symlink_after_non_existing_file() {
         .arg("-v")
         .arg(test_dangling_symlink)
         .arg(test_existing_symlink)
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_contains(expected_stdout)
         .stderr_contains(expected_stderr);
     assert_eq!(
         at.metadata(test_existing_symlink).permissions().mode(),
-        0o100_764
+        0o100_764,
+        "Expected mode: {:o}, but got: {:o}",
+        0o100_764,
+        at.metadata(test_existing_symlink).permissions().mode()
     );
 }
 
@@ -645,6 +692,20 @@ fn test_quiet_n_verbose_used_multiple_times() {
         .succeeds();
 }
 
+#[test]
+fn test_changes_from_identical_reference() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+    scene
+        .ucmd()
+        .arg("-c")
+        .arg("--reference=file")
+        .arg("file")
+        .succeeds()
+        .no_stdout();
+}
+
 #[test]
 fn test_gnu_invalid_mode() {
     let scene = TestScenario::new(util_name!());
@@ -710,3 +771,259 @@ fn test_gnu_special_options() {
     scene.ucmd().arg("--").arg("--").arg("file").succeeds();
     scene.ucmd().arg("--").arg("--").fails();
 }
+
+#[test]
+fn test_chmod_dereference_symlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let target = "file";
+    let symlink = "symlink";
+
+    at.touch(target);
+    set_permissions(at.plus(target), Permissions::from_mode(0o664)).unwrap();
+    at.symlink_file(target, symlink);
+
+    // Use --dereference: should modify the target file's permissions
+    scene
+        .ucmd()
+        .arg("--dereference")
+        .arg("u+x")
+        .arg(symlink)
+        .succeeds()
+        .no_stderr();
+    assert_eq!(at.metadata(target).permissions().mode(), 0o100_764);
+    assert_eq!(
+        at.symlink_metadata(symlink).permissions().mode(),
+        get_expected_symlink_permissions()
+    );
+}
+
+#[test]
+fn test_chmod_no_dereference_symlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let target = "file";
+    let symlink = "symlink";
+
+    at.touch(target);
+    set_permissions(at.plus(target), Permissions::from_mode(0o664)).unwrap();
+    at.symlink_file(target, symlink);
+
+    scene
+        .ucmd()
+        .arg("--no-dereference")
+        .arg("u+x")
+        .arg(symlink)
+        .succeeds()
+        .no_stderr();
+    assert_eq!(at.metadata(target).permissions().mode(), 0o100_664);
+    assert_eq!(
+        at.symlink_metadata(symlink).permissions().mode(),
+        get_expected_symlink_permissions()
+    );
+}
+
+#[test]
+fn test_chmod_symlink_to_dangling_target_dereference() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let dangling_target = "nonexistent_file";
+    let symlink = "symlink";
+
+    at.symlink_file(dangling_target, symlink);
+
+    // Use --dereference: should fail due to dangling symlink
+    scene
+        .ucmd()
+        .arg("--dereference")
+        .arg("u+x")
+        .arg(symlink)
+        .fails()
+        .stderr_contains(format!("cannot operate on dangling symlink '{symlink}'"));
+}
+
+#[test]
+fn test_chmod_symlink_target_no_dereference() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file = "a";
+    let symlink = "symlink";
+    at.touch(file);
+    at.symlink_file(file, symlink);
+    set_permissions(at.plus(file), Permissions::from_mode(0o644)).unwrap();
+
+    scene
+        .ucmd()
+        .arg("--no-dereference")
+        .arg("755")
+        .arg(symlink)
+        .succeeds()
+        .no_stderr();
+    assert_eq!(
+        at.symlink_metadata(file).permissions().mode(),
+        0o100_644,
+        "Expected symlink permissions: {:o}, but got: {:o}",
+        0o100_644,
+        at.symlink_metadata(file).permissions().mode()
+    );
+}
+
+#[test]
+fn test_chmod_symlink_recursive_final_traversal_flag() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let dangling_target = "nonexistent_file";
+    let symlink = "symlink";
+
+    at.symlink_file(dangling_target, symlink);
+
+    scene
+        .ucmd()
+        .arg("755")
+        .arg("-R")
+        .arg("-H")
+        .arg("-L")
+        .arg("-H")
+        .arg("-L")
+        .arg("-P")
+        .arg(symlink)
+        .succeeds()
+        .no_output();
+    assert_eq!(
+        at.symlink_metadata(symlink).permissions().mode(),
+        get_expected_symlink_permissions(),
+        "Expected symlink permissions: {:o}, but got: {:o}",
+        get_expected_symlink_permissions(),
+        at.symlink_metadata(symlink).permissions().mode()
+    );
+}
+
+#[test]
+fn test_chmod_symlink_to_dangling_recursive_no_traverse() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let dangling_target = "nonexistent_file";
+    let symlink = "symlink";
+
+    at.symlink_file(dangling_target, symlink);
+
+    scene
+        .ucmd()
+        .arg("755")
+        .arg("-R")
+        .arg("-P")
+        .arg(symlink)
+        .succeeds()
+        .no_output();
+    assert_eq!(
+        at.symlink_metadata(symlink).permissions().mode(),
+        get_expected_symlink_permissions(),
+        "Expected symlink permissions: {:o}, but got: {:o}",
+        get_expected_symlink_permissions(),
+        at.symlink_metadata(symlink).permissions().mode()
+    );
+}
+
+#[test]
+fn test_chmod_dangling_symlink_recursive_combos() {
+    let error_scenarios = [vec!["-R"], vec!["-R", "-H"], vec!["-R", "-L"]];
+
+    for flags in error_scenarios {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+
+        let dangling_target = "nonexistent_file";
+        let symlink = "symlink";
+
+        at.symlink_file(dangling_target, symlink);
+
+        let mut ucmd = scene.ucmd();
+        for f in &flags {
+            ucmd.arg(f);
+        }
+        ucmd.arg("u+x")
+            .umask(0o022)
+            .arg(symlink)
+            .fails()
+            .stderr_is("chmod: cannot operate on dangling symlink 'symlink'\n");
+        assert_eq!(
+            at.symlink_metadata(symlink).permissions().mode(),
+            get_expected_symlink_permissions(),
+            "Expected symlink permissions: {:o}, but got: {:o}",
+            get_expected_symlink_permissions(),
+            at.symlink_metadata(symlink).permissions().mode()
+        );
+    }
+}
+
+#[test]
+fn test_chmod_traverse_symlink_combo() {
+    let scenarios = [
+        (
+            vec!["-R"], // Should default to "-H"
+            0o100_664,
+            get_expected_symlink_permissions(),
+        ),
+        (
+            vec!["-R", "-H"],
+            0o100_664,
+            get_expected_symlink_permissions(),
+        ),
+        (
+            vec!["-R", "-L"],
+            0o100_764,
+            get_expected_symlink_permissions(),
+        ),
+        (
+            vec!["-R", "-P"],
+            0o100_664,
+            get_expected_symlink_permissions(),
+        ),
+    ];
+
+    for (flags, expected_target_perms, expected_symlink_perms) in scenarios {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+
+        let directory = "dir";
+        let target = "file";
+        let symlink = "symlink";
+
+        at.mkdir(directory);
+        at.touch(target);
+        at.symlink_file(target, &format!("{directory}/{symlink}"));
+
+        set_permissions(at.plus(target), Permissions::from_mode(0o664)).unwrap();
+
+        let mut ucmd = scene.ucmd();
+        for f in &flags {
+            ucmd.arg(f);
+        }
+        ucmd.arg("u+x")
+            .umask(0o022)
+            .arg(directory)
+            .succeeds()
+            .no_stderr();
+
+        let actual_target = at.metadata(target).permissions().mode();
+        assert_eq!(
+            actual_target, expected_target_perms,
+            "For flags {flags:?}, expected target perms = {expected_target_perms:o}, got = {actual_target:o}",
+        );
+
+        let actual_symlink = at
+            .symlink_metadata(&format!("{directory}/{symlink}"))
+            .permissions()
+            .mode();
+        assert_eq!(
+            actual_symlink, expected_symlink_perms,
+            "For flags {flags:?}, expected symlink perms = {expected_symlink_perms:o}, got = {actual_symlink:o}",
+        );
+    }
+}
diff --git a/tests/by-util/test_chown.rs b/tests/by-util/test_chown.rs
index 0a2e23c6d32..33bc4b850de 100644
--- a/tests/by-util/test_chown.rs
+++ b/tests/by-util/test_chown.rs
@@ -4,10 +4,11 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (words) agroupthatdoesntexist auserthatdoesntexist cuuser groupname notexisting passgrp
 
-use crate::common::util::{is_ci, run_ucmd_as_root, CmdResult, TestScenario};
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use uucore::process::geteuid;
-
+use uutests::new_ucmd;
+use uutests::util::{CmdResult, TestScenario, is_ci, run_ucmd_as_root};
+use uutests::util_name;
 // 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
 // considered okay. If we are not inside the CI this calls assert!(result.success).
@@ -29,9 +30,8 @@ fn skipping_test_is_okay(result: &CmdResult, needle: &str) -> bool {
         if is_ci() && result.stderr_str().contains(needle) {
             println!("test skipped:");
             return true;
-        } else {
-            result.success();
         }
+        result.success();
     }
     false
 }
@@ -82,7 +82,7 @@ fn test_invalid_option() {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -103,13 +103,13 @@ fn test_chown_only_owner() {
     at.touch(file1);
 
     // since only superuser can change owner, we have to change from ourself to ourself
-    let result = scene
+    scene
         .ucmd()
         .arg(user_name)
         .arg("--verbose")
         .arg(file1)
-        .run();
-    result.stderr_contains("retained as");
+        .succeeds()
+        .stderr_contains("retained as");
 
     // try to change to another existing user, e.g. 'root'
     scene
@@ -219,7 +219,7 @@ fn test_chown_failed_stdout() {
 
 #[test]
 // FixME: Fails on freebsd because of chown: invalid group: 'root:root'
-#[cfg(not(target_os = "freebsd"))]
+#[cfg(all(not(target_os = "freebsd"), not(target_os = "openbsd")))]
 fn test_chown_owner_group() {
     // test chown username:group file.txt
 
@@ -284,7 +284,7 @@ fn test_chown_owner_group() {
 
 #[test]
 // FixME: Fails on freebsd because of chown: invalid group: 'root:root'
-#[cfg(not(target_os = "freebsd"))]
+#[cfg(all(not(target_os = "freebsd"), not(target_os = "openbsd")))]
 fn test_chown_various_input() {
     // test chown username:group file.txt
 
@@ -347,7 +347,10 @@ fn test_chown_various_input() {
 // FixME: on macos & freebsd group name is not recognized correctly: "chown: invalid group: ':groupname'
 #[cfg(any(
     windows,
-    all(unix, not(any(target_os = "macos", target_os = "freebsd")))
+    all(
+        unix,
+        not(any(target_os = "macos", target_os = "freebsd", target_os = "openbsd"))
+    )
 ))]
 fn test_chown_only_group() {
     // test chown :group file.txt
@@ -471,7 +474,7 @@ fn test_chown_fail_id() {
 #[test]
 fn test_chown_only_user_id_nonexistent_user() {
     let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures.clone();
+    let at = &ts.fixtures;
     at.touch("f");
     if let Ok(result) = run_ucmd_as_root(&ts, &["12345", "f"]) {
         result.success().no_stdout().no_stderr();
@@ -482,7 +485,7 @@ fn test_chown_only_user_id_nonexistent_user() {
 
 #[test]
 // FixME: stderr = chown: ownership of 'test_chown_file1' retained as cuuser:wheel
-#[cfg(not(target_os = "freebsd"))]
+#[cfg(all(not(target_os = "freebsd"), not(target_os = "openbsd")))]
 fn test_chown_only_group_id() {
     // test chown :1111 file.txt
 
@@ -537,7 +540,7 @@ fn test_chown_only_group_id() {
 #[test]
 fn test_chown_only_group_id_nonexistent_group() {
     let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures.clone();
+    let at = &ts.fixtures;
     at.touch("f");
     if let Ok(result) = run_ucmd_as_root(&ts, &[":12345", "f"]) {
         result.success().no_stdout().no_stderr();
@@ -547,6 +550,7 @@ fn test_chown_only_group_id_nonexistent_group() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_chown_owner_group_id() {
     // test chown 1111:1111 file.txt
 
@@ -607,7 +611,7 @@ fn test_chown_owner_group_id() {
 
 #[test]
 // FixME: Fails on freebsd because of chown: invalid group: '0:root'
-#[cfg(not(target_os = "freebsd"))]
+#[cfg(all(not(target_os = "freebsd"), not(target_os = "openbsd")))]
 fn test_chown_owner_group_mix() {
     // test chown 1111:group file.txt
 
@@ -669,16 +673,16 @@ fn test_chown_recursive() {
     at.touch(at.plus_as_string("a/b/c/c"));
     at.touch(at.plus_as_string("z/y"));
 
-    let result = scene
+    scene
         .ucmd()
         .arg("-R")
         .arg("--verbose")
         .arg(user_name)
         .arg("a")
         .arg("z")
-        .run();
-    result.stderr_contains("ownership of 'a/a' retained as");
-    result.stderr_contains("ownership of 'z/y' retained as");
+        .succeeds()
+        .stderr_contains("ownership of 'a/a' retained as")
+        .stderr_contains("ownership of 'z/y' retained as");
 }
 
 #[test]
@@ -774,6 +778,7 @@ fn test_chown_no_change_to_user() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_chown_no_change_to_group() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -806,6 +811,7 @@ fn test_chown_no_change_to_group() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_chown_no_change_to_user_group() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
diff --git a/tests/by-util/test_chroot.rs b/tests/by-util/test_chroot.rs
index 1fc2231d57a..38c3727b1cd 100644
--- a/tests/by-util/test_chroot.rs
+++ b/tests/by-util/test_chroot.rs
@@ -4,24 +4,27 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (words) araba newroot userspec chdir pwd's isroot
 
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
 #[cfg(not(target_os = "android"))]
-use crate::common::util::is_ci;
-use crate::common::util::{run_ucmd_as_root, TestScenario};
+use uutests::util::is_ci;
+use uutests::util::{TestScenario, run_ucmd_as_root};
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(125);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
 }
 
 #[test]
 fn test_missing_operand() {
-    let result = new_ucmd!().fails();
+    let result = new_ucmd!().fails_with_code(125);
 
-    result.code_is(125);
-
-    assert!(result
-        .stderr_str()
-        .starts_with("error: the following required arguments were not provided"));
+    assert!(
+        result
+            .stderr_str()
+            .starts_with("error: the following required arguments were not provided")
+    );
 
     assert!(result.stderr_str().contains("<newroot>"));
 }
@@ -34,11 +37,12 @@ fn test_enter_chroot_fails() {
 
     at.mkdir("jail");
 
-    let result = ucmd.arg("jail").fails();
-    result.code_is(125);
-    assert!(result
-        .stderr_str()
-        .starts_with("chroot: cannot chroot to 'jail': Operation not permitted (os error 1)"));
+    let result = ucmd.arg("jail").fails_with_code(125);
+    assert!(
+        result
+            .stderr_str()
+            .starts_with("chroot: cannot chroot to 'jail': Operation not permitted (os error 1)")
+    );
 }
 
 #[test]
@@ -48,20 +52,77 @@ fn test_no_such_directory() {
     at.touch(at.plus_as_string("a"));
 
     ucmd.arg("a")
-        .fails()
-        .stderr_is("chroot: cannot change root directory to 'a': no such directory\n")
-        .code_is(125);
+        .fails_with_code(125)
+        .stderr_is("chroot: cannot change root directory to 'a': no such directory\n");
+}
+
+#[test]
+fn test_multiple_group_args() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkdir("id");
+
+    if let Ok(result) = run_ucmd_as_root(
+        &ts,
+        &["--groups='invalid ignored'", "--groups=''", "/", "id", "-G"],
+    ) {
+        result.success().stdout_is("0");
+    } else {
+        print!("Test skipped; requires root user");
+    }
 }
 
 #[test]
 fn test_invalid_user_spec() {
-    let (at, mut ucmd) = at_and_ucmd!();
+    let ts = TestScenario::new(util_name!());
 
-    at.mkdir("a");
+    if let Ok(result) = run_ucmd_as_root(&ts, &["--userspec=ARABA:", "/"]) {
+        result
+            .failure()
+            .code_is(125)
+            .stderr_is("chroot: invalid user");
+    } else {
+        print!("Test skipped; requires root user");
+    }
 
-    let result = ucmd.arg("a").arg("--userspec=ARABA:").fails();
-    result.code_is(125);
-    assert!(result.stderr_str().starts_with("chroot: invalid userspec"));
+    if let Ok(result) = run_ucmd_as_root(&ts, &["--userspec=ARABA:ARABA", "/"]) {
+        result
+            .failure()
+            .code_is(125)
+            .stderr_is("chroot: invalid user");
+    } else {
+        print!("Test skipped; requires root user");
+    }
+
+    if let Ok(result) = run_ucmd_as_root(&ts, &["--userspec=:ARABA", "/"]) {
+        result
+            .failure()
+            .code_is(125)
+            .stderr_is("chroot: invalid group");
+    } else {
+        print!("Test skipped; requires root user");
+    }
+}
+
+#[test]
+fn test_invalid_user() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    let dir = "CHROOT_DIR";
+    at.mkdir(dir);
+    if let Ok(result) = run_ucmd_as_root(&ts, &[dir, "whoami"]) {
+        result.success().no_stderr().stdout_is("root");
+    } else {
+        print!("Test skipped; requires root user");
+    }
+
+    // `--user` is an abbreviation of `--userspec`.
+    if let Ok(result) = run_ucmd_as_root(&ts, &["--user=nobody:+65535", dir, "pwd"]) {
+        result.failure().stderr_is("chroot: invalid user");
+    } else {
+        print!("Test skipped; requires root user");
+    }
 }
 
 #[test]
@@ -94,16 +155,15 @@ fn test_preference_of_userspec() {
 
     at.mkdir("a");
 
+    // `--user` is an abbreviation of `--userspec`.
     let result = ucmd
         .arg("a")
         .arg("--user")
         .arg("fake")
-        .arg("-G")
+        .arg("--groups")
         .arg("ABC,DEF")
         .arg(format!("--userspec={username}:{group_name}"))
-        .fails();
-
-    result.code_is(125);
+        .fails_with_code(125);
 
     println!("result.stdout = {}", result.stdout_str());
     println!("result.stderr = {}", result.stderr_str());
@@ -124,7 +184,7 @@ fn test_default_shell() {
     if let Ok(result) = run_ucmd_as_root(&ts, &[dir]) {
         result.stderr_contains(expected);
     } else {
-        print!("TEST SKIPPED");
+        print!("Test skipped; requires root user");
     }
 }
 
@@ -157,15 +217,14 @@ fn test_chroot_skip_chdir_not_root() {
 
     ucmd.arg("--skip-chdir")
         .arg(dir)
-        .fails()
-        .stderr_contains("chroot: option --skip-chdir only permitted if NEWROOT is old '/'")
-        .code_is(125);
+        .fails_with_code(125)
+        .stderr_contains("chroot: option --skip-chdir only permitted if NEWROOT is old '/'");
 }
 
 #[test]
 fn test_chroot_skip_chdir() {
     let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures.clone();
+    let at = &ts.fixtures;
     let dirs = ["/", "/.", "/..", "isroot"];
     at.symlink_file("/", "isroot");
     for dir in dirs {
diff --git a/tests/by-util/test_cksum.rs b/tests/by-util/test_cksum.rs
index a9d9b272b4c..8e7b18d3c7c 100644
--- a/tests/by-util/test_cksum.rs
+++ b/tests/by-util/test_cksum.rs
@@ -2,9 +2,12 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) asdf algo algos
+// spell-checker:ignore (words) asdf algo algos asha mgmt xffname hexa GFYEQ HYQK Yqxb dont
 
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 const ALGOS: [&str; 11] = [
     "sysv", "bsd", "crc", "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "blake2b", "sm3",
@@ -12,7 +15,7 @@ const ALGOS: [&str; 11] = [
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -75,21 +78,40 @@ fn test_nonexisting_file() {
 
     new_ucmd!()
         .arg(file_name)
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
         .stderr_contains(format!("cksum: {file_name}: No such file or directory"));
 }
 
 #[test]
-fn test_folder() {
+fn test_nonexisting_file_out() {
     let (at, mut ucmd) = at_and_ucmd!();
+    at.write(
+        "f",
+        "MD5 (nonexistent) = e5773576fc75ff0f8eba14f61587ae28\n",
+    );
 
-    let folder_name = "a_folder";
-    at.mkdir(folder_name);
+    ucmd.arg("-c")
+        .arg("f")
+        .fails()
+        .stdout_contains("nonexistent: FAILED open or read")
+        .stderr_contains("cksum: nonexistent: No such file or directory");
+}
 
-    ucmd.arg(folder_name)
-        .succeeds()
-        .stdout_only(format!("4294967295 0 {folder_name}\n"));
+#[test]
+fn test_one_nonexisting_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("abc.txt");
+    at.touch("xyz.txt");
+
+    ucmd.arg("abc.txt")
+        .arg("asdf.txt")
+        .arg("xyz.txt")
+        .fails()
+        .stdout_contains_line("4294967295 0 xyz.txt")
+        .stderr_contains("asdf.txt: No such file or directory")
+        .stdout_contains_line("4294967295 0 abc.txt");
 }
 
 // Make sure crc is correct for files larger than 32 bytes
@@ -124,6 +146,29 @@ fn test_stdin_larger_than_128_bytes() {
     assert_eq!(bytes_cnt, 2058);
 }
 
+#[test]
+fn test_repeated_flags() {
+    new_ucmd!()
+        .arg("-a")
+        .arg("sha1")
+        .arg("--algo=sha256")
+        .arg("-a=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is_fixture("md5_single_file.expected");
+}
+
+#[test]
+fn test_tag_after_untagged() {
+    new_ucmd!()
+        .arg("--untagged")
+        .arg("--tag")
+        .arg("-a=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is_fixture("md5_single_file.expected");
+}
+
 #[test]
 fn test_algorithm_single_file() {
     for algo in ALGOS {
@@ -204,6 +249,28 @@ fn test_untagged_algorithm_single_file() {
     }
 }
 
+#[test]
+fn test_tag_short() {
+    new_ucmd!()
+        .arg("-t")
+        .arg("--untagged")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is("cd724690f7dc61775dfac400a71f2caa  lorem_ipsum.txt\n");
+}
+
+#[test]
+fn test_untagged_algorithm_after_tag() {
+    new_ucmd!()
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is_fixture("untagged/md5_single_file.expected");
+}
+
 #[test]
 fn test_untagged_algorithm_multiple_files() {
     for algo in ALGOS {
@@ -228,3 +295,1980 @@ fn test_untagged_algorithm_stdin() {
             .stdout_is_fixture(format!("untagged/{algo}_stdin.expected"));
     }
 }
+
+#[test]
+fn test_check_algo() {
+    new_ucmd!()
+        .arg("-a=bsd")
+        .arg("--check")
+        .arg("lorem_ipsum.txt")
+        .fails()
+        .no_stdout()
+        .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
+    new_ucmd!()
+        .arg("-a=sysv")
+        .arg("--check")
+        .arg("lorem_ipsum.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
+    new_ucmd!()
+        .arg("-a=crc")
+        .arg("--check")
+        .arg("lorem_ipsum.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
+    new_ucmd!()
+        .arg("-a=crc32b")
+        .arg("--check")
+        .arg("lorem_ipsum.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}");
+}
+
+#[test]
+fn test_length_with_wrong_algorithm() {
+    new_ucmd!()
+        .arg("--length=16")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: --length is only supported with --algorithm=blake2b");
+
+    new_ucmd!()
+        .arg("--length=16")
+        .arg("--algorithm=md5")
+        .arg("-c")
+        .arg("foo.sums")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: --length is only supported with --algorithm=blake2b");
+}
+
+#[test]
+fn test_length_not_supported() {
+    new_ucmd!()
+        .arg("--length=15")
+        .arg("lorem_ipsum.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("--length is only supported with --algorithm=blake2b");
+
+    new_ucmd!()
+        .arg("-l")
+        .arg("158")
+        .arg("-c")
+        .arg("-a")
+        .arg("crc")
+        .arg("/tmp/xxx")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("--length is only supported with --algorithm=blake2b");
+}
+
+#[test]
+fn test_length() {
+    new_ucmd!()
+        .arg("--length=16")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .stdout_contains(
+            "BLAKE2b-16 (lorem_ipsum.txt) = 7e2f\nBLAKE2b-16 (alice_in_wonderland.txt) = a546",
+        );
+}
+
+#[test]
+fn test_length_greater_than_512() {
+    new_ucmd!()
+        .arg("--length=1024")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_is_fixture("length_larger_than_512.expected");
+}
+
+#[test]
+fn test_length_is_zero() {
+    new_ucmd!()
+        .arg("--length=0")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .no_stderr()
+        .stdout_is_fixture("length_is_zero.expected");
+}
+
+#[test]
+fn test_length_repeated() {
+    new_ucmd!()
+        .arg("--length=10")
+        .arg("--length=123456")
+        .arg("--length=0")
+        .arg("--algorithm=blake2b")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .no_stderr()
+        .stdout_is_fixture("length_is_zero.expected");
+}
+
+#[test]
+fn test_raw_single_file() {
+    for algo in ALGOS {
+        new_ucmd!()
+            .arg("--raw")
+            .arg("lorem_ipsum.txt")
+            .arg(format!("--algorithm={algo}"))
+            .succeeds()
+            .no_stderr()
+            .stdout_is_fixture_bytes(format!("raw/{algo}_single_file.expected"));
+    }
+}
+#[test]
+fn test_raw_multiple_files() {
+    new_ucmd!()
+        .arg("--raw")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: the --raw option is not supported with multiple files");
+}
+
+#[test]
+fn test_base64_raw_conflicts() {
+    new_ucmd!()
+        .arg("--base64")
+        .arg("--raw")
+        .arg("lorem_ipsum.txt")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("--base64")
+        .stderr_contains("cannot be used with")
+        .stderr_contains("--raw");
+}
+
+#[test]
+fn test_base64_single_file() {
+    for algo in ALGOS {
+        new_ucmd!()
+            .arg("--base64")
+            .arg("lorem_ipsum.txt")
+            .arg(format!("--algorithm={algo}"))
+            .succeeds()
+            .no_stderr()
+            .stdout_is_fixture_bytes(format!("base64/{algo}_single_file.expected"));
+    }
+}
+#[test]
+fn test_base64_multiple_files() {
+    new_ucmd!()
+        .arg("--base64")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .no_stderr()
+        .stdout_is_fixture_bytes("base64/md5_multiple_files.expected");
+}
+
+#[test]
+fn test_fail_on_folder() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let folder_name = "a_folder";
+    at.mkdir(folder_name);
+
+    ucmd.arg(folder_name)
+        .fails()
+        .no_stdout()
+        .stderr_contains(format!("cksum: {folder_name}: Is a directory"));
+}
+
+#[test]
+fn test_all_algorithms_fail_on_folder() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    let folder_name = "a_folder";
+    at.mkdir(folder_name);
+
+    for algo in ALGOS {
+        scene
+            .ucmd()
+            .arg(format!("--algorithm={algo}"))
+            .arg(folder_name)
+            .fails()
+            .no_stdout()
+            .stderr_contains(format!("cksum: {folder_name}: Is a directory"));
+    }
+}
+
+#[cfg(unix)]
+#[test]
+fn test_check_error_incorrect_format() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("checksum", "e5773576fc75ff0f8eba14f61587ae28  README.md");
+
+    scene
+        .ucmd()
+        .arg("-c")
+        .arg("checksum")
+        .fails()
+        .stderr_contains("no properly formatted checksum lines found");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_dev_null() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--algorithm=md5")
+        .arg("/dev/null")
+        .succeeds()
+        .stdout_contains("d41d8cd98f00b204e9800998ecf8427e ");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_blake2b_512() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("blake2b")
+        .arg("-l512")
+        .arg("f")
+        .succeeds()
+        .stdout_contains("BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce");
+
+    // test also the read
+    at.write("checksum", "BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("checksum")
+        .succeeds()
+        .stdout_contains("f: OK");
+
+    scene
+        .ucmd()
+        .arg("--status")
+        .arg("--check")
+        .arg("checksum")
+        .succeeds()
+        .no_output();
+}
+
+#[test]
+fn test_reset_binary() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("--binary") // should disappear because of the following option
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--algorithm=md5")
+        .arg(at.subdir.join("f"))
+        .succeeds()
+        .stdout_contains("d41d8cd98f00b204e9800998ecf8427e  ");
+}
+
+#[test]
+fn test_reset_binary_but_set() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("--binary")
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--binary")
+        .arg("--algorithm=md5")
+        .arg(at.subdir.join("f"))
+        .succeeds()
+        .stdout_contains("d41d8cd98f00b204e9800998ecf8427e *");
+}
+
+#[test]
+fn test_text_tag() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("--text") // should disappear because of the following option
+        .arg("--tag")
+        .arg(at.subdir.join("f"))
+        .succeeds()
+        .stdout_contains("4294967295 0 ");
+}
+
+#[test]
+fn test_binary_file() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("--untagged")
+        .arg("-b")
+        .arg("--algorithm=md5")
+        .arg(at.subdir.join("f"))
+        .succeeds()
+        .stdout_contains("d41d8cd98f00b204e9800998ecf8427e *");
+
+    scene
+        .ucmd()
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--binary")
+        .arg("--algorithm=md5")
+        .arg(at.subdir.join("f"))
+        .succeeds()
+        .stdout_contains("d41d8cd98f00b204e9800998ecf8427e *");
+
+    scene
+        .ucmd()
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--binary")
+        .arg("--algorithm=md5")
+        .arg("raw/blake2b_single_file.expected")
+        .succeeds()
+        .stdout_contains("7e297c07ed8e053600092f91bdd1dad7 *");
+
+    new_ucmd!()
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("--binary")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+    new_ucmd!()
+        .arg("--untagged")
+        .arg("--binary")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+    new_ucmd!()
+        .arg("--binary")
+        .arg("--untagged")
+        .arg("--algorithm=md5")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+    new_ucmd!()
+        .arg("-a")
+        .arg("md5")
+        .arg("--binary")
+        .arg("--untagged")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is("cd724690f7dc61775dfac400a71f2caa *lorem_ipsum.txt\n");
+
+    new_ucmd!()
+        .arg("-a")
+        .arg("md5")
+        .arg("--binary")
+        .arg("--tag")
+        .arg("--untagged")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is("cd724690f7dc61775dfac400a71f2caa  lorem_ipsum.txt\n");
+}
+
+#[test]
+fn test_folder_and_file() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    let folder_name = "a_folder";
+    at.mkdir(folder_name);
+
+    scene
+        .ucmd()
+        .arg(folder_name)
+        .arg("lorem_ipsum.txt")
+        .fails()
+        .stderr_contains(format!("cksum: {folder_name}: Is a directory"))
+        .stdout_is_fixture("crc_single_file.expected");
+}
+
+#[test]
+fn test_conflicting_options() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("--binary")
+        .arg("--check")
+        .arg("f")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains(
+            "cksum: the --binary and --text options are meaningless when verifying checksums",
+        );
+
+    scene
+        .ucmd()
+        .arg("--tag")
+        .arg("-c")
+        .arg("-a")
+        .arg("md5")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains(
+            "cksum: the --binary and --text options are meaningless when verifying checksums",
+        );
+}
+
+#[test]
+fn test_check_algo_err() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("sm3")
+        .arg("--check")
+        .arg("f")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_check_pipe() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("-")
+        .pipe_in("f")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("cksum: 'standard input': no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_cksum_check_empty_line() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("CHECKSUM", "\
+    SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+    BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+    BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+    SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n\n");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+        .stderr_does_not_contain("line is improperly formatted");
+}
+
+#[test]
+fn test_cksum_check_space() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("CHECKSUM", "\
+    SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+    BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+    BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+    SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n  \n");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+        .stderr_contains("line is improperly formatted");
+}
+
+#[test]
+fn test_cksum_check_leading_info() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("CHECKSUM", "\
+     \\SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+     \\BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+     \\BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+     \\SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n");
+}
+
+#[test]
+fn test_cksum_check() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("CHECKSUM", "\
+    SHA384 (f) = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b\n\
+    BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+    BLAKE2b-384 (f) = b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100\n\
+    SM3 (f) = 1ab21d8355cfa17f8e61194831e81a8f22bec8c728fefb747ed035eb5082aa2b\n");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+        .stderr_does_not_contain("line is improperly formatted");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("--strict")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+        .stderr_does_not_contain("line is improperly formatted");
+    // inject invalid content
+    at.append("CHECKSUM", "incorrect data");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+        .stderr_contains("line is improperly formatted");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("--strict")
+        .arg("CHECKSUM")
+        .fails()
+        .stdout_contains("f: OK\nf: OK\nf: OK\nf: OK\n")
+        .stderr_contains("line is improperly formatted");
+}
+
+#[test]
+fn test_cksum_check_case() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write(
+        "CHECKSUM",
+        "Sha1 (f) = da39a3ee5e6b4b0d3255bfef95601890afd80709\n",
+    );
+    scene.ucmd().arg("--check").arg("CHECKSUM").fails();
+}
+
+#[test]
+fn test_cksum_check_invalid() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let commands = [vec!["-a", "sha384"]];
+    at.touch("f");
+    at.touch("CHECKSUM");
+    for command in &commands {
+        let result = scene.ucmd().args(command).arg("f").succeeds();
+        at.append("CHECKSUM", result.stdout_str());
+    }
+    // inject invalid content
+    at.append("CHECKSUM", "again incorrect data\naze\n");
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("--strict")
+        .arg("CHECKSUM")
+        .fails()
+        .stdout_contains("f: OK\n")
+        .stderr_contains("2 lines");
+
+    // without strict, it passes
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .succeeds()
+        .stdout_contains("f: OK\n")
+        .stderr_contains("2 lines");
+}
+
+#[test]
+fn test_cksum_check_failed() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let commands = [vec!["-a", "sha384"]];
+    at.touch("f");
+    at.touch("CHECKSUM");
+    for command in &commands {
+        let result = scene.ucmd().args(command).arg("f").succeeds();
+        at.append("CHECKSUM", result.stdout_str());
+    }
+    // inject invalid content
+    at.append("CHECKSUM", "again incorrect data\naze\nSM3 (input) = 7cfb120d4fabea2a904948538a438fdb57c725157cb40b5aee8d937b8351477e\n");
+
+    let result = scene
+        .ucmd()
+        .arg("--check")
+        .arg("--strict")
+        .arg("CHECKSUM")
+        .fails();
+
+    assert!(
+        result
+            .stderr_str()
+            .contains("input: No such file or directory")
+    );
+    assert!(
+        result
+            .stderr_str()
+            .contains("2 lines are improperly formatted\n")
+    );
+    assert!(
+        result
+            .stderr_str()
+            .contains("1 listed file could not be read\n")
+    );
+    assert!(result.stdout_str().contains("f: OK\n"));
+
+    // without strict
+    let result = scene.ucmd().arg("--check").arg("CHECKSUM").fails();
+
+    assert!(
+        result
+            .stderr_str()
+            .contains("input: No such file or directory")
+    );
+    assert!(
+        result
+            .stderr_str()
+            .contains("2 lines are improperly formatted\n")
+    );
+    assert!(
+        result
+            .stderr_str()
+            .contains("1 listed file could not be read\n")
+    );
+    assert!(result.stdout_str().contains("f: OK\n"));
+
+    // tests with two files
+    at.touch("CHECKSUM2");
+    at.write("f2", "42");
+    for command in &commands {
+        let result = scene.ucmd().args(command).arg("f2").succeeds();
+        at.append("CHECKSUM2", result.stdout_str());
+    }
+    // inject invalid content
+    at.append("CHECKSUM2", "again incorrect data\naze\nSM3 (input2) = 7cfb120d4fabea2a904948538a438fdb57c725157cb40b5aee8d937b8351477e\n");
+    at.append("CHECKSUM2", "again incorrect data\naze\nSM3 (input2) = 7cfb120d4fabea2a904948538a438fdb57c725157cb40b5aee8d937b8351477e\n");
+
+    let result = scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .arg("CHECKSUM2")
+        .fails();
+    println!("result.stderr_str() {}", result.stderr_str());
+    println!("result.stdout_str() {}", result.stdout_str());
+    assert!(
+        result
+            .stderr_str()
+            .contains("input2: No such file or directory")
+    );
+    assert!(
+        result
+            .stderr_str()
+            .contains("4 lines are improperly formatted\n")
+    );
+    assert!(
+        result
+            .stderr_str()
+            .contains("2 listed files could not be read\n")
+    );
+    assert!(result.stdout_str().contains("f: OK\n"));
+    assert!(result.stdout_str().contains("2: OK\n"));
+}
+
+#[test]
+fn test_check_md5_format() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    at.touch("empty");
+    at.write("f", "d41d8cd98f00b204e9800998ecf8427e *empty\n");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("md5")
+        .arg("--check")
+        .arg("f")
+        .succeeds()
+        .stdout_contains("empty: OK");
+
+    // with a second file
+    at.write("not-empty", "42");
+    at.write("f2", "a1d0c6e83f027327d8461063f4ac58a6 *not-empty\n");
+
+    scene
+        .ucmd()
+        .arg("-a")
+        .arg("md5")
+        .arg("--check")
+        .arg("f")
+        .arg("f2")
+        .succeeds()
+        .stdout_contains("empty: OK")
+        .stdout_contains("not-empty: OK");
+}
+
+// Manage the mixed behavior
+// cksum --check -a sm3 CHECKSUMS
+// when CHECKSUM contains among other lines:
+// SHA384 (input) = f392fd0ae43879ced890c665a1d47179116b5eddf6fb5b49f4982746418afdcbd54ba5eedcd422af3592f57f666da285
+#[test]
+fn test_cksum_mixed() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let commands = [
+        vec!["-a", "sha384"],
+        vec!["-a", "blake2b"],
+        vec!["-a", "blake2b", "-l", "384"],
+        vec!["-a", "sm3"],
+    ];
+    at.touch("f");
+    at.touch("CHECKSUM");
+    for command in &commands {
+        let result = scene.ucmd().args(command).arg("f").succeeds();
+        at.append("CHECKSUM", result.stdout_str());
+    }
+    println!("Content of CHECKSUM:\n{}", at.read("CHECKSUM"));
+    let result = scene
+        .ucmd()
+        .arg("--check")
+        .arg("-a")
+        .arg("sm3")
+        .arg("CHECKSUM")
+        .succeeds();
+
+    println!("result.stderr_str() {}", result.stderr_str());
+    println!("result.stdout_str() {}", result.stdout_str());
+    assert!(result.stdout_str().contains("f: OK"));
+    assert!(
+        result
+            .stderr_str()
+            .contains("3 lines are improperly formatted")
+    );
+}
+
+#[test]
+fn test_cksum_garbage() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    // Incorrect data at the start
+    at.write(
+        "check-file",
+        "garbage MD5 (README.md) = e5773576fc75ff0f8eba14f61587ae28",
+    );
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("check-file")
+        .fails()
+        .stderr_contains("check-file: no properly formatted checksum lines found");
+
+    // Incorrect data at the end
+    at.write(
+        "check-file",
+        "MD5 (README.md) = e5773576fc75ff0f8eba14f61587ae28 garbage",
+    );
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("check-file")
+        .fails()
+        .stderr_contains("check-file: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_md5_bits() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write(
+        "f",
+        "MD5-65536 (README.md) = e5773576fc75ff0f8eba14f61587ae28\n",
+    );
+
+    ucmd.arg("-c")
+        .arg("f")
+        .fails()
+        .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_blake2b_bits() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write(
+        "f",
+        "BLAKE2b-257 (README.md) = f9a984b70cf9a7549920864860fd1131c9fb6c0552def0b6dcce1d87b4ec4c5d\n"
+    );
+
+    ucmd.arg("-c")
+        .arg("f")
+        .fails()
+        .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_bsd_case() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("f", "bSD (README.md) = 0000\n");
+
+    scene
+        .ucmd()
+        .arg("-c")
+        .arg("f")
+        .fails()
+        .stderr_contains("f: no properly formatted checksum lines found");
+    at.write("f", "BsD (README.md) = 0000\n");
+
+    scene
+        .ucmd()
+        .arg("-c")
+        .arg("f")
+        .fails()
+        .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_blake2d_tested_with_sha1() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write(
+        "f",
+        "BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n"
+    );
+
+    ucmd.arg("-a")
+        .arg("sha1")
+        .arg("-c")
+        .arg("f")
+        .fails()
+        .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_unknown_sha() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("f", "SHA4 (README.md) = 00000000\n");
+
+    ucmd.arg("-c")
+        .arg("f")
+        .fails()
+        .stderr_contains("f: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_check_directory_error() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("d");
+    at.write(
+        "f",
+        "BLAKE2b (d) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n"
+    );
+    #[cfg(not(windows))]
+    let err_msg = "cksum: d: Is a directory\n";
+    #[cfg(windows)]
+    let err_msg = "cksum: d: Permission denied\n";
+    ucmd.arg("--check")
+        .arg(at.subdir.join("f"))
+        .fails()
+        .stderr_contains(err_msg);
+}
+
+#[test]
+fn test_check_base64_hashes() {
+    let hashes = "MD5 (empty) = 1B2M2Y8AsgTpgAmY7PhCfg==\nSHA256 (empty) = 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\nBLAKE2b (empty) = eGoC90IBWQPGxv2FJVLScpEvR0DhWEdhiobiF/cfVBnSXhAxr+5YUxOJZESTTrBLkDpoWxRIt1XVb3Aa/pvizg==\n";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("empty");
+    at.write("check", hashes);
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg(at.subdir.join("check"))
+        .succeeds()
+        .stdout_is("empty: OK\nempty: OK\nempty: OK\n");
+}
+
+#[test]
+fn test_several_files_error_mgmt() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    // don't exist
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("empty")
+        .arg("incorrect")
+        .fails()
+        .stderr_contains("empty: No such file ")
+        .stderr_contains("incorrect: No such file ");
+
+    at.touch("empty");
+    at.touch("incorrect");
+
+    // exists but incorrect
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("empty")
+        .arg("incorrect")
+        .fails()
+        .stderr_contains("empty: no properly ")
+        .stderr_contains("incorrect: no properly ");
+}
+
+#[test]
+fn test_check_unknown_checksum_file() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("missing")
+        .fails()
+        .stderr_only("cksum: missing: No such file or directory\n");
+}
+
+#[test]
+fn test_check_comment_line() {
+    // A comment in a checksum file shall be discarded unnoticed.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo", "foo-content\n");
+    at.write(
+        "CHECKSUM-sha1",
+        "\
+        # This is a comment\n\
+        SHA1 (foo) = 058ab38dd3603703b3a7063cf95dc51a4286b6fe\n\
+        # next comment is empty\n#",
+    );
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM-sha1")
+        .succeeds()
+        .stdout_contains("foo: OK")
+        .no_stderr();
+}
+
+#[test]
+fn test_check_comment_only() {
+    // A file only filled with comments is equivalent to an empty file,
+    // and therefore produces an error.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("CHECKSUM", "# This is a comment\n");
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .fails()
+        .stderr_contains("no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_check_comment_leading_space() {
+    // A comment must have its '#' in first position on the line.
+    // A space before it will raise a warning for improperly formatted line.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo", "foo-content\n");
+    at.write(
+        "CHECKSUM-sha1",
+        " # This is a comment\n\
+        SHA1 (foo) = 058ab38dd3603703b3a7063cf95dc51a4286b6fe\n",
+    );
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM-sha1")
+        .succeeds()
+        .stdout_contains("foo: OK")
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+/// This test checks alignment with GNU's error handling.
+/// Windows has a different logic and is guarded by [`test_check_directory_error`].
+#[cfg(not(windows))]
+#[test]
+fn test_check_failed_to_read() {
+    // check `cksum`'s behavior when encountering directories or non existing files
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write(
+        "CHECKSUM",
+        "SHA1 (dir) = ffffffffffffffffffffffffffffffffffffffff\n\
+        SHA1 (not-file) = ffffffffffffffffffffffffffffffffffffffff\n",
+    );
+    at.mkdir("dir");
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .fails()
+        .stdout_is(
+            "dir: FAILED open or read\n\
+            not-file: FAILED open or read\n",
+        )
+        .stderr_contains("cksum: WARNING: 2 listed files could not be read");
+
+    // check with `--ignore-missing`
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .arg("--ignore-missing")
+        .fails()
+        .stdout_is("dir: FAILED open or read\n")
+        .stderr_contains("cksum: WARNING: 1 listed file could not be read");
+}
+
+#[test]
+fn test_zero_multiple_file() {
+    new_ucmd!()
+        .arg("-z")
+        .arg("alice_in_wonderland.txt")
+        .arg("lorem_ipsum.txt")
+        .succeeds()
+        .stdout_is_fixture("zero_multiple_file.expected");
+}
+
+#[test]
+fn test_zero_single_file() {
+    new_ucmd!()
+        .arg("--zero")
+        .arg("alice_in_wonderland.txt")
+        .succeeds()
+        .stdout_is_fixture("zero_single_file.expected");
+}
+
+#[test]
+fn test_check_trailing_space_fails() {
+    // If a checksum line has trailing spaces after the digest,
+    // it shall be considered improperly formatted.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo", "foo-content\n");
+    at.write(
+        "CHECKSUM",
+        "SHA1 (foo) = 058ab38dd3603703b3a7063cf95dc51a4286b6fe    \n",
+    );
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg("CHECKSUM")
+        .fails()
+        .no_stdout()
+        .stderr_contains("CHECKSUM: no properly formatted checksum lines found");
+}
+
+/// Regroup tests related to the handling of non-utf-8 content
+/// in checksum files.
+/// These tests are excluded from Windows because it does not provide any safe
+/// conversion between `OsString` and byte sequences for non-utf-8 strings.
+mod check_utf8 {
+
+    // This test should pass on linux and macos.
+    #[cfg(not(windows))]
+    #[test]
+    fn test_check_non_utf8_comment() {
+        use super::*;
+        let hashes =
+        b"MD5 (empty) = 1B2M2Y8AsgTpgAmY7PhCfg==\n\
+        # Comment with a non utf8 char: >>\xff<<\n\
+        SHA256 (empty) = 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=\n\
+        BLAKE2b (empty) = eGoC90IBWQPGxv2FJVLScpEvR0DhWEdhiobiF/cfVBnSXhAxr+5YUxOJZESTTrBLkDpoWxRIt1XVb3Aa/pvizg==\n"
+    ;
+
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+
+        at.touch("empty");
+        at.write_bytes("check", hashes);
+
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg(at.subdir.join("check"))
+            .succeeds()
+            .stdout_is("empty: OK\nempty: OK\nempty: OK\n")
+            .no_stderr();
+    }
+
+    // This test should pass on linux. Windows and macos will fail to
+    // create a file which name contains '\xff'.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn test_check_non_utf8_filename() {
+        use super::*;
+        use std::{ffi::OsString, os::unix::ffi::OsStringExt};
+
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let filename: OsString = OsStringExt::from_vec(b"funky\xffname".to_vec());
+        at.touch(filename);
+
+        // Checksum match
+        at.write_bytes("check",
+            b"SHA256 (funky\xffname) = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\n");
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg(at.subdir.join("check"))
+            .succeeds()
+            .stdout_is_bytes(b"funky\xffname: OK\n")
+            .no_stderr();
+
+        // Checksum mismatch
+        at.write_bytes("check",
+            b"SHA256 (funky\xffname) = ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\n");
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg(at.subdir.join("check"))
+            .fails()
+            .stdout_is_bytes(b"funky\xffname: FAILED\n")
+            .stderr_contains("1 computed checksum did NOT match");
+
+        // file not found
+        at.write_bytes("check",
+            b"SHA256 (flakey\xffname) = ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\n");
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg(at.subdir.join("check"))
+            .fails()
+            .stdout_is_bytes(b"flakey\xffname: FAILED open or read\n")
+            .stderr_contains("1 listed file could not be read");
+    }
+}
+
+#[test]
+fn test_check_blake_length_guess() {
+    let correct_lines = [
+        // Correct: The length is not explicit, but the checksum's size
+        // matches the default parameter.
+        "BLAKE2b (foo.dat) = ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6dc1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d",
+        // Correct: The length is explicitly given, and the checksum's size
+        // matches the length.
+        "BLAKE2b-512 (foo.dat) = ca002330e69d3e6b84a46a56a6533fd79d51d97a3bb7cad6c2ff43b354185d6dc1e723fb3db4ae0737e120378424c714bb982d9dc5bbd7a0ab318240ddd18f8d",
+        // Correct: the checksum size is not default but
+        // the length is explicitly given.
+        "BLAKE2b-48 (foo.dat) = 171cdfdf84ed",
+    ];
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo.dat", "foo");
+
+    for line in correct_lines {
+        at.write("foo.sums", line);
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg(at.subdir.join("foo.sums"))
+            .succeeds()
+            .stdout_is("foo.dat: OK\n");
+    }
+
+    // Incorrect lines
+
+    // This is incorrect because the algorithm provides no length,
+    // and the checksum length is not default.
+    let incorrect = "BLAKE2b (foo.dat) = 171cdfdf84ed";
+    at.write("foo.sums", incorrect);
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg(at.subdir.join("foo.sums"))
+        .fails()
+        .stderr_contains("foo.sums: no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_check_confusing_base64() {
+    let cksum = "BLAKE2b-48 (foo.dat) = fc1f97C4";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo.dat", "esq");
+    at.write("foo.sums", cksum);
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg(at.subdir.join("foo.sums"))
+        .succeeds()
+        .stdout_is("foo.dat: OK\n");
+}
+
+/// This test checks that when a file contains several checksum lines
+/// with different encoding, the decoding still works.
+#[test]
+fn test_check_mix_hex_base64() {
+    let b64 = "BLAKE2b-128 (foo1.dat) = BBNuJPhdRwRlw9tm5Y7VbA==";
+    let hex = "BLAKE2b-128 (foo2.dat) = 04136e24f85d470465c3db66e58ed56c";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo1.dat", "foo");
+    at.write("foo2.dat", "foo");
+
+    at.write("hex_b64", &format!("{hex}\n{b64}"));
+    at.write("b64_hex", &format!("{b64}\n{hex}"));
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg(at.subdir.join("hex_b64"))
+        .succeeds()
+        .stdout_only("foo2.dat: OK\nfoo1.dat: OK\n");
+
+    scene
+        .ucmd()
+        .arg("--check")
+        .arg(at.subdir.join("b64_hex"))
+        .succeeds()
+        .stdout_only("foo1.dat: OK\nfoo2.dat: OK\n");
+}
+
+/// This test ensures that an improperly formatted base64 checksum in a file
+/// does not interrupt the processing of next lines.
+#[test]
+fn test_check_incorrectly_formatted_checksum_keeps_processing_b64() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("f");
+
+    let good_ck = "MD5 (f) = 1B2M2Y8AsgTpgAmY7PhCfg=="; // OK
+    let bad_ck = "MD5 (f) = 1B2M2Y8AsgTpgAmY7PhCfg="; // Missing last '='
+
+    // Good then Bad
+    scene
+        .ucmd()
+        .arg("--check")
+        .pipe_in([good_ck, bad_ck].join("\n").as_bytes().to_vec())
+        .succeeds()
+        .stdout_contains("f: OK")
+        .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
+
+    // Bad then Good
+    scene
+        .ucmd()
+        .arg("--check")
+        .pipe_in([bad_ck, good_ck].join("\n").as_bytes().to_vec())
+        .succeeds()
+        .stdout_contains("f: OK")
+        .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
+}
+
+/// This test ensures that an improperly formatted hexadecimal checksum in a
+/// file does not interrupt the processing of next lines.
+#[test]
+fn test_check_incorrectly_formatted_checksum_keeps_processing_hex() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("f");
+
+    let good_ck = "MD5 (f) = d41d8cd98f00b204e9800998ecf8427e"; // OK
+    let bad_ck = "MD5 (f) = d41d8cd98f00b204e9800998ecf8427"; // Missing last
+
+    // Good then Bad
+    scene
+        .ucmd()
+        .arg("--check")
+        .pipe_in([good_ck, bad_ck].join("\n").as_bytes().to_vec())
+        .succeeds()
+        .stdout_contains("f: OK")
+        .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
+
+    // Bad then Good
+    scene
+        .ucmd()
+        .arg("--check")
+        .pipe_in([bad_ck, good_ck].join("\n").as_bytes().to_vec())
+        .succeeds()
+        .stdout_contains("f: OK")
+        .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
+}
+
+/// This module reimplements the cksum-base64.pl GNU test.
+mod gnu_cksum_base64 {
+    use super::*;
+    use uutests::util::log_info;
+
+    const PAIRS: [(&str, &str); 12] = [
+        ("sysv", "0 0 f"),
+        ("bsd", "00000     0 f"),
+        ("crc", "4294967295 0 f"),
+        ("crc32b", "0 0 f"),
+        ("md5", "1B2M2Y8AsgTpgAmY7PhCfg=="),
+        ("sha1", "2jmj7l5rSw0yVb/vlWAYkK/YBwk="),
+        ("sha224", "0UoCjCo6K8lHYQK7KII0xBWisB+CjqYqxbPkLw=="),
+        ("sha256", "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU="),
+        (
+            "sha384",
+            "OLBgp1GsljhM2TJ+sbHjaiH9txEUvgdDTAzHv2P24donTt6/529l+9Ua0vFImLlb",
+        ),
+        (
+            "sha512",
+            "z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg==",
+        ),
+        (
+            "blake2b",
+            "eGoC90IBWQPGxv2FJVLScpEvR0DhWEdhiobiF/cfVBnSXhAxr+5YUxOJZESTTrBLkDpoWxRIt1XVb3Aa/pvizg==",
+        ),
+        ("sm3", "GrIdg1XPoX+OYRlIMegajyK+yMco/vt0ftA161CCqis="),
+    ];
+
+    fn make_scene() -> TestScenario {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.touch("f");
+
+        scene
+    }
+
+    fn output_format(algo: &str, digest: &str) -> String {
+        if ["sysv", "bsd", "crc", "crc32b"].contains(&algo) {
+            digest.to_string()
+        } else {
+            format!("{} (f) = {digest}", algo.to_uppercase()).replace("BLAKE2B", "BLAKE2b")
+        }
+    }
+
+    #[test]
+    fn test_generating() {
+        // Ensure that each algorithm works with `--base64`.
+        let scene = make_scene();
+
+        for (algo, digest) in PAIRS {
+            log_info("ALGORITHM", algo);
+            scene
+                .ucmd()
+                .arg("--base64")
+                .arg("-a")
+                .arg(algo)
+                .arg("f")
+                .succeeds()
+                .stdout_only(format!("{}\n", output_format(algo, digest)));
+        }
+    }
+
+    #[test]
+    fn test_chk() {
+        // For each algorithm that accepts `--check`,
+        // ensure that it works with base64 digests.
+        let scene = make_scene();
+
+        for (algo, digest) in PAIRS {
+            if ["sysv", "bsd", "crc", "crc32b"].contains(&algo) {
+                // These algorithms do not accept `--check`
+                scene
+                    .ucmd()
+                    .arg("--check")
+                    .arg("-a")
+                    .arg(algo)
+                    .fails()
+                    .stderr_only(
+                        "cksum: --check is not supported with --algorithm={bsd,sysv,crc,crc32b}\n",
+                    );
+                continue;
+            }
+
+            let line = output_format(algo, digest);
+            scene
+                .ucmd()
+                .arg("--check")
+                .arg("--strict")
+                .pipe_in(line)
+                .succeeds()
+                .stdout_only("f: OK\n");
+        }
+    }
+
+    #[test]
+    fn test_chk_eq1() {
+        // For digests ending with '=', ensure `--check` fails if '=' is removed.
+        let scene = make_scene();
+
+        for (algo, digest) in PAIRS {
+            if !digest.ends_with('=') {
+                continue;
+            }
+
+            let mut line = output_format(algo, digest);
+            if line.ends_with('=') {
+                line.pop();
+            }
+
+            log_info(format!("ALGORITHM: {algo}, STDIN: '{line}'"), "");
+            scene
+                .ucmd()
+                .arg("--check")
+                .pipe_in(line)
+                .fails()
+                .no_stdout()
+                .stderr_contains("no properly formatted checksum lines found");
+        }
+    }
+
+    #[test]
+    fn test_chk_eq2() {
+        // For digests ending with '==',
+        // ensure `--check` fails if '==' is removed.
+        let scene = make_scene();
+
+        for (algo, digest) in PAIRS {
+            if !digest.ends_with("==") {
+                continue;
+            }
+
+            let line = output_format(algo, digest);
+            let line = line.trim_end_matches("==");
+
+            log_info(format!("ALGORITHM: {algo}, STDIN: '{line}'"), "");
+            scene
+                .ucmd()
+                .arg("--check")
+                .pipe_in(line)
+                .fails()
+                .no_stdout()
+                .stderr_contains("no properly formatted checksum lines found");
+        }
+    }
+}
+
+/// This module reimplements the cksum-c.sh GNU test.
+mod gnu_cksum_c {
+    use super::*;
+
+    const INVALID_SUM: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaafdb57c725157cb40b5aee8d937b8351477e";
+
+    fn make_scene() -> TestScenario {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.write("input", "9\n7\n1\n4\n2\n6\n3\n5\n8\n10\n");
+
+        let algos: &[&[&str]] = &[
+            &["-a", "sha384"],
+            &["-a", "blake2b"],
+            &["-a", "blake2b", "-l", "384"],
+            &["-a", "sm3"],
+        ];
+
+        for args in algos {
+            let result = scene.ucmd().args(args).succeeds();
+            let stdout = result.stdout();
+            at.append_bytes("CHECKSUMS", stdout);
+        }
+
+        scene
+    }
+
+    #[test]
+    #[ignore]
+    fn test_signed_checksums() {
+        todo!()
+    }
+
+    #[test]
+    fn test_check_individual_digests_in_mixed_file() {
+        let scene = make_scene();
+
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("-a")
+            .arg("sm3")
+            .arg("CHECKSUMS")
+            .succeeds();
+    }
+
+    #[test]
+    fn test_check_against_older_non_hex_formats() {
+        let scene = make_scene();
+
+        scene
+            .ucmd()
+            .arg("-c")
+            .arg("-a")
+            .arg("crc")
+            .arg("CHECKSUMS")
+            .fails();
+
+        let crc_cmd = scene.ucmd().arg("-a").arg("crc").arg("input").succeeds();
+        let crc_cmd_out = crc_cmd.stdout();
+        scene.fixtures.write_bytes("CHECKSUMS.crc", crc_cmd_out);
+
+        scene.ucmd().arg("-c").arg("CHECKSUMS.crc").fails();
+    }
+
+    #[test]
+    fn test_status() {
+        let scene = make_scene();
+
+        scene
+            .ucmd()
+            .arg("--status")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .succeeds()
+            .no_output();
+    }
+
+    fn make_scene_with_comment() -> TestScenario {
+        let scene = make_scene();
+
+        scene
+            .fixtures
+            .append("CHECKSUMS", "# Very important comment\n");
+
+        scene
+    }
+
+    #[test]
+    fn test_status_with_comment() {
+        let scene = make_scene_with_comment();
+
+        scene
+            .ucmd()
+            .arg("--status")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .succeeds()
+            .no_output();
+    }
+
+    fn make_scene_with_invalid_line() -> TestScenario {
+        let scene = make_scene_with_comment();
+
+        scene.fixtures.append("CHECKSUMS", "invalid_line\n");
+
+        scene
+    }
+
+    #[test]
+    fn test_check_strict() {
+        let scene = make_scene_with_invalid_line();
+
+        // without strict, succeeds
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .succeeds()
+            .stderr_contains("1 line is improperly formatted");
+
+        // with strict, fails
+        scene
+            .ucmd()
+            .arg("--strict")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stderr_contains("1 line is improperly formatted");
+    }
+
+    fn make_scene_with_two_invalid_lines() -> TestScenario {
+        let scene = make_scene_with_comment();
+
+        scene
+            .fixtures
+            .append("CHECKSUMS", "invalid_line\ninvalid_line\n");
+
+        scene
+    }
+
+    #[test]
+    fn test_check_strict_plural_checks() {
+        let scene = make_scene_with_two_invalid_lines();
+
+        scene
+            .ucmd()
+            .arg("--strict")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stderr_contains("2 lines are improperly formatted");
+    }
+
+    fn make_scene_with_incorrect_checksum() -> TestScenario {
+        let scene = make_scene_with_two_invalid_lines();
+
+        scene
+            .fixtures
+            .append("CHECKSUMS", &format!("SM3 (input) = {INVALID_SUM}\n"));
+
+        scene
+    }
+
+    #[test]
+    fn test_check_with_incorrect_checksum() {
+        let scene = make_scene_with_incorrect_checksum();
+
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stdout_contains("input: FAILED")
+            .stderr_contains("1 computed checksum did NOT match");
+
+        // also fails with strict
+        scene
+            .ucmd()
+            .arg("--strict")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stdout_contains("input: FAILED")
+            .stderr_contains("1 computed checksum did NOT match");
+    }
+
+    #[test]
+    fn test_status_with_errors() {
+        let scene = make_scene_with_incorrect_checksum();
+
+        scene
+            .ucmd()
+            .arg("--status")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .no_output();
+    }
+
+    #[test]
+    fn test_check_with_non_existing_file() {
+        let scene = make_scene();
+        scene
+            .fixtures
+            .write("CHECKSUMS2", &format!("SM3 (input2) = {INVALID_SUM}\n"));
+
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("CHECKSUMS2")
+            .fails()
+            .stdout_contains("input2: FAILED open or read")
+            .stderr_contains("1 listed file could not be read");
+
+        // also fails with strict
+        scene
+            .ucmd()
+            .arg("--strict")
+            .arg("--check")
+            .arg("CHECKSUMS2")
+            .fails()
+            .stdout_contains("input2: FAILED open or read")
+            .stderr_contains("1 listed file could not be read");
+    }
+
+    fn make_scene_with_another_improperly_formatted() -> TestScenario {
+        let scene = make_scene_with_incorrect_checksum();
+
+        scene.fixtures.append(
+            "CHECKSUMS",
+            &format!("BLAKE2b (missing-file) = {INVALID_SUM}\n"),
+        );
+
+        scene
+    }
+
+    #[test]
+    fn test_warn() {
+        let scene = make_scene_with_another_improperly_formatted();
+
+        scene
+            .ucmd()
+            .arg("--warn")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stderr_contains("CHECKSUMS: 6: improperly formatted SM3 checksum line")
+            .stderr_contains("CHECKSUMS: 9: improperly formatted BLAKE2b checksum line");
+    }
+
+    fn make_scene_with_checksum_missing() -> TestScenario {
+        let scene = make_scene_with_another_improperly_formatted();
+
+        scene.fixtures.write(
+            "CHECKSUMS-missing",
+            &format!("SM3 (nonexistent) = {INVALID_SUM}\n"),
+        );
+
+        scene
+    }
+
+    #[test]
+    fn test_ignore_missing() {
+        let scene = make_scene_with_checksum_missing();
+
+        scene
+            .ucmd()
+            .arg("--ignore-missing")
+            .arg("--check")
+            .arg("CHECKSUMS-missing")
+            .fails()
+            .stdout_does_not_contain("nonexistent: No such file or directory")
+            .stdout_does_not_contain("nonexistent: FAILED open or read")
+            .stderr_contains("CHECKSUMS-missing: no file was verified");
+    }
+
+    #[test]
+    fn test_status_and_warn() {
+        let scene = make_scene_with_checksum_missing();
+
+        // --status before --warn
+        scene
+            .ucmd()
+            .arg("--status")
+            .arg("--warn")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stderr_contains("CHECKSUMS: 9: improperly formatted BLAKE2b checksum line")
+            .stderr_contains("WARNING: 3 lines are improperly formatted")
+            .stderr_contains("WARNING: 1 computed checksum did NOT match");
+
+        // --warn before --status (status hides the results)
+        scene
+            .ucmd()
+            .arg("--warn")
+            .arg("--status")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .stderr_does_not_contain("CHECKSUMS: 9: improperly formatted BLAKE2b checksum line")
+            .stderr_does_not_contain("WARNING: 3 lines are improperly formatted")
+            .stderr_does_not_contain("WARNING: 1 computed checksum did NOT match");
+    }
+
+    #[test]
+    fn test_status_and_ignore_missing() {
+        let scene = make_scene_with_checksum_missing();
+
+        scene
+            .ucmd()
+            .arg("--status")
+            .arg("--ignore-missing")
+            .arg("--check")
+            .arg("CHECKSUMS")
+            .fails()
+            .no_output();
+    }
+
+    #[test]
+    fn test_status_warn_and_ignore_missing() {
+        let scene = make_scene_with_checksum_missing();
+
+        scene
+            .ucmd()
+            .arg("--status")
+            .arg("--warn")
+            .arg("--ignore-missing")
+            .arg("--check")
+            .arg("CHECKSUMS-missing")
+            .fails()
+            .stderr_contains("CHECKSUMS-missing: no file was verified")
+            .stdout_does_not_contain("nonexistent: No such file or directory");
+    }
+
+    #[test]
+    fn test_check_several_files_dont_exist() {
+        let scene = make_scene();
+
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("non-existing-1")
+            .arg("non-existing-2")
+            .fails()
+            .stderr_contains("non-existing-1: No such file or directory")
+            .stderr_contains("non-existing-2: No such file or directory");
+    }
+
+    #[test]
+    fn test_check_several_files_empty() {
+        let scene = make_scene();
+        scene.fixtures.touch("empty-1");
+        scene.fixtures.touch("empty-2");
+
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("empty-1")
+            .arg("empty-2")
+            .fails()
+            .stderr_contains("empty-1: no properly formatted checksum lines found")
+            .stderr_contains("empty-2: no properly formatted checksum lines found");
+    }
+}
+
+/// The tests in this module check the behavior of cksum when given different
+/// checksum formats and algorithms in the same file, while specifying an
+/// algorithm on CLI or not.
+mod format_mix {
+    use super::*;
+
+    // First line is algo-based, second one is not
+    const INPUT_ALGO_NON_ALGO: &str = "\
+        BLAKE2b (bar) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n\
+        786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce  foo";
+
+    // First line is non algo-based, second one is
+    const INPUT_NON_ALGO_ALGO: &str = "\
+        786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce  foo\n\
+        BLAKE2b (bar) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce";
+
+    /// Make a simple scene with foo and bar empty files
+    fn make_scene() -> TestScenario {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+
+        at.touch("foo");
+        at.touch("bar");
+
+        scene
+    }
+
+    #[test]
+    fn test_check_cli_algo_non_algo() {
+        let scene = make_scene();
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("--algo=blake2b")
+            .pipe_in(INPUT_ALGO_NON_ALGO)
+            .succeeds()
+            .stdout_contains("bar: OK\nfoo: OK")
+            .no_stderr();
+    }
+
+    #[test]
+    fn test_check_cli_non_algo_algo() {
+        let scene = make_scene();
+        scene
+            .ucmd()
+            .arg("--check")
+            .arg("--algo=blake2b")
+            .pipe_in(INPUT_NON_ALGO_ALGO)
+            .succeeds()
+            .stdout_contains("foo: OK\nbar: OK")
+            .no_stderr();
+    }
+
+    #[test]
+    fn test_check_algo_non_algo() {
+        let scene = make_scene();
+        scene
+            .ucmd()
+            .arg("--check")
+            .pipe_in(INPUT_ALGO_NON_ALGO)
+            .succeeds()
+            .stdout_contains("bar: OK")
+            .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
+    }
+
+    #[test]
+    fn test_check_non_algo_algo() {
+        let scene = make_scene();
+        scene
+            .ucmd()
+            .arg("--check")
+            .pipe_in(INPUT_NON_ALGO_ALGO)
+            .succeeds()
+            .stdout_contains("bar: OK")
+            .stderr_contains("cksum: WARNING: 1 line is improperly formatted");
+    }
+}
diff --git a/tests/by-util/test_comm.rs b/tests/by-util/test_comm.rs
index e2bcc1c443f..058ab80ed7e 100644
--- a/tests/by-util/test_comm.rs
+++ b/tests/by-util/test_comm.rs
@@ -2,150 +2,339 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) defaultcheck nocheck
+// spell-checker:ignore (words) defaultcheck nocheck helpb helpz nwordb nwordwordz wordtotal
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn ab_no_args() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+
+    scene
+        .ucmd()
         .args(&["a", "b"])
         .succeeds()
-        .stdout_only_fixture("ab.expected");
+        .stdout_is("a\n\tb\n\t\tz\n");
 }
 
 #[test]
 fn ab_dash_one() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+
+    scene
+        .ucmd()
         .args(&["a", "b", "-1"])
         .succeeds()
-        .stdout_only_fixture("ab1.expected");
+        .stdout_is("b\n\tz\n");
 }
 
 #[test]
 fn ab_dash_two() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+
+    scene
+        .ucmd()
         .args(&["a", "b", "-2"])
         .succeeds()
-        .stdout_only_fixture("ab2.expected");
+        .stdout_is("a\n\tz\n");
 }
 
 #[test]
 fn ab_dash_three() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+
+    scene
+        .ucmd()
         .args(&["a", "b", "-3"])
         .succeeds()
-        .stdout_only_fixture("ab3.expected");
+        .stdout_is("a\n\tb\n");
 }
 
 #[test]
 fn a_empty() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.touch("empty");
+    scene
+        .ucmd()
         .args(&["a", "empty"])
         .succeeds()
-        .stdout_only_fixture("aempty.expected"); // spell-checker:disable-line
+        .stdout_is("a\nz\n");
 }
 
 #[test]
 fn empty_empty() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("empty");
+    scene
+        .ucmd()
         .args(&["empty", "empty"])
         .succeeds()
-        .stdout_only_fixture("emptyempty.expected"); // spell-checker:disable-line
+        .no_output();
 }
 
 #[test]
 fn total() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
         .args(&["--total", "a", "b"])
         .succeeds()
-        .stdout_is_fixture("ab_total.expected");
+        .stdout_is("a\n\tb\n\t\tz\n1\t1\t1\ttotal\n");
 }
 
 #[test]
 fn total_with_suppressed_regular_output() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
         .args(&["--total", "-123", "a", "b"])
         .succeeds()
-        .stdout_is_fixture("ab_total_suppressed_regular_output.expected");
+        .stdout_is("1\t1\t1\ttotal\n");
+}
+
+#[test]
+fn repeated_flags() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
+        .args(&["--total", "-123123", "--total", "a", "b"])
+        .succeeds()
+        .stdout_is("1\t1\t1\ttotal\n");
 }
 
 #[test]
 fn total_with_output_delimiter() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
         .args(&["--total", "--output-delimiter=word", "a", "b"])
         .succeeds()
-        .stdout_is_fixture("ab_total_delimiter_word.expected");
+        .stdout_is("a\nwordb\nwordwordz\n1word1word1wordtotal\n");
 }
 
 #[test]
 fn output_delimiter() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
         .args(&["--output-delimiter=word", "a", "b"])
         .succeeds()
-        .stdout_only_fixture("ab_delimiter_word.expected");
+        .stdout_is("a\nwordb\nwordwordz\n");
+}
+
+#[test]
+fn output_delimiter_hyphen_one() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
+        .args(&["--output-delimiter", "-1", "a", "b"])
+        .succeeds()
+        .stdout_is("a\n-1b\n-1-1z\n");
+}
+
+#[test]
+fn output_delimiter_hyphen_help() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
+        .args(&["--output-delimiter", "--help", "a", "b"])
+        .succeeds()
+        .stdout_is("a\n--helpb\n--help--helpz\n");
+}
+
+#[test]
+fn output_delimiter_multiple_identical() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
+        .args(&[
+            "--output-delimiter=word",
+            "--output-delimiter=word",
+            "a",
+            "b",
+        ])
+        .succeeds()
+        .stdout_is("a\nwordb\nwordwordz\n");
+}
+
+#[test]
+fn output_delimiter_multiple_different() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
+        .args(&[
+            "--output-delimiter=word",
+            "--output-delimiter=other",
+            "a",
+            "b",
+        ])
+        .fails()
+        .no_stdout()
+        .stderr_contains("multiple")
+        .stderr_contains("output")
+        .stderr_contains("delimiters");
+}
+
+#[test]
+#[ignore = "This is too weird; deviate intentionally."]
+fn output_delimiter_multiple_different_prevents_help() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
+        .args(&[
+            "--output-delimiter=word",
+            "--output-delimiter=other",
+            "--help",
+            "a",
+            "b",
+        ])
+        .fails()
+        .no_stdout()
+        .stderr_contains("multiple")
+        .stderr_contains("output")
+        .stderr_contains("delimiters");
 }
 
 #[test]
 fn output_delimiter_nul() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("a", "a\nz\n");
+    at.write("b", "b\nz\n");
+    scene
+        .ucmd()
         .args(&["--output-delimiter=", "a", "b"])
         .succeeds()
-        .stdout_only_fixture("ab_delimiter_nul.expected");
+        .stdout_is("a\n\0b\n\0\0z\n");
 }
 
 #[test]
 fn zero_terminated() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("a_nul", "a\0z\0");
+    at.write("b_nul", "b\0z\0");
     for param in ["-z", "--zero-terminated"] {
-        new_ucmd!()
+        scene
+            .ucmd()
             .args(&[param, "a_nul", "b_nul"])
             .succeeds()
-            .stdout_only_fixture("ab_nul.expected");
+            .stdout_is("a\0\tb\0\t\tz\0");
     }
 }
 
 #[test]
 fn zero_terminated_provided_multiple_times() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("a_nul", "a\0z\0");
+    at.write("b_nul", "b\0z\0");
     for param in ["-z", "--zero-terminated"] {
-        new_ucmd!()
+        scene
+            .ucmd()
             .args(&[param, param, param, "a_nul", "b_nul"])
             .succeeds()
-            .stdout_only_fixture("ab_nul.expected");
+            .stdout_is("a\0\tb\0\t\tz\0");
     }
 }
 
 #[test]
 fn zero_terminated_with_total() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("a_nul", "a\0z\0");
+    at.write("b_nul", "b\0z\0");
+
     for param in ["-z", "--zero-terminated"] {
-        new_ucmd!()
+        scene
+            .ucmd()
             .args(&[param, "--total", "a_nul", "b_nul"])
             .succeeds()
-            .stdout_only_fixture("ab_nul_total.expected");
+            .stdout_is("a\0\tb\0\t\tz\x001\t1\t1\ttotal\0");
     }
 }
 
 #[cfg_attr(not(feature = "test_unimplemented"), ignore)]
 #[test]
 fn check_order() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("bad_order_1", "e\nd\nb\na\n");
+    at.write("bad_order_2", "e\nc\nb\na\n");
+    scene
+        .ucmd()
         .args(&["--check-order", "bad_order_1", "bad_order_2"])
         .fails()
-        .stdout_is_fixture("bad_order12.check_order.expected")
+        .stdout_is("\t\te")
         .stderr_is("error to be defined");
 }
 
 #[cfg_attr(not(feature = "test_unimplemented"), ignore)]
 #[test]
 fn nocheck_order() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("bad_order_1", "e\nd\nb\na\n");
+    at.write("bad_order_2", "e\nc\nb\na\n");
     new_ucmd!()
         .args(&["--nocheck-order", "bad_order_1", "bad_order_2"])
         .succeeds()
-        .stdout_only_fixture("bad_order12.nocheck_order.expected");
+        .stdout_is("\t\te\n\tc\n\tb\n\ta\nd\nb\na\n");
 }
 
 // when neither --check-order nor --no-check-order is provided,
@@ -154,6 +343,9 @@ fn nocheck_order() {
 #[cfg_attr(not(feature = "test_unimplemented"), ignore)]
 #[test]
 fn defaultcheck_order() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("bad_order_1", "e\nd\nb\na\n");
     new_ucmd!()
         .args(&["a", "bad_order_1"])
         .fails()
@@ -162,27 +354,26 @@ fn defaultcheck_order() {
 
 // * the first: if both files are not in order, the default behavior is the only
 // behavior that will provide an error message
-
 // * the second: if two rows are paired but are out of order,
 // it won't matter if all rows in the two files are exactly the same.
 // This is specified in the documentation
-
 #[test]
 fn defaultcheck_order_identical_bad_order_files() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("bad_order_1", "e\nd\nb\na\n");
+    scene
+        .ucmd()
         .args(&["bad_order_1", "bad_order_1"])
         .succeeds()
-        .stdout_only_fixture("bad_order11.defaultcheck_order.expected");
-}
-
-#[cfg_attr(not(feature = "test_unimplemented"), ignore)]
-#[test]
-fn defaultcheck_order_two_different_bad_order_files() {
-    new_ucmd!()
-        .args(&["bad_order_1", "bad_order_2"])
+        .stdout_is("\t\te\n\t\td\n\t\tb\n\t\ta\n");
+    scene
+        .ucmd()
+        .arg("--check-order")
+        .args(&["bad_order_1", "bad_order_1"])
         .fails()
-        .stdout_is_fixture("bad_order12.nocheck_order.expected")
-        .stderr_is("error to be defined");
+        .stdout_is("\t\te\n")
+        .stderr_is("comm: file 1 is not in sorted order\n");
 }
 
 // * the third: (it is not know whether this is a bug or not)
@@ -190,18 +381,21 @@ fn defaultcheck_order_two_different_bad_order_files() {
 // where both lines are different and one or both file lines being
 // compared are out of order from the preceding line,
 // it is ignored and no errors occur.
-
 // * the fourth: (it is not known whether this is a bug or not)
 // there are additional, not-yet-understood circumstances where an out-of-order
 // pair is ignored and is not counted against the 1 maximum out-of-order line.
-
-#[cfg_attr(not(feature = "test_unimplemented"), ignore)]
 #[test]
 fn unintuitive_default_behavior_1() {
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("defaultcheck_unintuitive_1", "m\nh\nn\no\nc\np\n");
+    at.write("defaultcheck_unintuitive_2", "m\nh\nn\no\np\n");
+    // Here, GNU does not fail, but uutils does
+    scene
+        .ucmd()
         .args(&["defaultcheck_unintuitive_1", "defaultcheck_unintuitive_2"])
-        .succeeds()
-        .stdout_only_fixture("defaultcheck_unintuitive.expected");
+        .fails()
+        .stdout_is("\t\tm\n\t\th\n\t\tn\n\t\to\nc\n\t\tp\n");
 }
 
 #[test]
@@ -221,3 +415,160 @@ fn test_no_such_file() {
         .fails()
         .stderr_only("comm: bogus_file_1: No such file or directory\n");
 }
+
+#[test]
+fn test_is_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    scene
+        .ucmd()
+        .args(&[".", "."])
+        .fails()
+        .stderr_only("comm: .: Is a directory\n");
+
+    at.mkdir("dir");
+    scene
+        .ucmd()
+        .args(&["dir", "."])
+        .fails()
+        .stderr_only("comm: dir: Is a directory\n");
+
+    at.touch("file");
+    scene
+        .ucmd()
+        .args(&[".", "file"])
+        .fails()
+        .stderr_only("comm: .: Is a directory\n");
+
+    at.touch("file");
+    scene
+        .ucmd()
+        .args(&["file", "."])
+        .fails()
+        .stderr_only("comm: .: Is a directory\n");
+}
+
+#[test]
+fn test_sorted() {
+    let expected_stderr =
+        "comm: file 2 is not in sorted order\ncomm: input is not in sorted order\n";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("comm1", "1\n3");
+    at.write("comm2", "3\n2");
+    scene
+        .ucmd()
+        .args(&["comm1", "comm2"])
+        .fails_with_code(1)
+        .stdout_is("1\n\t\t3\n\t2\n")
+        .stderr_is(expected_stderr);
+}
+
+#[test]
+fn test_sorted_check_order() {
+    let expected_stderr = "comm: file 2 is not in sorted order\n";
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("comm1", "1\n3");
+    at.write("comm2", "3\n2");
+    scene
+        .ucmd()
+        .arg("--check-order")
+        .args(&["comm1", "comm2"])
+        .fails_with_code(1)
+        .stdout_is("1\n\t\t3\n")
+        .stderr_is(expected_stderr);
+}
+
+#[test]
+fn test_both_inputs_out_of_order() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("file_a", "3\n1\n0\n");
+    at.write("file_b", "3\n2\n0\n");
+
+    scene
+        .ucmd()
+        .args(&["file_a", "file_b"])
+        .fails_with_code(1)
+        .stdout_is("\t\t3\n1\n0\n\t2\n\t0\n")
+        .stderr_is(
+            "comm: file 1 is not in sorted order\n\
+             comm: file 2 is not in sorted order\n\
+             comm: input is not in sorted order\n",
+        );
+}
+
+#[test]
+fn test_both_inputs_out_of_order_last_pair() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("file_a", "3\n1\n");
+    at.write("file_b", "3\n2\n");
+
+    scene
+        .ucmd()
+        .args(&["file_a", "file_b"])
+        .fails_with_code(1)
+        .stdout_is("\t\t3\n1\n\t2\n")
+        .stderr_is(
+            "comm: file 1 is not in sorted order\n\
+             comm: file 2 is not in sorted order\n\
+             comm: input is not in sorted order\n",
+        );
+}
+
+#[test]
+fn test_first_input_out_of_order_extended() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("file_a", "0\n3\n1\n");
+    at.write("file_b", "2\n3\n");
+
+    scene
+        .ucmd()
+        .args(&["file_a", "file_b"])
+        .fails_with_code(1)
+        .stdout_is("0\n\t2\n\t\t3\n1\n")
+        .stderr_is(
+            "comm: file 1 is not in sorted order\n\
+             comm: input is not in sorted order\n",
+        );
+}
+
+#[test]
+fn test_out_of_order_input_nocheck() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    // Create input files
+    at.write("file_a", "1\n3\n");
+    at.write("file_b", "3\n2\n");
+
+    scene
+        .ucmd()
+        .arg("--nocheck-order")
+        .args(&["file_a", "file_b"])
+        .succeeds()
+        .stdout_is("1\n\t\t3\n\t2\n")
+        .no_stderr();
+}
+
+#[test]
+fn test_both_inputs_out_of_order_but_identical() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("file_a", "2\n1\n0\n");
+    at.write("file_b", "2\n1\n0\n");
+
+    scene
+        .ucmd()
+        .args(&["file_a", "file_b"])
+        .succeeds()
+        .stdout_is("\t\t2\n\t\t1\n\t\t0\n")
+        .no_stderr();
+}
diff --git a/tests/by-util/test_cp.rs b/tests/by-util/test_cp.rs
index f72316b5daa..cb7eea5cdfb 100644
--- a/tests/by-util/test_cp.rs
+++ b/tests/by-util/test_cp.rs
@@ -2,18 +2,23 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs ROOTDIR USERDIR procfs outfile
 
-use crate::common::util::TestScenario;
+// spell-checker:ignore (flags) reflink (fs) tmpfs (linux) rlimit Rlim NOFILE clob btrfs neve ROOTDIR USERDIR procfs outfile uufs xattrs
+// spell-checker:ignore bdfl hlsl IRWXO IRWXG nconfined matchpathcon libselinux-devel
+use uucore::display::Quotable;
+use uutests::util::TestScenario;
+use uutests::{at_and_ucmd, new_ucmd, path_concat, util_name};
+
 #[cfg(not(windows))]
 use std::fs::set_permissions;
 
+use std::io::Write;
 #[cfg(not(windows))]
 use std::os::unix::fs;
 
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
 use std::os::unix::fs::MetadataExt;
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 #[cfg(windows)]
 use std::os::windows::fs::symlink_file;
@@ -24,8 +29,6 @@ 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"))]
@@ -35,7 +38,7 @@ use std::time::Duration;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[cfg(feature = "truncate")]
-use crate::common::util::PATH;
+use uutests::util::PATH;
 
 static TEST_EXISTING_FILE: &str = "existing_file.txt";
 static TEST_HELLO_WORLD_SOURCE: &str = "hello_world.txt";
@@ -56,8 +59,12 @@ static TEST_MOUNT_COPY_FROM_FOLDER: &str = "dir_with_mount";
 static TEST_MOUNT_MOUNTPOINT: &str = "mount";
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
 static TEST_MOUNT_OTHER_FILESYSTEM_FILE: &str = "mount/DO_NOT_copy_me.txt";
-#[cfg(unix)]
 static TEST_NONEXISTENT_FILE: &str = "nonexistent_file.txt";
+#[cfg(all(
+    unix,
+    not(any(target_os = "android", target_os = "macos", target_os = "openbsd"))
+))]
+use uutests::util::compare_xattrs;
 
 /// Assert that mode, ownership, and permissions of two metadata objects match.
 #[cfg(all(not(windows), not(target_os = "freebsd")))]
@@ -113,10 +120,79 @@ fn test_cp_duplicate_files() {
         .arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_COPY_TO_FOLDER)
         .succeeds()
-        .stderr_contains("specified more than once");
+        .stderr_contains(format!(
+            "source file '{TEST_HELLO_WORLD_SOURCE}' specified more than once"
+        ));
+    assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
+}
+
+#[test]
+fn test_cp_duplicate_folder() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg("-r")
+        .arg(TEST_COPY_FROM_FOLDER)
+        .arg(TEST_COPY_FROM_FOLDER)
+        .arg(TEST_COPY_TO_FOLDER)
+        .succeeds()
+        .stderr_contains(format!(
+            "source directory '{TEST_COPY_FROM_FOLDER}' specified more than once"
+        ));
+    assert!(at.dir_exists(format!("{TEST_COPY_TO_FOLDER}/{TEST_COPY_FROM_FOLDER}").as_str()));
+}
+
+#[test]
+fn test_cp_duplicate_files_normalized_path() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(format!("./{TEST_HELLO_WORLD_SOURCE}"))
+        .arg(TEST_COPY_TO_FOLDER)
+        .succeeds()
+        .stderr_contains(format!(
+            "source file './{TEST_HELLO_WORLD_SOURCE}' specified more than once"
+        ));
     assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
 }
 
+#[test]
+fn test_cp_duplicate_files_with_plain_backup() {
+    let (_, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_COPY_TO_FOLDER)
+        .arg("--backup")
+        .fails()
+        // cp would skip duplicate src check and fail when it tries to overwrite the "just-created" file.
+        .stderr_contains(
+            "will not overwrite just-created 'hello_dir/hello_world.txt' with 'hello_world.txt",
+        );
+}
+
+#[test]
+fn test_cp_duplicate_files_with_numbered_backup() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    // cp would skip duplicate src check and succeeds
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_COPY_TO_FOLDER)
+        .arg("--backup=numbered")
+        .succeeds();
+    at.file_exists(TEST_COPY_TO_FOLDER_FILE);
+    at.file_exists(format!("{TEST_COPY_TO_FOLDER}.~1~"));
+}
+
+#[test]
+fn test_cp_same_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "a";
+
+    at.touch(file);
+
+    ucmd.arg(file)
+        .arg(file)
+        .fails_with_code(1)
+        .stderr_contains(format!("'{file}' and '{file}' are the same file"));
+}
+
 #[test]
 fn test_cp_multiple_files_target_is_file() {
     new_ucmd!()
@@ -133,7 +209,9 @@ fn test_cp_directory_not_recursive() {
         .arg(TEST_COPY_TO_FOLDER)
         .arg(TEST_HELLO_WORLD_DEST)
         .fails()
-        .stderr_contains("omitting directory");
+        .stderr_is(format!(
+            "cp: -r not specified; omitting directory '{TEST_COPY_TO_FOLDER}'\n"
+        ));
 }
 
 #[test]
@@ -148,6 +226,42 @@ fn test_cp_multiple_files() {
     assert_eq!(at.read(TEST_HOW_ARE_YOU_DEST), "How are you?\n");
 }
 
+#[test]
+fn test_cp_multiple_files_with_nonexistent_file() {
+    #[cfg(windows)]
+    let error_msg = "The system cannot find the file specified";
+    #[cfg(not(windows))]
+    let error_msg = format!("'{TEST_NONEXISTENT_FILE}': No such file or directory");
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_NONEXISTENT_FILE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg(TEST_COPY_TO_FOLDER)
+        .fails()
+        .stderr_contains(error_msg);
+
+    assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
+    assert_eq!(at.read(TEST_HOW_ARE_YOU_DEST), "How are you?\n");
+}
+
+#[test]
+fn test_cp_multiple_files_with_empty_file_name() {
+    #[cfg(windows)]
+    let error_msg = "The system cannot find the path specified";
+    #[cfg(not(windows))]
+    let error_msg = "'': No such file or directory";
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("")
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg(TEST_COPY_TO_FOLDER)
+        .fails()
+        .stderr_contains(error_msg);
+
+    assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
+    assert_eq!(at.read(TEST_HOW_ARE_YOU_DEST), "How are you?\n");
+}
+
 #[test]
 // FixME: for MacOS, this has intermittent failures; track repair progress at GH:uutils/coreutils/issues/1590
 #[cfg(not(target_os = "macos"))]
@@ -176,6 +290,24 @@ fn test_cp_recurse_several() {
     assert_eq!(at.read(TEST_COPY_TO_FOLDER_NEW_FILE), "Hello, World!\n");
 }
 
+#[test]
+fn test_cp_recurse_source_path_ends_with_slash_dot() {
+    let source_dir = "source_dir";
+    let target_dir = "target_dir";
+    let file = "file";
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir(source_dir);
+    at.touch(format!("{source_dir}/{file}"));
+
+    ucmd.arg("-r")
+        .arg(format!("{source_dir}/."))
+        .arg(target_dir)
+        .succeeds()
+        .no_output();
+    assert!(at.file_exists(format!("{target_dir}/{file}")));
+}
+
 #[test]
 fn test_cp_with_dirs_t() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -230,6 +362,49 @@ fn test_cp_arg_no_target_directory() {
         .stderr_contains("cannot overwrite directory");
 }
 
+#[test]
+fn test_cp_arg_no_target_directory_with_recursive() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("dir");
+    at.mkdir("dir2");
+    at.touch("dir/a");
+    at.touch("dir/b");
+
+    ucmd.arg("-rT")
+        .arg("dir")
+        .arg("dir2")
+        .succeeds()
+        .no_output();
+
+    assert!(at.plus("dir2").join("a").exists());
+    assert!(at.plus("dir2").join("b").exists());
+    assert!(!at.plus("dir2").join("dir").exists());
+}
+
+#[test]
+#[ignore = "disabled until https://github.com/uutils/coreutils/issues/7455 is fixed"]
+fn test_cp_arg_no_target_directory_with_recursive_target_does_not_exists() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("dir");
+    at.touch("dir/a");
+    at.touch("dir/b");
+
+    let target = "create_me";
+    assert!(!at.plus(target).exists());
+
+    ucmd.arg("-rT")
+        .arg("dir")
+        .arg(target)
+        .succeeds()
+        .no_output();
+
+    assert!(at.plus(target).join("a").exists());
+    assert!(at.plus(target).join("b").exists());
+    assert!(!at.plus(target).join("dir").exists());
+}
+
 #[test]
 fn test_cp_target_directory_is_file() {
     new_ucmd!()
@@ -240,18 +415,6 @@ fn test_cp_target_directory_is_file() {
         .stderr_contains(format!("'{TEST_HOW_ARE_YOU_SOURCE}' is not a directory"));
 }
 
-#[test]
-fn test_cp_arg_update_interactive() {
-    new_ucmd!()
-        .arg(TEST_HELLO_WORLD_SOURCE)
-        .arg(TEST_HOW_ARE_YOU_SOURCE)
-        .arg("-i")
-        .arg("--update")
-        .succeeds()
-        .no_stdout()
-        .no_stderr();
-}
-
 #[test]
 fn test_cp_arg_update_interactive_error() {
     new_ucmd!()
@@ -265,14 +428,23 @@ fn test_cp_arg_update_interactive_error() {
 #[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_none_fail() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg("--update=none-fail")
+        .fails()
+        .stderr_contains(format!("not replacing '{TEST_HOW_ARE_YOU_SOURCE}'"));
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
 }
 
@@ -315,6 +487,29 @@ fn test_cp_arg_update_older_dest_not_older_than_src() {
     assert_eq!(at.read(new), "new content\n");
 }
 
+#[test]
+fn test_cp_arg_update_older_dest_not_older_than_src_no_verbose_output() {
+    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("--verbose")
+        .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!();
@@ -324,9 +519,9 @@ fn test_cp_arg_update_older_dest_older_than_src() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -340,6 +535,32 @@ fn test_cp_arg_update_older_dest_older_than_src() {
     assert_eq!(at.read(old), "new content\n");
 }
 
+#[test]
+fn test_cp_arg_update_older_dest_older_than_src_with_verbose_output() {
+    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";
+
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
+
+    at.write(new, new_content);
+
+    ucmd.arg(new)
+        .arg(old)
+        .arg("--verbose")
+        .arg("--update=older")
+        .succeeds()
+        .no_stderr()
+        .stdout_is(format!("'{new}' -> '{old}'\n"));
+
+    assert_eq!(at.read(old), "new content\n");
+}
+
 #[test]
 fn test_cp_arg_update_short_no_overwrite() {
     // same as --update=older
@@ -350,9 +571,9 @@ fn test_cp_arg_update_short_no_overwrite() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -376,9 +597,9 @@ fn test_cp_arg_update_short_overwrite() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -403,9 +624,9 @@ fn test_cp_arg_update_none_then_all() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -431,9 +652,9 @@ fn test_cp_arg_update_all_then_none() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -461,15 +682,47 @@ fn test_cp_arg_interactive() {
 }
 
 #[test]
-#[cfg(not(target_os = "android"))]
-fn test_cp_arg_interactive_update() {
+#[cfg(not(any(target_os = "android", target_os = "freebsd", target_os = "openbsd")))]
+fn test_cp_arg_interactive_update_overwrite_newer() {
     // -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("")
+        .succeeds()
+        .no_stdout();
+    // Make extra sure that closing stdin behaves identically to piping-in nothing.
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("a");
+    at.touch("b");
+    ucmd.args(&["-i", "-u", "a", "b"]).succeeds().no_stdout();
+}
+
+#[test]
+#[cfg(not(any(target_os = "android", target_os = "freebsd")))]
+fn test_cp_arg_interactive_update_overwrite_older() {
+    // -u -i *WILL* show the prompt to validate the override.
+    // Therefore, the error code depends on the prompt response.
+    // Option N
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("b");
+    sleep(Duration::from_millis(100));
+    at.touch("a");
     ucmd.args(&["-i", "-u", "a", "b"])
         .pipe_in("N\n")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_is("cp: overwrite 'b'? ");
+
+    // Option Y
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("b");
+    sleep(Duration::from_millis(100));
+    at.touch("a");
+    ucmd.args(&["-i", "-u", "a", "b"])
+        .pipe_in("Y\n")
         .succeeds()
         .no_stdout();
 }
@@ -483,7 +736,8 @@ fn test_cp_arg_interactive_verbose() {
     ucmd.args(&["-vi", "a", "b"])
         .pipe_in("N\n")
         .fails()
-        .stdout_is("skipped 'b'\n");
+        .stderr_is("cp: overwrite 'b'? ")
+        .no_stdout();
 }
 
 #[test]
@@ -492,9 +746,44 @@ 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"])
+    ucmd.args(&["-vin", "--debug", "a", "b"])
+        .succeeds()
+        .stdout_contains("skipped 'b'");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_f_i_verbose_non_writeable_destination_y() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("a");
+    at.touch("b");
+
+    // Non-writeable file
+    at.set_mode("b", 0o0000);
+
+    ucmd.args(&["-f", "-i", "--verbose", "a", "b"])
+        .pipe_in("y")
+        .succeeds()
+        .stderr_is("cp: replace 'b', overriding mode 0000 (---------)? ")
+        .stdout_is("'a' -> 'b'\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_f_i_verbose_non_writeable_destination_empty() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("a");
+    at.touch("b");
+
+    // Non-writeable file
+    at.set_mode("b", 0o0000);
+
+    ucmd.args(&["-f", "-i", "--verbose", "a", "b"])
+        .pipe_in("")
         .fails()
-        .stdout_is("skipped 'b'\n");
+        .stderr_only("cp: replace 'b', overriding mode 0000 (---------)? ");
 }
 
 #[test]
@@ -512,26 +801,92 @@ fn test_cp_arg_link() {
 }
 
 #[test]
-fn test_cp_arg_symlink() {
+#[cfg(target_os = "linux")]
+fn test_cp_arg_link_with_dest_hardlink_to_source() {
+    use std::os::linux::fs::MetadataExt;
+
     let (at, mut ucmd) = at_and_ucmd!();
-    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
-        .arg("--symbolic-link")
-        .arg(TEST_HELLO_WORLD_DEST)
-        .succeeds();
+    let file = "file";
+    let hardlink = "hardlink";
 
-    assert!(at.is_symlink(TEST_HELLO_WORLD_DEST));
+    at.touch(file);
+    at.hard_link(file, hardlink);
+
+    ucmd.args(&["--link", file, hardlink]).succeeds();
+
+    assert_eq!(at.metadata(file).st_nlink(), 2);
+    assert!(at.file_exists(file));
+    assert!(at.file_exists(hardlink));
 }
 
 #[test]
-fn test_cp_arg_no_clobber() {
+#[cfg(target_os = "linux")]
+fn test_cp_arg_link_with_same_file() {
+    use std::os::linux::fs::MetadataExt;
+
     let (at, mut ucmd) = at_and_ucmd!();
-    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
-        .arg(TEST_HOW_ARE_YOU_SOURCE)
-        .arg("--no-clobber")
-        .fails()
-        .stderr_contains("not replacing");
+    let file = "file";
 
-    assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
+    at.touch(file);
+
+    ucmd.args(&["--link", file, file]).succeeds();
+
+    assert_eq!(at.metadata(file).st_nlink(), 1);
+    assert!(at.file_exists(file));
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_verbose_preserved_link_to_dir() {
+    use std::os::linux::fs::MetadataExt;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let hardlink = "hardlink";
+    let dir = "dir";
+    let dst_file = "dir/file";
+    let dst_hardlink = "dir/hardlink";
+
+    at.touch(file);
+    at.hard_link(file, hardlink);
+    at.mkdir(dir);
+
+    ucmd.args(&["-d", "--verbose", file, hardlink, dir])
+        .succeeds()
+        .stdout_is("'file' -> 'dir/file'\n'hardlink' -> 'dir/hardlink'\n");
+
+    assert!(at.file_exists(dst_file));
+    assert!(at.file_exists(dst_hardlink));
+    assert_eq!(at.metadata(dst_file).st_nlink(), 2);
+    assert_eq!(at.metadata(dst_hardlink).st_nlink(), 2);
+    assert_eq!(
+        at.metadata(dst_file).st_ino(),
+        at.metadata(dst_hardlink).st_ino()
+    );
+}
+
+#[test]
+fn test_cp_arg_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("--symbolic-link")
+        .arg(TEST_HELLO_WORLD_DEST)
+        .succeeds();
+
+    assert!(at.is_symlink(TEST_HELLO_WORLD_DEST));
+}
+
+#[test]
+fn test_cp_arg_no_clobber() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HOW_ARE_YOU_SOURCE)
+        .arg("--no-clobber")
+        .arg("--debug")
+        .succeeds()
+        .stdout_contains("skipped 'how_are_you.txt'");
+
+    assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
 }
 
 #[test]
@@ -540,7 +895,9 @@ fn test_cp_arg_no_clobber_inferred_arg() {
     ucmd.arg(TEST_HELLO_WORLD_SOURCE)
         .arg(TEST_HOW_ARE_YOU_SOURCE)
         .arg("--no-clob")
-        .fails();
+        .arg("--debug")
+        .succeeds()
+        .stdout_contains("skipped 'how_are_you.txt'");
 
     assert_eq!(at.read(TEST_HOW_ARE_YOU_SOURCE), "How are you?\n");
 }
@@ -550,29 +907,32 @@ fn test_cp_arg_no_clobber_twice() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
-    at.touch("source.txt");
+    at.touch(TEST_HELLO_WORLD_SOURCE);
     scene
         .ucmd()
         .arg("--no-clobber")
-        .arg("source.txt")
-        .arg("dest.txt")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HELLO_WORLD_DEST)
+        .arg("--debug")
         .succeeds()
         .no_stderr();
 
-    assert_eq!(at.read("source.txt"), "");
+    assert_eq!(at.read(TEST_HELLO_WORLD_SOURCE), "");
 
-    at.append("source.txt", "some-content");
+    at.append(TEST_HELLO_WORLD_SOURCE, "some-content");
     scene
         .ucmd()
         .arg("--no-clobber")
-        .arg("source.txt")
-        .arg("dest.txt")
-        .fails();
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HELLO_WORLD_DEST)
+        .arg("--debug")
+        .succeeds()
+        .stdout_contains(format!("skipped '{}'", TEST_HELLO_WORLD_DEST));
 
-    assert_eq!(at.read("source.txt"), "some-content");
+    assert_eq!(at.read(TEST_HELLO_WORLD_SOURCE), "some-content");
     // Should be empty as the "no-clobber" should keep
     // the previous version
-    assert_eq!(at.read("dest.txt"), "");
+    assert_eq!(at.read(TEST_HELLO_WORLD_DEST), "");
 }
 
 #[test]
@@ -639,6 +999,46 @@ fn test_cp_arg_backup() {
     );
 }
 
+#[test]
+fn test_cp_arg_backup_with_dest_a_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "source";
+    let source_content = "content";
+    let symlink = "symlink";
+    let original = "original";
+    let backup = "symlink~";
+
+    at.write(source, source_content);
+    at.write(original, "original");
+    at.symlink_file(original, symlink);
+
+    ucmd.arg("-b").arg(source).arg(symlink).succeeds();
+
+    assert!(!at.symlink_exists(symlink));
+    assert_eq!(source_content, at.read(symlink));
+    assert!(at.symlink_exists(backup));
+    assert_eq!(original, at.resolve_link(backup));
+}
+
+#[test]
+fn test_cp_arg_backup_with_dest_a_symlink_to_source() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "source";
+    let source_content = "content";
+    let symlink = "symlink";
+    let backup = "symlink~";
+
+    at.write(source, source_content);
+    at.symlink_file(source, symlink);
+
+    ucmd.arg("-b").arg(source).arg(symlink).succeeds();
+
+    assert!(!at.symlink_exists(symlink));
+    assert_eq!(source_content, at.read(symlink));
+    assert!(at.symlink_exists(backup));
+    assert_eq!(source, at.resolve_link(backup));
+}
+
 #[test]
 fn test_cp_arg_backup_with_other_args() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -959,13 +1359,15 @@ fn test_cp_deref() {
         .join(TEST_COPY_TO_FOLDER)
         .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
-            .clone()
-            .into_os_string()
-            .into_string()
-            .unwrap()
-    ));
+    assert!(
+        at.file_exists(
+            path_to_new_symlink
+                .clone()
+                .into_os_string()
+                .into_string()
+                .unwrap()
+        )
+    );
     // Check the content of the destination file that was copied.
     assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
     let path_to_check = path_to_new_symlink.to_str().unwrap();
@@ -996,13 +1398,15 @@ fn test_cp_no_deref() {
         .subdir
         .join(TEST_COPY_TO_FOLDER)
         .join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
-    assert!(at.is_symlink(
-        &path_to_new_symlink
-            .clone()
-            .into_os_string()
-            .into_string()
-            .unwrap()
-    ));
+    assert!(
+        at.is_symlink(
+            &path_to_new_symlink
+                .clone()
+                .into_os_string()
+                .into_string()
+                .unwrap()
+        )
+    );
     // Check the content of the destination file that was copied.
     assert_eq!(at.read(TEST_COPY_TO_FOLDER_FILE), "Hello, World!\n");
     let path_to_check = path_to_new_symlink.to_str().unwrap();
@@ -1043,14 +1447,16 @@ fn test_cp_no_deref_link_onto_link() {
         .succeeds();
 
     // Ensure that the target of the destination was not modified.
-    assert!(!at
-        .symlink_metadata(TEST_HELLO_WORLD_DEST)
-        .file_type()
-        .is_symlink());
-    assert!(at
-        .symlink_metadata(TEST_HELLO_WORLD_DEST_SYMLINK)
-        .file_type()
-        .is_symlink());
+    assert!(
+        !at.symlink_metadata(TEST_HELLO_WORLD_DEST)
+            .file_type()
+            .is_symlink()
+    );
+    assert!(
+        at.symlink_metadata(TEST_HELLO_WORLD_DEST_SYMLINK)
+            .file_type()
+            .is_symlink()
+    );
     assert_eq!(at.read(TEST_HELLO_WORLD_DEST_SYMLINK), "Hello, World!\n");
 }
 
@@ -1118,6 +1524,7 @@ fn test_cp_parents_dest_not_directory() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_cp_parents_with_permissions_copy_file() {
     let (at, mut ucmd) = at_and_ucmd!();
 
@@ -1158,6 +1565,7 @@ fn test_cp_parents_with_permissions_copy_file() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_cp_parents_with_permissions_copy_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
 
@@ -1215,6 +1623,7 @@ fn test_cp_issue_1665() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_cp_preserve_no_args() {
     let (at, mut ucmd) = at_and_ucmd!();
     let src_file = "a";
@@ -1242,6 +1651,7 @@ fn test_cp_preserve_no_args() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_cp_preserve_no_args_before_opts() {
     let (at, mut ucmd) = at_and_ucmd!();
     let src_file = "a";
@@ -1270,34 +1680,33 @@ fn test_cp_preserve_no_args_before_opts() {
 
 #[test]
 fn test_cp_preserve_all() {
-    let (at, mut ucmd) = at_and_ucmd!();
-    let src_file = "a";
-    let dst_file = "b";
+    for argument in ["--preserve=all", "--preserve=al"] {
+        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);
+        // Prepare the source file
+        at.touch(src_file);
+        #[cfg(unix)]
+        at.set_mode(src_file, 0o0500);
 
-    // TODO: create a destination that does not allow copying of xattr and context
-    // Copy
-    ucmd.arg(src_file)
-        .arg(dst_file)
-        .arg("--preserve=all")
-        .succeeds();
+        // TODO: create a destination that does not allow copying of xattr and context
+        // Copy
+        ucmd.arg(src_file).arg(dst_file).arg(argument).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);
+        #[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]
-#[cfg(all(unix, not(target_os = "android")))]
+#[cfg(all(unix, not(any(target_os = "android", target_os = "openbsd"))))]
 fn test_cp_preserve_xattr() {
     let (at, mut ucmd) = at_and_ucmd!();
     let src_file = "a";
@@ -1340,8 +1749,37 @@ fn test_cp_preserve_all_context_fails_on_non_selinux() {
         .fails();
 }
 
+#[test]
+fn test_cp_preserve_link_parses() {
+    // TODO: Also check whether --preserve=link did the right thing!
+    for argument in [
+        "--preserve=links",
+        "--preserve=link",
+        "--preserve=li",
+        "--preserve=l",
+    ] {
+        new_ucmd!()
+            .arg(argument)
+            .arg(TEST_COPY_FROM_FOLDER_FILE)
+            .arg(TEST_HELLO_WORLD_DEST)
+            .succeeds()
+            .no_output();
+    }
+}
+
+#[test]
+fn test_cp_preserve_invalid_rejected() {
+    new_ucmd!()
+        .arg("--preserve=invalid-value")
+        .arg(TEST_COPY_FROM_FOLDER_FILE)
+        .arg(TEST_HELLO_WORLD_DEST)
+        .fails_with_code(1)
+        .no_stdout();
+}
+
 #[test]
 #[cfg(target_os = "android")]
+#[ignore = "disabled until fixed"] // FIXME: the test looks to .succeed on android
 fn test_cp_preserve_xattr_fails_on_android() {
     // Because of the SELinux extended attributes used on Android, trying to copy extended
     // attributes has to fail in this case, since we specify `--preserve=xattr` and this puts it
@@ -1353,6 +1791,226 @@ fn test_cp_preserve_xattr_fails_on_android() {
         .fails();
 }
 
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_1() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("a");
+    at.hard_link("a", "b");
+    at.mkdir("c");
+
+    ucmd.arg("-d").arg("a").arg("b").arg("c").succeeds();
+
+    assert!(at.dir_exists("c"));
+    assert!(at.plus("c").join("a").exists());
+    assert!(at.plus("c").join("b").exists());
+
+    #[cfg(unix)]
+    {
+        let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+        let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+        assert_eq!(metadata_a.ino(), metadata_b.ino());
+    }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_2() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("a");
+    at.symlink_file("a", "b");
+    at.mkdir("c");
+
+    ucmd.arg("--preserve=links")
+        .arg("-R")
+        .arg("-H")
+        .arg("a")
+        .arg("b")
+        .arg("c")
+        .succeeds();
+
+    assert!(at.dir_exists("c"));
+    assert!(at.plus("c").join("a").exists());
+    assert!(at.plus("c").join("b").exists());
+
+    #[cfg(unix)]
+    {
+        let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+        let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+        assert_eq!(metadata_a.ino(), metadata_b.ino());
+    }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_3() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("d");
+    at.touch("d/a");
+    at.symlink_file("d/a", "d/b");
+
+    ucmd.arg("--preserve=links")
+        .arg("-R")
+        .arg("-L")
+        .arg("d")
+        .arg("c")
+        .succeeds();
+
+    assert!(at.dir_exists("c"));
+    assert!(at.plus("c").join("a").exists());
+    assert!(at.plus("c").join("b").exists());
+
+    #[cfg(unix)]
+    {
+        let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+        let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+        assert_eq!(metadata_a.ino(), metadata_b.ino());
+    }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_4() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("d");
+    at.touch("d/a");
+    at.hard_link("d/a", "d/b");
+
+    ucmd.arg("--preserve=links")
+        .arg("-R")
+        .arg("-L")
+        .arg("d")
+        .arg("c")
+        .succeeds();
+
+    assert!(at.dir_exists("c"));
+    assert!(at.plus("c").join("a").exists());
+    assert!(at.plus("c").join("b").exists());
+
+    #[cfg(unix)]
+    {
+        let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+        let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+        assert_eq!(metadata_a.ino(), metadata_b.ino());
+    }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_5() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("d");
+    at.touch("d/a");
+    at.hard_link("d/a", "d/b");
+
+    ucmd.arg("-dR")
+        .arg("--no-preserve=links")
+        .arg("d")
+        .arg("c")
+        .succeeds();
+
+    assert!(at.dir_exists("c"));
+    assert!(at.plus("c").join("a").exists());
+    assert!(at.plus("c").join("b").exists());
+
+    #[cfg(unix)]
+    {
+        let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+        let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+        assert_ne!(metadata_a.ino(), metadata_b.ino());
+    }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_6() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("a");
+    at.hard_link("a", "b");
+    at.mkdir("c");
+
+    ucmd.arg("-d").arg("a").arg("b").arg("c").succeeds();
+
+    assert!(at.dir_exists("c"));
+    assert!(at.plus("c").join("a").exists());
+    assert!(at.plus("c").join("b").exists());
+
+    #[cfg(unix)]
+    {
+        let metadata_a = std::fs::metadata(at.subdir.join("c").join("a")).unwrap();
+        let metadata_b = std::fs::metadata(at.subdir.join("c").join("b")).unwrap();
+
+        assert_eq!(metadata_a.ino(), metadata_b.ino());
+    }
+}
+
+#[test]
+// android platform will causing stderr = cp: Permission denied (os error 13)
+#[cfg(not(target_os = "android"))]
+fn test_cp_preserve_links_case_7() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("src");
+    at.touch("src/f");
+    at.hard_link("src/f", "src/g");
+
+    at.mkdir("dest");
+    at.touch("dest/g");
+
+    ucmd.arg("-n")
+        .arg("--preserve=links")
+        .arg("--debug")
+        .arg("src/f")
+        .arg("src/g")
+        .arg("dest")
+        .succeeds()
+        .stdout_contains("skipped");
+
+    assert!(at.dir_exists("dest"));
+    assert!(at.plus("dest").join("f").exists());
+    assert!(at.plus("dest").join("g").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_no_preserve_mode() {
+    use uucore::fs as uufs;
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.touch("a");
+    at.set_mode("a", 0o731);
+
+    ucmd.arg("-a")
+        .arg("--no-preserve=mode")
+        .arg("a")
+        .arg("b")
+        .umask(0o077)
+        .succeeds();
+
+    assert!(at.file_exists("b"));
+
+    let metadata_b = std::fs::metadata(at.subdir.join("b")).unwrap();
+    let permission_b = uufs::display_permissions(&metadata_b, false);
+    assert_eq!(permission_b, "rw-------".to_string());
+}
+
 #[test]
 // For now, disable the test on Windows. Symlinks aren't well support on Windows.
 // It works on Unix for now and it works locally when run from a powershell
@@ -1399,44 +2057,46 @@ fn test_cp_deref_folder_to_folder() {
         // No action as this test is disabled but kept in case we want to
         // try to make it work in the future.
         let a = Command::new("cmd").args(&["/C", "dir"]).output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", &at.as_string()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", path_to_new_symlink.to_str().unwrap()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let path_to_new_symlink = at.subdir.join(TEST_COPY_FROM_FOLDER);
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", path_to_new_symlink.to_str().unwrap()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let path_to_new_symlink = at.subdir.join(TEST_COPY_TO_FOLDER_NEW);
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", path_to_new_symlink.to_str().unwrap()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
     }
 
     let path_to_new_symlink = at
         .subdir
         .join(TEST_COPY_TO_FOLDER_NEW)
         .join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
-    assert!(at.file_exists(
-        path_to_new_symlink
-            .clone()
-            .into_os_string()
-            .into_string()
-            .unwrap()
-    ));
+    assert!(
+        at.file_exists(
+            path_to_new_symlink
+                .clone()
+                .into_os_string()
+                .into_string()
+                .unwrap()
+        )
+    );
 
     let path_to_new = at.subdir.join(TEST_COPY_TO_FOLDER_NEW_FILE);
 
@@ -1495,44 +2155,46 @@ fn test_cp_no_deref_folder_to_folder() {
         // No action as this test is disabled but kept in case we want to
         // try to make it work in the future.
         let a = Command::new("cmd").args(&["/C", "dir"]).output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", &at.as_string()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", path_to_new_symlink.to_str().unwrap()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let path_to_new_symlink = at.subdir.join(TEST_COPY_FROM_FOLDER);
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", path_to_new_symlink.to_str().unwrap()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
 
         let path_to_new_symlink = at.subdir.join(TEST_COPY_TO_FOLDER_NEW);
 
         let a = Command::new("cmd")
             .args(&["/C", "dir", path_to_new_symlink.to_str().unwrap()])
             .output();
-        println!("output {:#?}", a);
+        println!("output {a:#?}");
     }
 
     let path_to_new_symlink = at
         .subdir
         .join(TEST_COPY_TO_FOLDER_NEW)
         .join(TEST_HELLO_WORLD_SOURCE_SYMLINK);
-    assert!(at.is_symlink(
-        &path_to_new_symlink
-            .clone()
-            .into_os_string()
-            .into_string()
-            .unwrap()
-    ));
+    assert!(
+        at.is_symlink(
+            &path_to_new_symlink
+                .clone()
+                .into_os_string()
+                .into_string()
+                .unwrap()
+        )
+    );
 
     let path_to_new = at.subdir.join(TEST_COPY_TO_FOLDER_NEW_FILE);
 
@@ -1609,7 +2271,7 @@ fn test_cp_archive_recursive() {
     let result = scene2
         .cmd("ls")
         .arg("-al")
-        .arg(&at.subdir.join(TEST_COPY_TO_FOLDER))
+        .arg(at.subdir.join(TEST_COPY_TO_FOLDER))
         .run();
 
     println!("ls dest {}", result.stdout_str());
@@ -1617,25 +2279,29 @@ fn test_cp_archive_recursive() {
     let result = scene2
         .cmd("ls")
         .arg("-al")
-        .arg(&at.subdir.join(TEST_COPY_TO_FOLDER_NEW))
+        .arg(at.subdir.join(TEST_COPY_TO_FOLDER_NEW))
         .run();
 
     println!("ls dest {}", result.stdout_str());
     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
-            .join(TEST_COPY_TO_FOLDER_NEW)
-            .join("1.link")
-            .to_string_lossy()
-    ));
-    assert!(at.is_symlink(
-        &at.subdir
-            .join(TEST_COPY_TO_FOLDER_NEW)
-            .join("2.link")
-            .to_string_lossy()
-    ));
+    assert!(
+        at.is_symlink(
+            &at.subdir
+                .join(TEST_COPY_TO_FOLDER_NEW)
+                .join("1.link")
+                .to_string_lossy()
+        )
+    );
+    assert!(
+        at.is_symlink(
+            &at.subdir
+                .join(TEST_COPY_TO_FOLDER_NEW)
+                .join("2.link")
+                .to_string_lossy()
+        )
+    );
 }
 
 #[test]
@@ -1684,7 +2350,7 @@ fn test_cp_no_preserve_timestamps() {
         previous,
     )
     .unwrap();
-    sleep(Duration::from_secs(3));
+    sleep(Duration::from_millis(100));
 
     ucmd.arg(TEST_HELLO_WORLD_SOURCE)
         .arg("--no-preserve=timestamps")
@@ -1728,10 +2394,10 @@ fn test_cp_target_file_dev_null() {
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
 fn test_cp_one_file_system() {
-    use crate::common::util::AtPath;
+    use uutests::util::AtPath;
     use walkdir::WalkDir;
 
-    let scene = TestScenario::new(util_name!());
+    let mut scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
     // Test must be run as root (or with `sudo -E`)
@@ -1747,14 +2413,8 @@ fn test_cp_one_file_system() {
     let mountpoint_path = &at_src.plus_as_string(TEST_MOUNT_MOUNTPOINT);
 
     scene
-        .cmd("mount")
-        .arg("-t")
-        .arg("tmpfs")
-        .arg("-o")
-        .arg("size=640k") // ought to be enough
-        .arg("tmpfs")
-        .arg(mountpoint_path)
-        .succeeds();
+        .mount_temp_fs(mountpoint_path)
+        .expect("mounting tmpfs failed");
 
     at_src.touch(TEST_MOUNT_OTHER_FILESYSTEM_FILE);
 
@@ -1767,7 +2427,7 @@ fn test_cp_one_file_system() {
         .succeeds();
 
     // Ditch the mount before the asserts
-    scene.cmd("umount").arg(mountpoint_path).succeeds();
+    scene.umount_temp_fs();
 
     assert!(!at_dst.file_exists(TEST_MOUNT_OTHER_FILESYSTEM_FILE));
     // Check if the other files were copied from the source folder hierarchy
@@ -1841,15 +2501,17 @@ fn test_cp_reflink_none() {
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
 fn test_cp_reflink_never() {
-    let (at, mut ucmd) = at_and_ucmd!();
-    ucmd.arg("--reflink=never")
-        .arg(TEST_HELLO_WORLD_SOURCE)
-        .arg(TEST_EXISTING_FILE)
-        .succeeds();
+    for argument in ["--reflink=never", "--reflink=neve", "--reflink=n"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        ucmd.arg(argument)
+            .arg(TEST_HELLO_WORLD_SOURCE)
+            .arg(TEST_EXISTING_FILE)
+            .succeeds();
 
-    // Check the content of the destination file
-    assert_eq!(at.read(TEST_EXISTING_FILE), "Hello, World!\n");
-}
+        // Check the content of the destination file
+        assert_eq!(at.read(TEST_EXISTING_FILE), "Hello, World!\n");
+    }
+}
 
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
@@ -1863,6 +2525,17 @@ fn test_cp_reflink_bad() {
         .stderr_contains("error: invalid value 'bad' for '--reflink[=<WHEN>]'");
 }
 
+#[test]
+fn test_cp_conflicting_update() {
+    new_ucmd!()
+        .arg("-b")
+        .arg("--update=none")
+        .arg("a")
+        .arg("b")
+        .fails()
+        .stderr_contains("--backup is mutually exclusive with -n or --update=none-fail");
+}
+
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android"))]
 fn test_cp_reflink_insufficient_permission() {
@@ -1884,6 +2557,7 @@ fn test_cp_reflink_insufficient_permission() {
 #[test]
 fn test_closes_file_descriptors() {
     use procfs::process::Process;
+    use rlimit::Resource;
     let me = Process::myself().unwrap();
 
     // The test suite runs in parallel, we have pipe, sockets
@@ -1893,10 +2567,9 @@ fn test_closes_file_descriptors() {
     let limit_fd: u64 = number_file_already_opened + 9;
 
     // For debugging purposes:
-    #[cfg(not(target_os = "android"))]
     for f in me.fd().unwrap() {
         let fd = f.unwrap();
-        println!("{:?} {:?}", fd, fd.mode());
+        println!("{fd:?} {:?}", fd.mode());
     }
 
     new_ucmd!()
@@ -1911,9 +2584,9 @@ fn test_closes_file_descriptors() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[test]
 fn test_cp_sparse_never_empty() {
+    const BUFFER_SIZE: usize = 4096 * 4;
     let (at, mut ucmd) = at_and_ucmd!();
 
-    const BUFFER_SIZE: usize = 4096 * 4;
     let buf: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
 
     at.make_file("src_file1");
@@ -1931,28 +2604,30 @@ fn test_cp_sparse_never_empty() {
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[test]
 fn test_cp_sparse_always_empty() {
-    let (at, mut ucmd) = at_and_ucmd!();
-
     const BUFFER_SIZE: usize = 4096 * 4;
-    let buf: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
+    for argument in ["--sparse=always", "--sparse=alway", "--sparse=al"] {
+        let (at, mut ucmd) = at_and_ucmd!();
 
-    at.make_file("src_file1");
-    at.write_bytes("src_file1", &buf);
+        let buf: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
 
-    ucmd.args(&["--sparse=always", "src_file1", "dst_file_sparse"])
-        .succeeds();
+        at.make_file("src_file1");
+        at.write_bytes("src_file1", &buf);
+
+        ucmd.args(&[argument, "src_file1", "dst_file_sparse"])
+            .succeeds();
 
-    assert_eq!(at.read_bytes("dst_file_sparse"), buf);
-    assert_eq!(at.metadata("dst_file_sparse").blocks(), 0);
+        assert_eq!(at.read_bytes("dst_file_sparse"), buf);
+        assert_eq!(at.metadata("dst_file_sparse").blocks(), 0);
+    }
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 #[test]
 fn test_cp_sparse_always_non_empty() {
+    const BUFFER_SIZE: usize = 4096 * 16 + 3;
     let (at, mut ucmd) = at_and_ucmd!();
 
-    const BUFFER_SIZE: usize = 4096 * 16 + 3;
-    let mut buf: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
+    let mut buf = vec![0; BUFFER_SIZE].into_boxed_slice();
     let blocks_to_touch = [buf.len() / 3, 2 * (buf.len() / 3)];
 
     for i in blocks_to_touch {
@@ -1968,7 +2643,7 @@ fn test_cp_sparse_always_non_empty() {
     let touched_block_count =
         blocks_to_touch.len() as u64 * at.metadata("dst_file_sparse").blksize() / 512;
 
-    assert_eq!(at.read_bytes("dst_file_sparse"), buf);
+    assert_eq!(at.read_bytes("dst_file_sparse").into_boxed_slice(), buf);
     assert_eq!(at.metadata("dst_file_sparse").blocks(), touched_block_count);
 }
 
@@ -2019,12 +2694,11 @@ fn test_cp_sparse_never_reflink_always() {
 #[cfg(feature = "truncate")]
 #[test]
 fn test_cp_reflink_always_override() {
-    let scene = TestScenario::new(util_name!());
-
     const DISK: &str = "disk.img";
     const ROOTDIR: &str = "disk_root/";
     const USERDIR: &str = "dir/";
     const MOUNTPOINT: &str = "mountpoint/";
+    let scene = TestScenario::new(util_name!());
 
     let src1_path: &str = &[MOUNTPOINT, USERDIR, "src1"].concat();
     let src2_path: &str = &[MOUNTPOINT, USERDIR, "src2"].concat();
@@ -2139,25 +2813,30 @@ fn test_copy_symlink_force() {
 }
 
 #[test]
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
 fn test_no_preserve_mode() {
     use std::os::unix::prelude::MetadataExt;
 
-    use uucore::mode::get_umask;
-
-    const PERMS_ALL: u32 = 0o7777;
+    const PERMS_ALL: u32 = if cfg!(target_os = "freebsd") {
+        // Only the superuser can set the sticky bit on a file.
+        0o6777
+    } else {
+        0o7777
+    };
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.touch("file");
     set_permissions(at.plus("file"), PermissionsExt::from_mode(PERMS_ALL)).unwrap();
+    let umask: u16 = 0o022;
     ucmd.arg("file")
         .arg("dest")
+        .umask(libc::mode_t::from(umask))
         .succeeds()
         .no_stderr()
         .no_stdout();
-    let umask = get_umask();
     // remove sticky bit, setuid and setgid bit; apply umask
-    let expected_perms = PERMS_ALL & !0o7000 & !umask;
+    let expected_perms = PERMS_ALL & !0o7000 & u32::from(!umask);
     assert_eq!(
         at.plus("dest").metadata().unwrap().mode() & 0o7777,
         expected_perms
@@ -2165,11 +2844,17 @@ fn test_no_preserve_mode() {
 }
 
 #[test]
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
 fn test_preserve_mode() {
     use std::os::unix::prelude::MetadataExt;
 
-    const PERMS_ALL: u32 = 0o7777;
+    const PERMS_ALL: u32 = if cfg!(target_os = "freebsd") {
+        // Only the superuser can set the sticky bit on a file.
+        0o6777
+    } else {
+        0o7777
+    };
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.touch("file");
@@ -2207,10 +2892,8 @@ fn test_copy_through_just_created_symlink() {
         at.mkdir("b");
         at.mkdir("c");
         at.relative_symlink_file("../t", "a/1");
-        at.touch("b/1");
         at.write("b/1", "hello");
         if create_t {
-            at.touch("t");
             at.write("t", "world");
         }
         ucmd.arg("--no-dereference")
@@ -2263,15 +2946,71 @@ fn test_copy_through_dangling_symlink_no_dereference() {
         .no_stdout();
 }
 
+#[test]
+fn test_cp_symlink_overwrite_detection() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("good");
+    at.mkdir("tmp");
+    at.write("README", "file1");
+    at.write("good/README", "file2");
+
+    at.symlink_file("tmp/foo", "tmp/README");
+    at.touch("tmp/foo");
+
+    ts.ucmd()
+        .arg("README")
+        .arg("good/README")
+        .arg("tmp")
+        .fails()
+        .stderr_only(if cfg!(target_os = "windows") {
+            "cp: will not copy 'good/README' through just-created symlink 'tmp\\README'\n"
+        } else if cfg!(target_os = "macos") {
+            "cp: will not overwrite just-created 'tmp/README' with 'good/README'\n"
+        } else {
+            "cp: will not copy 'good/README' through just-created symlink 'tmp/README'\n"
+        });
+    let contents = at.read("tmp/foo");
+    // None of the files seem to be copied in macos
+    if cfg!(not(target_os = "macos")) {
+        assert_eq!(contents, "file1");
+    }
+}
+
+#[test]
+fn test_cp_dangling_symlink_inside_directory() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("good");
+    at.mkdir("tmp");
+    at.write("README", "file1");
+    at.write("good/README", "file2");
+
+    at.symlink_file("foo", "tmp/README");
+
+    ts.ucmd()
+        .arg("README")
+        .arg("good/README")
+        .arg("tmp")
+        .fails()
+        .stderr_only( if cfg!(target_os="windows") {
+            "cp: not writing through dangling symlink 'tmp\\README'\ncp: not writing through dangling symlink 'tmp\\README'\n"
+        } else {
+            "cp: not writing through dangling symlink 'tmp/README'\ncp: not writing through dangling symlink 'tmp/README'\n"
+            } );
+}
+
 /// Test for copying a dangling symbolic link and its permissions.
-#[cfg(not(target_os = "freebsd"))] // FIXME: fix this test for FreeBSD
+#[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))] // FIXME: fix this test for FreeBSD/OpenBSD
 #[test]
 fn test_copy_through_dangling_symlink_no_dereference_permissions() {
     let (at, mut ucmd) = at_and_ucmd!();
     //               target name    link name
     at.symlink_file("no-such-file", "dangle");
     // to check if access time and modification time didn't change
-    sleep(Duration::from_millis(5000));
+    sleep(Duration::from_millis(100));
     //          don't dereference the link
     //           |    copy permissions, too
     //           |      |    from the link
@@ -2440,7 +3179,6 @@ fn test_copy_no_dereference_1() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("a");
     at.mkdir("b");
-    at.touch("a/foo");
     at.write("a/foo", "bar");
     at.relative_symlink_file("../a/foo", "b/foo");
     ucmd.args(&["-P", "a/foo", "b"]).fails();
@@ -2453,10 +3191,8 @@ fn test_abuse_existing() {
     at.mkdir("b");
     at.mkdir("c");
     at.relative_symlink_file("../t", "a/1");
-    at.touch("b/1");
     at.write("b/1", "hello");
     at.relative_symlink_file("../t", "c/1");
-    at.touch("t");
     at.write("t", "i");
     ucmd.args(&["-dR", "a/1", "b/1", "c"])
         .fails()
@@ -2485,7 +3221,7 @@ fn test_copy_same_symlink_no_dereference_dangling() {
 }
 
 // TODO: enable for Android, when #3477 solved
-#[cfg(not(any(windows, target_os = "android")))]
+#[cfg(not(any(windows, target_os = "android", target_os = "openbsd")))]
 #[test]
 fn test_cp_parents_2_dirs() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -2568,7 +3304,6 @@ fn test_cp_copy_symlink_contents_recursive() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("src-dir");
     at.mkdir("dest-dir");
-    at.touch("f");
     at.write("f", "f");
     at.relative_symlink_file("f", "slink");
     at.relative_symlink_file("no-file", &path_concat!("src-dir", "slink"));
@@ -2586,7 +3321,6 @@ fn test_cp_copy_symlink_contents_recursive() {
 fn test_cp_mode_symlink() {
     for from in ["file", "slink", "slink2"] {
         let (at, mut ucmd) = at_and_ucmd!();
-        at.touch("file");
         at.write("file", "f");
         at.relative_symlink_file("file", "slink");
         at.relative_symlink_file("slink", "slink2");
@@ -2602,7 +3336,6 @@ fn test_cp_mode_symlink() {
 fn test_cp_mode_hardlink() {
     for from in ["file", "slink", "slink2"] {
         let (at, mut ucmd) = at_and_ucmd!();
-        at.touch("file");
         at.write("file", "f");
         at.relative_symlink_file("file", "slink");
         at.relative_symlink_file("slink", "slink2");
@@ -2620,7 +3353,6 @@ fn test_cp_mode_hardlink() {
 #[test]
 fn test_cp_mode_hardlink_no_dereference() {
     let (at, mut ucmd) = at_and_ucmd!();
-    at.touch("file");
     at.write("file", "f");
     at.relative_symlink_file("file", "slink");
     at.relative_symlink_file("slink", "slink2");
@@ -2629,6 +3361,40 @@ fn test_cp_mode_hardlink_no_dereference() {
     assert_eq!(at.read_symlink("z"), "slink");
 }
 
+#[cfg(not(any(windows, target_os = "android")))]
+#[test]
+fn test_remove_destination_with_destination_being_a_hardlink_to_source() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let hardlink = "hardlink";
+
+    at.touch(file);
+    at.hard_link(file, hardlink);
+
+    ucmd.args(&["--remove-destination", file, hardlink])
+        .succeeds();
+
+    assert_eq!("", at.resolve_link(hardlink));
+    assert!(at.file_exists(file));
+    assert!(at.file_exists(hardlink));
+}
+
+#[test]
+fn test_remove_destination_with_destination_being_a_symlink_to_source() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let symlink = "symlink";
+
+    at.touch(file);
+    at.symlink_file(file, symlink);
+
+    ucmd.args(&["--remove-destination", file, symlink])
+        .succeeds();
+    assert!(!at.symlink_exists(symlink));
+    assert!(at.file_exists(file));
+    assert!(at.file_exists(symlink));
+}
+
 #[test]
 fn test_remove_destination_symbolic_link_loop() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -2685,7 +3451,7 @@ fn test_copy_nested_directory_to_itself_disallowed() {
 }
 
 /// Test for preserving permissions when copying a directory.
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(all(not(windows), not(target_os = "freebsd"), not(target_os = "openbsd")))]
 #[test]
 fn test_copy_dir_preserve_permissions() {
     // Create a directory that has some non-default permissions.
@@ -2713,9 +3479,32 @@ fn test_copy_dir_preserve_permissions() {
     assert_metadata_eq!(metadata1, metadata2);
 }
 
+/// cp should preserve attributes of subdirectories when copying recursively.
+#[cfg(all(not(windows), not(target_os = "freebsd"), not(target_os = "openbsd")))]
+#[test]
+fn test_copy_dir_preserve_subdir_permissions() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a1");
+    at.mkdir("a1/a2");
+    // Use different permissions for a better test
+    at.set_mode("a1/a2", 0o0555);
+    at.set_mode("a1", 0o0777);
+
+    ucmd.args(&["-p", "-r", "a1", "b1"])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    // Make sure everything is preserved
+    assert!(at.dir_exists("b1"));
+    assert!(at.dir_exists("b1/a2"));
+    assert_metadata_eq!(at.metadata("a1"), at.metadata("b1"));
+    assert_metadata_eq!(at.metadata("a1/a2"), at.metadata("b1/a2"));
+}
+
 /// Test for preserving permissions when copying a directory, even in
 /// the face of an inaccessible file in that directory.
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(all(not(windows), not(target_os = "freebsd"), not(target_os = "openbsd")))]
 #[test]
 fn test_copy_dir_preserve_permissions_inaccessible_file() {
     // Create a directory that has some non-default permissions and
@@ -2736,8 +3525,7 @@ fn test_copy_dir_preserve_permissions_inaccessible_file() {
     //            |      |    |     |
     //            V      V    V     V
     ucmd.args(&["-p", "-R", "d1", "d2"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_only("cp: cannot open 'd1/f' for reading: permission denied\n");
     assert!(at.dir_exists("d2"));
     assert!(!at.file_exists("d2/f"));
@@ -2785,15 +3573,9 @@ fn test_same_file_force_backup() {
 }
 
 /// Test for copying the contents of a FIFO as opposed to the FIFO object itself.
-#[cfg(all(unix, not(target_os = "freebsd")))]
+#[cfg(unix)]
 #[test]
 fn test_copy_contents_fifo() {
-    // TODO this test should work on FreeBSD, but the command was
-    // causing an error:
-    //
-    // cp: 'fifo' -> 'outfile': the source path is neither a regular file nor a symlink to a regular file
-    //
-    // the underlying `std::fs:copy` doesn't support copying fifo on freeBSD
     let scenario = TestScenario::new(util_name!());
     let at = &scenario.fixtures;
 
@@ -2845,7 +3627,7 @@ fn test_reflink_never_sparse_always() {
 
 /// Test for preserving attributes of a hard link in a directory.
 #[test]
-#[cfg(not(target_os = "android"))]
+#[cfg(not(any(target_os = "android", target_os = "openbsd")))]
 fn test_preserve_hardlink_attributes_in_directory() {
     let (at, mut ucmd) = at_and_ucmd!();
 
@@ -2904,7 +3686,7 @@ fn test_symbolic_link_file() {
 #[test]
 fn test_src_base_dot() {
     let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures.clone();
+    let at = &ts.fixtures;
     at.mkdir("x");
     at.mkdir("y");
     ts.ucmd()
@@ -2976,33 +3758,29 @@ fn test_cp_archive_on_directory_ending_dot() {
 }
 
 #[test]
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
 fn test_cp_debug_default() {
+    #[cfg(target_os = "macos")]
+    let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+    #[cfg(target_os = "linux")]
+    let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+    #[cfg(windows)]
+    let expected = "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported";
+
     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}");
-    }
+    ts.ucmd()
+        .arg("--debug")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains(expected);
 }
 
 #[test]
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
 fn test_cp_debug_multiple_default() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
@@ -3010,6 +3788,7 @@ fn test_cp_debug_multiple_default() {
     at.touch("a");
     at.touch("b");
     at.mkdir(dir);
+
     let result = ts
         .ucmd()
         .arg("--debug")
@@ -3018,62 +3797,15 @@ fn test_cp_debug_multiple_default() {
         .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
-        );
-    }
-
+    let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
     #[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}");
-        }
+    let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+    #[cfg(windows)]
+    let expected = "copy offload: unsupported, reflink: unsupported, sparse detection: unsupported";
 
-        // two files, two occurrences
-        assert_eq!(
-            result
-                .stdout_str()
-                .matches("copy offload: unsupported, reflink: unsupported, sparse detection: unsupported")
-                .count(),
-            2
-        );
-    }
+    // two files, two occurrences
+    assert_eq!(result.stdout_str().matches(expected).count(), 2);
 }
 
 #[test]
@@ -3082,19 +3814,30 @@ fn test_cp_debug_sparse_reflink() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
     at.touch("a");
-    let result = ts
-        .ucmd()
+
+    ts.ucmd()
         .arg("--debug")
         .arg("--sparse=always")
         .arg("--reflink=never")
         .arg("a")
         .arg("b")
-        .succeeds();
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
+}
 
-    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]
+fn test_cp_debug_no_update() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    at.touch("b");
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--update=none")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("skipped 'b'");
 }
 
 #[test]
@@ -3103,18 +3846,14 @@ fn test_cp_debug_sparse_always() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
     at.touch("a");
-    let result = ts
-        .ucmd()
+
+    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}");
-    }
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
 }
 
 #[test]
@@ -3123,17 +3862,14 @@ fn test_cp_debug_sparse_never() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
     at.touch("a");
-    let result = ts
-        .ucmd()
+
+    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}");
-    }
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
 }
 
 #[test]
@@ -3152,63 +3888,40 @@ fn test_cp_debug_sparse_auto() {
 
     #[cfg(any(target_os = "linux", target_os = "macos"))]
     {
-        let result = ts
-            .ucmd()
+        #[cfg(target_os = "macos")]
+        let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+        #[cfg(target_os = "linux")]
+        let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+
+        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}");
-        }
+            .succeeds()
+            .stdout_contains(expected);
     }
 }
 
 #[test]
-#[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 fn test_cp_debug_reflink_auto() {
+    #[cfg(target_os = "macos")]
+    let expected = "copy offload: unknown, reflink: unsupported, sparse detection: unsupported";
+    #[cfg(target_os = "linux")]
+    let expected = "copy offload: unknown, reflink: unsupported, sparse detection: no";
+
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
     at.touch("a");
-    let result = ts
-        .ucmd()
+
+    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}");
-        }
-    }
+        .succeeds()
+        .stdout_contains(expected);
 }
 
 #[test]
@@ -3217,17 +3930,2733 @@ 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()
+    ts.ucmd()
         .arg("--debug")
         .arg("--sparse=always")
         .arg("--reflink=auto")
         .arg("a")
         .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
+}
+
+#[test]
+fn test_cp_only_source_no_target() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    ts.ucmd().arg("a").fails().stderr_contains(format!(
+        "missing destination file operand after {}",
+        "a".quote()
+    ));
+}
+
+#[test]
+fn test_cp_dest_no_permissions() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.touch("valid.txt");
+    at.touch("invalid_perms.txt");
+    at.set_readonly("invalid_perms.txt");
+
+    ts.ucmd()
+        .args(&["valid.txt", "invalid_perms.txt"])
+        .fails()
+        .stderr_contains("invalid_perms.txt")
+        .stderr_contains("denied");
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "freebsd")))]
+fn test_cp_attributes_only() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let a = "file_a";
+    let b = "file_b";
+    let mode_a = 0o0500;
+    let mode_b = 0o0777;
+
+    at.write(a, "a");
+    at.write(b, "b");
+    at.set_mode(a, mode_a);
+    at.set_mode(b, mode_b);
+
+    let mode_a = at.metadata(a).mode();
+    let mode_b = at.metadata(b).mode();
+
+    // --attributes-only doesn't do anything without other attribute preservation flags
+    ucmd.arg("--attributes-only")
+        .arg(a)
+        .arg(b)
+        .succeeds()
+        .no_output();
+
+    assert_eq!("a", at.read(a));
+    assert_eq!("b", at.read(b));
+    assert_eq!(mode_a, at.metadata(a).mode());
+    assert_eq!(mode_b, at.metadata(b).mode());
+}
+
+#[test]
+fn test_cp_seen_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+    #[cfg(not(unix))]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c\\f' with 'b/f'")
+    );
+    #[cfg(unix)]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c/f' with 'b/f'")
+    );
+
+    assert!(at.plus("c").join("f").exists());
+
+    ts.ucmd()
+        .arg("--backup=numbered")
+        .arg("a/f")
+        .arg("b/f")
+        .arg("c")
         .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}");
+    assert!(at.plus("c").join("f").exists());
+    assert!(at.plus("c").join("f.~1~").exists());
+}
+
+#[test]
+fn test_cp_path_ends_with_terminator() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkdir("a");
+    ts.ucmd().arg("-r").arg("-T").arg("a").arg("e/").succeeds();
+}
+
+#[test]
+fn test_cp_no_such() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("b");
+    ts.ucmd()
+        .arg("b")
+        .arg("no-such/")
+        .fails()
+        .stderr_is("cp: 'no-such/' is not a directory\n");
+}
+
+#[cfg(all(
+    unix,
+    not(any(target_os = "android", target_os = "macos", target_os = "openbsd"))
+))]
+#[test]
+fn test_acl_preserve() {
+    use std::process::Command;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let path1 = "a";
+    let path2 = "b";
+    let file = "a/file";
+    let file_target = "b/file";
+    at.mkdir(path1);
+    at.mkdir(path2);
+    at.touch(file);
+
+    let path1 = at.plus_as_string(path1);
+    // calling the command directly. xattr requires some dev packages to be installed
+    // and it adds a complex dependency just for a test
+    match Command::new("setfacl")
+        .args(["-m", "group::rwx", &path1])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfacl failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfacl failed with {e}");
+            return;
+        }
+    }
+
+    let path = at.plus_as_string(file);
+    scene.ucmd().args(&["-p", &path, path2]).succeeds();
+
+    assert!(compare_xattrs(&file, &file_target));
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.write("a", "hello");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
+
+    let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_empty_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+
+    let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    at.append_bytes("a", "hello".as_bytes());
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: SEEK_HOLE");
+
+    let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_less_than_512_bytes() {
+    let ts = TestScenario::new(util_name!());
+
+    let at = &ts.fixtures;
+    at.write_bytes("a", "hello".as_bytes());
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(400).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=auto")
+        .arg("--sparse=auto")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_without_hole() {
+    let ts = TestScenario::new(util_name!());
+
+    let at = &ts.fixtures;
+    at.write_bytes("a", "hello".as_bytes());
+
+    let filler_bytes = [0_u8; 10000];
+
+    at.append_bytes("a", &filler_bytes);
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: yes, reflink: unsupported, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_default_empty_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains(
+            "copy offload: unknown, reflink: unsupported, sparse detection: SEEK_HOLE",
+        );
+
+    let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.write("a", "hello");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("--sparse=always")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE + zeros");
+
+    let src_file_metadata = std::fs::metadata(at.plus("a")).unwrap();
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(src_file_metadata.blocks(), dst_file_metadata.blocks());
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_without_hole() {
+    let ts = TestScenario::new(util_name!());
+    let empty_bytes = [0_u8; 10000];
+    let at = &ts.fixtures;
+    at.write("a", "hello");
+    at.append_bytes("a", &empty_bytes);
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("--sparse=always")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
+
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(
+        dst_file_metadata.blocks(),
+        dst_file_metadata.blksize() / 512
+    );
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_empty_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("--sparse=always")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_default_virtual_file() {
+    // This file has existed at least since 2008, so we assume that it is present on "all" Linux kernels.
+    // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-profiling
+
+    use std::os::unix::prelude::MetadataExt;
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    ts.ucmd().arg("/sys/kernel/profiling").arg("b").succeeds();
+
+    let dest_size = std::fs::metadata(at.plus("b"))
+        .expect("Metadata of copied file cannot be read")
+        .size();
+    assert!(dest_size > 0);
+}
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_auto_sparse_always_non_sparse_file_with_long_zero_sequence() {
+    let ts = TestScenario::new(util_name!());
+
+    let buf: Vec<u8> = vec![0; 4096 * 4];
+    let at = &ts.fixtures;
+    at.touch("a");
+    at.append_bytes("a", &buf);
+    at.append_bytes("a", "hello".as_bytes());
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--sparse=always")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: unsupported, sparse detection: zeros");
+
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(
+        dst_file_metadata.blocks(),
+        dst_file_metadata.blksize() / 512
+    );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_never_empty_sparse_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_always_non_sparse_file_with_long_zero_sequence() {
+    let ts = TestScenario::new(util_name!());
+
+    let buf: Vec<u8> = vec![0; 4096 * 4];
+    let at = &ts.fixtures;
+    at.touch("a");
+    at.append_bytes("a", &buf);
+    at.append_bytes("a", "hello".as_bytes());
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("--sparse=always")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: zeros");
+
+    let dst_file_metadata = std::fs::metadata(at.plus("b")).unwrap();
+    assert_eq!(
+        dst_file_metadata.blocks(),
+        dst_file_metadata.blksize() / 512
+    );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_always_sparse_virtual_file() {
+    // This file has existed at least since 2008, so we assume that it is present on "all" Linux kernels.
+    // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-profiling
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--sparse=always")
+        .arg("/sys/kernel/profiling")
+        .arg("b")
+        .succeeds()
+        .stdout_contains(
+            "copy offload: avoided, reflink: unsupported, sparse detection: SEEK_HOLE + zeros",
+        );
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_less_than_512_bytes() {
+    let ts = TestScenario::new(util_name!());
+
+    let at = &ts.fixtures;
+    at.write_bytes("a", "hello".as_bytes());
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(400).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_sparse_never_empty_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+    at.append_bytes("a", "hello".as_bytes());
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_less_than_512_bytes() {
+    let ts = TestScenario::new(util_name!());
+
+    let at = &ts.fixtures;
+    at.write_bytes("a", "hello".as_bytes());
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(400).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=auto")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_without_hole() {
+    let ts = TestScenario::new(util_name!());
+
+    let at = &ts.fixtures;
+    at.write_bytes("a", "hello".as_bytes());
+
+    let filler_bytes = [0_u8; 10000];
+
+    at.append_bytes("a", &filler_bytes);
+
+    ts.ucmd()
+        .arg("--reflink=auto")
+        .arg("--sparse=never")
+        .arg("--debug")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_empty_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=auto")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: unknown, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_sparse_never_file_with_hole() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    let f = std::fs::OpenOptions::new()
+        .write(true)
+        .open(at.plus("a"))
+        .unwrap();
+    f.set_len(10000).unwrap();
+    at.append_bytes("a", "hello".as_bytes());
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=auto")
+        .arg("--sparse=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: SEEK_HOLE");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_default_sparse_virtual_file() {
+    // This file has existed at least since 2008, so we assume that it is present on "all" Linux kernels.
+    // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-profiling
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .arg("--debug")
+        .arg("/sys/kernel/profiling")
+        .arg("b")
+        .succeeds()
+        .stdout_contains(
+            "copy offload: unsupported, reflink: unsupported, sparse detection: SEEK_HOLE",
+        );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_sparse_never_zero_sized_virtual_file() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--sparse=never")
+        .arg("/proc/version")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_cp_debug_default_zero_sized_virtual_file() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .arg("--debug")
+        .arg("/proc/version")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: unsupported, reflink: unsupported, sparse detection: no");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_cp_debug_reflink_never_without_hole() {
+    let ts = TestScenario::new(util_name!());
+    let filler_bytes = [0_u8; 1000];
+    let at = &ts.fixtures;
+    at.write("a", "hello");
+    at.append_bytes("a", &filler_bytes);
+
+    ts.ucmd()
+        .arg("--debug")
+        .arg("--reflink=never")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_contains("copy offload: avoided, reflink: no, sparse detection: no");
+}
+
+#[test]
+fn test_cp_force_remove_destination_attributes_only_with_symlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("file1", "1");
+    at.write("file2", "2");
+    at.symlink_file("file1", "sym1");
+
+    scene
+        .ucmd()
+        .args(&[
+            "-a",
+            "--remove-destination",
+            "--attributes-only",
+            "sym1",
+            "file2",
+        ])
+        .succeeds();
+
+    assert!(
+        at.symlink_exists("file2"),
+        "file2 is not a symbolic link as expected"
+    );
+
+    assert_eq!(
+        at.read("file1"),
+        at.read("file2"),
+        "Contents of file1 and file2 do not match"
+    );
+}
+
+#[test]
+fn test_cp_no_dereference_attributes_only_with_symlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("file1", "1");
+    at.write("file2", "2");
+    at.write("file2.exp", "2");
+    at.symlink_file("file1", "sym1");
+
+    let result = scene
+        .ucmd()
+        .args(&["--no-dereference", "--attributes-only", "sym1", "file2"])
+        .fails();
+
+    assert_eq!(result.code(), 1, "cp command did not fail");
+
+    assert_eq!(
+        at.read("file2"),
+        at.read("file2.exp"),
+        "file2 content does not match expected"
+    );
+}
+#[cfg(all(unix, not(target_os = "android")))]
+#[cfg(test)]
+/// contains the test for cp when the source and destination points to the same file
+mod same_file {
+
+    use std::os::unix::fs::MetadataExt;
+    use uutests::util::TestScenario;
+    use uutests::util_name;
+
+    const FILE_NAME: &str = "foo";
+    const SYMLINK_NAME: &str = "symlink";
+    const CONTENTS: &str = "abcd";
+
+    // the following tests tries to copy a file to the symlink of the same file with
+    // various options
+    #[test]
+    fn test_same_file_from_file_to_symlink() {
+        for option in ["-d", "-f", "-df"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, SYMLINK_NAME])
+                .fails()
+                .stderr_contains("'foo' and 'symlink' are the same file");
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_rem_option() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        scene
+            .ucmd()
+            .args(&["--rem", FILE_NAME, SYMLINK_NAME])
+            .succeeds();
+        assert!(at.file_exists(SYMLINK_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_backup_option() {
+        for option in ["-b", "-bd", "-bf", "-bdf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "symlink~";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.symlink_exists(backup));
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+            assert!(at.file_exists(SYMLINK_NAME));
+            assert_eq!(at.read(SYMLINK_NAME), CONTENTS);
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_link_option() {
+        for option in ["-l", "-dl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, SYMLINK_NAME])
+                .fails()
+                .stderr_contains("cp: cannot create hard link 'symlink' to 'foo'");
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_options_link_and_force() {
+        for option in ["-fl", "-dfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(SYMLINK_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_options_backup_and_link() {
+        for option in ["-bl", "-bdl", "-bfl", "-bdfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "symlink~";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(SYMLINK_NAME));
+            assert!(at.symlink_exists(backup));
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_options_symlink() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        scene
+            .ucmd()
+            .args(&["-s", FILE_NAME, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("cp: cannot create symlink 'symlink' to 'foo'");
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_symlink_with_options_symlink_and_force() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        scene
+            .ucmd()
+            .args(&["-sf", FILE_NAME, SYMLINK_NAME])
+            .succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+    // the following tests tries to copy a symlink to the file that symlink points to with
+    // various options
+    #[test]
+    fn test_same_file_from_symlink_to_file() {
+        for option in ["-d", "-f", "-df", "--rem"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, SYMLINK_NAME, FILE_NAME])
+                .fails()
+                .stderr_contains("'symlink' and 'foo' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_file_with_option_backup() {
+        for option in ["-b", "-bf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, SYMLINK_NAME, FILE_NAME])
+                .fails()
+                .stderr_contains("'symlink' and 'foo' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+    #[test]
+    fn test_same_file_from_symlink_to_file_with_option_backup_without_deref() {
+        for option in ["-bd", "-bdf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "foo~";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, SYMLINK_NAME, FILE_NAME])
+                .succeeds();
+            assert!(at.file_exists(backup));
+            assert!(at.symlink_exists(FILE_NAME));
+            // this doesn't makes sense but this is how gnu does it
+            assert_eq!(FILE_NAME, at.resolve_link(FILE_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(at.read(backup), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_file_with_options_link() {
+        for option in ["-l", "-dl", "-fl", "-bl", "-bfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, SYMLINK_NAME, FILE_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_file_with_option_symlink() {
+        for option in ["-s", "-sf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            scene
+                .ucmd()
+                .args(&[option, SYMLINK_NAME, FILE_NAME])
+                .fails()
+                .stderr_contains("'symlink' and 'foo' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    // the following tests tries to copy a file to the same file with various options
+    #[test]
+    fn test_same_file_from_file_to_file() {
+        for option in ["-d", "-f", "-df", "--rem"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, FILE_NAME])
+                .fails()
+                .stderr_contains("'foo' and 'foo' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+    #[test]
+    fn test_same_file_from_file_to_file_with_backup() {
+        for option in ["-b", "-bd"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, FILE_NAME])
+                .fails()
+                .stderr_contains("'foo' and 'foo' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_file_with_options_backup_and_no_deref() {
+        for option in ["-bf", "-bdf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "foo~";
+            at.write(FILE_NAME, CONTENTS);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, FILE_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(at.read(backup), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_file_with_options_link() {
+        for option in ["-l", "-dl", "-fl", "-dfl", "-bl", "-bdl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "foo~";
+            at.write(FILE_NAME, CONTENTS);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, FILE_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(!at.file_exists(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_file_with_options_link_and_backup_and_force() {
+        for option in ["-bfl", "-bdfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "foo~";
+            at.write(FILE_NAME, CONTENTS);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, FILE_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(at.read(backup), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_file_with_options_symlink() {
+        for option in ["-s", "-sf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.write(FILE_NAME, CONTENTS);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, FILE_NAME])
+                .fails()
+                .stderr_contains("'foo' and 'foo' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    // the following tests tries to copy a symlink that points to a file to a symlink
+    // that points to the same file with various options
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_no_deref() {
+        for option in ["-d", "-df"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let symlink1 = "sl1";
+            let symlink2 = "sl2";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, symlink1);
+            at.symlink_file(FILE_NAME, symlink2);
+            scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+            assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_force() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let symlink1 = "sl1";
+        let symlink2 = "sl2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, symlink1);
+        at.symlink_file(FILE_NAME, symlink2);
+        scene
+            .ucmd()
+            .args(&["-f", symlink1, symlink2])
+            .fails()
+            .stderr_contains("'sl1' and 'sl2' are the same file");
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+        assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_rem() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let symlink1 = "sl1";
+        let symlink2 = "sl2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, symlink1);
+        at.symlink_file(FILE_NAME, symlink2);
+        scene.ucmd().args(&["--rem", symlink1, symlink2]).succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+        assert!(at.file_exists(symlink2));
+        assert_eq!(at.read(symlink2), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_backup() {
+        for option in ["-b", "-bf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let symlink1 = "sl1";
+            let symlink2 = "sl2";
+            let backup = "sl2~";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, symlink1);
+            at.symlink_file(FILE_NAME, symlink2);
+            scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+            assert!(at.file_exists(symlink2));
+            assert_eq!(at.read(symlink2), CONTENTS);
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_backup_and_no_deref() {
+        for option in ["-bd", "-bdf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let symlink1 = "sl1";
+            let symlink2 = "sl2";
+            let backup = "sl2~";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, symlink1);
+            at.symlink_file(FILE_NAME, symlink2);
+            scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+            assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+        }
+    }
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_link() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let symlink1 = "sl1";
+        let symlink2 = "sl2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, symlink1);
+        at.symlink_file(FILE_NAME, symlink2);
+        scene
+            .ucmd()
+            .args(&["-l", symlink1, symlink2])
+            .fails()
+            .stderr_contains("cannot create hard link 'sl2' to 'sl1'");
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+        assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_force_link() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let symlink1 = "sl1";
+        let symlink2 = "sl2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, symlink1);
+        at.symlink_file(FILE_NAME, symlink2);
+        scene.ucmd().args(&["-fl", symlink1, symlink2]).succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+        assert!(at.file_exists(symlink2));
+        assert_eq!(at.read(symlink2), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_backup_and_link() {
+        for option in ["-bl", "-bfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let symlink1 = "sl1";
+            let symlink2 = "sl2";
+            let backup = "sl2~";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, symlink1);
+            at.symlink_file(FILE_NAME, symlink2);
+            scene.ucmd().args(&[option, symlink1, symlink2]).succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+            assert!(at.file_exists(symlink2));
+            assert_eq!(at.read(symlink2), CONTENTS);
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_symlink() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let symlink1 = "sl1";
+        let symlink2 = "sl2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, symlink1);
+        at.symlink_file(FILE_NAME, symlink2);
+        scene
+            .ucmd()
+            .args(&["-s", symlink1, symlink2])
+            .fails()
+            .stderr_contains("cannot create symlink 'sl2' to 'sl1'");
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+        assert_eq!(FILE_NAME, at.resolve_link(symlink2));
+    }
+
+    #[test]
+    fn test_same_file_from_symlink_to_symlink_with_option_symlink_and_force() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let symlink1 = "sl1";
+        let symlink2 = "sl2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, symlink1);
+        at.symlink_file(FILE_NAME, symlink2);
+        scene.ucmd().args(&["-sf", symlink1, symlink2]).succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(FILE_NAME, at.resolve_link(symlink1));
+        assert_eq!(symlink1, at.resolve_link(symlink2));
+    }
+
+    #[test]
+    fn test_same_symlink_to_itself_no_dereference() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        scene
+            .ucmd()
+            .args(&["-P", SYMLINK_NAME, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("are the same file");
+    }
+
+    #[test]
+    fn test_same_dangling_symlink_to_itself_no_dereference() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.symlink_file("nonexistent_file", SYMLINK_NAME);
+        scene
+            .ucmd()
+            .args(&["-P", SYMLINK_NAME, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("are the same file");
+    }
+
+    // the following tests tries to copy file to a hardlink of the same file with
+    // various options
+    #[test]
+    fn test_same_file_from_file_to_hardlink() {
+        for option in ["-d", "-f", "-df"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink = "hardlink";
+            at.write(FILE_NAME, CONTENTS);
+            at.hard_link(FILE_NAME, hardlink);
+
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, hardlink])
+                .fails()
+                .stderr_contains("'foo' and 'hardlink' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(hardlink));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_hardlink_with_option_rem() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink = "hardlink";
+        at.write(FILE_NAME, CONTENTS);
+        at.hard_link(FILE_NAME, hardlink);
+        scene
+            .ucmd()
+            .args(&["--rem", FILE_NAME, hardlink])
+            .succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.file_exists(hardlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_hardlink_with_option_backup() {
+        for option in ["-b", "-bd", "-bf", "-bdf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink = "hardlink";
+            let backup = "hardlink~";
+            at.write(FILE_NAME, CONTENTS);
+            at.hard_link(FILE_NAME, hardlink);
+            scene.ucmd().args(&[option, FILE_NAME, hardlink]).succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(hardlink));
+            assert!(at.file_exists(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_hardlink_with_option_link() {
+        for option in ["-l", "-dl", "-fl", "-dfl", "-bl", "-bdl", "-bfl", "-bdfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink = "hardlink";
+            at.write(FILE_NAME, CONTENTS);
+            at.hard_link(FILE_NAME, hardlink);
+            scene.ucmd().args(&[option, FILE_NAME, hardlink]).succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(hardlink));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_file_to_hardlink_with_option_symlink() {
+        for option in ["-s", "-sf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink = "hardlink";
+            at.write(FILE_NAME, CONTENTS);
+            at.hard_link(FILE_NAME, hardlink);
+            scene
+                .ucmd()
+                .args(&[option, FILE_NAME, hardlink])
+                .fails()
+                .stderr_contains("'foo' and 'hardlink' are the same file");
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(hardlink));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    // the following tests tries to copy symlink to a hardlink of the same symlink with
+    // various options
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&[hardlink_to_symlink, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("cp: 'hlsl' and 'symlink' are the same file");
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_force() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&["-f", hardlink_to_symlink, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("cp: 'hlsl' and 'symlink' are the same file");
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_no_deref() {
+        for option in ["-d", "-df"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink_to_symlink = "hlsl";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+            scene
+                .ucmd()
+                .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert!(at.symlink_exists(hardlink_to_symlink));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_rem() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&["--rem", hardlink_to_symlink, SYMLINK_NAME])
+            .succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.file_exists(SYMLINK_NAME));
+        assert!(!at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+        assert_eq!(at.read(SYMLINK_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_backup() {
+        for option in ["-b", "-bf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "symlink~";
+            let hardlink_to_symlink = "hlsl";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+            scene
+                .ucmd()
+                .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(SYMLINK_NAME));
+            assert!(!at.symlink_exists(SYMLINK_NAME));
+            assert!(at.symlink_exists(hardlink_to_symlink));
+            assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+            assert!(at.symlink_exists(backup));
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+            assert_eq!(at.read(SYMLINK_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_backup_and_no_deref() {
+        for option in ["-bd", "-bdf"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "symlink~";
+            let hardlink_to_symlink = "hlsl";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+            scene
+                .ucmd()
+                .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert!(at.symlink_exists(hardlink_to_symlink));
+            assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+            assert!(at.symlink_exists(backup));
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&["-l", hardlink_to_symlink, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("cannot create hard link 'symlink' to 'hlsl'");
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link_and_no_deref() {
+        for option in ["-dl", "-dfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink_to_symlink = "hlsl";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+            scene
+                .ucmd()
+                .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert!(at.symlink_exists(hardlink_to_symlink));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link_and_force() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&["-fl", hardlink_to_symlink, SYMLINK_NAME])
+            .succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.file_exists(SYMLINK_NAME));
+        assert!(!at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_link_and_backup() {
+        for option in ["-bl", "-bfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let backup = "symlink~";
+            let hardlink_to_symlink = "hlsl";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+            scene
+                .ucmd()
+                .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.file_exists(SYMLINK_NAME));
+            assert!(!at.symlink_exists(SYMLINK_NAME));
+            assert!(at.symlink_exists(hardlink_to_symlink));
+            assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+            assert!(at.symlink_exists(backup));
+            assert_eq!(FILE_NAME, at.resolve_link(backup));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_options_backup_link_no_deref() {
+        for option in ["-bdl", "-bdfl"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            let hardlink_to_symlink = "hlsl";
+            at.write(FILE_NAME, CONTENTS);
+            at.symlink_file(FILE_NAME, SYMLINK_NAME);
+            at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+            scene
+                .ucmd()
+                .args(&[option, hardlink_to_symlink, SYMLINK_NAME])
+                .succeeds();
+            assert!(at.file_exists(FILE_NAME));
+            assert!(at.symlink_exists(SYMLINK_NAME));
+            assert!(at.symlink_exists(hardlink_to_symlink));
+            assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+            assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+            assert_eq!(at.read(FILE_NAME), CONTENTS);
+        }
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_symlink() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&["-s", hardlink_to_symlink, SYMLINK_NAME])
+            .fails()
+            .stderr_contains("cannot create symlink 'symlink' to 'hlsl'");
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(FILE_NAME, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_same_file_from_hard_link_of_symlink_to_symlink_with_option_symlink_and_force() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink_to_symlink = "hlsl";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink_to_symlink);
+        scene
+            .ucmd()
+            .args(&["-sf", hardlink_to_symlink, SYMLINK_NAME])
+            .succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        assert!(at.symlink_exists(hardlink_to_symlink));
+        assert_eq!(hardlink_to_symlink, at.resolve_link(SYMLINK_NAME));
+        assert_eq!(FILE_NAME, at.resolve_link(hardlink_to_symlink));
+        assert_eq!(at.read(FILE_NAME), CONTENTS);
+    }
+
+    #[test]
+    fn test_hardlink_of_symlink_to_hardlink_of_same_symlink_with_option_no_deref() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        let hardlink1 = "hardlink_to_symlink_1";
+        let hardlink2 = "hardlink_to_symlink_2";
+        at.write(FILE_NAME, CONTENTS);
+        at.symlink_file(FILE_NAME, SYMLINK_NAME);
+        at.hard_link(SYMLINK_NAME, hardlink1);
+        at.hard_link(SYMLINK_NAME, hardlink2);
+        let ino = at.symlink_metadata(hardlink1).ino();
+        assert_eq!(ino, at.symlink_metadata(hardlink2).ino()); // Sanity check
+        scene.ucmd().args(&["-P", hardlink1, hardlink2]).succeeds();
+        assert!(at.file_exists(FILE_NAME));
+        assert!(at.symlink_exists(SYMLINK_NAME));
+        // If hardlink a and b point to the same symlink, then cp a b doesn't create a new file
+        assert_eq!(ino, at.symlink_metadata(hardlink1).ino());
+        assert_eq!(ino, at.symlink_metadata(hardlink2).ino());
+    }
+}
+
+// the following tests are for how the cp should behave when the source is a symlink
+// and link option is given
+#[cfg(all(unix, not(target_os = "android")))]
+mod link_deref {
+
+    use std::os::unix::fs::MetadataExt;
+    use uutests::util::{AtPath, TestScenario};
+    use uutests::util_name;
+
+    const FILE: &str = "file";
+    const FILE_LINK: &str = "file_link";
+    const DIR: &str = "dir";
+    const DIR_LINK: &str = "dir_link";
+    const DANG_LINK: &str = "dang_link";
+    const DST: &str = "dst";
+
+    fn setup_link_deref_tests(source: &str, at: &AtPath) {
+        match source {
+            FILE_LINK => {
+                at.touch(FILE);
+                at.symlink_file(FILE, FILE_LINK);
+            }
+            DIR_LINK => {
+                at.mkdir(DIR);
+                at.symlink_dir(DIR, DIR_LINK);
+            }
+            DANG_LINK => at.symlink_file("nowhere", DANG_LINK),
+            _ => {}
+        }
+    }
+
+    // cp --link shouldn't deref source if -P is given
+    #[test]
+    fn test_cp_symlink_as_source_with_link_and_no_deref() {
+        for src in [FILE_LINK, DIR_LINK, DANG_LINK] {
+            for r in [false, true] {
+                let scene = TestScenario::new(util_name!());
+                let at = &scene.fixtures;
+                setup_link_deref_tests(src, at);
+                let mut args = vec!["--link", "-P", src, DST];
+                if r {
+                    args.push("-R");
+                }
+                scene.ucmd().args(&args).succeeds().no_stderr();
+                at.is_symlink(DST);
+                let src_ino = at.symlink_metadata(src).ino();
+                let dest_ino = at.symlink_metadata(DST).ino();
+                assert_eq!(src_ino, dest_ino);
+            }
+        }
+    }
+
+    // Dereferencing should fail for dangling symlink.
+    #[test]
+    fn test_cp_dang_link_as_source_with_link() {
+        for option in ["", "-L", "-H"] {
+            for r in [false, true] {
+                let scene = TestScenario::new(util_name!());
+                let at = &scene.fixtures;
+                setup_link_deref_tests(DANG_LINK, at);
+                let mut args = vec!["--link", DANG_LINK, DST];
+                if r {
+                    args.push("-R");
+                }
+                if !option.is_empty() {
+                    args.push(option);
+                }
+                scene
+                    .ucmd()
+                    .args(&args)
+                    .fails()
+                    .stderr_contains("No such file or directory");
+            }
+        }
+    }
+
+    // Dereferencing should fail for the 'dir_link' without -R.
+    #[test]
+    fn test_cp_dir_link_as_source_with_link() {
+        for option in ["", "-L", "-H"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            setup_link_deref_tests(DIR_LINK, at);
+            let mut args = vec!["--link", DIR_LINK, DST];
+            if !option.is_empty() {
+                args.push(option);
+            }
+            scene
+                .ucmd()
+                .args(&args)
+                .fails()
+                .stderr_contains("cp: -r not specified; omitting directory");
+        }
+    }
+
+    // cp --link -R 'dir_link' should create a new directory.
+    #[test]
+    fn test_cp_dir_link_as_source_with_link_and_r() {
+        for option in ["", "-L", "-H"] {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            setup_link_deref_tests(DIR_LINK, at);
+            let mut args = vec!["--link", "-R", DIR_LINK, DST];
+            if !option.is_empty() {
+                args.push(option);
+            }
+            scene.ucmd().args(&args).succeeds();
+            at.dir_exists(DST);
+        }
+    }
+
+    //cp --link 'file_link' should create a hard link to the target.
+    #[test]
+    fn test_cp_file_link_as_source_with_link() {
+        for option in ["", "-L", "-H"] {
+            for r in [false, true] {
+                let scene = TestScenario::new(util_name!());
+                let at = &scene.fixtures;
+                setup_link_deref_tests(FILE_LINK, at);
+                let mut args = vec!["--link", "-R", FILE_LINK, DST];
+                if !option.is_empty() {
+                    args.push(option);
+                }
+                if r {
+                    args.push("-R");
+                }
+                scene.ucmd().args(&args).succeeds();
+                at.file_exists(DST);
+                let src_ino = at.symlink_metadata(FILE).ino();
+                let dest_ino = at.symlink_metadata(DST).ino();
+                assert_eq!(src_ino, dest_ino);
+            }
+        }
+    }
+}
+
+// The cp command might create directories with excessively permissive permissions temporarily,
+// which could be problematic if we aim to preserve ownership or mode. For example, when
+// copying a directory, the destination directory could temporarily be setgid on some filesystems.
+// This temporary setgid status could grant access to other users who share the same group
+// ownership as the newly created directory. To mitigate this issue, when creating a directory we
+// disable these excessive permissions.
+#[test]
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
+fn test_dir_perm_race_with_preserve_mode_and_ownership() {
+    const SRC_DIR: &str = "src";
+    const DEST_DIR: &str = "dest";
+    const FIFO: &str = "src/fifo";
+    for attr in ["mode", "ownership"] {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.mkdir(SRC_DIR);
+        at.mkdir(DEST_DIR);
+        at.set_mode(SRC_DIR, 0o775);
+        at.set_mode(DEST_DIR, 0o2775);
+        at.mkfifo(FIFO);
+        let child = scene
+            .ucmd()
+            .args(&[
+                format!("--preserve={attr}").as_str(),
+                "-R",
+                "--copy-contents",
+                "--parents",
+                SRC_DIR,
+                DEST_DIR,
+            ])
+            // make sure permissions weren't disabled because of umask.
+            .umask(0)
+            .run_no_wait();
+        // while cp wait for fifo we could check the dirs created by cp
+        let timeout = Duration::from_secs(10);
+        let start_time = std::time::Instant::now();
+        // wait for cp to create dirs
+        loop {
+            assert!(
+                start_time.elapsed() < timeout,
+                "timed out: cp took too long to create destination directory"
+            );
+            if at.dir_exists(&format!("{DEST_DIR}/{SRC_DIR}")) {
+                break;
+            }
+            sleep(Duration::from_millis(100));
+        }
+        let mode = at.metadata(&format!("{DEST_DIR}/{SRC_DIR}")).mode();
+        #[allow(clippy::unnecessary_cast, clippy::cast_lossless)]
+        let mask = if attr == "mode" {
+            libc::S_IWGRP | libc::S_IWOTH
+        } else {
+            libc::S_IRWXG | libc::S_IRWXO
+        } as u32;
+        assert_eq!(mode & mask, 0, "unwanted permissions are present - {attr}");
+        at.write(FIFO, "done");
+        child.wait().unwrap().succeeded();
+    }
+}
+
+#[test]
+// when -d and -a are overridden with --preserve or --no-preserve make sure that it only
+// overrides attributes not other flags like -r or --no_deref implied in -a and -d.
+fn test_preserve_attrs_overriding_1() {
+    const FILE: &str = "file";
+    const SYMLINK: &str = "symlink";
+    const DEST: &str = "dest";
+    for f in ["-d", "-a"] {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.make_file(FILE);
+        at.symlink_file(FILE, SYMLINK);
+        scene
+            .ucmd()
+            .args(&[f, "--no-preserve=all", SYMLINK, DEST])
+            .succeeds();
+        at.symlink_exists(DEST);
+    }
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_preserve_attrs_overriding_2() {
+    const FILE1: &str = "file1";
+    const FILE2: &str = "file2";
+    const FOLDER: &str = "folder";
+    const DEST: &str = "dest";
+    for mut args in [
+        // All of the following to args should tell cp to preserve mode and
+        // timestamp, but not the link.
+        vec!["-r", "--preserve=mode,link,timestamp", "--no-preserve=link"],
+        vec![
+            "-r",
+            "--preserve=mode",
+            "--preserve=link",
+            "--preserve=timestamp",
+            "--no-preserve=link",
+        ],
+        vec![
+            "-r",
+            "--preserve=mode,link",
+            "--no-preserve=link",
+            "--preserve=timestamp",
+        ],
+        vec!["-a", "--no-preserve=link"],
+        vec!["-r", "--preserve", "--no-preserve=link"],
+    ] {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+        at.mkdir(FOLDER);
+        at.make_file(&format!("{FOLDER}/{FILE1}"));
+        at.set_mode(&format!("{FOLDER}/{FILE1}"), 0o775);
+        at.hard_link(&format!("{FOLDER}/{FILE1}"), &format!("{FOLDER}/{FILE2}"));
+        args.append(&mut vec![FOLDER, DEST]);
+        let src_file1_metadata = at.metadata(&format!("{FOLDER}/{FILE1}"));
+        scene.ucmd().args(&args).succeeds();
+        at.dir_exists(DEST);
+        let dest_file1_metadata = at.metadata(&format!("{DEST}/{FILE1}"));
+        let dest_file2_metadata = at.metadata(&format!("{DEST}/{FILE2}"));
+        assert_eq!(
+            src_file1_metadata.modified().unwrap(),
+            dest_file1_metadata.modified().unwrap()
+        );
+        assert_eq!(src_file1_metadata.mode(), dest_file1_metadata.mode());
+        assert_ne!(dest_file1_metadata.ino(), dest_file2_metadata.ino());
+    }
+}
+
+/// Test the behavior of preserving permissions when copying through a symlink
+#[test]
+#[cfg(unix)]
+fn test_cp_symlink_permissions() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("a");
+    at.set_mode("a", 0o700);
+    at.symlink_file("a", "symlink");
+    at.mkdir("dest");
+    scene
+        .ucmd()
+        .args(&["--preserve", "symlink", "dest"])
+        .succeeds();
+    let dest_dir_metadata = at.metadata("dest/symlink");
+    let src_dir_metadata = at.metadata("a");
+    assert_eq!(
+        src_dir_metadata.permissions().mode(),
+        dest_dir_metadata.permissions().mode()
+    );
+}
+
+/// Test the behavior of preserving permissions of parents when copying through a symlink
+#[test]
+#[cfg(unix)]
+fn test_cp_parents_symlink_permissions_file() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("a");
+    at.touch("a/file");
+    at.set_mode("a", 0o700);
+    at.symlink_dir("a", "symlink");
+    at.mkdir("dest");
+    scene
+        .ucmd()
+        .args(&["--parents", "-a", "symlink/file", "dest"])
+        .succeeds();
+    let dest_dir_metadata = at.metadata("dest/symlink");
+    let src_dir_metadata = at.metadata("a");
+    assert_eq!(
+        src_dir_metadata.permissions().mode(),
+        dest_dir_metadata.permissions().mode()
+    );
+}
+
+/// Test the behavior of preserving permissions of parents when copying through
+/// a symlink when source is a dir.
+#[test]
+#[cfg(unix)]
+fn test_cp_parents_symlink_permissions_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir_all("a/b");
+    at.set_mode("a", 0o755); // Set mode for the actual directory
+    at.symlink_dir("a", "symlink");
+    at.mkdir("dest");
+    scene
+        .ucmd()
+        .args(&["--parents", "-a", "symlink/b", "dest"])
+        .succeeds();
+    let dest_dir_metadata = at.metadata("dest/symlink");
+    let src_dir_metadata = at.metadata("a");
+    assert_eq!(
+        src_dir_metadata.permissions().mode(),
+        dest_dir_metadata.permissions().mode()
+    );
+}
+
+/// Test the behavior of copying a file to a destination with parents using absolute paths.
+#[cfg(unix)]
+#[test]
+fn test_cp_parents_absolute_path() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir_all("a/b");
+    at.touch("a/b/f");
+    at.mkdir("dest");
+    let src = format!("{}/a/b/f", at.root_dir_resolved());
+    scene
+        .ucmd()
+        .args(&["--parents", src.as_str(), "dest"])
+        .succeeds();
+    let res = format!("dest{}/a/b/f", at.root_dir_resolved());
+    at.file_exists(res);
+}
+
+#[test]
+fn test_copy_symlink_overwrite() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+
+    at.write("t", "hello");
+    at.relative_symlink_file("../t", "a/1");
+    at.relative_symlink_file("../t", "b/1");
+
+    ucmd.arg("--no-dereference")
+        .arg("a/1")
+        .arg("b/1")
+        .arg("c")
+        .fails()
+        .stderr_only(if cfg!(not(target_os = "windows")) {
+            "cp: will not overwrite just-created 'c/1' with 'b/1'\n"
+        } else {
+            "cp: will not overwrite just-created 'c\\1' with 'b/1'\n"
+        });
+}
+
+#[test]
+fn test_symlink_mode_overwrite() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a");
+    at.mkdir("b");
+
+    at.write("a/t", "hello");
+    at.write("b/t", "hello");
+
+    if cfg!(not(target_os = "windows")) {
+        ucmd.arg("-s")
+            .arg("a/t")
+            .arg("b/t")
+            .arg(".")
+            .fails()
+            .stderr_only("cp: will not overwrite just-created './t' with 'b/t'\n");
+
+        assert_eq!(at.read("./t"), "hello");
+    } else {
+        ucmd.arg("-s")
+            .arg("a\\t")
+            .arg("b\\t")
+            .arg(".")
+            .fails()
+            .stderr_only("cp: will not overwrite just-created '.\\t' with 'b\\t'\n");
+
+        assert_eq!(at.read(".\\t"), "hello");
+    }
+}
+
+// make sure that cp backup dest symlink before removing it.
+#[test]
+fn test_cp_with_options_backup_and_rem_when_dest_is_symlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("file", "xyz");
+    at.mkdir("inner_dir");
+    at.write("inner_dir/inner_file", "abc");
+    at.relative_symlink_file("inner_file", "inner_dir/sl");
+    scene
+        .ucmd()
+        .args(&["-b", "--rem", "file", "inner_dir/sl"])
+        .succeeds();
+    assert!(at.file_exists("inner_dir/inner_file"));
+    assert_eq!(at.read("inner_dir/inner_file"), "abc");
+    assert!(at.symlink_exists("inner_dir/sl~"));
+    assert!(!at.symlink_exists("inner_dir/sl"));
+    assert_eq!(at.read("inner_dir/sl"), "xyz");
+}
+
+#[test]
+fn test_cp_single_file() {
+    let (_at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg(TEST_HELLO_WORLD_SOURCE)
+        .fails_with_code(1)
+        .stderr_contains("missing destination file");
+}
+
+#[test]
+fn test_cp_no_file() {
+    let (_at, mut ucmd) = at_and_ucmd!();
+    ucmd.fails_with_code(1)
+        .stderr_contains("error: the following required arguments were not provided:");
+}
+
+#[test]
+#[cfg(all(
+    unix,
+    not(any(target_os = "android", target_os = "macos", target_os = "openbsd"))
+))]
+fn test_cp_preserve_xattr_readonly_source() {
+    use std::process::Command;
+    use uutests::util::compare_xattrs;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source_file = "a";
+    let dest_file = "e";
+
+    at.touch(source_file);
+
+    let xattr_key = "user.test";
+    match Command::new("setfattr")
+        .args([
+            "-n",
+            xattr_key,
+            "-v",
+            "value",
+            &at.plus_as_string(source_file),
+        ])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfattr failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfattr failed with {e}");
+            return;
+        }
+    }
+
+    let getfattr_output = Command::new("getfattr")
+        .args([&at.plus_as_string(source_file)])
+        .output()
+        .expect("Failed to run `getfattr` on the destination file");
+
+    assert!(
+        getfattr_output.status.success(),
+        "getfattr did not run successfully: {}",
+        String::from_utf8_lossy(&getfattr_output.stderr)
+    );
+
+    let stdout = String::from_utf8_lossy(&getfattr_output.stdout);
+    assert!(
+        stdout.contains(xattr_key),
+        "Expected '{xattr_key}' not found in getfattr output:\n{stdout}"
+    );
+
+    at.set_readonly(source_file);
+    assert!(
+        scene
+            .fixtures
+            .metadata(source_file)
+            .permissions()
+            .readonly()
+    );
+
+    scene
+        .ucmd()
+        .args(&[
+            "--preserve=xattr",
+            &at.plus_as_string(source_file),
+            &at.plus_as_string(dest_file),
+        ])
+        .succeeds()
+        .no_output();
+
+    assert!(scene.fixtures.metadata(dest_file).permissions().readonly());
+    assert!(
+        compare_xattrs(&at.plus(source_file), &at.plus(dest_file)),
+        "Extended attributes were not preserved"
+    );
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cp_from_stdin() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let target = "target";
+    let test_string = "Hello, World!\n";
+
+    ucmd.arg("/dev/fd/0")
+        .arg(target)
+        .pipe_in(test_string)
+        .succeeds();
+
+    assert!(at.file_exists(target));
+    assert_eq!(at.read(target), test_string);
+}
+
+#[test]
+fn test_cp_update_older_interactive_prompt_yes() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let old_file = "old";
+    let new_file = "new";
+
+    let f = at.make_file(old_file);
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
+    at.touch(new_file);
+
+    ucmd.args(&["-i", "-v", "--update=older", new_file, old_file])
+        .pipe_in("Y\n")
+        .stderr_to_stdout()
+        .succeeds()
+        .stdout_is("cp: overwrite 'old'? 'new' -> 'old'\n");
+}
+
+#[test]
+fn test_cp_update_older_interactive_prompt_no() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let old_file = "old";
+    let new_file = "new";
+
+    let f = at.make_file(old_file);
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
+    at.touch(new_file);
+
+    ucmd.args(&["-i", "-v", "--update=older", new_file, old_file])
+        .pipe_in("N\n")
+        .stderr_to_stdout()
+        .fails()
+        .stdout_is("cp: overwrite 'old'? ");
+}
+
+#[test]
+fn test_cp_update_none_interactive_prompt_no() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let old_file = "old";
+    let new_file = "new";
+
+    at.write(old_file, "old content");
+    at.write(new_file, "new content");
+
+    ucmd.args(&["-i", "--update=none", new_file, old_file])
+        .succeeds()
+        .no_output();
+
+    assert_eq!(at.read(old_file), "old content");
+    assert_eq!(at.read(new_file), "new content");
+}
+
+#[cfg(feature = "feat_selinux")]
+fn get_getfattr_output(f: &str) -> String {
+    use std::process::Command;
+
+    let getfattr_output = Command::new("getfattr")
+        .arg(f)
+        .arg("-n")
+        .arg("security.selinux")
+        .output()
+        .expect("Failed to run `getfattr` on the destination file");
+    println!("{:?}", getfattr_output);
+    assert!(
+        getfattr_output.status.success(),
+        "getfattr did not run successfully: {}",
+        String::from_utf8_lossy(&getfattr_output.stderr)
+    );
+
+    String::from_utf8_lossy(&getfattr_output.stdout)
+        .split('"')
+        .nth(1)
+        .unwrap_or("")
+        .to_string()
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_selinux() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let args = ["-Z", "--context=unconfined_u:object_r:user_tmp_t:s0"];
+    at.touch(TEST_HELLO_WORLD_SOURCE);
+    for arg in args {
+        ts.ucmd()
+            .arg(arg)
+            .arg(TEST_HELLO_WORLD_SOURCE)
+            .arg(TEST_HELLO_WORLD_DEST)
+            .succeeds();
+        assert!(at.file_exists(TEST_HELLO_WORLD_DEST));
+
+        let selinux_perm = get_getfattr_output(&at.plus_as_string(TEST_HELLO_WORLD_DEST));
+
+        assert!(
+            selinux_perm.contains("unconfined_u"),
+            "Expected 'foo' not found in getfattr output:\n{selinux_perm}"
+        );
+        at.remove(&at.plus_as_string(TEST_HELLO_WORLD_DEST));
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_selinux_invalid() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch(TEST_HELLO_WORLD_SOURCE);
+    let args = [
+        "--context=a",
+        "--context=unconfined_u:object_r:user_tmp_t:s0:a",
+        "--context=nconfined_u:object_r:user_tmp_t:s0",
+    ];
+    for arg in args {
+        new_ucmd!()
+            .arg(arg)
+            .arg(TEST_HELLO_WORLD_SOURCE)
+            .arg(TEST_HELLO_WORLD_DEST)
+            .fails()
+            .stderr_contains("failed to");
+        if at.file_exists(TEST_HELLO_WORLD_DEST) {
+            at.remove(TEST_HELLO_WORLD_DEST);
+        }
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_preserve_selinux() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let args = ["-Z", "--context=unconfined_u:object_r:user_tmp_t:s0"];
+    at.touch(TEST_HELLO_WORLD_SOURCE);
+    for arg in args {
+        ts.ucmd()
+            .arg(arg)
+            .arg(TEST_HELLO_WORLD_SOURCE)
+            .arg(TEST_HELLO_WORLD_DEST)
+            .arg("--preserve=all")
+            .succeeds();
+        assert!(at.file_exists(TEST_HELLO_WORLD_DEST));
+        let selinux_perm_dest = get_getfattr_output(&at.plus_as_string(TEST_HELLO_WORLD_DEST));
+        assert!(
+            selinux_perm_dest.contains("unconfined_u"),
+            "Expected 'foo' not found in getfattr output:\n{selinux_perm_dest}"
+        );
+        assert_eq!(
+            get_getfattr_output(&at.plus_as_string(TEST_HELLO_WORLD_SOURCE)),
+            selinux_perm_dest
+        );
+
+        #[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(TEST_HELLO_WORLD_SOURCE);
+            let metadata_dst = at.metadata(TEST_HELLO_WORLD_DEST);
+            assert_metadata_eq!(metadata_src, metadata_dst);
+        }
+
+        at.remove(&at.plus_as_string(TEST_HELLO_WORLD_DEST));
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_preserve_selinux_admin_context() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.touch(TEST_HELLO_WORLD_SOURCE);
+
+    // Get the default SELinux context for the destination file path
+    // On Debian/Ubuntu, this program is provided by the selinux-utils package
+    // On Fedora/RHEL, this program is provided by the libselinux-devel package
+    let output = std::process::Command::new("matchpathcon")
+        .arg(at.plus_as_string(TEST_HELLO_WORLD_DEST))
+        .output()
+        .expect("failed to execute matchpathcon command");
+
+    assert!(
+        output.status.success(),
+        "matchpathcon command failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    let output_str = String::from_utf8_lossy(&output.stdout);
+    let default_context = output_str
+        .split_whitespace()
+        .nth(1)
+        .unwrap_or_default()
+        .to_string();
+
+    assert!(
+        !default_context.is_empty(),
+        "Unable to determine default SELinux context for the test file"
+    );
+
+    let cmd_result = ts
+        .ucmd()
+        .arg("-Z")
+        .arg(format!("--context={}", default_context))
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg(TEST_HELLO_WORLD_DEST)
+        .run();
+
+    println!("cp command result: {:?}", cmd_result);
+
+    if !cmd_result.succeeded() {
+        println!("Skipping test: Cannot set SELinux context, system may not support this context");
+        return;
+    }
+
+    assert!(at.file_exists(TEST_HELLO_WORLD_DEST));
+
+    let selinux_perm_dest = get_getfattr_output(&at.plus_as_string(TEST_HELLO_WORLD_DEST));
+    println!("Destination SELinux context: {}", selinux_perm_dest);
+
+    assert_eq!(default_context, selinux_perm_dest);
+
+    at.remove(&at.plus_as_string(TEST_HELLO_WORLD_DEST));
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_selinux_context_priority() {
+    // This test verifies that the priority order is respected:
+    // -Z > --context > --preserve=context
+
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.write(TEST_HELLO_WORLD_SOURCE, "source content");
+
+    // First, set a known context on source file (only if system supports it)
+    let setup_result = ts
+        .ucmd()
+        .arg("--context=unconfined_u:object_r:user_tmp_t:s0")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("initial_context.txt")
+        .run();
+
+    // If the system doesn't support setting contexts, skip the test
+    if !setup_result.succeeded() {
+        println!("Skipping test: System doesn't support setting SELinux contexts");
+        return;
+    }
+
+    // Create different copies with different context options
+
+    // 1. Using --preserve=context
+    ts.ucmd()
+        .arg("--preserve=context")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("preserve.txt")
+        .succeeds();
+
+    // 2. Using --context with a different context (we already know this works from setup)
+    ts.ucmd()
+        .arg("--context=unconfined_u:object_r:user_tmp_t:s0")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("context.txt")
+        .succeeds();
+
+    // 3. Using -Z (should use default type context)
+    ts.ucmd()
+        .arg("-Z")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("z_flag.txt")
+        .succeeds();
+
+    // 4. Using both -Z and --context (Z should win)
+    ts.ucmd()
+        .arg("-Z")
+        .arg("--context=unconfined_u:object_r:user_tmp_t:s0")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("z_and_context.txt")
+        .succeeds();
+
+    // 5. Using both -Z and --preserve=context (Z should win)
+    ts.ucmd()
+        .arg("-Z")
+        .arg("--preserve=context")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("z_and_preserve.txt")
+        .succeeds();
+
+    // Get all the contexts
+    let source_ctx = get_getfattr_output(&at.plus_as_string(TEST_HELLO_WORLD_SOURCE));
+    let preserve_ctx = get_getfattr_output(&at.plus_as_string("preserve.txt"));
+    let context_ctx = get_getfattr_output(&at.plus_as_string("context.txt"));
+    let z_ctx = get_getfattr_output(&at.plus_as_string("z_flag.txt"));
+    let z_and_context_ctx = get_getfattr_output(&at.plus_as_string("z_and_context.txt"));
+    let z_and_preserve_ctx = get_getfattr_output(&at.plus_as_string("z_and_preserve.txt"));
+
+    if source_ctx.is_empty() {
+        println!("Skipping test assertions: Failed to get SELinux contexts");
+        return;
+    }
+    assert_eq!(
+        source_ctx, preserve_ctx,
+        "--preserve=context should match the source context"
+    );
+    assert_eq!(
+        source_ctx, context_ctx,
+        "--preserve=context should match the source context"
+    );
+    assert_eq!(
+        z_ctx, z_and_context_ctx,
+        "-Z context should be the same regardless of --context"
+    );
+    assert_eq!(
+        z_ctx, z_and_preserve_ctx,
+        "-Z context should be the same regardless of --preserve=context"
+    );
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_selinux_empty_context() {
+    // This test verifies that --context without a value works like -Z
+
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.write(TEST_HELLO_WORLD_SOURCE, "test content");
+
+    // Try creating copies - if this fails, the system doesn't support SELinux properly
+    let z_result = ts
+        .ucmd()
+        .arg("-Z")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("z_flag.txt")
+        .run();
+
+    if !z_result.succeeded() {
+        println!("Skipping test: SELinux contexts not supported");
+        return;
+    }
+
+    // Now try with --context (no value)
+    let context_result = ts
+        .ucmd()
+        .arg("--context")
+        .arg(TEST_HELLO_WORLD_SOURCE)
+        .arg("empty_context.txt")
+        .run();
+
+    if !context_result.succeeded() {
+        println!("Skipping test: Empty context parameter not supported");
+        return;
+    }
+
+    let z_ctx = get_getfattr_output(&at.plus_as_string("z_flag.txt"));
+    let empty_ctx = get_getfattr_output(&at.plus_as_string("empty_context.txt"));
+
+    if !z_ctx.is_empty() && !empty_ctx.is_empty() {
+        assert_eq!(
+            z_ctx, empty_ctx,
+            "--context without a value should behave like -Z"
+        );
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_selinux_recursive() {
+    // Test SELinux context preservation in recursive directory copies
+
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("source_dir");
+    at.write("source_dir/file1.txt", "file1 content");
+    at.mkdir("source_dir/subdir");
+    at.write("source_dir/subdir/file2.txt", "file2 content");
+
+    let setup_result = ts
+        .ucmd()
+        .arg("--context=unconfined_u:object_r:user_tmp_t:s0")
+        .arg("source_dir/file1.txt")
+        .arg("source_dir/context_set.txt")
+        .run();
+
+    if !setup_result.succeeded() {
+        println!("Skipping test: System doesn't support setting SELinux contexts");
+        return;
+    }
+
+    ts.ucmd()
+        .arg("-rZ")
+        .arg("source_dir")
+        .arg("dest_dir_z")
+        .succeeds();
+
+    ts.ucmd()
+        .arg("-r")
+        .arg("--preserve=context")
+        .arg("source_dir")
+        .arg("dest_dir_preserve")
+        .succeeds();
+
+    let z_dir_ctx = get_getfattr_output(&at.plus_as_string("dest_dir_z"));
+    let preserve_dir_ctx = get_getfattr_output(&at.plus_as_string("dest_dir_preserve"));
+
+    if !z_dir_ctx.is_empty() && !preserve_dir_ctx.is_empty() {
+        assert!(
+            z_dir_ctx.contains("_u:"),
+            "SELinux contexts not properly set with -Z flag"
+        );
+
+        assert!(
+            preserve_dir_ctx.contains("_u:"),
+            "SELinux contexts not properly preserved with --preserve=context"
+        );
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_cp_preserve_context_root() {
+    use uutests::util::run_ucmd_as_root;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source_file = "c";
+    let dest_file = "e";
+    at.touch(source_file);
+
+    let context = "root:object_r:tmp_t:s0";
+
+    let chcon_result = std::process::Command::new("chcon")
+        .arg(context)
+        .arg(at.plus_as_string(source_file))
+        .status();
+
+    if !chcon_result.is_ok_and(|status| status.success()) {
+        println!("Skipping test: Failed to set context: {}", context);
+        return;
+    }
+
+    // Copy the file with preserved context
+    // Only works as root
+    if let Ok(result) = run_ucmd_as_root(&scene, &["--preserve=context", source_file, dest_file]) {
+        let src_ctx = get_getfattr_output(&at.plus_as_string(source_file));
+        let dest_ctx = get_getfattr_output(&at.plus_as_string(dest_file));
+        println!("Source context: {}", src_ctx);
+        println!("Destination context: {}", dest_ctx);
+
+        if !result.succeeded() {
+            println!("Skipping test: Failed to copy with preserved context");
+            return;
+        }
+
+        let dest_context = get_getfattr_output(&at.plus_as_string(dest_file));
+
+        assert!(
+            dest_context.contains("root:object_r:tmp_t"),
+            "Expected context '{}' not found in destination context: '{}'",
+            context,
+            dest_context
+        );
+    } else {
+        print!("Test skipped; requires root user");
     }
 }
diff --git a/tests/by-util/test_csplit.rs b/tests/by-util/test_csplit.rs
index b83d5e0eede..96322e44474 100644
--- a/tests/by-util/test_csplit.rs
+++ b/tests/by-util/test_csplit.rs
@@ -2,8 +2,11 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
 use glob::glob;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 /// Returns a string of numbers with the given range, each on a new line.
 /// The upper bound is not included.
@@ -13,7 +16,7 @@ fn generate(from: u32, to: u32) -> String {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -80,6 +83,15 @@ fn test_up_to_line_sequence() {
     assert_eq!(at.read("xx02"), generate(25, 51));
 }
 
+#[test]
+fn test_up_to_line_with_non_ascii_repeat() {
+    // we use a different error message than GNU
+    new_ucmd!()
+        .args(&["numbers50.txt", "10", "{�}"])
+        .fails()
+        .stderr_contains("invalid pattern");
+}
+
 #[test]
 fn test_up_to_match() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -130,17 +142,21 @@ fn test_up_to_match_sequence() {
 
 #[test]
 fn test_up_to_match_offset() {
-    let (at, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["numbers50.txt", "/9$/+3"])
-        .succeeds()
-        .stdout_only("24\n117\n");
+    for offset in ["3", "+3"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        ucmd.args(&["numbers50.txt", &format!("/9$/{offset}")])
+            .succeeds()
+            .stdout_only("24\n117\n");
 
-    let count = glob(&at.plus_as_string("xx*"))
-        .expect("there should be splits created")
-        .count();
-    assert_eq!(count, 2);
-    assert_eq!(at.read("xx00"), generate(1, 12));
-    assert_eq!(at.read("xx01"), generate(12, 51));
+        let count = glob(&at.plus_as_string("xx*"))
+            .expect("there should be splits created")
+            .count();
+        assert_eq!(count, 2);
+        assert_eq!(at.read("xx00"), generate(1, 12));
+        assert_eq!(at.read("xx01"), generate(12, 51));
+        at.remove("xx00");
+        at.remove("xx01");
+    }
 }
 
 #[test]
@@ -160,6 +176,15 @@ fn test_up_to_match_offset_repeat_twice() {
     assert_eq!(at.read("xx03"), generate(32, 51));
 }
 
+#[test]
+fn test_up_to_match_non_ascii_offset() {
+    // we use a different error message than GNU
+    new_ucmd!()
+        .args(&["numbers50.txt", "/9$/�"])
+        .fails()
+        .stderr_contains("invalid pattern");
+}
+
 #[test]
 fn test_up_to_match_negative_offset() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -316,16 +341,29 @@ fn test_skip_to_match_sequence4() {
 
 #[test]
 fn test_skip_to_match_offset() {
+    for offset in ["3", "+3"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        ucmd.args(&["numbers50.txt", &format!("%23%{offset}")])
+            .succeeds()
+            .stdout_only("75\n");
+
+        let count = glob(&at.plus_as_string("xx*"))
+            .expect("there should be splits created")
+            .count();
+        assert_eq!(count, 1);
+        assert_eq!(at.read("xx00"), generate(26, 51));
+        at.remove("xx00");
+    }
+}
+
+#[test]
+fn test_skip_to_match_offset_suppress_empty() {
     let (at, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["numbers50.txt", "%23%+3"])
+    ucmd.args(&["-z", "-", "%a%1"])
+        .pipe_in("a\n")
         .succeeds()
-        .stdout_only("75\n");
-
-    let count = glob(&at.plus_as_string("xx*"))
-        .expect("there should be splits created")
-        .count();
-    assert_eq!(count, 1);
-    assert_eq!(at.read("xx00"), generate(26, 51));
+        .no_output();
+    assert!(!at.file_exists("xx00"));
 }
 
 #[test]
@@ -387,18 +425,23 @@ fn test_option_keep() {
 
 #[test]
 fn test_option_quiet() {
-    let (at, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["--quiet", "numbers50.txt", "13", "%25%", "/0$/"])
-        .succeeds()
-        .no_stdout();
-
-    let count = glob(&at.plus_as_string("xx*"))
-        .expect("there should be splits created")
-        .count();
-    assert_eq!(count, 3);
-    assert_eq!(at.read("xx00"), generate(1, 13));
-    assert_eq!(at.read("xx01"), generate(25, 30));
-    assert_eq!(at.read("xx02"), generate(30, 51));
+    for arg in ["-q", "--quiet", "-s", "--silent"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        ucmd.args(&[arg, "numbers50.txt", "13", "%25%", "/0$/"])
+            .succeeds()
+            .no_stdout();
+
+        let count = glob(&at.plus_as_string("xx*"))
+            .expect("there should be splits created")
+            .count();
+        assert_eq!(count, 3);
+        assert_eq!(at.read("xx00"), generate(1, 13));
+        assert_eq!(at.read("xx01"), generate(25, 30));
+        assert_eq!(at.read("xx02"), generate(30, 51));
+        at.remove("xx00");
+        at.remove("xx01");
+        at.remove("xx02");
+    }
 }
 
 #[test]
@@ -457,14 +500,14 @@ fn test_up_to_match_offset_option_suppress_matched() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "--suppress-matched", "/10/+4"])
         .succeeds()
-        .stdout_only("27\n111\n");
+        .stdout_only("30\n108\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
         .count();
     assert_eq!(count, 2);
-    assert_eq!(at.read("xx00"), generate(1, 10) + &generate(11, 14));
-    assert_eq!(at.read("xx01"), generate(14, 51));
+    assert_eq!(at.read("xx00"), generate(1, 14));
+    assert_eq!(at.read("xx01"), generate(15, 51));
 }
 
 #[test]
@@ -472,14 +515,14 @@ fn test_up_to_match_negative_offset_option_suppress_matched() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "--suppress-matched", "/10/-4"])
         .succeeds()
-        .stdout_only("10\n128\n");
+        .stdout_only("10\n129\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
         .count();
     assert_eq!(count, 2);
     assert_eq!(at.read("xx00"), generate(1, 6));
-    assert_eq!(at.read("xx01"), generate(6, 10) + &generate(11, 51));
+    assert_eq!(at.read("xx01"), generate(7, 51));
 }
 
 #[test]
@@ -575,7 +618,7 @@ fn test_skip_to_match_context_underflow() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%5%-10"])
         .fails()
-        .stdout_is("141\n")
+        .stdout_is("")
         .stderr_is("csplit: '%5%-10': line number out of range\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -586,14 +629,13 @@ fn test_skip_to_match_context_underflow() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "%5%-10", "-k"])
         .fails()
-        .stdout_is("141\n")
+        .stdout_is("")
         .stderr_is("csplit: '%5%-10': line number out of range\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
         .count();
-    assert_eq!(count, 1);
-    assert_eq!(at.read("xx00"), generate(1, 51));
+    assert_eq!(count, 0);
 }
 
 #[test]
@@ -1225,13 +1267,12 @@ fn test_corner_case4() {
     assert_eq!(at.read("xx02"), generate(26, 51));
 }
 
-// NOTE: differs from gnu's output: the empty split is not written
 #[test]
 fn test_up_to_match_context_underflow() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "/5/-10"])
         .fails()
-        .stdout_is("0\n141\n")
+        .stdout_is("0\n")
         .stderr_is("csplit: '/5/-10': line number out of range\n");
 
     let count = glob(&at.plus_as_string("xx*"))
@@ -1242,26 +1283,24 @@ fn test_up_to_match_context_underflow() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "/5/-10", "-k"])
         .fails()
-        .stdout_is("0\n141\n")
+        .stdout_is("0\n")
         .stderr_is("csplit: '/5/-10': line number out of range\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("counting splits")
         .count();
-    assert_eq!(count, 2);
+    assert_eq!(count, 1);
     assert_eq!(at.read("xx00"), "");
-    assert_eq!(at.read("xx01"), generate(1, 51));
 }
 
 // the offset is out of range because of the first pattern
-// NOTE: output different than gnu's: the empty split is written but the rest of the input file is not
 #[test]
 fn test_line_num_range_with_up_to_match1() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/12/-5"])
         .fails()
         .stderr_is("csplit: '/12/-5': line number out of range\n")
-        .stdout_is("18\n0\n123\n");
+        .stdout_is("18\n0\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1272,26 +1311,24 @@ fn test_line_num_range_with_up_to_match1() {
     ucmd.args(&["numbers50.txt", "10", "/12/-5", "-k"])
         .fails()
         .stderr_is("csplit: '/12/-5': line number out of range\n")
-        .stdout_is("18\n0\n123\n");
+        .stdout_is("18\n0\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
         .count();
-    assert_eq!(count, 3);
+    assert_eq!(count, 2);
     assert_eq!(at.read("xx00"), generate(1, 10));
     assert_eq!(at.read("xx01"), "");
-    assert_eq!(at.read("xx02"), generate(10, 51));
 }
 
 // the offset is out of range because more lines are needed than physically available
-// NOTE: output different than gnu's: the empty split is not written but the rest of the input file is
 #[test]
 fn test_line_num_range_with_up_to_match2() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["numbers50.txt", "10", "/12/-15"])
         .fails()
         .stderr_is("csplit: '/12/-15': line number out of range\n")
-        .stdout_is("18\n0\n123\n");
+        .stdout_is("18\n0\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
@@ -1302,15 +1339,14 @@ fn test_line_num_range_with_up_to_match2() {
     ucmd.args(&["numbers50.txt", "10", "/12/-15", "-k"])
         .fails()
         .stderr_is("csplit: '/12/-15': line number out of range\n")
-        .stdout_is("18\n0\n123\n");
+        .stdout_is("18\n0\n");
 
     let count = glob(&at.plus_as_string("xx*"))
         .expect("there should be splits created")
         .count();
-    assert_eq!(count, 3);
+    assert_eq!(count, 2);
     assert_eq!(at.read("xx00"), generate(1, 10));
     assert_eq!(at.read("xx01"), "");
-    assert_eq!(at.read("xx02"), generate(10, 51));
 }
 
 // NOTE: output different than gnu's: the pattern /10/ is matched but should not
@@ -1342,3 +1378,128 @@ fn test_line_num_range_with_up_to_match3() {
     assert_eq!(at.read("xx01"), "");
     assert_eq!(at.read("xx02"), generate(10, 51));
 }
+
+#[test]
+fn precision_format() {
+    for f in ["%#6.3x", "%0#6.3x"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        ucmd.args(&["numbers50.txt", "10", "--suffix-format", f])
+            .succeeds()
+            .stdout_only("18\n123\n");
+
+        let count = glob(&at.plus_as_string("xx*"))
+            .expect("there should be splits created")
+            .count();
+        assert_eq!(count, 2);
+        assert_eq!(at.read("xx   000"), generate(1, 10));
+        assert_eq!(at.read("xx 0x001"), generate(10, 51));
+    }
+}
+
+#[test]
+fn zero_error() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("in");
+    ucmd.args(&["in", "0"])
+        .fails()
+        .stderr_contains("0: line number must be greater");
+}
+
+#[test]
+fn no_such_file() {
+    new_ucmd!()
+        .args(&["in", "0"])
+        .fails()
+        .stderr_contains("cannot open 'in' for reading: No such file or directory");
+}
+
+#[test]
+fn repeat_everything() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&[
+        "numbers50.txt",
+        "--suppress-matched",
+        "--suppress-matched",
+        "-kzsn", // spell-checker:disable-line
+        "2",
+        "-szkn3", // spell-checker:disable-line
+        "-b",
+        "%03d",
+        "-b%03x",
+        "-f",
+        "xxy_",
+        "-fxxz_", // spell-checker:disable-line
+        "/13/",
+        "9",
+        "{5}",
+    ])
+    .fails_with_code(1)
+    .no_stdout()
+    .stderr_only("csplit: '9': line number out of range on repetition 5\n");
+    let count = glob(&at.plus_as_string("xx*"))
+        .expect("there should be some splits created")
+        .count();
+    assert_eq!(count, 6);
+    assert_eq!(at.read("xxz_000"), generate(1, 12 + 1));
+    assert_eq!(at.read("xxz_001"), generate(14, 17 + 1)); // FIXME: GNU starts at 15
+    assert_eq!(at.read("xxz_002"), generate(19, 26 + 1));
+    assert_eq!(at.read("xxz_003"), generate(28, 35 + 1));
+    assert_eq!(at.read("xxz_004"), generate(37, 44 + 1));
+    assert_eq!(at.read("xxz_005"), generate(46, 50 + 1));
+}
+
+#[cfg(unix)]
+#[test]
+fn test_named_pipe_input_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let mut fifo_writer =
+        create_named_pipe_with_writer(&at.plus_as_string("fifo"), &generate(1, 51));
+
+    let result = ucmd.args(&["fifo", "10"]).succeeds();
+    fifo_writer.kill().unwrap();
+    fifo_writer.wait().unwrap();
+    result.stdout_only("18\n123\n");
+
+    let count = glob(&at.plus_as_string("xx*"))
+        .expect("there should be splits created")
+        .count();
+    assert_eq!(count, 2);
+    assert_eq!(at.read("xx00"), generate(1, 10));
+    assert_eq!(at.read("xx01"), generate(10, 51));
+}
+
+#[cfg(unix)]
+fn create_named_pipe_with_writer(path: &str, data: &str) -> std::process::Child {
+    // cSpell:ignore IRWXU
+    nix::unistd::mkfifo(path, nix::sys::stat::Mode::S_IRWXU).unwrap();
+    std::process::Command::new("sh")
+        .arg("-c")
+        .arg(format!("printf '{data}' > {path}"))
+        .spawn()
+        .unwrap()
+}
+
+#[test]
+fn test_directory_input_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("test_directory");
+
+    #[cfg(unix)]
+    ucmd.args(&["test_directory", "1"])
+        .fails_with_code(1)
+        .stderr_only("csplit: read error: Is a directory\n");
+    #[cfg(windows)]
+    ucmd.args(&["test_directory", "1"])
+        .fails_with_code(1)
+        .stderr_only("csplit: cannot open 'test_directory' for reading: Permission denied\n");
+}
+
+#[test]
+fn test_stdin_no_trailing_newline() {
+    new_ucmd!()
+        .args(&["-", "2"])
+        .pipe_in("a\nb\nc\nd")
+        .succeeds()
+        .stdout_only("2\n5\n");
+}
diff --git a/tests/by-util/test_cut.rs b/tests/by-util/test_cut.rs
index 7f86c803e8f..9cded39d8c7 100644
--- a/tests/by-util/test_cut.rs
+++ b/tests/by-util/test_cut.rs
@@ -2,7 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore defg
+
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 static INPUT: &str = "lists.txt";
 
@@ -43,9 +49,16 @@ static COMPLEX_SEQUENCE: &TestedSequence = &TestedSequence {
     sequence: "9-,6-7,-2,4",
 };
 
+#[test]
+fn test_no_args() {
+    new_ucmd!().fails().stderr_is(
+        "cut: invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)\n",
+    );
+}
+
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -97,28 +110,43 @@ fn test_whitespace_delimited() {
 fn test_whitespace_with_explicit_delimiter() {
     new_ucmd!()
         .args(&["-w", "-f", COMPLEX_SEQUENCE.sequence, "-d:"])
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
 fn test_whitespace_with_byte() {
     new_ucmd!()
         .args(&["-w", "-b", COMPLEX_SEQUENCE.sequence])
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
 fn test_whitespace_with_char() {
     new_ucmd!()
         .args(&["-c", COMPLEX_SEQUENCE.sequence, "-w"])
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
-fn test_specify_delimiter() {
+fn test_delimiter_with_byte_and_char() {
+    for conflicting_arg in ["-c", "-b"] {
+        new_ucmd!()
+            .args(&[conflicting_arg, COMPLEX_SEQUENCE.sequence, "-d="])
+            .fails_with_code(1)
+            .stderr_is("cut: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n")
+;
+    }
+}
+
+#[test]
+fn test_too_large() {
+    new_ucmd!()
+        .args(&["-b1-18446744073709551615", "/dev/null"])
+        .fails_with_code(1);
+}
+
+#[test]
+fn test_delimiter() {
     for param in ["-d", "--delimiter", "--del"] {
         new_ucmd!()
             .args(&[param, ":", "-f", COMPLEX_SEQUENCE.sequence, INPUT])
@@ -127,6 +155,15 @@ fn test_specify_delimiter() {
     }
 }
 
+#[test]
+fn test_delimiter_with_more_than_one_char() {
+    new_ucmd!()
+        .args(&["-d", "ab", "-f1"])
+        .fails()
+        .stderr_contains("cut: the delimiter must be a single character")
+        .no_stdout();
+}
+
 #[test]
 fn test_output_delimiter() {
     // we use -d here to ensure output delimiter
@@ -195,46 +232,158 @@ fn test_zero_terminated_only_delimited() {
 }
 
 #[test]
-fn test_directory_and_no_such_file() {
+fn test_is_a_directory() {
     let (at, mut ucmd) = at_and_ucmd!();
 
     at.mkdir("some");
 
     ucmd.arg("-b1")
         .arg("some")
-        .run()
+        .fails_with_code(1)
         .stderr_is("cut: some: Is a directory\n");
+}
 
+#[test]
+fn test_no_such_file() {
     new_ucmd!()
         .arg("-b1")
         .arg("some")
-        .run()
+        .fails_with_code(1)
         .stderr_is("cut: some: No such file or directory\n");
 }
 
 #[test]
-fn test_equal_as_delimiter1() {
+fn test_equal_as_delimiter() {
+    for arg in ["-d=", "--delimiter=="] {
+        new_ucmd!()
+            .args(&["-f2", arg])
+            .pipe_in("--dir=./out/lib")
+            .succeeds()
+            .stdout_only("./out/lib\n");
+    }
+}
+
+#[test]
+fn test_empty_string_as_delimiter() {
+    for arg in ["-d''", "--delimiter=", "--delimiter=''"] {
+        new_ucmd!()
+            .args(&["-f2", arg])
+            .pipe_in("a\0b\n")
+            .succeeds()
+            .stdout_only("b\n");
+    }
+}
+
+#[test]
+fn test_empty_string_as_delimiter_with_output_delimiter() {
     new_ucmd!()
-        .args(&["-f", "2", "-d="])
-        .pipe_in("--dir=./out/lib")
+        .args(&["-f", "1,2", "-d", "''", "--output-delimiter=Z"])
+        .pipe_in("ab\0cd\n")
         .succeeds()
-        .stdout_only("./out/lib\n");
+        .stdout_only_bytes("abZcd\n");
 }
 
 #[test]
-fn test_equal_as_delimiter2() {
+fn test_newline_as_delimiter() {
+    for (field, expected_output) in [("1", "a:1\n"), ("2", "b:\n")] {
+        new_ucmd!()
+            .args(&["-f", field, "-d", "\n"])
+            .pipe_in("a:1\nb:")
+            .succeeds()
+            .stdout_only_bytes(expected_output);
+    }
+}
+
+#[test]
+fn test_newline_as_delimiter_with_output_delimiter() {
     new_ucmd!()
-        .args(&["-f2", "--delimiter="])
-        .pipe_in("a=b\n")
+        .args(&["-f1-", "-d", "\n", "--output-delimiter=:"])
+        .pipe_in("a\nb\n")
         .succeeds()
-        .stdout_only("a=b\n");
+        .stdout_only_bytes("a:b\n");
 }
 
 #[test]
-fn test_equal_as_delimiter3() {
+fn test_multiple_delimiters() {
     new_ucmd!()
-        .args(&["-f", "1,2", "-d", "''", "--output-delimiter=Z"])
-        .pipe_in("ab\0cd\n")
+        .args(&["-f2", "-d:", "-d="])
+        .pipe_in("a:=b\n")
         .succeeds()
-        .stdout_only_bytes("abZcd\n");
+        .stdout_only("b\n");
+
+    new_ucmd!()
+        .args(&["-f2", "-d=", "-d:"])
+        .pipe_in("a:=b\n")
+        .succeeds()
+        .stdout_only("=b\n");
+}
+
+#[test]
+fn test_multiple_mode_args() {
+    for args in [
+        vec!["-b1", "-b2"],
+        vec!["-c1", "-c2"],
+        vec!["-f1", "-f2"],
+        vec!["-b1", "-c2"],
+        vec!["-b1", "-f2"],
+        vec!["-c1", "-f2"],
+        vec!["-b1", "-c2", "-f3"],
+    ] {
+        new_ucmd!()
+        .args(&args)
+        .fails()
+        .stderr_is("cut: invalid usage: expects no more than one of --fields (-f), --chars (-c) or --bytes (-b)\n");
+    }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_8bit_non_utf8_delimiter() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+    let delim = OsStr::from_bytes(b"\xAD".as_slice());
+    new_ucmd!()
+        .arg("-d")
+        .arg(delim)
+        .args(&["--out=_", "-f2,3", "8bit-delim.txt"])
+        .succeeds()
+        .stdout_check(|out| out == "b_c\n".as_bytes());
+}
+
+#[test]
+fn test_newline_preservation_with_f1_option() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("1", "a\nb");
+    let expected = "a\nb\n";
+    ucmd.args(&["-f1-", "1"]).succeeds().stdout_is(expected);
+}
+
+#[test]
+fn test_output_delimiter_with_character_ranges() {
+    new_ucmd!()
+        .args(&["-c2-3,4-", "--output-delim=:"])
+        .pipe_in("abcdefg\n")
+        .succeeds()
+        .stdout_only("bc:defg\n");
+}
+
+#[test]
+fn test_output_delimiter_with_adjacent_ranges() {
+    new_ucmd!()
+        .args(&["-b1-2,3-4", "--output-d=:"])
+        .pipe_in("abcd\n")
+        .succeeds()
+        .stdout_only("ab:cd\n");
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .arg("-d=")
+        .arg("-f1")
+        .pipe_in("key=value")
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("cut: write error: No space left on device\n");
 }
diff --git a/tests/by-util/test_date.rs b/tests/by-util/test_date.rs
index a65f02fa4c7..09cf7ac790e 100644
--- a/tests/by-util/test_date.rs
+++ b/tests/by-util/test_date.rs
@@ -2,14 +2,17 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+use chrono::{DateTime, Datelike, Duration, NaiveTime, Utc}; // spell-checker:disable-line
 use regex::Regex;
 #[cfg(all(unix, not(target_os = "macos")))]
 use uucore::process::geteuid;
+use uutests::util::TestScenario;
+use uutests::{at_and_ucmd, new_ucmd, util_name};
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -141,6 +144,17 @@ fn test_date_utc() {
     }
 }
 
+#[test]
+fn test_date_utc_issue_6495() {
+    new_ucmd!()
+        .env("TZ", "UTC0")
+        .arg("-u")
+        .arg("-d")
+        .arg("@0")
+        .succeeds()
+        .stdout_is("Thu Jan  1 00:00:00 UTC 1970\n");
+}
+
 #[test]
 fn test_date_format_y() {
     let scene = TestScenario::new(util_name!());
@@ -152,6 +166,14 @@ fn test_date_format_y() {
     scene.ucmd().arg("+%y").succeeds().stdout_matches(&re);
 }
 
+#[test]
+fn test_date_format_q() {
+    let scene = TestScenario::new(util_name!());
+
+    let re = Regex::new(r"^[1-4]\n$").unwrap();
+    scene.ucmd().arg("+%q").succeeds().stdout_matches(&re);
+}
+
 #[test]
 fn test_date_format_m() {
     let scene = TestScenario::new(util_name!());
@@ -203,9 +225,8 @@ fn test_date_format_without_plus() {
     // [+FORMAT]
     new_ucmd!()
         .arg("%s")
-        .fails()
-        .stderr_contains("date: invalid date '%s'")
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_contains("date: invalid date '%s'");
 }
 
 #[test]
@@ -256,14 +277,16 @@ fn test_date_set_mac_unavailable() {
         .arg("2020-03-11 21:45:00+08:00")
         .fails();
     result.no_stdout();
-    assert!(result
-        .stderr_str()
-        .starts_with("date: setting the date is not supported by macOS"));
+    assert!(
+        result
+            .stderr_str()
+            .starts_with("date: setting the date is not supported by macOS")
+    );
 }
 
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
-/// TODO: expected to fail currently; change to succeeds() when required.
+/// TODO: expected to fail currently; change to `succeeds()` when required.
 fn test_date_set_valid_2() {
     if geteuid() == 0 {
         let result = new_ucmd!()
@@ -288,12 +311,14 @@ fn test_date_for_invalid_file() {
 #[test]
 #[cfg(unix)]
 fn test_date_for_no_permission_file() {
-    let (at, mut ucmd) = at_and_ucmd!();
+    use std::os::unix::fs::PermissionsExt;
     const FILE: &str = "file-no-perm-1";
 
-    use std::os::unix::fs::PermissionsExt;
+    let (at, mut ucmd) = at_and_ucmd!();
+
     let file = std::fs::OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(true)
         .open(at.plus(FILE))
         .unwrap();
@@ -327,7 +352,7 @@ fn test_date_for_file() {
 
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
-/// TODO: expected to fail currently; change to succeeds() when required.
+/// TODO: expected to fail currently; change to `succeeds()` when required.
 fn test_date_set_valid_3() {
     if geteuid() == 0 {
         let result = new_ucmd!()
@@ -341,7 +366,7 @@ fn test_date_set_valid_3() {
 
 #[test]
 #[cfg(all(unix, not(target_os = "macos")))]
-/// TODO: expected to fail currently; change to succeeds() when required.
+/// TODO: expected to fail currently; change to `succeeds()` when required.
 fn test_date_set_valid_4() {
     if geteuid() == 0 {
         let result = new_ucmd!()
@@ -361,10 +386,12 @@ fn test_invalid_format_string() {
 }
 
 #[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"));
+fn test_capitalized_numeric_time_zone() {
+    // %z     +hhmm numeric time zone (e.g., -0400)
+    // # is supposed to capitalize, which makes little sense here, but chrono crashes
+    // on such format so it's good to test.
+    let re = Regex::new(r"^[+-]\d{4,4}\n$").unwrap();
+    new_ucmd!().arg("+%#z").succeeds().stdout_matches(&re);
 }
 
 #[test]
@@ -378,6 +405,17 @@ fn test_date_string_human() {
         "5 hours ago",
         "30 minutes ago",
         "10 seconds",
+        "last day",
+        "last monday",
+        "last week",
+        "last month",
+        "last year",
+        "this monday",
+        "next day",
+        "next monday",
+        "next week",
+        "next month",
+        "next year",
     ];
     let re = Regex::new(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}\n$").unwrap();
     for date_format in date_formats {
@@ -390,6 +428,61 @@ fn test_date_string_human() {
     }
 }
 
+#[test]
+fn test_negative_offset() {
+    let data_formats = vec![
+        ("-1 hour", Duration::hours(1)),
+        ("-1 hours", Duration::hours(1)),
+        ("-1 day", Duration::days(1)),
+        ("-2 weeks", Duration::weeks(2)),
+    ];
+    for (date_format, offset) in data_formats {
+        new_ucmd!()
+            .arg("-d")
+            .arg(date_format)
+            .arg("--rfc-3339=seconds")
+            .succeeds()
+            .stdout_str_check(|out| {
+                let date = DateTime::parse_from_rfc3339(out.trim()).unwrap();
+
+                // Is the resulting date roughly what is expected?
+                let expected_date = Utc::now() - offset;
+                (date.to_utc() - expected_date).abs() < Duration::minutes(10)
+            });
+    }
+}
+
+#[test]
+fn test_relative_weekdays() {
+    // Truncate time component to midnight
+    let today = Utc::now().with_time(NaiveTime::MIN).unwrap();
+    // Loop through each day of the week, starting with today
+    for offset in 0..7 {
+        for direction in ["last", "this", "next"] {
+            let weekday = (today + Duration::days(offset))
+                .weekday()
+                .to_string()
+                .to_lowercase();
+            new_ucmd!()
+                .arg("-d")
+                .arg(format!("{} {}", direction, weekday))
+                .arg("--rfc-3339=seconds")
+                .arg("--utc")
+                .succeeds()
+                .stdout_str_check(|out| {
+                    let result = DateTime::parse_from_rfc3339(out.trim()).unwrap().to_utc();
+                    let expected = match (direction, offset) {
+                        ("last", _) => today - Duration::days(7 - offset),
+                        ("this", 0) => today,
+                        ("next", 0) => today + Duration::days(7),
+                        _ => today + Duration::days(offset),
+                    };
+                    result == expected
+                });
+        }
+    }
+}
+
 #[test]
 fn test_invalid_date_string() {
     new_ucmd!()
@@ -398,6 +491,32 @@ fn test_invalid_date_string() {
         .fails()
         .no_stdout()
         .stderr_contains("invalid date");
+
+    new_ucmd!()
+        .arg("-d")
+        // cSpell:disable
+        .arg("this fooday")
+        // cSpell:enable
+        .fails()
+        .no_stdout()
+        .stderr_contains("invalid date");
+}
+
+#[test]
+fn test_date_one_digit_date() {
+    new_ucmd!()
+        .env("TZ", "UTC0")
+        .arg("-d")
+        .arg("2000-1-1")
+        .succeeds()
+        .stdout_only("Sat Jan  1 00:00:00 UTC 2000\n");
+
+    new_ucmd!()
+        .env("TZ", "UTC0")
+        .arg("-d")
+        .arg("2000-1-4")
+        .succeeds()
+        .stdout_only("Tue Jan  4 00:00:00 UTC 2000\n");
 }
 
 #[test]
@@ -408,3 +527,48 @@ fn test_date_overflow() {
         .no_stdout()
         .stderr_contains("invalid date");
 }
+
+#[test]
+fn test_date_parse_from_format() {
+    const FILE: &str = "file-with-dates";
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.write(
+        FILE,
+        "2023-03-27 08:30:00\n\
+         2023-04-01 12:00:00\n\
+         2023-04-15 18:30:00",
+    );
+    ucmd.arg("-f")
+        .arg(at.plus(FILE))
+        .arg("+%Y-%m-%d %H:%M:%S")
+        .succeeds();
+}
+
+#[test]
+fn test_date_from_stdin() {
+    new_ucmd!()
+        .env("TZ", "UTC0")
+        .arg("-f")
+        .arg("-")
+        .pipe_in(
+            "2023-03-27 08:30:00\n\
+             2023-04-01 12:00:00\n\
+             2023-04-15 18:30:00\n",
+        )
+        .succeeds()
+        .stdout_is(
+            "Mon Mar 27 08:30:00 UTC 2023\n\
+             Sat Apr  1 12:00:00 UTC 2023\n\
+             Sat Apr 15 18:30:00 UTC 2023\n",
+        );
+}
+
+#[test]
+fn test_date_empty_tz() {
+    new_ucmd!()
+        .env("TZ", "")
+        .arg("+%Z")
+        .succeeds()
+        .stdout_only("UTC\n");
+}
diff --git a/tests/by-util/test_dd.rs b/tests/by-util/test_dd.rs
index fe38acca47b..b63905cbc7c 100644
--- a/tests/by-util/test_dd.rs
+++ b/tests/by-util/test_dd.rs
@@ -2,18 +2,29 @@
 //
 // 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, 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
+// 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 fifoname seekable
 
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+#[cfg(all(unix, not(feature = "feat_selinux")))]
+use uutests::util::run_ucmd_as_root_with_stdin_stdout;
 #[cfg(all(not(windows), feature = "printf"))]
-use crate::common::util::{UCommand, TESTS_BINARY};
+use uutests::util::{UCommand, get_tests_binary};
+use uutests::util_name;
 
 use regex::Regex;
+use uucore::io::OwnedFileDescriptorOrHandle;
 
 use std::fs::{File, OpenOptions};
 use std::io::{BufReader, Read, Write};
 use std::path::PathBuf;
-#[cfg(all(unix, not(target_os = "macos"), not(target_os = "freebsd")))]
+#[cfg(all(
+    unix,
+    not(target_os = "macos"),
+    not(target_os = "freebsd"),
+    feature = "printf"
+))]
 use std::process::{Command, Stdio};
 #[cfg(not(windows))]
 use std::thread::sleep;
@@ -22,27 +33,25 @@ use std::time::Duration;
 use tempfile::tempfile;
 
 macro_rules! inf {
-    ($fname:expr) => {{
-        &format!("if={}", $fname)
-    }};
+    ($fname:expr) => {
+        format!("if={}", $fname)
+    };
 }
 
 macro_rules! of {
-    ($fname:expr) => {{
-        &format!("of={}", $fname)
-    }};
+    ($fname:expr) => {
+        format!("of={}", $fname)
+    };
 }
 
 macro_rules! fixture_path {
-    ($fname:expr) => {{
-        PathBuf::from(format!("./tests/fixtures/dd/{}", $fname))
-    }};
+    ($fname:expr) => {{ PathBuf::from(format!("./tests/fixtures/dd/{}", $fname)) }};
 }
 
 macro_rules! assert_fixture_exists {
     ($fname:expr) => {{
         let fpath = fixture_path!($fname);
-        assert!(fpath.exists(), "Fixture missing: {:?}", fpath);
+        assert!(fpath.exists(), "Fixture missing: {fpath:?}");
     }};
 }
 
@@ -50,7 +59,7 @@ macro_rules! assert_fixture_exists {
 macro_rules! assert_fixture_not_exists {
     ($fname:expr) => {{
         let fpath = PathBuf::from(format!("./fixtures/dd/{}", $fname));
-        assert!(!fpath.exists(), "Fixture present: {:?}", fpath);
+        assert!(!fpath.exists(), "Fixture present: {fpath:?}");
     }};
 }
 
@@ -91,7 +100,7 @@ fn build_ascii_block(n: usize) -> Vec<u8> {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 // Sanity Tests
@@ -112,8 +121,7 @@ fn test_stdin_stdout() {
     new_ucmd!()
         .args(&["status=none"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
+        .succeeds()
         .stdout_only(output);
 }
 
@@ -127,8 +135,7 @@ fn test_stdin_stdout_count() {
     new_ucmd!()
         .args(&["status=none", "count=2", "ibs=128"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
+        .succeeds()
         .stdout_only(output);
 }
 
@@ -140,8 +147,7 @@ fn test_stdin_stdout_count_bytes() {
     new_ucmd!()
         .args(&["status=none", "count=256", "iflag=count_bytes"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
+        .succeeds()
         .stdout_only(output);
 }
 
@@ -153,8 +159,7 @@ fn test_stdin_stdout_skip() {
     new_ucmd!()
         .args(&["status=none", "skip=2", "ibs=128"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
+        .succeeds()
         .stdout_only(output);
 }
 
@@ -166,8 +171,7 @@ fn test_stdin_stdout_skip_bytes() {
     new_ucmd!()
         .args(&["status=none", "skip=256", "ibs=128", "iflag=skip_bytes"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
+        .succeeds()
         .stdout_only(output);
 }
 
@@ -178,10 +182,8 @@ fn test_stdin_stdout_skip_w_multiplier() {
     new_ucmd!()
         .args(&["status=none", "skip=5K", "iflag=skip_bytes"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
-        .stdout_is(output)
-        .success();
+        .succeeds()
+        .stdout_is(output);
 }
 
 #[test]
@@ -191,10 +193,8 @@ fn test_stdin_stdout_count_w_multiplier() {
     new_ucmd!()
         .args(&["status=none", "count=2KiB", "iflag=count_bytes"])
         .pipe_in(input)
-        .run()
-        .no_stderr()
-        .stdout_is(output)
-        .success();
+        .succeeds()
+        .stdout_only(output);
 }
 
 #[test]
@@ -268,11 +268,10 @@ fn test_final_stats_noxfer() {
 #[test]
 fn test_final_stats_unspec() {
     new_ucmd!()
-        .run()
+        .succeeds()
         .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();
+        .stderr_matches(&Regex::new(r"\d(\.\d+)?(e-\d\d)? s, ").unwrap())
+        .stderr_contains("0.0 B/s");
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -296,11 +295,11 @@ fn test_noatime_does_not_update_infile_atime() {
     assert_fixture_exists!(&fname);
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", "iflag=noatime", inf!(fname)]);
+    ucmd.args(&["status=none", "iflag=noatime", &inf!(fname)]);
 
     let pre_atime = fix.metadata(fname).accessed().unwrap();
 
-    ucmd.run().no_stderr().success();
+    ucmd.succeeds().no_output();
 
     let post_atime = fix.metadata(fname).accessed().unwrap();
     assert_eq!(pre_atime, post_atime);
@@ -316,11 +315,11 @@ fn test_noatime_does_not_update_ofile_atime() {
     assert_fixture_exists!(&fname);
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", "oflag=noatime", of!(fname)]);
+    ucmd.args(&["status=none", "oflag=noatime", &of!(fname)]);
 
     let pre_atime = fix.metadata(fname).accessed().unwrap();
 
-    ucmd.pipe_in("").run().no_stderr().success();
+    ucmd.pipe_in("").succeeds().no_output();
 
     let post_atime = fix.metadata(fname).accessed().unwrap();
     assert_eq!(pre_atime, post_atime);
@@ -333,7 +332,7 @@ fn test_nocreat_causes_failure_when_outfile_not_present() {
     assert_fixture_not_exists!(&fname);
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["conv=nocreat", of!(&fname)])
+    ucmd.args(&["conv=nocreat", &of!(&fname)])
         .pipe_in("")
         .fails()
         .stderr_only(
@@ -353,11 +352,9 @@ fn test_notrunc_does_not_truncate() {
     }
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", "conv=notrunc", of!(&fname), "if=null.txt"])
-        .run()
-        .no_stdout()
-        .no_stderr()
-        .success();
+    ucmd.args(&["status=none", "conv=notrunc", &of!(&fname), "if=null.txt"])
+        .succeeds()
+        .no_output();
 
     assert_eq!(256, fix.metadata(fname).len());
 }
@@ -373,11 +370,9 @@ fn test_existing_file_truncated() {
     }
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", "if=null.txt", of!(fname)])
-        .run()
-        .no_stdout()
-        .no_stderr()
-        .success();
+    ucmd.args(&["status=none", "if=null.txt", &of!(fname)])
+        .succeeds()
+        .no_output();
 
     assert_eq!(0, fix.metadata(fname).len());
 }
@@ -386,21 +381,18 @@ fn test_existing_file_truncated() {
 fn test_null_stats() {
     new_ucmd!()
         .arg("if=null.txt")
-        .run()
+        .succeeds()
         .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();
+        .stderr_matches(&Regex::new(r"\d(\.\d+)?(e-\d\d)? s, ").unwrap())
+        .stderr_contains("0.0 B/s");
 }
 
 #[test]
 fn test_null_fullblock() {
     new_ucmd!()
         .args(&["if=null.txt", "status=none", "iflag=fullblock"])
-        .run()
-        .no_stdout()
-        .no_stderr()
-        .success();
+        .succeeds()
+        .no_output();
 }
 
 #[cfg(unix)]
@@ -408,7 +400,7 @@ fn test_null_fullblock() {
 #[test]
 fn test_fullblock() {
     let tname = "fullblock-from-urand";
-    let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
+    let tmp_fn = format!("TESTFILE-{tname}.tmp");
     let exp_stats = vec![
         "1+0 records in\n",
         "1+0 records out\n",
@@ -422,7 +414,7 @@ fn test_fullblock() {
     let ucmd = new_ucmd!()
         .args(&[
             "if=/dev/urandom",
-            of!(&tmp_fn),
+            &of!(&tmp_fn),
             "bs=128M",
             // Note: In order for this test to actually test iflag=fullblock, the bs=VALUE
             // must be big enough to 'overwhelm' the urandom store of bytes.
@@ -433,8 +425,7 @@ fn test_fullblock() {
             "count=1",
             "iflag=fullblock",
         ])
-        .run();
-    ucmd.success();
+        .succeeds();
 
     let run_stats = &ucmd.stderr()[..exp_stats.len()];
     assert_eq!(exp_stats, run_stats);
@@ -448,10 +439,8 @@ fn test_ys_to_stdout() {
 
     new_ucmd!()
         .args(&["status=none", "if=y-nl-1k.txt"])
-        .run()
-        .no_stderr()
-        .stdout_is(output)
-        .success();
+        .succeeds()
+        .stdout_only(output);
 }
 
 #[test]
@@ -460,10 +449,8 @@ fn test_zeros_to_stdout() {
     let output = String::from_utf8(output).unwrap();
     new_ucmd!()
         .args(&["status=none", "if=zero-256k.txt"])
-        .run()
-        .no_stderr()
-        .stdout_is(output)
-        .success();
+        .succeeds()
+        .stdout_only(output);
 }
 
 #[cfg(target_pointer_width = "32")]
@@ -471,12 +458,11 @@ fn test_zeros_to_stdout() {
 fn test_oversized_bs_32_bit() {
     for bs_param in ["bs", "ibs", "obs", "cbs"] {
         new_ucmd!()
-            .args(&[format!("{}=5GB", bs_param)])
-            .run()
+            .args(&[format!("{bs_param}=5GB")])
+            .fails()
             .no_stdout()
-            .failure()
             .code_is(1)
-            .stderr_is(format!("dd: {}=N cannot fit into memory\n", bs_param));
+            .stderr_is(format!("dd: {bs_param}=N cannot fit into memory\n"));
     }
 }
 
@@ -487,10 +473,8 @@ fn test_to_stdout_with_ibs_obs() {
 
     new_ucmd!()
         .args(&["status=none", "if=y-nl-1k.txt", "ibs=521", "obs=1031"])
-        .run()
-        .no_stderr()
-        .stdout_is(output)
-        .success();
+        .succeeds()
+        .stdout_only(output);
 }
 
 #[test]
@@ -501,25 +485,21 @@ fn test_ascii_10k_to_stdout() {
 
     new_ucmd!()
         .args(&["status=none", "if=ascii-10k.txt"])
-        .run()
-        .no_stderr()
-        .stdout_is(output)
-        .success();
+        .succeeds()
+        .stdout_only(output);
 }
 
 #[test]
 fn test_zeros_to_file() {
     let tname = "zero-256k";
     let test_fn = format!("{tname}.txt");
-    let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
+    let tmp_fn = format!("TESTFILE-{tname}.tmp");
     assert_fixture_exists!(test_fn);
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", inf!(test_fn), of!(tmp_fn)])
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .success();
+    ucmd.args(&["status=none", &inf!(test_fn), &of!(tmp_fn)])
+        .succeeds()
+        .no_output();
 
     cmp_file!(
         File::open(fixture_path!(&test_fn)).unwrap(),
@@ -531,21 +511,19 @@ fn test_zeros_to_file() {
 fn test_to_file_with_ibs_obs() {
     let tname = "zero-256k";
     let test_fn = format!("{tname}.txt");
-    let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
+    let tmp_fn = format!("TESTFILE-{tname}.tmp");
     assert_fixture_exists!(test_fn);
 
     let (fix, mut ucmd) = at_and_ucmd!();
     ucmd.args(&[
         "status=none",
-        inf!(test_fn),
-        of!(tmp_fn),
+        &inf!(test_fn),
+        &of!(tmp_fn),
         "ibs=222",
         "obs=111",
     ])
-    .run()
-    .no_stderr()
-    .no_stdout()
-    .success();
+    .succeeds()
+    .no_output();
 
     cmp_file!(
         File::open(fixture_path!(&test_fn)).unwrap(),
@@ -557,15 +535,13 @@ fn test_to_file_with_ibs_obs() {
 fn test_ascii_521k_to_file() {
     let tname = "ascii-521k";
     let input = build_ascii_block(512 * 1024);
-    let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
+    let tmp_fn = format!("TESTFILE-{tname}.tmp");
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", of!(tmp_fn)])
+    ucmd.args(&["status=none", &of!(tmp_fn)])
         .pipe_in(input.clone())
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .success();
+        .succeeds()
+        .no_output();
 
     assert_eq!(512 * 1024, fix.metadata(&tmp_fn).len());
 
@@ -584,7 +560,7 @@ fn test_ascii_521k_to_file() {
 #[test]
 fn test_ascii_5_gibi_to_file() {
     let tname = "ascii-5G";
-    let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
+    let tmp_fn = format!("TESTFILE-{tname}.tmp");
 
     let (fix, mut ucmd) = at_and_ucmd!();
     ucmd.args(&[
@@ -592,12 +568,10 @@ fn test_ascii_5_gibi_to_file() {
         "count=5G",
         "iflag=count_bytes",
         "if=/dev/zero",
-        of!(tmp_fn),
+        &of!(tmp_fn),
     ])
-    .run()
-    .no_stderr()
-    .no_stdout()
-    .success();
+    .succeeds()
+    .no_output();
 
     assert_eq!(5 * 1024 * 1024 * 1024, fix.metadata(&tmp_fn).len());
 }
@@ -608,12 +582,12 @@ fn test_self_transfer() {
     assert_fixture_exists!(fname);
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", "conv=notrunc", inf!(fname), of!(fname)]);
+    ucmd.args(&["status=none", "conv=notrunc", &inf!(fname), &of!(fname)]);
 
     assert!(fix.file_exists(fname));
     assert_eq!(256 * 1024, fix.metadata(fname).len());
 
-    ucmd.run().no_stdout().no_stderr().success();
+    ucmd.succeeds().no_output();
 
     assert!(fix.file_exists(fname));
     assert_eq!(256 * 1024, fix.metadata(fname).len());
@@ -623,15 +597,13 @@ fn test_self_transfer() {
 fn test_unicode_filenames() {
     let tname = "😎💚🦊";
     let test_fn = format!("{tname}.txt");
-    let tmp_fn = format!("TESTFILE-{}.tmp", &tname);
+    let tmp_fn = format!("TESTFILE-{tname}.tmp");
     assert_fixture_exists!(test_fn);
 
     let (fix, mut ucmd) = at_and_ucmd!();
-    ucmd.args(&["status=none", inf!(test_fn), of!(tmp_fn)])
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .success();
+    ucmd.args(&["status=none", &inf!(test_fn), &of!(tmp_fn)])
+        .succeeds()
+        .no_output();
 
     cmp_file!(
         File::open(fixture_path!(&test_fn)).unwrap(),
@@ -1398,6 +1370,36 @@ fn test_bytes_suffix() {
         .stdout_only("\0\0\0abcdef");
 }
 
+#[test]
+// the recursive nature of the suffix allows any string with a 'B' in it treated as bytes.
+fn test_bytes_suffix_recursive() {
+    new_ucmd!()
+        .args(&["count=2Bx2", "status=none"])
+        .pipe_in("abcdef")
+        .succeeds()
+        .stdout_only("abcd");
+    new_ucmd!()
+        .args(&["skip=2Bx2", "status=none"])
+        .pipe_in("abcdef")
+        .succeeds()
+        .stdout_only("ef");
+    new_ucmd!()
+        .args(&["iseek=2Bx2", "status=none"])
+        .pipe_in("abcdef")
+        .succeeds()
+        .stdout_only("ef");
+    new_ucmd!()
+        .args(&["seek=2Bx2", "status=none"])
+        .pipe_in("abcdef")
+        .succeeds()
+        .stdout_only("\0\0\0\0abcdef");
+    new_ucmd!()
+        .args(&["oseek=2Bx2", "status=none"])
+        .pipe_in("abcdef")
+        .succeeds()
+        .stdout_only("\0\0\0\0abcdef");
+}
+
 /// Test for "conv=sync" with a slow reader.
 #[cfg(not(windows))]
 #[test]
@@ -1457,74 +1459,48 @@ fn test_sparse() {
     assert_eq!(at.metadata("infile").len(), at.metadata("outfile").len());
 }
 
-// TODO These FIFO tests should work on macos, but some issue is
-// causing our implementation of dd to wait indefinitely when it
-// shouldn't.
-
 /// Test that a seek on an output FIFO results in a read.
 #[test]
-#[cfg(all(unix, not(target_os = "macos"), not(target_os = "freebsd")))]
+#[cfg(unix)]
 fn test_seek_output_fifo() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
     at.mkfifo("fifo");
 
-    // TODO When `dd` is a bit more advanced, we could use the uutils
-    // version of dd here as well.
-    let child = Command::new("dd")
-        .current_dir(&at.subdir)
-        .args([
-            "count=1",
-            "if=/dev/zero",
-            &format!("of={}", at.plus_as_string("fifo")),
-            "status=noxfer",
-        ])
-        .stderr(Stdio::piped())
-        .spawn()
-        .expect("failed to execute child process");
-
-    ts.ucmd()
+    let mut ucmd = ts.ucmd();
+    let child = ucmd
         .args(&["count=0", "seek=1", "of=fifo", "status=noxfer"])
-        .succeeds()
-        .stderr_only("0+0 records in\n0+0 records out\n");
+        .run_no_wait();
 
-    let output = child.wait_with_output().unwrap();
-    assert!(output.status.success());
-    assert!(output.stdout.is_empty());
-    assert_eq!(&output.stderr, b"1+0 records in\n1+0 records out\n");
+    std::fs::write(at.plus("fifo"), vec![0; 512]).unwrap();
+
+    child
+        .wait()
+        .unwrap()
+        .success()
+        .stderr_only("0+0 records in\n0+0 records out\n");
 }
 
 /// Test that a skip on an input FIFO results in a read.
 #[test]
-#[cfg(all(unix, not(target_os = "macos"), not(target_os = "freebsd")))]
+#[cfg(unix)]
 fn test_skip_input_fifo() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
     at.mkfifo("fifo");
 
-    // TODO When `dd` is a bit more advanced, we could use the uutils
-    // version of dd here as well.
-    let child = Command::new("dd")
-        .current_dir(&at.subdir)
-        .args([
-            "count=1",
-            "if=/dev/zero",
-            &format!("of={}", at.plus_as_string("fifo")),
-            "status=noxfer",
-        ])
-        .stderr(Stdio::piped())
-        .spawn()
-        .expect("failed to execute child process");
-
-    ts.ucmd()
+    let mut ucmd = ts.ucmd();
+    let child = ucmd
         .args(&["count=0", "skip=1", "if=fifo", "status=noxfer"])
-        .succeeds()
-        .stderr_only("0+0 records in\n0+0 records out\n");
+        .run_no_wait();
 
-    let output = child.wait_with_output().unwrap();
-    assert!(output.status.success());
-    assert!(output.stdout.is_empty());
-    assert_eq!(&output.stderr, b"1+0 records in\n1+0 records out\n");
+    std::fs::write(at.plus("fifo"), vec![0; 512]).unwrap();
+
+    child
+        .wait()
+        .unwrap()
+        .success()
+        .stderr_only("0+0 records in\n0+0 records out\n");
 }
 
 /// Test for reading part of stdin from each of two child processes.
@@ -1532,9 +1508,9 @@ fn test_skip_input_fifo() {
 #[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");
+    let printf = format!("{} printf 'abcdef\n'", get_tests_binary());
+    let dd_skip = format!("{} dd bs=1 skip=3 count=0", get_tests_binary());
+    let dd = format!("{} dd", get_tests_binary());
     UCommand::new()
         .arg(format!("{printf} | ( {dd_skip} && {dd} ) 2> /dev/null"))
         .succeeds()
@@ -1551,11 +1527,19 @@ fn test_nocache_stdin_error() {
     let detail = "Invalid seek";
     new_ucmd!()
         .args(&["iflag=nocache", "count=0", "status=noxfer"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_only(format!("dd: failed to discard cache for: 'standard input': {detail}\n0+0 records in\n0+0 records out\n"));
 }
 
+/// Test that dd fails when no number in count.
+#[test]
+fn test_empty_count_number() {
+    new_ucmd!()
+        .args(&["count=B"])
+        .fails_with_code(1)
+        .stderr_only("dd: invalid number: ‘B’\n");
+}
+
 /// Test for discarding system file cache.
 #[test]
 #[cfg(target_os = "linux")]
@@ -1566,3 +1550,227 @@ fn test_nocache_file() {
         .succeeds()
         .stderr_only("2048+0 records in\n2048+0 records out\n");
 }
+
+#[test]
+#[cfg(unix)]
+#[cfg(not(feature = "feat_selinux"))]
+// Disabled on SELinux for now
+fn test_skip_past_dev() {
+    // NOTE: This test intends to trigger code which can only be reached with root permissions.
+    let ts = TestScenario::new(util_name!());
+
+    if let Ok(result) = run_ucmd_as_root_with_stdin_stdout(
+        &ts,
+        &["bs=1", "skip=10000000000000000", "count=0", "status=noxfer"],
+        Some("/dev/sda1"),
+        None,
+    ) {
+        result.stderr_contains("dd: 'standard input': cannot skip: Invalid argument");
+        result.stderr_contains("0+0 records in");
+        result.stderr_contains("0+0 records out");
+        result.code_is(1);
+    } else {
+        print!("Test skipped; requires root user");
+    }
+}
+
+#[test]
+#[cfg(unix)]
+#[cfg(not(feature = "feat_selinux"))]
+fn test_seek_past_dev() {
+    // NOTE: This test intends to trigger code which can only be reached with root permissions.
+    let ts = TestScenario::new(util_name!());
+
+    if let Ok(result) = run_ucmd_as_root_with_stdin_stdout(
+        &ts,
+        &["bs=1", "seek=10000000000000000", "count=0", "status=noxfer"],
+        None,
+        Some("/dev/sda1"),
+    ) {
+        result.stderr_contains("dd: 'standard output': cannot seek: Invalid argument");
+        result.stderr_contains("0+0 records in");
+        result.stderr_contains("0+0 records out");
+        result.code_is(1);
+    } else {
+        print!("Test skipped; requires root user");
+    }
+}
+
+#[test]
+#[cfg(all(
+    unix,
+    not(target_os = "macos"),
+    not(target_os = "freebsd"),
+    feature = "printf"
+))]
+fn test_reading_partial_blocks_from_fifo() {
+    // Create the FIFO.
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkfifo("fifo");
+    let fifoname = at.plus_as_string("fifo");
+
+    // Start a `dd` process that reads from the fifo (so it will wait
+    // until the writer process starts).
+    let mut reader_command = Command::new(get_tests_binary());
+    let child = reader_command
+        .args(["dd", "ibs=3", "obs=3", &format!("if={fifoname}")])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+    // Start different processes to write to the FIFO, with a small
+    // pause in between.
+    let mut writer_command = Command::new("sh");
+    let _ = writer_command
+        .args([
+            "-c",
+            &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {fifoname}"),
+        ])
+        .spawn()
+        .unwrap()
+        .wait();
+
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.stdout, b"abcd");
+    let expected = b"0+2 records in\n1+1 records out\n4 bytes copied";
+    assert!(output.stderr.starts_with(expected));
+}
+
+#[test]
+#[cfg(all(
+    unix,
+    not(target_os = "macos"),
+    not(target_os = "freebsd"),
+    feature = "printf"
+))]
+fn test_reading_partial_blocks_from_fifo_unbuffered() {
+    // Create the FIFO.
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkfifo("fifo");
+    let fifoname = at.plus_as_string("fifo");
+
+    // Start a `dd` process that reads from the fifo (so it will wait
+    // until the writer process starts).
+    //
+    // `bs=N` takes precedence over `ibs=N` and `obs=N`.
+    let mut reader_command = Command::new(get_tests_binary());
+    let child = reader_command
+        .args(["dd", "bs=3", "ibs=1", "obs=1", &format!("if={fifoname}")])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+    // Start different processes to write to the FIFO, with a small
+    // pause in between.
+    let mut writer_command = Command::new("sh");
+    let _ = writer_command
+        .args([
+            "-c",
+            &format!("(printf \"ab\"; sleep 0.1; printf \"cd\") > {fifoname}"),
+        ])
+        .spawn()
+        .unwrap()
+        .wait();
+
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.stdout, b"abcd");
+    let expected = b"0+2 records in\n0+2 records out\n4 bytes copied";
+    assert!(output.stderr.starts_with(expected));
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_iflag_directory_fails_when_file_is_passed_via_std_in() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.make_file("input");
+    let filename = at.plus_as_string("input");
+    new_ucmd!()
+        .args(&["iflag=directory", "count=0"])
+        .set_stdin(std::process::Stdio::from(File::open(filename).unwrap()))
+        .fails()
+        .stderr_only("dd: setting flags for 'standard input': Not a directory\n");
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_iflag_directory_passes_when_dir_is_redirected() {
+    new_ucmd!()
+        .args(&["iflag=directory", "count=0"])
+        .set_stdin(std::process::Stdio::from(File::open(".").unwrap()))
+        .succeeds();
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn test_iflag_directory_fails_when_file_is_piped_via_std_in() {
+    new_ucmd!()
+        .arg("iflag=directory")
+        .pipe_in("")
+        .fails()
+        .stderr_only("dd: setting flags for 'standard input': Not a directory\n");
+}
+
+#[test]
+fn test_stdin_stdout_not_rewound_even_when_connected_to_seekable_file() {
+    use std::process::Stdio;
+
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.write("in", "abcde");
+
+    let stdin = OwnedFileDescriptorOrHandle::open_file(
+        OpenOptions::new().read(true),
+        at.plus("in").as_path(),
+    )
+    .unwrap();
+    let stdout = OwnedFileDescriptorOrHandle::open_file(
+        OpenOptions::new().create(true).write(true),
+        at.plus("out").as_path(),
+    )
+    .unwrap();
+    let stderr = OwnedFileDescriptorOrHandle::open_file(
+        OpenOptions::new().create(true).write(true),
+        at.plus("err").as_path(),
+    )
+    .unwrap();
+
+    ts.ucmd()
+        .args(&["bs=1", "skip=1", "count=1"])
+        .set_stdin(Stdio::from(stdin.try_clone().unwrap()))
+        .set_stdout(Stdio::from(stdout.try_clone().unwrap()))
+        .set_stderr(Stdio::from(stderr.try_clone().unwrap()))
+        .succeeds();
+
+    ts.ucmd()
+        .args(&["bs=1", "skip=1"])
+        .set_stdin(stdin)
+        .set_stdout(stdout)
+        .set_stderr(stderr)
+        .succeeds();
+
+    let err_file_content = std::fs::read_to_string(at.plus_as_string("err")).unwrap();
+    println!("stderr:\n{err_file_content}");
+
+    let out_file_content = std::fs::read_to_string(at.plus_as_string("out")).unwrap();
+    println!("stdout:\n{out_file_content}");
+    assert_eq!(out_file_content, "bde");
+}
+
+#[test]
+fn test_wrong_number_err_msg() {
+    new_ucmd!()
+        .args(&["count=kBb"])
+        .fails()
+        .stderr_contains("dd: invalid number: ‘kBb’\n");
+
+    new_ucmd!()
+        .args(&["count=1kBb555"])
+        .fails()
+        .stderr_contains("dd: invalid number: ‘1kBb555’\n");
+}
diff --git a/tests/by-util/test_df.rs b/tests/by-util/test_df.rs
index 227121ef4df..d9d63296153 100644
--- a/tests/by-util/test_df.rs
+++ b/tests/by-util/test_df.rs
@@ -3,13 +3,24 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore udev pcent iuse itotal iused ipcent
+#![allow(
+    clippy::similar_names,
+    clippy::cast_possible_truncation,
+    clippy::cast_sign_loss,
+    clippy::float_cmp
+)]
+
 use std::collections::HashSet;
 
-use crate::common::util::TestScenario;
+#[cfg(not(any(target_os = "freebsd", target_os = "windows")))]
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -179,13 +190,28 @@ fn test_default_headers() {
 }
 
 #[test]
-fn test_precedence_of_human_readable_header_over_output_header() {
+fn test_precedence_of_human_readable_and_si_header_over_output_header() {
+    let args = ["-h", "--human-readable", "-H", "--si"];
+
+    for arg in args {
+        let output = new_ucmd!()
+            .args(&[arg, "--output=size"])
+            .succeeds()
+            .stdout_move_str();
+        let header = output.lines().next().unwrap();
+        assert_eq!(header, " Size");
+    }
+}
+
+#[test]
+fn test_used_header_starts_with_space() {
     let output = new_ucmd!()
-        .args(&["-H", "--output=size"])
+        // using -h here to ensure the width of the column's content is <= 4
+        .args(&["-h", "--output=used"])
         .succeeds()
         .stdout_move_str();
-    let header = output.lines().next().unwrap().to_string();
-    assert_eq!(header.trim(), "Size");
+    let header = output.lines().next().unwrap();
+    assert_eq!(header, " Used");
 }
 
 #[test]
@@ -263,6 +289,7 @@ fn test_type_option() {
 
 #[test]
 #[cfg(not(any(target_os = "freebsd", target_os = "windows")))] // FIXME: fix test for FreeBSD & Win
+#[cfg(not(feature = "feat_selinux"))]
 fn test_type_option_with_file() {
     let fs_type = new_ucmd!()
         .args(&["--output=fstype", "."])
@@ -276,6 +303,12 @@ fn test_type_option_with_file() {
         .fails()
         .stderr_contains("no file systems processed");
 
+    // Assume the mount point at /dev has a different filesystem type to the mount point at /
+    new_ucmd!()
+        .args(&["-t", fs_type, "/dev"])
+        .fails()
+        .stderr_contains("no file systems processed");
+
     let fs_types = new_ucmd!()
         .arg("--output=fstype")
         .succeeds()
@@ -335,6 +368,10 @@ fn test_include_exclude_same_type() {
         );
 }
 
+#[cfg_attr(
+    all(target_arch = "aarch64", target_os = "linux"),
+    ignore = "Issue #7158 - Test not supported on ARM64 Linux"
+)]
 #[test]
 fn test_total() {
     // Example output:
@@ -422,7 +459,11 @@ fn test_total_label_in_correct_column() {
 #[test]
 fn test_use_percentage() {
     let output = new_ucmd!()
-        .args(&["--total", "--output=used,avail,pcent"])
+        // set block size = 1, otherwise the returned values for
+        // "used" and "avail" will be rounded. And using them to calculate
+        // the "percentage" values might lead to a mismatch with the returned
+        // "percentage" values.
+        .args(&["--total", "--output=used,avail,pcent", "--block-size=1"])
         .succeeds()
         .stdout_move_str();
 
diff --git a/tests/by-util/test_dir.rs b/tests/by-util/test_dir.rs
index 3d16f8a67c6..ef455c6bd8e 100644
--- a/tests/by-util/test_dir.rs
+++ b/tests/by-util/test_dir.rs
@@ -2,8 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
 use regex::Regex;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 /*
  * 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 d4fa0a3b0a3..28722f2e33e 100644
--- a/tests/by-util/test_dircolors.rs
+++ b/tests/by-util/test_dircolors.rs
@@ -2,39 +2,59 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore overridable
-use crate::common::util::TestScenario;
+// spell-checker:ignore overridable colorterm
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
-use dircolors::{guess_syntax, OutputFmt, StrUtils};
+use dircolors::{OutputFmt, StrUtils, guess_syntax};
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_shell_syntax() {
     use std::env;
     let last = env::var("SHELL");
-    env::set_var("SHELL", "/path/csh");
+    unsafe {
+        env::set_var("SHELL", "/path/csh");
+    }
     assert_eq!(OutputFmt::CShell, guess_syntax());
-    env::set_var("SHELL", "csh");
+    unsafe {
+        env::set_var("SHELL", "csh");
+    }
     assert_eq!(OutputFmt::CShell, guess_syntax());
-    env::set_var("SHELL", "/path/bash");
+    unsafe {
+        env::set_var("SHELL", "/path/bash");
+    }
     assert_eq!(OutputFmt::Shell, guess_syntax());
-    env::set_var("SHELL", "bash");
+    unsafe {
+        env::set_var("SHELL", "bash");
+    }
     assert_eq!(OutputFmt::Shell, guess_syntax());
-    env::set_var("SHELL", "/asd/bar");
+    unsafe {
+        env::set_var("SHELL", "/asd/bar");
+    }
     assert_eq!(OutputFmt::Shell, guess_syntax());
-    env::set_var("SHELL", "foo");
+    unsafe {
+        env::set_var("SHELL", "foo");
+    }
     assert_eq!(OutputFmt::Shell, guess_syntax());
-    env::set_var("SHELL", "");
+    unsafe {
+        env::set_var("SHELL", "");
+    }
     assert_eq!(OutputFmt::Unknown, guess_syntax());
-    env::remove_var("SHELL");
+    unsafe {
+        env::remove_var("SHELL");
+    }
     assert_eq!(OutputFmt::Unknown, guess_syntax());
 
     if let Ok(s) = last {
-        env::set_var("SHELL", s);
+        unsafe {
+            env::set_var("SHELL", s);
+        }
     }
 }
 
@@ -66,7 +86,7 @@ fn test_keywords() {
 fn test_internal_db() {
     new_ucmd!()
         .arg("-p")
-        .run()
+        .succeeds()
         .stdout_is_fixture("internal.expected");
 }
 
@@ -74,7 +94,7 @@ fn test_internal_db() {
 fn test_ls_colors() {
     new_ucmd!()
         .arg("--print-ls-colors")
-        .run()
+        .succeeds()
         .stdout_is_fixture("ls_colors.expected");
 }
 
@@ -83,7 +103,7 @@ fn test_bash_default() {
     new_ucmd!()
         .env("TERM", "screen")
         .arg("-b")
-        .run()
+        .succeeds()
         .stdout_is_fixture("bash_def.expected");
 }
 
@@ -92,7 +112,7 @@ fn test_csh_default() {
     new_ucmd!()
         .env("TERM", "screen")
         .arg("-c")
-        .run()
+        .succeeds()
         .stdout_is_fixture("csh_def.expected");
 }
 #[test]
@@ -100,12 +120,12 @@ fn test_overridable_args() {
     new_ucmd!()
         .env("TERM", "screen")
         .arg("-bc")
-        .run()
+        .succeeds()
         .stdout_is_fixture("csh_def.expected");
     new_ucmd!()
         .env("TERM", "screen")
         .arg("-cb")
-        .run()
+        .succeeds()
         .stdout_is_fixture("bash_def.expected");
 }
 
@@ -159,6 +179,18 @@ fn test_quoting() {
         .no_stderr();
 }
 
+/*
+#[test]
+fn test_print_ls_colors() {
+    new_ucmd!()
+        .pipe_in("OWT 40;33\n")
+        .args(&["--print-ls-colors"])
+        .succeeds()
+        .stdout_is("\x1B[40;33mtw\t40;33\x1B[0m\n")
+        .no_stderr();
+}
+*/
+
 #[test]
 fn test_extra_operand() {
     new_ucmd!()
@@ -188,15 +220,15 @@ TERM {term_pattern}
             .no_stderr();
     }
 
-    let expectation_if_match = r#"
+    let expectation_if_match = r"
 LS_COLORS='*.term_matching=00;38;5;61:';
 export LS_COLORS
-"#
+"
     .trim_start();
-    let expectation_if_no_match = r#"
+    let expectation_if_no_match = r"
 LS_COLORS='';
 export LS_COLORS
-"#
+"
     .trim_start();
 
     // sanity checks
@@ -214,14 +246,14 @@ fn test_helper(file_name: &str, term: &str) {
         .env("TERM", term)
         .arg("-c")
         .arg(format!("{file_name}.txt"))
-        .run()
+        .succeeds()
         .stdout_is_fixture(format!("{file_name}.csh.expected"));
 
     new_ucmd!()
         .env("TERM", term)
         .arg("-b")
         .arg(format!("{file_name}.txt"))
-        .run()
+        .succeeds()
         .stdout_is_fixture(format!("{file_name}.sh.expected"));
 }
 
@@ -234,3 +266,21 @@ fn test_dircolors_for_dir_as_file() {
         "dircolors: expected file, got directory '/'",
     );
 }
+
+#[test]
+fn test_repeated() {
+    for arg in ["-b", "-c", "--print-database", "--print-ls-colors"] {
+        new_ucmd!().arg(arg).arg(arg).succeeds().no_stderr();
+    }
+}
+
+#[test]
+fn test_colorterm_empty_with_wildcard() {
+    new_ucmd!()
+        .env("COLORTERM", "")
+        .pipe_in("COLORTERM ?*\nowt 40;33\n")
+        .args(&["-b", "-"])
+        .succeeds()
+        .stdout_is("LS_COLORS='';\nexport LS_COLORS\n")
+        .no_stderr();
+}
diff --git a/tests/by-util/test_dirname.rs b/tests/by-util/test_dirname.rs
index 8471b48c44b..3b8aee37d7b 100644
--- a/tests/by-util/test_dirname.rs
+++ b/tests/by-util/test_dirname.rs
@@ -2,18 +2,20 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_path_with_trailing_slashes() {
     new_ucmd!()
         .arg("/root/alpha/beta/gamma/delta/epsilon/omega//")
-        .run()
+        .succeeds()
         .stdout_is("/root/alpha/beta/gamma/delta/epsilon\n");
 }
 
@@ -21,7 +23,7 @@ fn test_path_with_trailing_slashes() {
 fn test_path_without_trailing_slashes() {
     new_ucmd!()
         .arg("/root/alpha/beta/gamma/delta/epsilon/omega")
-        .run()
+        .succeeds()
         .stdout_is("/root/alpha/beta/gamma/delta/epsilon\n");
 }
 
@@ -40,17 +42,27 @@ fn test_path_without_trailing_slashes_and_zero() {
         .stdout_is("/root/alpha/beta/gamma/delta/epsilon\u{0}");
 }
 
+#[test]
+fn test_repeated_zero() {
+    new_ucmd!()
+        .arg("--zero")
+        .arg("--zero")
+        .arg("foo/bar")
+        .succeeds()
+        .stdout_only("foo\u{0}");
+}
+
 #[test]
 fn test_root() {
-    new_ucmd!().arg("/").run().stdout_is("/\n");
+    new_ucmd!().arg("/").succeeds().stdout_is("/\n");
 }
 
 #[test]
 fn test_pwd() {
-    new_ucmd!().arg(".").run().stdout_is(".\n");
+    new_ucmd!().arg(".").succeeds().stdout_is(".\n");
 }
 
 #[test]
 fn test_empty() {
-    new_ucmd!().arg("").run().stdout_is(".\n");
+    new_ucmd!().arg("").succeeds().stdout_is(".\n");
 }
diff --git a/tests/by-util/test_du.rs b/tests/by-util/test_du.rs
index 9a508da255e..48043a83117 100644
--- a/tests/by-util/test_du.rs
+++ b/tests/by-util/test_du.rs
@@ -3,52 +3,90 @@
 // 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 tsublink
+// spell-checker:ignore (paths) atim sublink subwords azerty azeaze xcwww azeaz amaz azea qzerty tazerty tsublink testfile1 testfile2 filelist fpath testdir testfile
 #[cfg(not(windows))]
 use regex::Regex;
-#[cfg(not(windows))]
-use std::io::Write;
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
-use crate::common::util::expected_result;
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+#[cfg(not(target_os = "windows"))]
+use uutests::unwrap_or_return;
+use uutests::util::TestScenario;
+#[cfg(not(target_os = "windows"))]
+use uutests::util::expected_result;
+use uutests::util_name;
 
+#[cfg(not(target_os = "openbsd"))]
 const SUB_DIR: &str = "subdir/deeper";
 const SUB_DEEPER_DIR: &str = "subdir/deeper/deeper_dir";
 const SUB_DIR_LINKS: &str = "subdir/links";
 const SUB_DIR_LINKS_DEEPER_SYM_DIR: &str = "subdir/links/deeper_dir";
+#[cfg(not(target_os = "openbsd"))]
 const SUB_FILE: &str = "subdir/links/subwords.txt";
+#[cfg(not(target_os = "openbsd"))]
 const SUB_LINK: &str = "subdir/links/sublink.txt";
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_basics() {
-    new_ucmd!().succeeds().no_stderr();
+    let ts = TestScenario::new(util_name!());
+
+    let result = ts.ucmd().succeeds();
+
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    {
+        let result_reference = unwrap_or_return!(expected_result(&ts, &[]));
+        if result_reference.succeeded() {
+            assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            return;
+        }
+    }
+    du_basics(result.stdout_str());
 }
+
 #[cfg(target_vendor = "apple")]
-fn _du_basics(s: &str) {
-    let answer = "32\t./subdir
-8\t./subdir/deeper
-24\t./subdir/links
-40\t.
-";
+fn du_basics(s: &str) {
+    let answer = concat!(
+        "4\t./subdir/deeper/deeper_dir\n",
+        "8\t./subdir/deeper\n",
+        "12\t./subdir/links\n",
+        "20\t./subdir\n",
+        "24\t.\n"
+    );
     assert_eq!(s, answer);
 }
-#[cfg(not(target_vendor = "apple"))]
-fn _du_basics(s: &str) {
-    let answer = "28\t./subdir
-8\t./subdir/deeper
-16\t./subdir/links
-36\t.
-";
+
+#[cfg(target_os = "windows")]
+fn du_basics(s: &str) {
+    let answer = concat!(
+        "0\t.\\subdir\\deeper\\deeper_dir\n",
+        "0\t.\\subdir\\deeper\n",
+        "8\t.\\subdir\\links\n",
+        "8\t.\\subdir\n",
+        "8\t.\n"
+    );
+    assert_eq!(s, answer);
+}
+
+#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
+fn du_basics(s: &str) {
+    let answer = concat!(
+        "8\t./subdir/deeper/deeper_dir\n",
+        "16\t./subdir/deeper\n",
+        "16\t./subdir/links\n",
+        "36\t./subdir\n",
+        "44\t.\n"
+    );
     assert_eq!(s, answer);
 }
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_basics_subdir() {
     let ts = TestScenario::new(util_name!());
 
@@ -62,19 +100,19 @@ fn test_du_basics_subdir() {
             return;
         }
     }
-    _du_basics_subdir(result.stdout_str());
+    du_basics_subdir(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_basics_subdir(s: &str) {
+fn du_basics_subdir(s: &str) {
     assert_eq!(s, "4\tsubdir/deeper/deeper_dir\n8\tsubdir/deeper\n");
 }
 #[cfg(target_os = "windows")]
-fn _du_basics_subdir(s: &str) {
+fn du_basics_subdir(s: &str) {
     assert_eq!(s, "0\tsubdir/deeper\\deeper_dir\n0\tsubdir/deeper\n");
 }
 #[cfg(target_os = "freebsd")]
-fn _du_basics_subdir(s: &str) {
+fn du_basics_subdir(s: &str) {
     assert_eq!(s, "8\tsubdir/deeper/deeper_dir\n16\tsubdir/deeper\n");
 }
 #[cfg(all(
@@ -82,7 +120,7 @@ fn _du_basics_subdir(s: &str) {
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))]
-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, "0\tsubdir/deeper\n");
@@ -99,34 +137,61 @@ fn test_du_invalid_size() {
         ts.ucmd()
             .arg(format!("--{s}=1fb4t"))
             .arg("/tmp")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_only(format!("du: invalid suffix in --{s} argument '1fb4t'\n"));
         ts.ucmd()
             .arg(format!("--{s}=x"))
             .arg("/tmp")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_only(format!("du: invalid --{s} argument 'x'\n"));
-        #[cfg(not(target_pointer_width = "128"))]
         ts.ucmd()
             .arg(format!("--{s}=1Y"))
             .arg("/tmp")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_only(format!("du: --{s} argument '1Y' too large\n"));
     }
 }
 
 #[test]
-fn test_du_basics_bad_name() {
+fn test_du_with_posixly_correct() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dir = "a";
+
+    at.mkdir(dir);
+    at.write(&format!("{dir}/file"), "some content");
+
+    let expected = ts
+        .ucmd()
+        .arg(dir)
+        .arg("--block-size=512")
+        .succeeds()
+        .stdout_move_str();
+
+    let result = ts
+        .ucmd()
+        .arg(dir)
+        .env("POSIXLY_CORRECT", "1")
+        .succeeds()
+        .stdout_move_str();
+
+    assert_eq!(expected, result);
+}
+
+#[test]
+fn test_du_non_existing_files() {
     new_ucmd!()
-        .arg("bad_name")
+        .arg("non_existing_a")
+        .arg("non_existing_b")
         .fails()
-        .stderr_only("du: bad_name: No such file or directory\n");
+        .stderr_only(concat!(
+            "du: cannot access 'non_existing_a': No such file or directory\n",
+            "du: cannot access 'non_existing_b': No such file or directory\n"
+        ));
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_soft_link() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
@@ -143,20 +208,20 @@ fn test_du_soft_link() {
             return;
         }
     }
-    _du_soft_link(result.stdout_str());
+    du_soft_link(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_soft_link(s: &str) {
+fn du_soft_link(s: &str) {
     // 'macos' host variants may have `du` output variation for soft links
     assert!((s == "12\tsubdir/links\n") || (s == "16\tsubdir/links\n"));
 }
 #[cfg(target_os = "windows")]
-fn _du_soft_link(s: &str) {
+fn du_soft_link(s: &str) {
     assert_eq!(s, "8\tsubdir/links\n");
 }
 #[cfg(target_os = "freebsd")]
-fn _du_soft_link(s: &str) {
+fn du_soft_link(s: &str) {
     assert_eq!(s, "16\tsubdir/links\n");
 }
 #[cfg(all(
@@ -164,7 +229,7 @@ fn _du_soft_link(s: &str) {
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))]
-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, "8\tsubdir/links\n");
@@ -173,7 +238,7 @@ fn _du_soft_link(s: &str) {
     }
 }
 
-#[cfg(not(target_os = "android"))]
+#[cfg(all(not(target_os = "android"), not(target_os = "openbsd")))]
 #[test]
 fn test_du_hard_link() {
     let ts = TestScenario::new(util_name!());
@@ -192,27 +257,29 @@ fn test_du_hard_link() {
         }
     }
     // We do not double count hard links as the inodes are identical
-    _du_hard_link(result.stdout_str());
+    du_hard_link(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_hard_link(s: &str) {
+fn du_hard_link(s: &str) {
     assert_eq!(s, "12\tsubdir/links\n");
 }
 #[cfg(target_os = "windows")]
-fn _du_hard_link(s: &str) {
+fn du_hard_link(s: &str) {
     assert_eq!(s, "8\tsubdir/links\n");
 }
 #[cfg(target_os = "freebsd")]
-fn _du_hard_link(s: &str) {
+fn du_hard_link(s: &str) {
     assert_eq!(s, "16\tsubdir/links\n");
 }
 #[cfg(all(
     not(target_vendor = "apple"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd"),
+    not(target_os = "android")
 ))]
-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, "8\tsubdir/links\n");
@@ -222,6 +289,7 @@ fn _du_hard_link(s: &str) {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_d_flag() {
     let ts = TestScenario::new(util_name!());
 
@@ -235,19 +303,19 @@ fn test_du_d_flag() {
             return;
         }
     }
-    _du_d_flag(result.stdout_str());
+    du_d_flag(result.stdout_str());
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_d_flag(s: &str) {
+fn du_d_flag(s: &str) {
     assert_eq!(s, "20\t./subdir\n24\t.\n");
 }
 #[cfg(target_os = "windows")]
-fn _du_d_flag(s: &str) {
+fn du_d_flag(s: &str) {
     assert_eq!(s, "8\t.\\subdir\n8\t.\n");
 }
 #[cfg(target_os = "freebsd")]
-fn _du_d_flag(s: &str) {
+fn du_d_flag(s: &str) {
     assert_eq!(s, "36\t./subdir\n44\t.\n");
 }
 #[cfg(all(
@@ -255,7 +323,7 @@ fn _du_d_flag(s: &str) {
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))]
-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, "8\t./subdir\n8\t.\n");
@@ -265,6 +333,7 @@ fn _du_d_flag(s: &str) {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_dereference() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
@@ -283,7 +352,7 @@ fn test_du_dereference() {
         }
     }
 
-    _du_dereference(result.stdout_str());
+    du_dereference(result.stdout_str());
 }
 
 #[cfg(not(windows))]
@@ -292,18 +361,18 @@ 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");
+    at.mkdir("dir");
+    at.write("dir/file-ignore1", "azeaze");
+    at.write("dir/file-ignore2", "amaz?ng");
+    at.symlink_dir("dir", "sublink");
 
-    let result = ts.ucmd().arg("-D").arg("-s").arg("sublink").succeeds();
-    let stdout = result.stdout_str();
+    for arg in ["-D", "-H", "--dereference-args"] {
+        let result = ts.ucmd().arg(arg).arg("-s").arg("sublink").succeeds();
+        let stdout = result.stdout_str();
 
-    assert!(!stdout.starts_with('0'));
-    assert!(stdout.contains("sublink"));
+        assert!(!stdout.starts_with('0'));
+        assert!(stdout.contains("sublink"));
+    }
 
     // Without the option
     let result = ts.ucmd().arg("-s").arg("sublink").succeeds();
@@ -311,15 +380,15 @@ fn test_du_dereference_args() {
 }
 
 #[cfg(target_vendor = "apple")]
-fn _du_dereference(s: &str) {
+fn du_dereference(s: &str) {
     assert_eq!(s, "4\tsubdir/links/deeper_dir\n16\tsubdir/links\n");
 }
 #[cfg(target_os = "windows")]
-fn _du_dereference(s: &str) {
+fn du_dereference(s: &str) {
     assert_eq!(s, "0\tsubdir/links\\deeper_dir\n8\tsubdir/links\n");
 }
 #[cfg(target_os = "freebsd")]
-fn _du_dereference(s: &str) {
+fn du_dereference(s: &str) {
     assert_eq!(s, "8\tsubdir/links/deeper_dir\n24\tsubdir/links\n");
 }
 #[cfg(all(
@@ -327,7 +396,7 @@ fn _du_dereference(s: &str) {
     not(target_os = "windows"),
     not(target_os = "freebsd")
 ))]
-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, "0\tsubdir/links/deeper_dir\n8\tsubdir/links\n");
@@ -336,44 +405,75 @@ fn _du_dereference(s: &str) {
     }
 }
 
+#[cfg(not(any(
+    target_os = "windows",
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "openbsd"
+)))]
+#[test]
+fn test_du_no_dereference() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dir = "a_dir";
+    let symlink = "symlink";
+
+    at.mkdir(dir);
+    at.symlink_dir(dir, symlink);
+
+    for arg in ["-P", "--no-dereference"] {
+        ts.ucmd()
+            .arg(arg)
+            .succeeds()
+            .stdout_contains(dir)
+            .stdout_does_not_contain(symlink);
+
+        // ensure no-dereference "wins"
+        ts.ucmd()
+            .arg("--dereference")
+            .arg(arg)
+            .succeeds()
+            .stdout_contains(dir)
+            .stdout_does_not_contain(symlink);
+
+        // ensure dereference "wins"
+        let result = ts.ucmd().arg(arg).arg("--dereference").succeeds();
+
+        #[cfg(target_os = "linux")]
+        {
+            let result_reference = unwrap_or_return!(expected_result(&ts, &[arg, "--dereference"]));
+
+            if result_reference.succeeded() {
+                assert_eq!(result.stdout_str(), result_reference.stdout_str());
+            }
+        }
+
+        #[cfg(not(target_os = "linux"))]
+        result.stdout_contains(symlink).stdout_does_not_contain(dir);
+    }
+}
+
 #[test]
 fn test_du_inodes_basic() {
     let ts = TestScenario::new(util_name!());
     let result = ts.ucmd().arg("--inodes").succeeds();
 
-    #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[cfg(not(target_os = "windows"))]
     {
         let result_reference = unwrap_or_return!(expected_result(&ts, &["--inodes"]));
         assert_eq!(result.stdout_str(), result_reference.stdout_str());
     }
 
-    #[cfg(not(any(target_os = "linux", target_os = "android")))]
-    _du_inodes_basic(result.stdout_str());
-}
-
-#[cfg(target_os = "windows")]
-fn _du_inodes_basic(s: &str) {
-    assert_eq!(
-        s,
-        "2\t.\\subdir\\deeper\\deeper_dir
-4\t.\\subdir\\deeper
-3\t.\\subdir\\links
-8\t.\\subdir
-11\t.
-"
-    );
-}
-
-#[cfg(not(target_os = "windows"))]
-fn _du_inodes_basic(s: &str) {
+    #[cfg(target_os = "windows")]
     assert_eq!(
-        s,
-        "2\t./subdir/deeper/deeper_dir
-4\t./subdir/deeper
-3\t./subdir/links
-8\t./subdir
-11\t.
-"
+        result.stdout_str(),
+        concat!(
+            "2\t.\\subdir\\deeper\\deeper_dir\n",
+            "4\t.\\subdir\\deeper\n",
+            "3\t.\\subdir\\links\n",
+            "8\t.\\subdir\n",
+            "11\t.\n",
+        )
     );
 }
 
@@ -403,6 +503,61 @@ fn test_du_inodes() {
     }
 }
 
+#[cfg(not(target_os = "android"))]
+#[test]
+fn test_du_inodes_with_count_links() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir");
+    at.touch("dir/file");
+    at.hard_link("dir/file", "dir/hard_link_a");
+    at.hard_link("dir/file", "dir/hard_link_b");
+
+    // ensure the hard links are not counted without --count-links
+    ts.ucmd()
+        .arg("--inodes")
+        .arg("dir")
+        .succeeds()
+        .stdout_is("2\tdir\n");
+
+    for arg in ["-l", "--count-links"] {
+        ts.ucmd()
+            .arg("--inodes")
+            .arg(arg)
+            .arg("dir")
+            .succeeds()
+            .stdout_is("4\tdir\n");
+    }
+}
+
+#[cfg(not(target_os = "android"))]
+#[test]
+fn test_du_inodes_with_count_links_all() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("d");
+    at.mkdir("d/d");
+    at.touch("d/f");
+    at.hard_link("d/f", "d/h");
+
+    let result = ts.ucmd().arg("--inodes").arg("-al").arg("d").succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<String> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    result_seq.sort_unstable();
+    #[cfg(windows)]
+    assert_eq!(result_seq, ["1\td\\d", "1\td\\f", "1\td\\h", "4\td"]);
+    #[cfg(not(windows))]
+    assert_eq!(result_seq, ["1\td/d", "1\td/f", "1\td/h", "4\td"]);
+}
+
 #[test]
 fn test_du_h_flag_empty_file() {
     new_ucmd!()
@@ -412,6 +567,30 @@ fn test_du_h_flag_empty_file() {
         .stdout_only("0\tempty.txt\n");
 }
 
+#[test]
+fn test_du_h_precision() {
+    let test_cases = [
+        (133_456_345, "128M"),
+        (12 * 1024 * 1024, "12M"),
+        (8500, "8.4K"),
+    ];
+
+    for &(test_len, expected_output) in &test_cases {
+        let (at, mut ucmd) = at_and_ucmd!();
+
+        let fpath = at.plus("test.txt");
+        std::fs::File::create(&fpath)
+            .expect("cannot create test file")
+            .set_len(test_len)
+            .expect("cannot truncate test len to size");
+        ucmd.arg("-h")
+            .arg("--apparent-size")
+            .arg(&fpath)
+            .succeeds()
+            .stdout_only(format!("{expected_output}\t{}\n", fpath.to_string_lossy()));
+    }
+}
+
 #[cfg(feature = "touch")]
 #[test]
 fn test_du_time() {
@@ -445,13 +624,15 @@ fn test_du_time() {
         .succeeds();
     result.stdout_only("0\t2016-06-16 00:00\tdate_test\n");
 
-    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");
+    for argument in ["--time=atime", "--time=atim", "--time=a"] {
+        let result = ts
+            .ucmd()
+            .env("TZ", "UTC")
+            .arg(argument)
+            .arg("date_test")
+            .succeeds();
+        result.stdout_only("0\t2015-05-15 00:00\tdate_test\n");
+    }
 
     let result = ts
         .ucmd()
@@ -474,14 +655,14 @@ fn test_du_time() {
 #[cfg(feature = "touch")]
 fn birth_supported() -> bool {
     let ts = TestScenario::new(util_name!());
-    let m = match std::fs::metadata(ts.fixtures.subdir) {
+    let m = match std::fs::metadata(&ts.fixtures.subdir) {
         Ok(m) => m,
-        Err(e) => panic!("{}", e),
+        Err(e) => panic!("{e}"),
     };
     m.created().is_ok()
 }
 
-#[cfg(not(target_os = "windows"))]
+#[cfg(not(any(target_os = "windows", target_os = "openbsd")))]
 #[cfg(feature = "chmod")]
 #[test]
 fn test_du_no_permission() {
@@ -506,8 +687,10 @@ fn test_du_no_permission() {
             return;
         }
     }
-
-    _du_no_permission(result.stdout_str());
+    #[cfg(not(target_vendor = "apple"))]
+    assert_eq!(result.stdout_str(), "4\tsubdir/links\n");
+    #[cfg(target_vendor = "apple")]
+    assert_eq!(result.stdout_str(), "0\tsubdir/links\n");
 }
 
 #[cfg(not(target_os = "windows"))]
@@ -525,16 +708,8 @@ fn test_du_no_exec_permission() {
     result.stderr_contains("du: cannot access 'd/no-x/y': Permission denied");
 }
 
-#[cfg(target_vendor = "apple")]
-fn _du_no_permission(s: &str) {
-    assert_eq!(s, "0\tsubdir/links\n");
-}
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))]
-fn _du_no_permission(s: &str) {
-    assert_eq!(s, "4\tsubdir/links\n");
-}
-
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_one_file_system() {
     let ts = TestScenario::new(util_name!());
 
@@ -548,10 +723,11 @@ fn test_du_one_file_system() {
             return;
         }
     }
-    _du_basics_subdir(result.stdout_str());
+    du_basics_subdir(result.stdout_str());
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_du_threshold() {
     let ts = TestScenario::new(util_name!());
 
@@ -720,10 +896,8 @@ fn test_du_exclude_mix() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
 
-    let mut file1 = at.make_file("file-ignore1");
-    file1.write_all(b"azeaze").unwrap();
-    let mut file2 = at.make_file("file-ignore2");
-    file2.write_all(b"amaz?ng").unwrap();
+    at.write("file-ignore1", "azeaze");
+    at.write("file-ignore2", "amaz?ng");
 
     at.mkdir_all("azerty/xcwww/azeaze");
     at.mkdir_all("azerty/xcwww/qzerty");
@@ -845,20 +1019,279 @@ fn test_du_symlink_fail() {
 
     at.symlink_file("non-existing.txt", "target.txt");
 
-    ts.ucmd().arg("-L").arg("target.txt").fails().code_is(1);
+    ts.ucmd().arg("-L").arg("target.txt").fails_with_code(1);
 }
 
 #[cfg(not(windows))]
+#[cfg(not(target_os = "openbsd"))]
 #[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();
+    at.write("file1", "azeaze");
 
     let result = ts.ucmd().arg("-L").arg("target.txt").arg("file1").fails();
     assert_eq!(result.code(), 1);
     result.stdout_contains("4\tfile1\n");
 }
+
+#[test]
+// Disable on Windows because of different path separators and handling of null characters
+#[cfg(not(target_os = "windows"))]
+fn test_du_files0_from() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.write("testfile1", "content1");
+    at.write("testfile2", "content2");
+
+    at.mkdir("testdir");
+    at.write("testdir/testfile3", "content3");
+
+    at.write("filelist", "testfile1\0testfile2\0testdir\0");
+
+    ts.ucmd()
+        .arg("--files0-from=filelist")
+        .succeeds()
+        .stdout_contains("testfile1")
+        .stdout_contains("testfile2")
+        .stdout_contains("testdir");
+}
+
+#[test]
+fn test_du_files0_from_ignore_duplicate_file_names() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let file = "testfile";
+
+    at.touch(file);
+    at.write("filelist", &format!("{file}\0{file}\0"));
+
+    ts.ucmd()
+        .arg("--files0-from=filelist")
+        .succeeds()
+        .stdout_is(format!("0\t{file}\n"));
+}
+
+#[test]
+fn test_du_files0_from_with_invalid_zero_length_file_names() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.touch("testfile");
+
+    at.write("filelist", "\0testfile\0\0");
+
+    ts.ucmd()
+        .arg("--files0-from=filelist")
+        .fails_with_code(1)
+        .stdout_contains("testfile")
+        .stderr_contains("filelist:1: invalid zero-length file name")
+        .stderr_contains("filelist:3: invalid zero-length file name");
+}
+
+#[test]
+fn test_du_files0_from_stdin() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.write("testfile1", "content1");
+    at.write("testfile2", "content2");
+
+    let input = "testfile1\0testfile2\0";
+
+    ts.ucmd()
+        .arg("--files0-from=-")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_contains("testfile1")
+        .stdout_contains("testfile2");
+}
+
+#[test]
+fn test_du_files0_from_stdin_ignore_duplicate_file_names() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let file = "testfile";
+
+    at.touch(file);
+
+    let input = format!("{file}\0{file}");
+
+    ts.ucmd()
+        .arg("--files0-from=-")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_is(format!("0\t{file}\n"));
+}
+
+#[test]
+fn test_du_files0_from_stdin_with_invalid_zero_length_file_names() {
+    new_ucmd!()
+        .arg("--files0-from=-")
+        .pipe_in("\0\0")
+        .fails_with_code(1)
+        .stderr_contains("-:1: invalid zero-length file name")
+        .stderr_contains("-:2: invalid zero-length file name");
+}
+
+#[test]
+fn test_du_files0_from_dir() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir");
+
+    let result = ts.ucmd().arg("--files0-from=dir").fails();
+    assert_eq!(result.stderr_str(), "du: dir: read error: Is a directory\n");
+}
+
+#[test]
+fn test_du_files0_from_combined() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir");
+
+    let result = ts.ucmd().arg("--files0-from=-").arg("foo").fails();
+    let stderr = result.stderr_str();
+
+    assert!(stderr.contains("file operands cannot be combined with --files0-from"));
+}
+
+#[test]
+fn test_invalid_time_style() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .arg("-s")
+        .arg("--time-style=banana")
+        .succeeds()
+        .stdout_does_not_contain("du: invalid argument 'banana' for 'time style'");
+}
+
+#[test]
+fn test_human_size() {
+    use std::fs::File;
+
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dir = at.plus_as_string("d");
+    at.mkdir(&dir);
+
+    for i in 1..=1023 {
+        let file_path = format!("{dir}/file{i}");
+        File::create(&file_path).expect("Failed to create file");
+    }
+
+    ts.ucmd()
+        .arg("--inodes")
+        .arg("-h")
+        .arg(&dir)
+        .succeeds()
+        .stdout_contains(format!("1.0K	{dir}"));
+}
+
+#[cfg(not(target_os = "android"))]
+#[test]
+fn test_du_deduplicated_input_args() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("d");
+    at.mkdir("d/d");
+    at.touch("d/f");
+    at.hard_link("d/f", "d/h");
+
+    let result = ts
+        .ucmd()
+        .arg("--inodes")
+        .arg("d")
+        .arg("d")
+        .arg("d")
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<String> = result
+        .stdout_str()
+        .lines()
+        .map(|x| x.parse().unwrap())
+        .collect();
+    #[cfg(windows)]
+    assert_eq!(result_seq, ["1\td\\d", "3\td"]);
+    #[cfg(not(windows))]
+    assert_eq!(result_seq, ["1\td/d", "3\td"]);
+}
+
+#[cfg(not(target_os = "android"))]
+#[test]
+fn test_du_no_deduplicated_input_args() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("d");
+    at.touch("d/d");
+
+    let result = ts
+        .ucmd()
+        .arg("--inodes")
+        .arg("-l")
+        .arg("d")
+        .arg("d")
+        .arg("d")
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<String> = result
+        .stdout_str()
+        .lines()
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq, ["2\td", "2\td", "2\td"]);
+}
+
+#[test]
+fn test_du_blocksize_zero_do_not_panic() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.write("foo", "some content");
+    for block_size in ["0", "00", "000", "0x0"] {
+        ts.ucmd()
+            .arg(format!("-B{block_size}"))
+            .arg("foo")
+            .fails()
+            .stderr_only(format!(
+                "du: invalid --block-size argument '{block_size}'\n"
+            ));
+    }
+}
+
+#[test]
+fn test_du_inodes_blocksize_ineffective() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let fpath = at.plus("test.txt");
+    at.touch(fpath);
+    for method in ["-B3", "--block-size=3"] {
+        // No warning
+        ts.ucmd()
+            .arg(method)
+            .arg("--inodes")
+            .arg("test.txt")
+            .succeeds()
+            .stdout_only("1\ttest.txt\n");
+    }
+    for method in ["--apparent-size", "-b"] {
+        // A warning appears!
+        ts.ucmd()
+            .arg(method)
+            .arg("--inodes")
+            .arg("test.txt")
+            .succeeds()
+            .stdout_is("1\ttest.txt\n")
+            .stderr_is(
+                "du: warning: options --apparent-size and -b are ineffective with --inodes\n",
+            );
+    }
+}
diff --git a/tests/by-util/test_echo.rs b/tests/by-util/test_echo.rs
index 3a8e7f86b34..0f314da965c 100644
--- a/tests/by-util/test_echo.rs
+++ b/tests/by-util/test_echo.rs
@@ -2,9 +2,12 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) araba merci
+// spell-checker:ignore (words) araba merci efjkow
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util::UCommand;
+use uutests::util_name;
 
 #[test]
 fn test_default() {
@@ -13,12 +16,7 @@ fn test_default() {
 
 #[test]
 fn test_no_trailing_newline() {
-    new_ucmd!()
-        .arg("-n")
-        .arg("hi")
-        .succeeds()
-        .no_stderr()
-        .stdout_only("hi");
+    new_ucmd!().arg("-n").arg("hi").succeeds().stdout_only("hi");
 }
 
 #[test]
@@ -117,12 +115,35 @@ fn test_escape_newline() {
         .stdout_only("\na\n");
 }
 
+#[test]
+fn test_escape_override() {
+    new_ucmd!()
+        .args(&["-e", "-E", "\\na"])
+        .succeeds()
+        .stdout_only("\\na\n");
+
+    new_ucmd!()
+        .args(&["-E", "-e", "\\na"])
+        .succeeds()
+        .stdout_only("\na\n");
+
+    new_ucmd!()
+        .args(&["-E", "-e", "-n", "\\na"])
+        .succeeds()
+        .stdout_only("\na");
+
+    new_ucmd!()
+        .args(&["-e", "-E", "-n", "\\na"])
+        .succeeds()
+        .stdout_only("\\na");
+}
+
 #[test]
 fn test_escape_no_further_output() {
     new_ucmd!()
         .args(&["-e", "a\\cb", "c"])
         .succeeds()
-        .stdout_only("a\n");
+        .stdout_only("a");
 }
 
 #[test]
@@ -211,8 +232,7 @@ fn test_hyphen_values_at_start() {
         .arg("-test")
         .arg("araba")
         .arg("-merci")
-        .run()
-        .success()
+        .succeeds()
         .stdout_does_not_contain("-E")
         .stdout_is("-test araba -merci\n");
 }
@@ -223,8 +243,7 @@ fn test_hyphen_values_between() {
         .arg("test")
         .arg("-E")
         .arg("araba")
-        .run()
-        .success()
+        .succeeds()
         .stdout_is("test -E araba\n");
 
     new_ucmd!()
@@ -232,7 +251,523 @@ fn test_hyphen_values_between() {
         .arg("dum dum dum")
         .arg("-e")
         .arg("dum")
+        .succeeds()
+        .stdout_is("dumdum  dum dum dum -e dum\n");
+}
+
+#[test]
+fn test_double_hyphens_at_start() {
+    new_ucmd!().arg("--").succeeds().stdout_only("--\n");
+    new_ucmd!()
+        .arg("--")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-- --\n");
+
+    new_ucmd!()
+        .arg("--")
+        .arg("a")
+        .succeeds()
+        .stdout_only("-- a\n");
+
+    new_ucmd!()
+        .arg("--")
+        .arg("a")
+        .arg("b")
+        .succeeds()
+        .stdout_only("-- a b\n");
+
+    new_ucmd!()
+        .arg("--")
+        .arg("a")
+        .arg("b")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-- a b --\n");
+}
+
+#[test]
+fn test_double_hyphens_after_single_hyphen() {
+    new_ucmd!()
+        .arg("-")
+        .arg("--")
+        .succeeds()
+        .stdout_only("- --\n");
+
+    new_ucmd!()
+        .arg("-")
+        .arg("-n")
+        .arg("--")
+        .succeeds()
+        .stdout_only("- -n --\n");
+
+    new_ucmd!()
+        .arg("-n")
+        .arg("-")
+        .arg("--")
+        .succeeds()
+        .stdout_only("- --");
+}
+
+#[test]
+fn test_flag_like_arguments_which_are_no_flags() {
+    new_ucmd!()
+        .arg("-efjkow")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-efjkow --\n");
+
+    new_ucmd!()
+        .arg("--")
+        .arg("-efjkow")
+        .succeeds()
+        .stdout_only("-- -efjkow\n");
+
+    new_ucmd!()
+        .arg("-efjkow")
+        .arg("-n")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-efjkow -n --\n");
+
+    new_ucmd!()
+        .arg("-n")
+        .arg("--")
+        .arg("-efjkow")
+        .succeeds()
+        .stdout_only("-- -efjkow");
+}
+
+#[test]
+fn test_backslash_n_last_char_in_last_argument() {
+    new_ucmd!()
+        .arg("-n")
+        .arg("-e")
+        .arg("--")
+        .arg("foo\n")
+        .succeeds()
+        .stdout_only("-- foo\n");
+
+    new_ucmd!()
+        .arg("-e")
+        .arg("--")
+        .arg("foo\\n")
+        .succeeds()
+        .stdout_only("-- foo\n\n");
+
+    new_ucmd!()
+        .arg("-n")
+        .arg("--")
+        .arg("foo\n")
+        .succeeds()
+        .stdout_only("-- foo\n");
+
+    new_ucmd!()
+        .arg("--")
+        .arg("foo\n")
+        .succeeds()
+        .stdout_only("-- foo\n\n");
+}
+
+#[test]
+fn test_double_hyphens_after_flags() {
+    new_ucmd!()
+        .arg("-e")
+        .arg("--")
+        .succeeds()
+        .stdout_only("--\n");
+
+    new_ucmd!()
+        .arg("-n")
+        .arg("-e")
+        .arg("--")
+        .arg("foo\n")
+        .succeeds()
+        .stdout_only("-- foo\n");
+
+    new_ucmd!()
+        .arg("-ne")
+        .arg("--")
+        .succeeds()
+        .stdout_only("--");
+
+    new_ucmd!()
+        .arg("-neE")
+        .arg("--")
+        .succeeds()
+        .stdout_only("--");
+
+    new_ucmd!()
+        .arg("-e")
+        .arg("--")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-- --\n");
+
+    new_ucmd!()
+        .arg("-e")
+        .arg("--")
+        .arg("a")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-- a --\n");
+
+    new_ucmd!()
+        .arg("-n")
+        .arg("--")
+        .arg("a")
+        .succeeds()
+        .stdout_only("-- a");
+
+    new_ucmd!()
+        .arg("-n")
+        .arg("--")
+        .arg("a")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-- a --");
+}
+
+#[test]
+fn test_double_hyphens() {
+    new_ucmd!().arg("--").succeeds().stdout_only("--\n");
+    new_ucmd!()
+        .arg("--")
+        .arg("--")
+        .succeeds()
+        .stdout_only("-- --\n");
+
+    new_ucmd!()
+        .arg("a")
+        .arg("--")
+        .arg("b")
+        .succeeds()
+        .stdout_only("a -- b\n");
+
+    new_ucmd!()
+        .arg("a")
+        .arg("--")
+        .arg("b")
+        .arg("--")
+        .succeeds()
+        .stdout_only("a -- b --\n");
+
+    new_ucmd!()
+        .arg("a")
+        .arg("b")
+        .arg("--")
+        .arg("--")
+        .succeeds()
+        .stdout_only("a b -- --\n");
+}
+
+#[test]
+fn wrapping_octal() {
+    // Some odd behavior of GNU. Values of \0400 and greater do not fit in the
+    // u8 that we write to stdout. So we test that it wraps:
+    //
+    // We give it this input:
+    //     \o501 = 1_0100_0001 (yes, **9** bits)
+    // This should be wrapped into:
+    //     \o101 = 'A' = 0100_0001,
+    // because we only write a single character
+    new_ucmd!()
+        .arg("-e")
+        .arg("\\0501")
+        .succeeds()
+        .stdout_is("A\n");
+}
+
+#[test]
+fn old_octal_syntax() {
+    new_ucmd!()
+        .arg("-e")
+        .arg("\\1foo")
+        .succeeds()
+        .stdout_is("\x01foo\n");
+
+    new_ucmd!()
+        .arg("-e")
+        .arg("\\43foo")
+        .succeeds()
+        .stdout_is("#foo\n");
+
+    new_ucmd!()
+        .arg("-e")
+        .arg("\\101 foo")
+        .succeeds()
+        .stdout_is("A foo\n");
+
+    new_ucmd!()
+        .arg("-e")
+        .arg("\\1011")
+        .succeeds()
+        .stdout_is("A1\n");
+}
+
+#[test]
+fn partial_version_argument() {
+    new_ucmd!().arg("--ver").succeeds().stdout_is("--ver\n");
+}
+
+#[test]
+fn partial_help_argument() {
+    new_ucmd!().arg("--he").succeeds().stdout_is("--he\n");
+}
+
+#[test]
+fn multibyte_escape_unicode() {
+    // spell-checker:disable-next-line
+    // Tests suggested by kkew3
+    // https://github.com/uutils/coreutils/issues/6741
+
+    // \u{1F602} is:
+    //
+    // "Face with Tears of Joy"
+    // U+1F602
+    // "😂"
+
+    new_ucmd!()
+        .args(&["-e", r"\xf0\x9f\x98\x82"])
+        .succeeds()
+        .stdout_only("\u{1F602}\n");
+
+    new_ucmd!()
+        .args(&["-e", r"\x41\xf0\x9f\x98\x82\x42"])
+        .succeeds()
+        .stdout_only("A\u{1F602}B\n");
+
+    new_ucmd!()
+        .args(&["-e", r"\xf0\x41\x9f\x98\x82"])
+        .succeeds()
+        .stdout_only_bytes(b"\xF0A\x9F\x98\x82\n");
+
+    new_ucmd!()
+        .args(&["-e", r"\x41\xf0\c\x9f\x98\x82"])
+        .succeeds()
+        .stdout_only_bytes(b"A\xF0");
+}
+
+#[test]
+fn non_utf_8_hex_round_trip() {
+    new_ucmd!()
+        .args(&["-e", r"\xFF"])
+        .succeeds()
+        .stdout_only_bytes(b"\xFF\n");
+}
+
+#[test]
+fn nine_bit_octal() {
+    const RESULT: &[u8] = b"\xFF\n";
+
+    new_ucmd!()
+        .args(&["-e", r"\0777"])
+        .succeeds()
+        .stdout_only_bytes(RESULT);
+
+    new_ucmd!()
+        .args(&["-e", r"\777"])
+        .succeeds()
+        .stdout_only_bytes(RESULT);
+}
+
+#[test]
+#[cfg(target_family = "unix")]
+fn non_utf_8() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    // ISO-8859-1 encoded text
+    // spell-checker:disable
+    const INPUT_AND_OUTPUT: &[u8] =
+        b"Swer an rehte g\xFCete wendet s\xEEn gem\xFCete, dem volget s\xE6lde und \xEAre.";
+    // spell-checker:enable
+
+    let os_str = OsStr::from_bytes(INPUT_AND_OUTPUT);
+
+    new_ucmd!()
+        .arg("-n")
+        .arg(os_str)
+        .succeeds()
+        .stdout_only_bytes(INPUT_AND_OUTPUT);
+}
+
+#[test]
+fn slash_eight_off_by_one() {
+    new_ucmd!()
+        .args(&["-e", "-n", r"\8"])
+        .succeeds()
+        .stdout_only(r"\8");
+}
+
+#[test]
+fn test_normalized_newlines_stdout_is() {
+    let res = new_ucmd!().args(&["-ne", "A\r\nB\nC"]).run();
+
+    res.normalized_newlines_stdout_is("A\r\nB\nC");
+    res.normalized_newlines_stdout_is("A\nB\nC");
+    res.normalized_newlines_stdout_is("A\nB\r\nC");
+}
+
+#[test]
+fn test_normalized_newlines_stdout_is_fail() {
+    new_ucmd!()
+        .args(&["-ne", "A\r\nB\nC"])
+        .run()
+        .stdout_is("A\r\nB\nC");
+}
+
+#[test]
+fn test_cmd_result_stdout_check_and_stdout_str_check() {
+    let result = new_ucmd!().arg("Hello world").run();
+
+    result.stdout_str_check(|stdout| stdout.ends_with("world\n"));
+    result.stdout_check(|stdout| stdout.get(0..2).unwrap().eq(b"He"));
+    result.no_stderr();
+}
+
+#[test]
+fn test_cmd_result_stderr_check_and_stderr_str_check() {
+    let ts = TestScenario::new("echo");
+
+    let result = UCommand::new()
+        .arg(format!(
+            "{} {} Hello world >&2",
+            ts.bin_path.display(),
+            ts.util_name
+        ))
+        .run();
+
+    result.stderr_str_check(|stderr| stderr.ends_with("world\n"));
+    result.stderr_check(|stdout| stdout.get(0..2).unwrap().eq(b"He"));
+    result.no_stdout();
+}
+
+#[test]
+fn test_cmd_result_stdout_str_check_when_false_then_panics() {
+    new_ucmd!()
+        .args(&["-e", "\\f"])
+        .succeeds()
+        .stdout_only("\x0C\n");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_cmd_result_signal_when_normal_exit_then_no_signal() {
+    let result = TestScenario::new("echo").ucmd().run();
+    assert!(result.signal().is_none());
+}
+
+mod posixly_correct {
+    use super::*;
+
+    #[test]
+    fn ignore_options() {
+        for arg in ["--help", "--version", "-E -n 'foo'", "-nE 'foo'"] {
+            new_ucmd!()
+                .env("POSIXLY_CORRECT", "1")
+                .arg(arg)
+                .succeeds()
+                .stdout_only(format!("{arg}\n"));
+        }
+    }
+
+    #[test]
+    fn process_n_option() {
+        new_ucmd!()
+            .env("POSIXLY_CORRECT", "1")
+            .args(&["-n", "foo"])
+            .succeeds()
+            .stdout_only("foo");
+
+        // ignore -E & process escapes
+        new_ucmd!()
+            .env("POSIXLY_CORRECT", "1")
+            .args(&["-n", "-E", "foo\\cbar"])
+            .succeeds()
+            .stdout_only("foo");
+    }
+
+    #[test]
+    fn process_escapes() {
+        new_ucmd!()
+            .env("POSIXLY_CORRECT", "1")
+            .arg("foo\\n")
+            .succeeds()
+            .stdout_only("foo\n\n");
+
+        new_ucmd!()
+            .env("POSIXLY_CORRECT", "1")
+            .arg("foo\\tbar")
+            .succeeds()
+            .stdout_only("foo\tbar\n");
+
+        new_ucmd!()
+            .env("POSIXLY_CORRECT", "1")
+            .arg("foo\\ctbar")
+            .succeeds()
+            .stdout_only("foo");
+    }
+}
+
+#[test]
+fn test_child_when_run_with_a_non_blocking_util() {
+    new_ucmd!()
+        .arg("hello world")
         .run()
         .success()
-        .stdout_is("dumdum  dum dum dum -e dum\n");
+        .stdout_only("hello world\n");
+}
+
+// Test basically that most of the methods of UChild are working
+#[test]
+fn test_uchild_when_run_no_wait_with_a_non_blocking_util() {
+    let mut child = new_ucmd!().arg("hello world").run_no_wait();
+
+    // check `child.is_alive()` and `child.delay()` is working
+    let mut trials = 10;
+    while child.is_alive() {
+        assert!(
+            trials > 0,
+            "Assertion failed: child process is still alive."
+        );
+
+        child.delay(500);
+        trials -= 1;
+    }
+
+    assert!(!child.is_alive());
+
+    // check `child.is_not_alive()` is working
+    assert!(child.is_not_alive());
+
+    // check the current output is correct
+    std::assert_eq!(child.stdout(), "hello world\n");
+    assert!(child.stderr().is_empty());
+
+    // check the current output of echo is empty. We already called `child.stdout()` and `echo`
+    // exited so there's no additional output after the first call of `child.stdout()`
+    assert!(child.stdout().is_empty());
+    assert!(child.stderr().is_empty());
+
+    // check that we're still able to access all output of the child process, even after exit
+    // and call to `child.stdout()`
+    std::assert_eq!(child.stdout_all(), "hello world\n");
+    assert!(child.stderr_all().is_empty());
+
+    // we should be able to call kill without panics, even if the process already exited
+    child.make_assertion().is_not_alive();
+    child.kill();
+
+    // we should be able to call wait without panics and apply some assertions
+    child.wait().unwrap().code_is(0).no_stdout().no_stderr();
+}
+
+#[test]
+fn test_escape_sequence_ctrl_c() {
+    new_ucmd!()
+        .args(&["-e", "show\\c123"])
+        .run()
+        .success()
+        .stdout_only("show");
 }
diff --git a/tests/by-util/test_env.rs b/tests/by-util/test_env.rs
index 8ce55a1d3a2..c52202ec20c 100644
--- a/tests/by-util/test_env.rs
+++ b/tests/by-util/test_env.rs
@@ -2,16 +2,123 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC
+// spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC cout cerr FFFD winsize xpixel ypixel
+#![allow(clippy::missing_errors_doc)]
 
-use crate::common::util::TestScenario;
+#[cfg(unix)]
+use nix::sys::signal::Signal;
+#[cfg(feature = "echo")]
+use regex::Regex;
 use std::env;
 use std::path::Path;
+#[cfg(unix)]
+use std::process::Command;
 use tempfile::tempdir;
+use uutests::new_ucmd;
+#[cfg(unix)]
+use uutests::util::TerminalSimulation;
+use uutests::util::TestScenario;
+#[cfg(unix)]
+use uutests::util::UChild;
+use uutests::util_name;
+
+#[cfg(unix)]
+struct Target {
+    child: UChild,
+}
+#[cfg(unix)]
+impl Target {
+    fn new(signals: &[&str]) -> Self {
+        let mut child = new_ucmd!()
+            .args(&[
+                format!("--ignore-signal={}", signals.join(",")).as_str(),
+                "sleep",
+                "1000",
+            ])
+            .run_no_wait();
+        child.delay(500);
+        Self { child }
+    }
+    fn send_signal(&mut self, signal: Signal) {
+        let _ = Command::new("kill")
+            .args(&[
+                format!("-{}", signal as i32),
+                format!("{}", self.child.id()),
+            ])
+            .spawn()
+            .expect("failed to send signal")
+            .wait();
+        self.child.delay(100);
+    }
+    fn is_alive(&mut self) -> bool {
+        self.child.is_alive()
+    }
+}
+#[cfg(unix)]
+impl Drop for Target {
+    fn drop(&mut self) {
+        self.child.kill();
+    }
+}
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(125);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
+}
+
+#[test]
+#[cfg(not(target_os = "windows"))]
+fn test_flags_after_command() {
+    new_ucmd!()
+        // This would cause an error if -u=v were processed because it's malformed
+        .args(&["echo", "-u=v"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-u=v\n");
+
+    new_ucmd!()
+        // Ensure the string isn't split
+        // cSpell:disable
+        .args(&["printf", "%s-%s", "-Sfoo bar"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-Sfoo bar-");
+    // cSpell:enable
+
+    new_ucmd!()
+        // Ensure -- is recognized
+        .args(&["-i", "--", "-u=v"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-u=v\n");
+
+    new_ucmd!()
+        // Recognize echo as the command after a flag that takes a value
+        .args(&["-C", "..", "echo", "-u=v"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-u=v\n");
+
+    new_ucmd!()
+        // Recognize echo as the command after a flag that takes an inline value
+        .args(&["-C..", "echo", "-u=v"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-u=v\n");
+
+    new_ucmd!()
+        // Recognize echo as the command after a flag that takes a value after another flag
+        .args(&["-iC", "..", "echo", "-u=v"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-u=v\n");
+
+    new_ucmd!()
+        // Similar to the last two combined
+        .args(&["-iC..", "echo", "-u=v"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("-u=v\n");
 }
 
 #[test]
@@ -32,19 +139,139 @@ fn test_env_version() {
         .stdout_contains(util_name!());
 }
 
+#[test]
+#[cfg(unix)]
+fn test_env_permissions() {
+    // Try to execute `empty` in test fixture, that does not have exec permission.
+    new_ucmd!()
+        .arg("./empty")
+        .fails_with_code(126)
+        .stderr_is("env: './empty': Permission denied\n");
+}
+
 #[test]
 fn test_echo() {
-    let result = new_ucmd!().arg("echo").arg("FOO-bar").succeeds();
+    #[cfg(target_os = "windows")]
+    let args = ["cmd", "/d/c", "echo"];
+    #[cfg(not(target_os = "windows"))]
+    let args = ["echo"];
+
+    let result = new_ucmd!().args(&args).arg("FOO-bar").succeeds();
 
     assert_eq!(result.stdout_str().trim(), "FOO-bar");
 }
 
+#[cfg(target_os = "windows")]
+#[test]
+fn test_if_windows_batch_files_can_be_executed() {
+    let result = new_ucmd!().arg("./runBat.bat").succeeds();
+
+    assert!(result.stdout_str().contains("Hello Windows World!"));
+}
+
+#[cfg(feature = "echo")]
+#[test]
+fn test_debug_1() {
+    let ts = TestScenario::new(util_name!());
+    let result = ts
+        .ucmd()
+        .arg("-v")
+        .arg(&ts.bin_path)
+        .args(&["echo", "hello"])
+        .succeeds();
+    result.stderr_matches(
+        &Regex::new(concat!(
+            r"executing: [^\n]+(\/|\\)coreutils(\.exe)?\n",
+            r"   arg\[0\]= '[^\n]+(\/|\\)coreutils(\.exe)?'\n",
+            r"   arg\[1\]= 'echo'\n",
+            r"   arg\[2\]= 'hello'"
+        ))
+        .unwrap(),
+    );
+}
+
+#[cfg(feature = "echo")]
+#[test]
+fn test_debug_2() {
+    let ts = TestScenario::new(util_name!());
+    let result = ts
+        .ucmd()
+        .arg("-vv")
+        .arg(&ts.bin_path)
+        .args(&["echo", "hello2"])
+        .succeeds();
+    result.stderr_matches(
+        &Regex::new(concat!(
+            r"input args:\n",
+            r"arg\[0\]: 'env'\n",
+            r"arg\[1\]: '-vv'\n",
+            r"arg\[2\]: '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+            r"arg\[3\]: 'echo'\n",
+            r"arg\[4\]: 'hello2'\n",
+            r"executing: [^\n]+(\/|\\)coreutils(.exe)?\n",
+            r"   arg\[0\]= '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+            r"   arg\[1\]= 'echo'\n",
+            r"   arg\[2\]= 'hello2'"
+        ))
+        .unwrap(),
+    );
+}
+
+#[cfg(feature = "echo")]
+#[test]
+fn test_debug1_part_of_string_arg() {
+    let ts = TestScenario::new(util_name!());
+
+    let result = ts
+        .ucmd()
+        .arg("-vS FOO=BAR")
+        .arg(&ts.bin_path)
+        .args(&["echo", "hello1"])
+        .succeeds();
+    result.stderr_matches(
+        &Regex::new(concat!(
+            r"executing: [^\n]+(\/|\\)coreutils(\.exe)?\n",
+            r"   arg\[0\]= '[^\n]+(\/|\\)coreutils(\.exe)?'\n",
+            r"   arg\[1\]= 'echo'\n",
+            r"   arg\[2\]= 'hello1'"
+        ))
+        .unwrap(),
+    );
+}
+
+#[cfg(feature = "echo")]
+#[test]
+fn test_debug2_part_of_string_arg() {
+    let ts = TestScenario::new(util_name!());
+    let result = ts
+        .ucmd()
+        .arg("-vvS FOO=BAR")
+        .arg(&ts.bin_path)
+        .args(&["echo", "hello2"])
+        .succeeds();
+    result.stderr_matches(
+        &Regex::new(concat!(
+            r"input args:\n",
+            r"arg\[0\]: 'env'\n",
+            r"arg\[1\]: '-vvS FOO=BAR'\n",
+            r"arg\[2\]: '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+            r"arg\[3\]: 'echo'\n",
+            r"arg\[4\]: 'hello2'\n",
+            r"executing: [^\n]+(\/|\\)coreutils(.exe)?\n",
+            r"   arg\[0\]= '[^\n]+(\/|\\)coreutils(.exe)?'\n",
+            r"   arg\[1\]= 'echo'\n",
+            r"   arg\[2\]= 'hello2'"
+        ))
+        .unwrap(),
+    );
+}
+
 #[test]
 fn test_file_option() {
     let out = new_ucmd!()
         .arg("-f")
         .arg("vars.conf.txt")
-        .run()
+        .succeeds()
         .stdout_move_str();
 
     assert_eq!(
@@ -61,7 +288,7 @@ fn test_combined_file_set() {
         .arg("-f")
         .arg("vars.conf.txt")
         .arg("FOO=bar.alt")
-        .run()
+        .succeeds()
         .stdout_move_str();
 
     assert_eq!(out.lines().filter(|&line| line == "FOO=bar.alt").count(), 1);
@@ -93,7 +320,7 @@ fn test_unset_invalid_variables() {
     // Cannot test input with \0 in it, since output will also contain \0. rlimit::prlimit fails
     // with this error: Error { kind: InvalidInput, message: "nul byte found in provided data" }
     for var in ["", "a=b"] {
-        new_ucmd!().arg("-u").arg(var).run().stderr_only(format!(
+        new_ucmd!().arg("-u").arg(var).fails().stderr_only(format!(
             "env: cannot unset {}: Invalid argument\n",
             var.quote()
         ));
@@ -102,14 +329,17 @@ fn test_unset_invalid_variables() {
 
 #[test]
 fn test_single_name_value_pair() {
-    let out = new_ucmd!().arg("FOO=bar").run();
-
-    assert!(out.stdout_str().lines().any(|line| line == "FOO=bar"));
+    new_ucmd!()
+        .arg("FOO=bar")
+        .succeeds()
+        .stdout_str()
+        .lines()
+        .any(|line| line == "FOO=bar");
 }
 
 #[test]
 fn test_multiple_name_value_pairs() {
-    let out = new_ucmd!().arg("FOO=bar").arg("ABC=xyz").run();
+    let out = new_ucmd!().arg("FOO=bar").arg("ABC=xyz").succeeds();
 
     assert_eq!(
         out.stdout_str()
@@ -133,7 +363,7 @@ fn test_empty_name() {
     new_ucmd!()
         .arg("-i")
         .arg("=xyz")
-        .run()
+        .succeeds()
         .stderr_only("env: warning: no name specified for value 'xyz'\n");
 }
 
@@ -245,3 +475,1301 @@ fn test_fail_change_directory() {
         .stderr_move_str();
     assert!(out.contains("env: cannot change directory to "));
 }
+
+#[cfg(not(target_os = "windows"))] // windows has no executable "echo", its only supported as part of a batch-file
+#[test]
+fn test_split_string_into_args_one_argument_no_quotes() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene
+        .ucmd()
+        .arg("-S echo hello world")
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(out, "hello world\n");
+}
+
+#[cfg(not(target_os = "windows"))] // windows has no executable "echo", its only supported as part of a batch-file
+#[test]
+fn test_split_string_into_args_one_argument() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene
+        .ucmd()
+        .arg("-S echo \"hello world\"")
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(out, "hello world\n");
+}
+
+#[cfg(not(target_os = "windows"))] // windows has no executable "echo", its only supported as part of a batch-file
+#[test]
+fn test_split_string_into_args_s_escaping_challenge() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene
+        .ucmd()
+        .args(&[r#"-S echo "hello \"great\" world""#])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(out, "hello \"great\" world\n");
+}
+
+#[test]
+fn test_split_string_into_args_s_escaped_c_not_allowed() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene.ucmd().args(&[r#"-S"\c""#]).fails().stderr_move_str();
+    assert_eq!(
+        out,
+        "env: '\\c' must not appear in double-quoted -S string\n"
+    );
+}
+
+#[cfg(not(target_os = "windows"))] // no printf available
+#[test]
+fn test_split_string_into_args_s_whitespace_handling() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene
+        .ucmd()
+        .args(&["-Sprintf x%sx\\n A \t B \x0B\x0C\r\n"])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(out, "xAx\nxBx\n");
+}
+
+#[cfg(not(target_os = "windows"))] // no printf available
+#[test]
+fn test_split_string_into_args_long_option_whitespace_handling() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene
+        .ucmd()
+        .args(&["--split-string printf x%sx\\n A \t B \x0B\x0C\r\n"])
+        .succeeds()
+        .stdout_move_str();
+    assert_eq!(out, "xAx\nxBx\n");
+}
+
+#[cfg(not(target_os = "windows"))] // no printf available
+#[test]
+fn test_split_string_into_args_debug_output_whitespace_handling() {
+    let scene = TestScenario::new(util_name!());
+
+    let out = scene
+        .ucmd()
+        .args(&["-vvS printf x%sx\\n A \t B \x0B\x0C\r\n"])
+        .succeeds();
+    assert_eq!(out.stdout_str(), "xAx\nxBx\n");
+    assert_eq!(
+        out.stderr_str(),
+        "input args:\narg[0]: 'env'\narg[1]: $\
+        '-vvS printf x%sx\\\\n A \\t B \\x0B\\x0C\\r\\n'\nexecuting: printf\
+        \n   arg[0]= 'printf'\n   arg[1]= $'x%sx\\n'\n   arg[2]= 'A'\n   arg[3]= 'B'\n"
+    );
+}
+
+// FixMe: This test fails on MACOS:
+// thread 'test_env::test_gnu_e20' panicked at 'assertion failed: `(left == right)`
+// left: `"A=B C=D\n__CF_USER_TEXT_ENCODING=0x1F5:0x0:0x0\n"`,
+// right: `"A=B C=D\n"`', tests/by-util/test_env.rs:369:5
+#[cfg(not(target_os = "macos"))]
+#[test]
+fn test_gnu_e20() {
+    let scene = TestScenario::new(util_name!());
+
+    let env_bin = String::from(uutests::util::get_tests_binary()) + " " + util_name!();
+    let input = [
+        String::from("-i"),
+        String::from(r#"-SA="B\_C=D" "#) + env_bin.escape_default().to_string().as_str() + "",
+    ];
+
+    let mut output = "A=B C=D\n".to_string();
+
+    // Workaround for the test to pass when coverage is being run.
+    // If enabled, the binary called by env_bin will most probably be
+    // instrumented for coverage, and thus will set the
+    // __LLVM_PROFILE_RT_INIT_ONCE
+    if env::var("__LLVM_PROFILE_RT_INIT_ONCE").is_ok() {
+        output.push_str("__LLVM_PROFILE_RT_INIT_ONCE=__LLVM_PROFILE_RT_INIT_ONCE\n");
+    }
+
+    let out = scene.ucmd().args(&input).succeeds();
+    assert_eq!(out.stdout_str(), output);
+}
+
+#[test]
+#[allow(clippy::cognitive_complexity)] // Ignore clippy lint of too long function sign
+fn test_env_parsing_errors() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .arg("-S\\|echo hallo") // no quotes, invalid escape sequence |
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\|' in -S\n");
+
+    ts.ucmd()
+        .arg("-S\\a") // no quotes, invalid escape sequence a
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+    ts.ucmd()
+        .arg("-S\"\\a\"") // double quotes, invalid escape sequence a
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+    ts.ucmd()
+        .arg(r#"-S"\a""#) // same as before, just using r#""#
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+    ts.ucmd()
+        .arg("-S'\\a'") // single quotes, invalid escape sequence a
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\a' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S\|\&\;") // no quotes, invalid escape sequence |
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\|' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S\<\&\;") // no quotes, invalid escape sequence <
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\<' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S\>\&\;") // no quotes, invalid escape sequence >
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\>' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S\`\&\;") // no quotes, invalid escape sequence `
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+    ts.ucmd()
+        .arg(r#"-S"\`\&\;""#) // double quotes, invalid escape sequence `
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S'\`\&\;'") // single quotes, invalid escape sequence `
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S\`") // ` escaped without quotes
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+    ts.ucmd()
+        .arg(r#"-S"\`""#) // ` escaped in double quotes
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+    ts.ucmd()
+        .arg(r"-S'\`'") // ` escaped in single quotes
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\`' in -S\n");
+
+    ts.ucmd()
+        .args(&[r"-S\🦉"]) // ` escaped in single quotes
+        .fails_with_code(125)
+        .no_stdout()
+        .stderr_is("env: invalid sequence '\\\u{FFFD}' in -S\n"); // gnu doesn't show the owl. Instead a invalid unicode ?
+}
+
+#[test]
+fn test_env_with_empty_executable_single_quotes() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .args(&["-S''"]) // empty single quotes, considered as program name
+        .fails_with_code(127)
+        .no_stdout()
+        .stderr_is("env: '': No such file or directory\n"); // gnu version again adds escaping here
+}
+
+#[test]
+fn test_env_with_empty_executable_double_quotes() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .args(&["-S\"\""]) // empty double quotes, considered as program name
+        .fails_with_code(127)
+        .no_stdout()
+        .stderr_is("env: '': No such file or directory\n");
+}
+
+#[test]
+#[cfg(all(unix, feature = "dirname", feature = "echo"))]
+fn test_env_overwrite_arg0() {
+    let ts = TestScenario::new(util_name!());
+
+    let bin = ts.bin_path.clone();
+
+    ts.ucmd()
+        .args(&["--argv0", "echo"])
+        .arg(&bin)
+        .args(&["-n", "hello", "world!"])
+        .succeeds()
+        .stdout_is("hello world!")
+        .stderr_is("");
+
+    ts.ucmd()
+        .args(&["-a", "dirname"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb\n")
+        .stderr_is("");
+}
+
+#[test]
+#[cfg(all(unix, feature = "echo"))]
+fn test_env_arg_argv0_overwrite() {
+    let ts = TestScenario::new(util_name!());
+
+    let bin = &ts.bin_path;
+
+    // overwrite --argv0 by --argv0
+    ts.ucmd()
+        .args(&["--argv0", "dirname"])
+        .args(&["--argv0", "echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // overwrite -a by -a
+    ts.ucmd()
+        .args(&["-a", "dirname"])
+        .args(&["-a", "echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // overwrite --argv0 by -a
+    ts.ucmd()
+        .args(&["--argv0", "dirname"])
+        .args(&["-a", "echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // overwrite -a by --argv0
+    ts.ucmd()
+        .args(&["-a", "dirname"])
+        .args(&["--argv0", "echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+}
+
+#[test]
+#[cfg(all(unix, feature = "echo"))]
+fn test_env_arg_argv0_overwrite_mixed_with_string_args() {
+    let ts = TestScenario::new(util_name!());
+
+    let bin = &ts.bin_path;
+
+    // string arg following normal
+    ts.ucmd()
+        .args(&["-S--argv0 dirname"])
+        .args(&["--argv0", "echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // normal following string arg
+    ts.ucmd()
+        .args(&["-a", "dirname"])
+        .args(&["-S-a echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // one large string arg
+    ts.ucmd()
+        .args(&["-S--argv0 dirname -a echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // two string args
+    ts.ucmd()
+        .args(&["-S-a dirname"])
+        .args(&["-S--argv0 echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+
+    // three args: normal, string, normal
+    ts.ucmd()
+        .args(&["-a", "sleep"])
+        .args(&["-S-a dirname"])
+        .args(&["-a", "echo"])
+        .arg(bin)
+        .args(&["aa/bb/cc"])
+        .succeeds()
+        .stdout_is("aa/bb/cc\n")
+        .stderr_is("");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_invalid_signals() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .args(&["--ignore-signal=banana"])
+        .fails_with_code(125)
+        .stderr_contains("env: 'banana': invalid signal");
+    ts.ucmd()
+        .args(&["--ignore-signal=SIGbanana"])
+        .fails_with_code(125)
+        .stderr_contains("env: 'SIGbanana': invalid signal");
+    ts.ucmd()
+        .args(&["--ignore-signal=exit"])
+        .fails_with_code(125)
+        .stderr_contains("env: 'exit': invalid signal");
+    ts.ucmd()
+        .args(&["--ignore-signal=SIGexit"])
+        .fails_with_code(125)
+        .stderr_contains("env: 'SIGexit': invalid signal");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_special_signals() {
+    let ts = TestScenario::new(util_name!());
+    let signal_stop = nix::sys::signal::SIGSTOP;
+    let signal_kill = nix::sys::signal::SIGKILL;
+    ts.ucmd()
+        .args(&["--ignore-signal=stop", "echo", "hello"])
+        .fails_with_code(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_stop as i32
+        ));
+    ts.ucmd()
+        .args(&["--ignore-signal=kill", "echo", "hello"])
+        .fails_with_code(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_kill as i32
+        ));
+    ts.ucmd()
+        .args(&["--ignore-signal=SToP", "echo", "hello"])
+        .fails_with_code(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_stop as i32
+        ));
+    ts.ucmd()
+        .args(&["--ignore-signal=SIGKILL", "echo", "hello"])
+        .fails_with_code(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_kill as i32
+        ));
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_valid_signals() {
+    {
+        let mut target = Target::new(&["int"]);
+        target.send_signal(Signal::SIGINT);
+        assert!(target.is_alive());
+    }
+    {
+        let mut target = Target::new(&["usr2"]);
+        target.send_signal(Signal::SIGUSR2);
+        assert!(target.is_alive());
+    }
+    {
+        let mut target = Target::new(&["int", "usr2"]);
+        target.send_signal(Signal::SIGUSR1);
+        assert!(!target.is_alive());
+    }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_empty() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .args(&["--ignore-signal=", "echo", "hello"])
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("hello");
+}
+
+#[test]
+fn disallow_equals_sign_on_short_unset_option() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .arg("-u=")
+        .fails_with_code(125)
+        .stderr_contains("env: cannot unset '=': Invalid argument");
+    ts.ucmd()
+        .arg("-u=A1B2C3")
+        .fails_with_code(125)
+        .stderr_contains("env: cannot unset '=A1B2C3': Invalid argument");
+    ts.ucmd().arg("--split-string=A1B=2C3=").succeeds();
+    ts.ucmd()
+        .arg("--unset=")
+        .fails_with_code(125)
+        .stderr_contains("env: cannot unset '': Invalid argument");
+}
+
+#[cfg(test)]
+mod tests_split_iterator {
+
+    enum EscapeStyle {
+        /// No escaping.
+        None,
+        /// Wrap in single quotes.
+        SingleQuoted,
+        /// Single quotes combined with backslash.
+        Mixed,
+    }
+
+    /// Determines escaping style to use.
+    fn escape_style(s: &str) -> EscapeStyle {
+        if s.is_empty() {
+            return EscapeStyle::SingleQuoted;
+        }
+
+        let mut special = false;
+        let mut newline = false;
+        let mut single_quote = false;
+
+        for c in s.chars() {
+            match c {
+                '\n' => {
+                    newline = true;
+                    special = true;
+                }
+                '\'' => {
+                    single_quote = true;
+                    special = true;
+                }
+                '|' | '&' | ';' | '<' | '>' | '(' | ')' | '$' | '`' | '\\' | '"' | ' ' | '\t'
+                | '*' | '?' | '[' | '#' | '˜' | '=' | '%' => {
+                    special = true;
+                }
+                _ => (),
+            }
+        }
+
+        if !special {
+            EscapeStyle::None
+        } else if newline && !single_quote {
+            EscapeStyle::SingleQuoted
+        } else {
+            EscapeStyle::Mixed
+        }
+    }
+
+    /// Escapes special characters in a string, so that it will retain its literal
+    /// meaning when used as a part of command in Unix shell.
+    ///
+    /// It tries to avoid introducing any unnecessary quotes or escape characters,
+    /// but specifics regarding quoting style are left unspecified.
+    pub fn quote(s: &str) -> std::borrow::Cow<str> {
+        // We are going somewhat out of the way to provide
+        // minimal amount of quoting in typical cases.
+        match escape_style(s) {
+            EscapeStyle::None => s.into(),
+            EscapeStyle::SingleQuoted => format!("'{s}'").into(),
+            EscapeStyle::Mixed => {
+                let mut quoted = String::new();
+                quoted.push('\'');
+                for c in s.chars() {
+                    if c == '\'' {
+                        quoted.push_str("'\\''");
+                    } else {
+                        quoted.push(c);
+                    }
+                }
+                quoted.push('\'');
+                quoted.into()
+            }
+        }
+    }
+
+    /// Joins arguments into a single command line suitable for execution in Unix
+    /// shell.
+    ///
+    /// Each argument is quoted using [`quote`] to preserve its literal meaning when
+    /// parsed by Unix shell.
+    ///
+    /// Note: This function is essentially an inverse of [`split`].
+    ///
+    /// # Examples
+    ///
+    /// Logging executed commands in format that can be easily copied and pasted
+    /// into an actual shell:
+    ///
+    /// ```rust,no_run
+    /// fn execute(args: &[&str]) {
+    ///     use std::process::Command;
+    ///     println!("Executing: {}", shell_words::join(args));
+    ///     Command::new(&args[0])
+    ///         .args(&args[1..])
+    ///         .spawn()
+    ///         .expect("failed to start subprocess")
+    ///         .wait()
+    ///         .expect("failed to wait for subprocess");
+    /// }
+    ///
+    /// execute(&["python", "-c", "print('Hello world!')"]);
+    /// ```
+    ///
+    /// [`quote`]: fn.quote.html
+    /// [`split`]: fn.split.html
+    pub fn join<I, S>(words: I) -> String
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        let mut line = words.into_iter().fold(String::new(), |mut line, word| {
+            let quoted = quote(word.as_ref());
+            line.push_str(quoted.as_ref());
+            line.push(' ');
+            line
+        });
+        line.pop();
+        line
+    }
+
+    use std::ffi::OsString;
+
+    use env::{
+        EnvError,
+        native_int_str::{Convert, NCvt, from_native_int_representation_owned},
+    };
+
+    fn split(input: &str) -> Result<Vec<OsString>, EnvError> {
+        ::env::split_iterator::split(&NCvt::convert(input)).map(|vec| {
+            vec.into_iter()
+                .map(from_native_int_representation_owned)
+                .collect()
+        })
+    }
+
+    fn split_ok(cases: &[(&str, &[&str])]) {
+        for (i, &(input, expected)) in cases.iter().enumerate() {
+            match split(input) {
+                Err(actual) => {
+                    panic!(
+                        "[{i}] calling split({input:?}):\nexpected: Ok({expected:?})\n  actual: Err({actual:?})\n"
+                    );
+                }
+                Ok(actual) => {
+                    assert_eq!(
+                        expected,
+                        actual.as_slice(),
+                        "[{i}] After split({input:?}).unwrap()\nexpected: {expected:?}\n  actual: {actual:?}\n"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn split_empty() {
+        split_ok(&[("", &[])]);
+    }
+
+    #[test]
+    fn split_initial_whitespace_is_removed() {
+        split_ok(&[
+            ("     a", &["a"]),
+            ("\t\t\t\tbar", &["bar"]),
+            ("\t \nc", &["c"]),
+        ]);
+    }
+
+    #[test]
+    fn split_trailing_whitespace_is_removed() {
+        split_ok(&[
+            ("a  ", &["a"]),
+            ("b\t", &["b"]),
+            ("c\t \n \n \n", &["c"]),
+            ("d\n\n", &["d"]),
+        ]);
+    }
+
+    #[test]
+    fn split_carriage_return() {
+        split_ok(&[("c\ra\r'\r'\r", &["c", "a", "\r"])]);
+    }
+
+    #[test]
+    fn split_() {
+        split_ok(&[("\\'\\'", &["''"])]);
+    }
+
+    #[test]
+    fn split_single_quotes() {
+        split_ok(&[
+            (r"''", &[r""]),
+            (r"'a'", &[r"a"]),
+            (r"'\\'", &[r"\"]),
+            (r"' \\ '", &[r" \ "]),
+            (r"'#'", &[r"#"]),
+        ]);
+    }
+
+    #[test]
+    fn split_double_quotes() {
+        split_ok(&[
+            (r#""""#, &[""]),
+            (r#""""""#, &[""]),
+            (r#""a b c' d""#, &["a b c' d"]),
+            (r#""\$""#, &["$"]),
+            (r#""`""#, &["`"]),
+            (r#""\"""#, &["\""]),
+            (r#""\\""#, &["\\"]),
+            ("\"\n\"", &["\n"]),
+            ("\"\\\n\"", &[""]),
+        ]);
+    }
+
+    #[test]
+    fn split_unquoted() {
+        split_ok(&[
+            (r"\\|\\&\\;", &[r"\|\&\;"]),
+            (r"\\<\\>", &[r"\<\>"]),
+            (r"\\(\\)", &[r"\(\)"]),
+            (r"\$", &[r"$"]),
+            (r#"\""#, &[r#"""#]),
+            (r"\'", &[r"'"]),
+            ("\\\n", &[]),
+            (" \\\n \n", &[]),
+            ("a\nb\nc", &["a", "b", "c"]),
+            ("a\\\nb\\\nc", &["abc"]),
+            ("foo bar baz", &["foo", "bar", "baz"]),
+        ]);
+    }
+
+    #[test]
+    fn split_trailing_backslash() {
+        assert_eq!(
+            split("\\"),
+            Err(EnvError::EnvInvalidBackslashAtEndOfStringInMinusS(
+                1,
+                "Delimiter".into()
+            ))
+        );
+        assert_eq!(
+            split(" \\"),
+            Err(EnvError::EnvInvalidBackslashAtEndOfStringInMinusS(
+                2,
+                "Delimiter".into()
+            ))
+        );
+        assert_eq!(
+            split("a\\"),
+            Err(EnvError::EnvInvalidBackslashAtEndOfStringInMinusS(
+                2,
+                "Unquoted".into()
+            ))
+        );
+    }
+
+    #[test]
+    fn split_errors() {
+        assert_eq!(
+            split("'abc"),
+            Err(EnvError::EnvMissingClosingQuote(4, '\''))
+        );
+        assert_eq!(split("\""), Err(EnvError::EnvMissingClosingQuote(1, '"')));
+        assert_eq!(split("'\\"), Err(EnvError::EnvMissingClosingQuote(2, '\'')));
+        assert_eq!(split("'\\"), Err(EnvError::EnvMissingClosingQuote(2, '\'')));
+        assert_eq!(
+            split(r#""$""#),
+            Err(EnvError::EnvParsingOfMissingVariable(2)),
+        );
+    }
+
+    #[test]
+    fn split_error_fail_with_unknown_escape_sequences() {
+        assert_eq!(
+            split("\\a"),
+            Err(EnvError::EnvInvalidSequenceBackslashXInMinusS(1, 'a'))
+        );
+        assert_eq!(
+            split("\"\\a\""),
+            Err(EnvError::EnvInvalidSequenceBackslashXInMinusS(2, 'a'))
+        );
+        assert_eq!(
+            split("'\\a'"),
+            Err(EnvError::EnvInvalidSequenceBackslashXInMinusS(2, 'a'))
+        );
+        assert_eq!(
+            split(r#""\a""#),
+            Err(EnvError::EnvInvalidSequenceBackslashXInMinusS(2, 'a'))
+        );
+        assert_eq!(
+            split(r"\🦉"),
+            Err(EnvError::EnvInvalidSequenceBackslashXInMinusS(
+                1, '\u{FFFD}'
+            ))
+        );
+    }
+
+    #[test]
+    fn split_comments() {
+        split_ok(&[
+            (r" x # comment ", &["x"]),
+            (r" w1#w2 ", &["w1#w2"]),
+            (r"'not really a # comment'", &["not really a # comment"]),
+            (" a # very long comment \n b # another comment", &["a", "b"]),
+        ]);
+    }
+
+    #[test]
+    fn test_quote() {
+        assert_eq!(quote(""), "''");
+        assert_eq!(quote("'"), "''\\'''");
+        assert_eq!(quote("abc"), "abc");
+        assert_eq!(quote("a \n  b"), "'a \n  b'");
+        assert_eq!(quote("X'\nY"), "'X'\\''\nY'");
+    }
+
+    #[test]
+    fn test_join() {
+        assert_eq!(join(["a", "b", "c"]), "a b c");
+        assert_eq!(join([" ", "$", "\n"]), "' ' '$' '\n'");
+    }
+
+    #[test]
+    fn join_followed_by_split_is_identity() {
+        let cases: Vec<&[&str]> = vec![
+            &["a"],
+            &["python", "-c", "print('Hello world!')"],
+            &["echo", " arg with spaces ", "arg \' with \" quotes"],
+            &["even newlines are quoted correctly\n", "\n", "\n\n\t "],
+            &["$", "`test`"],
+            &["cat", "~user/log*"],
+            &["test", "'a \"b", "\"X'"],
+            &["empty", "", "", ""],
+        ];
+        for argv in cases {
+            let args = join(argv);
+            assert_eq!(split(&args).unwrap(), argv);
+        }
+    }
+}
+
+mod test_raw_string_parser {
+    use std::{
+        borrow::Cow,
+        ffi::{OsStr, OsString},
+    };
+
+    use env::{
+        native_int_str::{
+            NativeStr, from_native_int_representation, from_native_int_representation_owned,
+            to_native_int_representation,
+        },
+        string_expander::StringExpander,
+        string_parser,
+    };
+
+    const LEN_OWL: usize = if cfg!(target_os = "windows") { 2 } else { 4 };
+
+    #[test]
+    fn test_ascii_only_take_one_look_at_correct_data_and_end_behavior() {
+        let input = "hello";
+        let cow = to_native_int_representation(OsStr::new(input));
+        let mut uut = StringExpander::new(&cow);
+        for c in input.chars() {
+            assert_eq!(c, uut.get_parser().peek().unwrap());
+            uut.take_one().unwrap();
+        }
+        assert_eq!(
+            uut.get_parser().peek(),
+            Err(string_parser::Error {
+                peek_position: 5,
+                err_type: string_parser::ErrorType::EndOfInput
+            })
+        );
+        uut.take_one().unwrap_err();
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            input
+        );
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            ""
+        );
+    }
+
+    #[test]
+    fn test_multi_byte_codes_take_one_look_at_correct_data_and_end_behavior() {
+        let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+        let cow = to_native_int_representation(input.as_os_str());
+        let mut uut = StringExpander::new(&cow);
+        for _i in 0..3 {
+            assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+            uut.take_one().unwrap();
+            assert_eq!(uut.get_parser().peek().unwrap(), 'x');
+            uut.take_one().unwrap();
+        }
+        assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+        uut.take_one().unwrap();
+        assert_eq!(
+            uut.get_parser().peek(),
+            Err(string_parser::Error {
+                peek_position: 10 * LEN_OWL + 3,
+                err_type: string_parser::ErrorType::EndOfInput
+            })
+        );
+        uut.take_one().unwrap_err();
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            input
+        );
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            ""
+        );
+    }
+
+    #[test]
+    fn test_multi_byte_codes_put_one_ascii_start_middle_end_try_invalid_ascii() {
+        let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+        let cow = to_native_int_representation(input.as_os_str());
+        let owl: char = '🦉';
+        let mut uut = StringExpander::new(&cow);
+        uut.put_one_char('a');
+        for _i in 0..3 {
+            assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+            uut.take_one().unwrap();
+            uut.put_one_char('a');
+            assert_eq!(uut.get_parser().peek().unwrap(), 'x');
+            uut.take_one().unwrap();
+            uut.put_one_char('a');
+        }
+        assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+        uut.take_one().unwrap();
+        uut.put_one_char(owl);
+        uut.put_one_char('a');
+        assert_eq!(
+            uut.get_parser().peek(),
+            Err(string_parser::Error {
+                peek_position: LEN_OWL * 10 + 3,
+                err_type: string_parser::ErrorType::EndOfInput
+            })
+        );
+        uut.take_one().unwrap_err();
+        uut.put_one_char('a');
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            "a🦉🦉🦉axa🦉🦉axa🦉axa🦉🦉🦉🦉🦉aa"
+        );
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            ""
+        );
+    }
+
+    #[test]
+    fn test_multi_byte_codes_skip_one_take_one_skip_until_ascii_char_or_end() {
+        let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+        let cow = to_native_int_representation(input.as_os_str());
+        let mut uut = StringExpander::new(&cow);
+
+        uut.skip_one().unwrap(); // skip 🦉🦉🦉
+        let p = LEN_OWL * 3;
+        assert_eq!(uut.get_peek_position(), p);
+
+        uut.skip_one().unwrap(); // skip x
+        assert_eq!(uut.get_peek_position(), p + 1);
+        uut.take_one().unwrap(); // take 🦉🦉
+        let p = p + 1 + LEN_OWL * 2;
+        assert_eq!(uut.get_peek_position(), p);
+
+        uut.skip_one().unwrap(); // skip x
+        assert_eq!(uut.get_peek_position(), p + 1);
+        uut.get_parser_mut().skip_until_char_or_end('x'); // skip 🦉
+        let p = p + 1 + LEN_OWL;
+        assert_eq!(uut.get_peek_position(), p);
+        uut.take_one().unwrap(); // take x
+        uut.get_parser_mut().skip_until_char_or_end('x'); // skip 🦉🦉🦉🦉 till end
+        let p = p + 1 + LEN_OWL * 4;
+        assert_eq!(uut.get_peek_position(), p);
+
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            "🦉🦉x"
+        );
+    }
+
+    #[test]
+    fn test_multi_byte_codes_skip_multiple_ascii_bounded_good_and_bad() {
+        let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+        let cow = to_native_int_representation(input.as_os_str());
+        let mut uut = StringExpander::new(&cow);
+
+        uut.get_parser_mut().skip_multiple(0);
+        assert_eq!(uut.get_peek_position(), 0);
+        let p = LEN_OWL * 3;
+        uut.get_parser_mut().skip_multiple(p); // skips 🦉🦉🦉
+        assert_eq!(uut.get_peek_position(), p);
+
+        uut.take_one().unwrap(); // take x
+        assert_eq!(uut.get_peek_position(), p + 1);
+        let step = LEN_OWL * 3 + 1;
+        uut.get_parser_mut().skip_multiple(step); // skips 🦉🦉x🦉
+        let p = p + 1 + step;
+        assert_eq!(uut.get_peek_position(), p);
+        uut.take_one().unwrap(); // take x
+
+        assert_eq!(uut.get_peek_position(), p + 1);
+        let step = 4 * LEN_OWL;
+        uut.get_parser_mut().skip_multiple(step); // skips 🦉🦉🦉🦉
+        let p = p + 1 + step;
+        assert_eq!(uut.get_peek_position(), p);
+
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            "xx"
+        );
+    }
+
+    #[test]
+    fn test_multi_byte_codes_put_string_utf8_start_middle_end() {
+        let input = OsString::from("🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉");
+        let cow = to_native_int_representation(input.as_os_str());
+        let mut uut = StringExpander::new(&cow);
+
+        uut.put_string("🦔oo");
+        uut.take_one().unwrap(); // takes 🦉🦉🦉
+        uut.put_string("oo🦔");
+        uut.take_one().unwrap(); // take x
+        uut.get_parser_mut().skip_until_char_or_end('\n'); // skips till end
+        uut.put_string("o🦔o");
+
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            "🦔oo🦉🦉🦉oo🦔xo🦔o"
+        );
+    }
+
+    #[test]
+    fn test_multi_byte_codes_look_at_remaining_start_middle_end() {
+        let input = "🦉🦉🦉x🦉🦉x🦉x🦉🦉🦉🦉";
+        let cow = to_native_int_representation(OsStr::new(input));
+        let mut uut = StringExpander::new(&cow);
+
+        assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(input));
+        uut.take_one().unwrap(); // takes 🦉🦉🦉
+        assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(&input[12..]));
+        uut.get_parser_mut().skip_until_char_or_end('\n'); // skips till end
+        assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(""));
+
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            "🦉🦉🦉"
+        );
+    }
+
+    #[test]
+    fn test_deal_with_invalid_encoding() {
+        let owl_invalid_part;
+        let (brace_1, brace_2);
+        #[cfg(target_os = "windows")]
+        {
+            let mut buffer = [0u16; 2];
+            let owl = '🦉'.encode_utf16(&mut buffer);
+            owl_invalid_part = owl[0];
+            brace_1 = '<'.encode_utf16(&mut buffer).to_vec();
+            brace_2 = '>'.encode_utf16(&mut buffer).to_vec();
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            let mut buffer = [0u8; 4];
+            let owl = '🦉'.encode_utf8(&mut buffer);
+            owl_invalid_part = owl.bytes().next().unwrap();
+            brace_1 = [b'<'].to_vec();
+            brace_2 = [b'>'].to_vec();
+        }
+        let mut input_ux = brace_1;
+        input_ux.push(owl_invalid_part);
+        input_ux.extend(brace_2);
+        let input_str = from_native_int_representation(Cow::Borrowed(&input_ux));
+        let mut uut = StringExpander::new(&input_ux);
+
+        assert_eq!(uut.get_parser().peek_remaining(), input_str);
+        assert_eq!(uut.get_parser().peek().unwrap(), '<');
+        uut.take_one().unwrap(); // takes "<"
+        assert_eq!(
+            uut.get_parser().peek_remaining(),
+            NativeStr::new(&input_str).split_at(1).1
+        );
+        assert_eq!(uut.get_parser().peek().unwrap(), '\u{FFFD}');
+        uut.take_one().unwrap(); // takes owl_b
+        assert_eq!(
+            uut.get_parser().peek_remaining(),
+            NativeStr::new(&input_str).split_at(2).1
+        );
+        assert_eq!(uut.get_parser().peek().unwrap(), '>');
+        uut.get_parser_mut().skip_until_char_or_end('\n');
+        assert_eq!(uut.get_parser().peek_remaining(), OsStr::new(""));
+
+        uut.take_one().unwrap_err();
+        assert_eq!(
+            from_native_int_representation_owned(uut.take_collected_output()),
+            NativeStr::new(&input_str).split_at(2).0
+        );
+    }
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_false() {
+    let scene = TestScenario::new("util");
+
+    let out = scene.ccmd("env").arg("sh").arg("is_a_tty.sh").succeeds();
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "stdin is not a tty\nstdout is not a tty\nstderr is not a tty\n"
+    );
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stderr()),
+        "This is an error message.\n"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_true() {
+    let scene = TestScenario::new("util");
+
+    let out = scene
+        .ccmd("env")
+        .arg("sh")
+        .arg("is_a_tty.sh")
+        .terminal_simulation(true)
+        .succeeds();
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "stdin is a tty\r\nterminal size: 30 80\r\nstdout is a tty\r\nstderr is a tty\r\n"
+    );
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stderr()),
+        "This is an error message.\r\n"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_for_stdin_only() {
+    let scene = TestScenario::new("util");
+
+    let out = scene
+        .ccmd("env")
+        .arg("sh")
+        .arg("is_a_tty.sh")
+        .terminal_sim_stdio(TerminalSimulation {
+            stdin: true,
+            stdout: false,
+            stderr: false,
+            ..Default::default()
+        })
+        .succeeds();
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "stdin is a tty\nterminal size: 30 80\nstdout is not a tty\nstderr is not a tty\n"
+    );
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stderr()),
+        "This is an error message.\n"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_for_stdout_only() {
+    let scene = TestScenario::new("util");
+
+    let out = scene
+        .ccmd("env")
+        .arg("sh")
+        .arg("is_a_tty.sh")
+        .terminal_sim_stdio(TerminalSimulation {
+            stdin: false,
+            stdout: true,
+            stderr: false,
+            ..Default::default()
+        })
+        .succeeds();
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "stdin is not a tty\r\nstdout is a tty\r\nstderr is not a tty\r\n"
+    );
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stderr()),
+        "This is an error message.\n"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_for_stderr_only() {
+    let scene = TestScenario::new("util");
+
+    let out = scene
+        .ccmd("env")
+        .arg("sh")
+        .arg("is_a_tty.sh")
+        .terminal_sim_stdio(TerminalSimulation {
+            stdin: false,
+            stdout: false,
+            stderr: true,
+            ..Default::default()
+        })
+        .succeeds();
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "stdin is not a tty\nstdout is not a tty\nstderr is a tty\n"
+    );
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stderr()),
+        "This is an error message.\r\n"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_size_information() {
+    let scene = TestScenario::new("util");
+
+    let out = scene
+        .ccmd("env")
+        .arg("sh")
+        .arg("is_a_tty.sh")
+        .terminal_sim_stdio(TerminalSimulation {
+            size: Some(libc::winsize {
+                ws_col: 40,
+                ws_row: 10,
+                ws_xpixel: 40 * 8,
+                ws_ypixel: 10 * 10,
+            }),
+            stdout: true,
+            stdin: true,
+            stderr: true,
+        })
+        .succeeds();
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "stdin is a tty\r\nterminal size: 10 40\r\nstdout is a tty\r\nstderr is a tty\r\n"
+    );
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stderr()),
+        "This is an error message.\r\n"
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_pty_sends_eot_automatically() {
+    let scene = TestScenario::new("util");
+
+    let mut cmd = scene.ccmd("env");
+    cmd.timeout(std::time::Duration::from_secs(10));
+    cmd.args(&["cat", "-"]);
+    cmd.terminal_simulation(true);
+    let child = cmd.run_no_wait();
+    let out = child.wait().unwrap(); // cat would block if there is no eot
+
+    std::assert_eq!(String::from_utf8_lossy(out.stderr()), "");
+    std::assert_eq!(String::from_utf8_lossy(out.stdout()), "\r\n");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_pty_pipes_into_data_and_sends_eot_automatically() {
+    let scene = TestScenario::new("util");
+
+    let message = "Hello stdin forwarding!";
+
+    let mut cmd = scene.ccmd("env");
+    cmd.args(&["cat", "-"]);
+    cmd.terminal_simulation(true);
+    cmd.pipe_in(message);
+    let child = cmd.run_no_wait();
+    let out = child.wait().unwrap();
+
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        format!("{message}\r\n")
+    );
+    std::assert_eq!(String::from_utf8_lossy(out.stderr()), "");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_simulation_of_terminal_pty_write_in_data_and_sends_eot_automatically() {
+    let scene = TestScenario::new("util");
+
+    let mut cmd = scene.ccmd("env");
+    cmd.args(&["cat", "-"]);
+    cmd.terminal_simulation(true);
+    let mut child = cmd.run_no_wait();
+    child.write_in("Hello stdin forwarding via write_in!");
+    let out = child.wait().unwrap();
+
+    std::assert_eq!(
+        String::from_utf8_lossy(out.stdout()),
+        "Hello stdin forwarding via write_in!\r\n"
+    );
+    std::assert_eq!(String::from_utf8_lossy(out.stderr()), "");
+}
diff --git a/tests/by-util/test_expand.rs b/tests/by-util/test_expand.rs
index f6802358cc3..8e4de344e3d 100644
--- a/tests/by-util/test_expand.rs
+++ b/tests/by-util/test_expand.rs
@@ -2,13 +2,15 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
 use uucore::display::Quotable;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 // spell-checker:ignore (ToDO) taaaa tbbbb tcccc
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -392,3 +394,37 @@ fn test_comma_with_plus_4() {
         //          01234567890
         .stdout_is("a  b    c");
 }
+
+#[test]
+fn test_args_override() {
+    new_ucmd!()
+        .args(&["-i", "-i", "with-trailing-tab.txt"])
+        .succeeds()
+        .stdout_is(
+            "// !note: file contains significant whitespace
+// * indentation uses <TAB> characters
+int main() {
+        // * next line has both a leading & trailing tab
+        // with tabs=>\t
+        return 0;
+}
+",
+        );
+}
+
+#[test]
+fn test_expand_directory() {
+    new_ucmd!()
+        .args(&["."])
+        .fails()
+        .stderr_contains("expand: .: Is a directory");
+}
+
+#[test]
+fn test_nonexisting_file() {
+    new_ucmd!()
+        .args(&["nonexistent", "with-spaces.txt"])
+        .fails()
+        .stderr_contains("expand: nonexistent: No such file or directory")
+        .stdout_contains_line("// !note: file contains significant whitespace");
+}
diff --git a/tests/by-util/test_expr.rs b/tests/by-util/test_expr.rs
index 665f89615e4..0a16d4ea958 100644
--- a/tests/by-util/test_expr.rs
+++ b/tests/by-util/test_expr.rs
@@ -3,27 +3,36 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore αbcdef ; (people) kkos
+// spell-checker:ignore aabcccd aabcd aabd abbb abbbd abbcabc abbcac abbcbbbd abbcbd
+// spell-checker:ignore abbccd abcabc abcac acabc andand bigcmp bignum emptysub
+// spell-checker:ignore orempty oror
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+#[test]
+fn test_no_arguments() {
+    new_ucmd!()
+        .fails_with_code(2)
+        .usage_error("missing operand");
+}
 
 #[test]
 fn test_simple_values() {
     // null or 0 => EXIT_VALUE == 1
-    new_ucmd!().args(&[""]).fails().code_is(1).stdout_only("\n");
+    new_ucmd!().args(&[""]).fails_with_code(1).stdout_only("\n");
     new_ucmd!()
         .args(&["0"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_only("0\n");
     new_ucmd!()
         .args(&["00"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_only("00\n");
     new_ucmd!()
         .args(&["-0"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_only("-0\n");
 
     // non-null and non-0 => EXIT_VALUE = 0
@@ -39,8 +48,7 @@ fn test_simple_arithmetic() {
 
     new_ucmd!()
         .args(&["1", "-", "1"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_only("0\n");
 
     new_ucmd!()
@@ -100,6 +108,11 @@ fn test_parenthesis() {
         .args(&["(", "1", "+", "1", ")", "*", "2"])
         .succeeds()
         .stdout_only("4\n");
+
+    new_ucmd!()
+        .args(&["1", "(", ")"])
+        .fails_with_code(2)
+        .stderr_only("expr: syntax error: unexpected argument '('\n");
 }
 
 #[test]
@@ -113,6 +126,50 @@ fn test_or() {
         .args(&["foo", "|", "bar"])
         .succeeds()
         .stdout_only("foo\n");
+
+    new_ucmd!()
+        .args(&["14", "|", "1"])
+        .succeeds()
+        .stdout_only("14\n");
+
+    new_ucmd!()
+        .args(&["-14", "|", "1"])
+        .succeeds()
+        .stdout_only("-14\n");
+
+    new_ucmd!()
+        .args(&["1", "|", "a", "/", "5"])
+        .succeeds()
+        .stdout_only("1\n");
+
+    new_ucmd!()
+        .args(&["foo", "|", "a", "/", "5"])
+        .succeeds()
+        .stdout_only("foo\n");
+
+    new_ucmd!()
+        .args(&["0", "|", "10", "/", "5"])
+        .succeeds()
+        .stdout_only("2\n");
+
+    new_ucmd!()
+        .args(&["12", "|", "9a", "+", "1"])
+        .succeeds()
+        .stdout_only("12\n");
+
+    new_ucmd!().args(&["", "|", ""]).fails().stdout_only("0\n");
+
+    new_ucmd!().args(&["", "|", "0"]).fails().stdout_only("0\n");
+
+    new_ucmd!()
+        .args(&["", "|", "00"])
+        .fails()
+        .stdout_only("0\n");
+
+    new_ucmd!()
+        .args(&["", "|", "-0"])
+        .fails()
+        .stdout_only("0\n");
 }
 
 #[test]
@@ -122,15 +179,41 @@ fn test_and() {
         .succeeds()
         .stdout_only("foo\n");
 
-    new_ucmd!().args(&["", "&", "1"]).run().stdout_is("0\n");
+    new_ucmd!()
+        .args(&["14", "&", "1"])
+        .succeeds()
+        .stdout_only("14\n");
+
+    new_ucmd!()
+        .args(&["-14", "&", "1"])
+        .succeeds()
+        .stdout_only("-14\n");
+
+    new_ucmd!()
+        .args(&["-1", "&", "10", "/", "5"])
+        .succeeds()
+        .stdout_only("-1\n");
+
+    new_ucmd!()
+        .args(&["0", "&", "a", "/", "5"])
+        .fails()
+        .stdout_only("0\n");
+
+    new_ucmd!()
+        .args(&["", "&", "a", "/", "5"])
+        .fails()
+        .stdout_only("0\n");
+
+    new_ucmd!().args(&["", "&", "1"]).fails().stdout_only("0\n");
+
+    new_ucmd!().args(&["", "&", ""]).fails().stdout_only("0\n");
 }
 
 #[test]
 fn test_index() {
     new_ucmd!()
         .args(&["index", "αbcdef", "x"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_only("0\n");
     new_ucmd!()
         .args(&["index", "αbcdef", "α"])
@@ -156,6 +239,11 @@ fn test_index() {
         .args(&["index", "αbcdef_f", "f"])
         .succeeds()
         .stdout_only("6\n");
+
+    new_ucmd!()
+        .args(&["αbcdef", "index", "α"])
+        .fails_with_code(2)
+        .stderr_only("expr: syntax error: unexpected argument 'index'\n");
 }
 
 #[test]
@@ -169,6 +257,11 @@ fn test_length() {
         .args(&["length", "abcdef"])
         .succeeds()
         .stdout_only("6\n");
+
+    new_ucmd!()
+        .args(&["abcdef", "length"])
+        .fails_with_code(2)
+        .stderr_only("expr: syntax error: unexpected argument 'length'\n");
 }
 
 #[test]
@@ -180,24 +273,225 @@ fn test_length_mb() {
 }
 
 #[test]
-fn test_regex() {
-    // FixME: [2022-12-19; rivy] test disabled as it currently fails due to 'oniguruma' bug (see GH:kkos/oniguruma/issues/279)
-    // new_ucmd!()
-    //     .args(&["a^b", ":", "a^b"])
-    //     .succeeds()
-    //     .stdout_only("3\n");
+fn test_regex_empty() {
+    new_ucmd!().args(&["", ":", ""]).fails().stdout_only("0\n");
+    new_ucmd!()
+        .args(&["abc", ":", ""])
+        .fails()
+        .stdout_only("0\n");
+}
+
+#[test]
+fn test_regex_trailing_backslash() {
+    new_ucmd!()
+        .args(&["\\", ":", "\\\\"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["\\", ":", "\\"])
+        .fails()
+        .stderr_only("expr: Trailing backslash\n");
+    new_ucmd!()
+        .args(&["abc\\", ":", "abc\\\\"])
+        .succeeds()
+        .stdout_only("4\n");
+    new_ucmd!()
+        .args(&["abc\\", ":", "abc\\"])
+        .fails()
+        .stderr_only("expr: Trailing backslash\n");
+}
+
+#[test]
+fn test_regex_caret() {
+    new_ucmd!()
+        .args(&["a^b", ":", "a^b"])
+        .succeeds()
+        .stdout_only("3\n");
     new_ucmd!()
         .args(&["a^b", ":", "a\\^b"])
         .succeeds()
         .stdout_only("3\n");
+    new_ucmd!()
+        .args(&["abc", ":", "^abc"])
+        .succeeds()
+        .stdout_only("3\n");
+    new_ucmd!()
+        .args(&["^abc", ":", "^^abc"])
+        .succeeds()
+        .stdout_only("4\n");
+    new_ucmd!()
+        .args(&["b", ":", "a\\|^b"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["ab", ":", "\\(^a\\)b"])
+        .succeeds()
+        .stdout_only("a\n");
+    new_ucmd!()
+        .args(&["^abc", ":", "^abc"])
+        .fails()
+        .stdout_only("0\n");
+    new_ucmd!()
+        .args(&["^^^^^^^^^", ":", "^^^"])
+        .succeeds()
+        .stdout_only("2\n");
+    new_ucmd!()
+        .args(&["ab[^c]", ":", "ab[^c]"])
+        .succeeds()
+        .stdout_only("3\n"); // Matches "ab["
+    new_ucmd!()
+        .args(&["ab[^c]", ":", "ab\\[^c]"])
+        .succeeds()
+        .stdout_only("6\n");
+    new_ucmd!()
+        .args(&["[^a]", ":", "\\[^a]"])
+        .succeeds()
+        .stdout_only("4\n");
+    new_ucmd!()
+        .args(&["\\a", ":", "\\\\[^^]"])
+        .succeeds()
+        .stdout_only("2\n");
+    // Patterns are anchored to the beginning of the pattern "^bc"
+    new_ucmd!()
+        .args(&["abc", ":", "bc"])
+        .fails()
+        .stdout_only("0\n");
+    new_ucmd!()
+        .args(&["^a", ":", "^^[^^]"])
+        .succeeds()
+        .stdout_only("2\n");
+    new_ucmd!()
+        .args(&["abc", ":", "ab[^c]"])
+        .fails()
+        .stdout_only("0\n");
+}
+
+#[test]
+fn test_regex_dollar() {
     new_ucmd!()
         .args(&["a$b", ":", "a\\$b"])
         .succeeds()
         .stdout_only("3\n");
+    new_ucmd!()
+        .args(&["a", ":", "a$\\|b"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["ab", ":", "a\\(b$\\)"])
+        .succeeds()
+        .stdout_only("b\n");
+    new_ucmd!()
+        .args(&["a$c", ":", "a$\\c"])
+        .succeeds()
+        .stdout_only("3\n");
+    new_ucmd!()
+        .args(&["$a", ":", "$a"])
+        .succeeds()
+        .stdout_only("2\n");
+    new_ucmd!()
+        .args(&["a", ":", "a$\\|b"])
+        .succeeds()
+        .stdout_only("1\n");
     new_ucmd!()
         .args(&["-5", ":", "-\\{0,1\\}[0-9]*$"])
         .succeeds()
         .stdout_only("2\n");
+    new_ucmd!()
+        .args(&["$", ":", "$"])
+        .fails()
+        .stdout_only("0\n");
+    new_ucmd!()
+        .args(&["a$", ":", "a$\\|b"])
+        .fails()
+        .stdout_only("0\n");
+}
+
+#[test]
+fn test_regex_range_quantifier() {
+    new_ucmd!()
+        .args(&["a", ":", "a\\{1\\}"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["aaaaaaaaaa", ":", "a\\{1,\\}"])
+        .succeeds()
+        .stdout_only("10\n");
+    new_ucmd!()
+        .args(&["aaa", ":", "a\\{,3\\}"])
+        .succeeds()
+        .stdout_only("3\n");
+    new_ucmd!()
+        .args(&["aa", ":", "a\\{1,3\\}"])
+        .succeeds()
+        .stdout_only("2\n");
+    new_ucmd!()
+        .args(&["aaaa", ":", "a\\{,\\}"])
+        .succeeds()
+        .stdout_only("4\n");
+    new_ucmd!()
+        .args(&["a", ":", "ab\\{,3\\}"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["abbb", ":", "ab\\{,3\\}"])
+        .succeeds()
+        .stdout_only("4\n");
+    new_ucmd!()
+        .args(&["abcabc", ":", "\\(abc\\)\\{,\\}"])
+        .succeeds()
+        .stdout_only("abc\n");
+    new_ucmd!()
+        .args(&["a", ":", "a\\{,6\\}"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["{abc}", ":", "\\{abc\\}"])
+        .succeeds()
+        .stdout_only("5\n");
+    new_ucmd!()
+        .args(&["a{bc}", ":", "a\\(\\{bc\\}\\)"])
+        .succeeds()
+        .stdout_only("{bc}\n");
+    new_ucmd!()
+        .args(&["{b}", ":", "a\\|\\{b\\}"])
+        .succeeds()
+        .stdout_only("3\n");
+    new_ucmd!()
+        .args(&["{", ":", "a\\|\\{"])
+        .succeeds()
+        .stdout_only("1\n");
+    new_ucmd!()
+        .args(&["{}}}", ":", "\\{\\}\\}\\}"])
+        .succeeds()
+        .stdout_only("4\n");
+    new_ucmd!()
+        .args(&["a{}}}", ":", "a\\{\\}\\}\\}"])
+        .fails()
+        .stderr_only("expr: Invalid content of \\{\\}\n");
+    new_ucmd!()
+        .args(&["ab", ":", "ab\\{\\}"])
+        .fails()
+        .stderr_only("expr: Invalid content of \\{\\}\n");
+    new_ucmd!()
+        .args(&["_", ":", "a\\{12345678901234567890\\}"])
+        .fails()
+        .stderr_only("expr: Regular expression too big\n");
+    new_ucmd!()
+        .args(&["_", ":", "a\\{12345678901234567890,\\}"])
+        .fails()
+        .stderr_only("expr: Regular expression too big\n");
+    new_ucmd!()
+        .args(&["_", ":", "a\\{,12345678901234567890\\}"])
+        .fails()
+        .stderr_only("expr: Regular expression too big\n");
+    new_ucmd!()
+        .args(&["_", ":", "a\\{1,12345678901234567890\\}"])
+        .fails()
+        .stderr_only("expr: Regular expression too big\n");
+    new_ucmd!()
+        .args(&["_", ":", "a\\{1,1234567890abcdef\\}"])
+        .fails()
+        .stderr_only("expr: Invalid content of \\{\\}\n");
 }
 
 #[test]
@@ -206,25 +500,968 @@ fn test_substr() {
         .args(&["substr", "abc", "1", "1"])
         .succeeds()
         .stdout_only("a\n");
+
+    new_ucmd!()
+        .args(&["abc", "substr", "1", "1"])
+        .fails_with_code(2)
+        .stderr_only("expr: syntax error: unexpected argument 'substr'\n");
 }
 
 #[test]
 fn test_invalid_substr() {
     new_ucmd!()
         .args(&["substr", "abc", "0", "1"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_only("\n");
 
     new_ucmd!()
-        .args(&["substr", "abc", &(std::usize::MAX.to_string() + "0"), "1"])
-        .fails()
-        .code_is(1)
+        .args(&["substr", "abc", &(usize::MAX.to_string() + "0"), "1"])
+        .fails_with_code(1)
         .stdout_only("\n");
 
     new_ucmd!()
-        .args(&["substr", "abc", "0", &(std::usize::MAX.to_string() + "0")])
-        .fails()
-        .code_is(1)
+        .args(&["substr", "abc", "0", &(usize::MAX.to_string() + "0")])
+        .fails_with_code(1)
         .stdout_only("\n");
 }
+
+#[test]
+fn test_escape() {
+    new_ucmd!().args(&["+", "1"]).succeeds().stdout_only("1\n");
+
+    new_ucmd!()
+        .args(&["1", "+", "+", "1"])
+        .succeeds()
+        .stdout_only("2\n");
+
+    new_ucmd!()
+        .args(&["2", "*", "+", "3"])
+        .succeeds()
+        .stdout_only("6\n");
+
+    new_ucmd!()
+        .args(&["(", "1", ")", "+", "1"])
+        .succeeds()
+        .stdout_only("2\n");
+}
+
+#[test]
+fn test_invalid_syntax() {
+    let invalid_syntaxes = [["12", "12"], ["12", "|"], ["|", "12"]];
+
+    for invalid_syntax in invalid_syntaxes {
+        new_ucmd!()
+            .args(&invalid_syntax)
+            .fails_with_code(2)
+            .stderr_contains("syntax error");
+    }
+}
+
+#[test]
+fn test_num_str_comparison() {
+    new_ucmd!()
+        .args(&["1a", "<", "1", "+", "1"])
+        .succeeds()
+        .stdout_is("1\n");
+}
+
+#[test]
+fn test_eager_evaluation() {
+    new_ucmd!()
+        .args(&["(", "1", "/", "0"])
+        .fails()
+        .stderr_contains("division by zero");
+}
+
+#[test]
+fn test_long_input() {
+    // Giving expr an arbitrary long expression should succeed rather than end with a segfault due to a stack overflow.
+    #[cfg(not(windows))]
+    const MAX_NUMBER: usize = 40000;
+    #[cfg(not(windows))]
+    const RESULT: &str = "800020000\n";
+
+    // On windows there is 8192 characters input limit
+    #[cfg(windows)]
+    const MAX_NUMBER: usize = 1300; // 7993 characters (with spaces)
+    #[cfg(windows)]
+    const RESULT: &str = "845650\n";
+
+    let mut args: Vec<String> = vec!["1".to_string()];
+
+    for i in 2..=MAX_NUMBER {
+        args.push('+'.to_string());
+        args.push(i.to_string());
+    }
+
+    new_ucmd!().args(&args).succeeds().stdout_is(RESULT);
+}
+
+/// Regroup the testcases of the GNU test expr.pl
+mod gnu_expr {
+    use uutests::new_ucmd;
+    use uutests::util::TestScenario;
+    use uutests::util_name;
+
+    #[test]
+    fn test_a() {
+        new_ucmd!()
+            .args(&["5", "+", "6"])
+            .succeeds()
+            .stdout_only("11\n");
+    }
+
+    #[test]
+    fn test_b() {
+        new_ucmd!()
+            .args(&["5", "-", "6"])
+            .succeeds()
+            .stdout_only("-1\n");
+    }
+
+    #[test]
+    fn test_c() {
+        new_ucmd!()
+            .args(&["5", "*", "6"])
+            .succeeds()
+            .stdout_only("30\n");
+    }
+
+    #[test]
+    fn test_d() {
+        new_ucmd!()
+            .args(&["100", "/", "6"])
+            .succeeds()
+            .stdout_only("16\n");
+    }
+
+    #[test]
+    fn test_e() {
+        new_ucmd!()
+            .args(&["100", "%", "6"])
+            .succeeds()
+            .stdout_only("4\n");
+    }
+
+    #[test]
+    fn test_f() {
+        new_ucmd!()
+            .args(&["3", "+", "-2"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_g() {
+        new_ucmd!()
+            .args(&["-2", "+", "-2"])
+            .succeeds()
+            .stdout_only("-4\n");
+    }
+
+    #[test]
+    fn test_opt1() {
+        new_ucmd!()
+            .args(&["--", "-11", "+", "12"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_opt2() {
+        new_ucmd!()
+            .args(&["-11", "+", "12"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_opt3() {
+        new_ucmd!()
+            .args(&["--", "-1", "+", "2"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_opt4() {
+        new_ucmd!()
+            .args(&["-1", "+", "2"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_opt5() {
+        new_ucmd!()
+            .args(&["--", "2", "+", "2"])
+            .succeeds()
+            .stdout_only("4\n");
+    }
+
+    #[test]
+    fn test_paren1() {
+        new_ucmd!()
+            .args(&["(", "100", "%", "6", ")"])
+            .succeeds()
+            .stdout_only("4\n");
+    }
+
+    #[test]
+    fn test_paren2() {
+        new_ucmd!()
+            .args(&["(", "100", "%", "6", ")", "-", "8"])
+            .succeeds()
+            .stdout_only("-4\n");
+    }
+
+    #[test]
+    fn test_paren3() {
+        new_ucmd!()
+            .args(&["9", "/", "(", "100", "%", "6", ")", "-", "8"])
+            .succeeds()
+            .stdout_only("-6\n");
+    }
+
+    #[test]
+    fn test_paren4() {
+        new_ucmd!()
+            .args(&["9", "/", "(", "(", "100", "%", "6", ")", "-", "8", ")"])
+            .succeeds()
+            .stdout_only("-2\n");
+    }
+
+    #[test]
+    fn test_paren5() {
+        new_ucmd!()
+            .args(&["9", "+", "(", "100", "%", "6", ")"])
+            .succeeds()
+            .stdout_only("13\n");
+    }
+
+    #[test]
+    fn test_0bang() {
+        new_ucmd!()
+            .args(&["00", "<", "0!"])
+            .fails()
+            .code_is(1)
+            .stdout_only("0\n");
+    }
+
+    #[test]
+    fn test_00() {
+        new_ucmd!()
+            .args(&["00"])
+            .fails()
+            .code_is(1)
+            .stdout_only("00\n");
+    }
+
+    #[test]
+    fn test_minus0() {
+        new_ucmd!()
+            .args(&["-0"])
+            .fails()
+            .code_is(1)
+            .stdout_only("-0\n");
+    }
+
+    #[test]
+    fn test_andand() {
+        new_ucmd!()
+            .args(&["0", "&", "1", "/", "0"])
+            .fails()
+            .code_is(1)
+            .stdout_only("0\n");
+    }
+
+    #[test]
+    fn test_oror() {
+        new_ucmd!()
+            .args(&["1", "|", "1", "/", "0"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_orempty() {
+        new_ucmd!()
+            .args(&["", "|", ""])
+            .fails()
+            .code_is(1)
+            .stdout_only("0\n");
+    }
+
+    #[test]
+    fn test_fail_a() {
+        new_ucmd!()
+            .args(&["3", "+", "-"])
+            .fails()
+            .code_is(2)
+            .no_stdout()
+            .stderr_contains("non-integer argument");
+    }
+
+    #[test]
+    fn test_bigcmp() {
+        new_ucmd!()
+            .args(&[
+                "--",
+                "-2417851639229258349412352",
+                "<",
+                "2417851639229258349412352",
+            ])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_anchor() {
+        new_ucmd!()
+            .args(&["a\nb", ":", "a$"])
+            .fails()
+            .code_is(1)
+            .stdout_only("0\n");
+    }
+
+    #[test]
+    fn test_emptysub() {
+        new_ucmd!()
+            .args(&["a", ":", "\\(b\\)*"])
+            .fails()
+            .code_is(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre1() {
+        new_ucmd!()
+            .args(&["abc", ":", "a\\(b\\)c"])
+            .succeeds()
+            .stdout_only("b\n");
+    }
+
+    #[test]
+    fn test_bre2() {
+        new_ucmd!()
+            .args(&["a(", ":", "a("])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre3() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\("])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Unmatched ( or \\(");
+    }
+
+    #[test]
+    fn test_bre4() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\(b"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Unmatched ( or \\(");
+    }
+
+    #[test]
+    fn test_bre5() {
+        new_ucmd!()
+            .args(&["a(b", ":", "a(b"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre6() {
+        new_ucmd!()
+            .args(&["a)", ":", "a)"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre7() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\)"])
+            .fails_with_code(2)
+            .stderr_contains("Unmatched ) or \\)");
+    }
+
+    #[test]
+    fn test_bre8() {
+        new_ucmd!()
+            .args(&["_", ":", "\\)"])
+            .fails_with_code(2)
+            .stderr_contains("Unmatched ) or \\)");
+    }
+
+    #[test]
+    fn test_bre9() {
+        new_ucmd!()
+            .args(&["ab", ":", "a\\(\\)b"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre10() {
+        new_ucmd!()
+            .args(&["a^b", ":", "a^b"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre11() {
+        new_ucmd!()
+            .args(&["a$b", ":", "a$b"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre12() {
+        new_ucmd!()
+            .args(&["", ":", "\\($\\)\\(^\\)"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre13() {
+        new_ucmd!()
+            .args(&["b", ":", "a*\\(b$\\)c*"])
+            .succeeds()
+            .stdout_only("b\n");
+    }
+
+    #[test]
+    fn test_bre14() {
+        new_ucmd!()
+            .args(&["X|", ":", "X\\(|\\)", ":", "(", "X|", ":", "X\\(|\\)", ")"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre15() {
+        new_ucmd!()
+            .args(&["X*", ":", "X\\(*\\)", ":", "(", "X*", ":", "X\\(*\\)", ")"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre16() {
+        new_ucmd!()
+            .args(&["abc", ":", "\\(\\)"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre17() {
+        new_ucmd!()
+            .args(&["{1}a", ":", "\\(\\{1\\}a\\)"])
+            .succeeds()
+            .stdout_only("{1}a\n");
+    }
+
+    #[test]
+    fn test_bre18() {
+        new_ucmd!()
+            .args(&["X*", ":", "X\\(*\\)", ":", "^*"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre19() {
+        new_ucmd!()
+            .args(&["{1}", ":", "\\{1\\}"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre20() {
+        new_ucmd!()
+            .args(&["{", ":", "{"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre21() {
+        new_ucmd!()
+            .args(&["abbcbd", ":", "a\\(b*\\)c\\1d"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre22() {
+        new_ucmd!()
+            .args(&["abbcbbbd", ":", "a\\(b*\\)c\\1d"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre23() {
+        new_ucmd!()
+            .args(&["abc", ":", "\\(.\\)\\1"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre24() {
+        new_ucmd!()
+            .args(&["abbccd", ":", "a\\(\\([bc]\\)\\2\\)*d"])
+            .succeeds()
+            .stdout_only("cc\n");
+    }
+
+    #[test]
+    fn test_bre25() {
+        new_ucmd!()
+            .args(&["abbcbd", ":", "a\\(\\([bc]\\)\\2\\)*d"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre26() {
+        new_ucmd!()
+            .args(&["abbbd", ":", "a\\(\\(b\\)*\\2\\)*d"])
+            .succeeds()
+            .stdout_only("bbb\n");
+    }
+
+    #[test]
+    fn test_bre27() {
+        new_ucmd!()
+            .args(&["aabcd", ":", "\\(a\\)\\1bcd"])
+            .succeeds()
+            .stdout_only("a\n");
+    }
+
+    #[test]
+    fn test_bre28() {
+        new_ucmd!()
+            .args(&["aabcd", ":", "\\(a\\)\\1bc*d"])
+            .succeeds()
+            .stdout_only("a\n");
+    }
+
+    #[test]
+    fn test_bre29() {
+        new_ucmd!()
+            .args(&["aabd", ":", "\\(a\\)\\1bc*d"])
+            .succeeds()
+            .stdout_only("a\n");
+    }
+
+    #[test]
+    fn test_bre30() {
+        new_ucmd!()
+            .args(&["aabcccd", ":", "\\(a\\)\\1bc*d"])
+            .succeeds()
+            .stdout_only("a\n");
+    }
+
+    #[test]
+    fn test_bre31() {
+        new_ucmd!()
+            .args(&["aabcccd", ":", "\\(a\\)\\1bc*[ce]d"])
+            .succeeds()
+            .stdout_only("a\n");
+    }
+
+    #[test]
+    fn test_bre32() {
+        new_ucmd!()
+            .args(&["aabcccd", ":", "\\(a\\)\\1b\\(c\\)*cd"])
+            .succeeds()
+            .stdout_only("a\n");
+    }
+
+    #[test]
+    fn test_bre33() {
+        new_ucmd!()
+            .args(&["a*b", ":", "a\\(*\\)b"])
+            .succeeds()
+            .stdout_only("*\n");
+    }
+
+    #[test]
+    fn test_bre34() {
+        new_ucmd!()
+            .args(&["ab", ":", "a\\(**\\)b"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre35() {
+        new_ucmd!()
+            .args(&["ab", ":", "a\\(***\\)b"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre36() {
+        new_ucmd!()
+            .args(&["*a", ":", "*a"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre37() {
+        new_ucmd!()
+            .args(&["a", ":", "**a"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre38() {
+        new_ucmd!()
+            .args(&["a", ":", "***a"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre39() {
+        new_ucmd!()
+            .args(&["ab", ":", "a\\{1\\}b"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre40() {
+        new_ucmd!()
+            .args(&["ab", ":", "a\\{1,\\}b"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre41() {
+        new_ucmd!()
+            .args(&["aab", ":", "a\\{1,2\\}b"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre42() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{1"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Unmatched \\{");
+    }
+
+    #[test]
+    fn test_bre43() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{1a"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Unmatched \\{");
+    }
+
+    #[test]
+    fn test_bre44() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{1a\\}"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Invalid content of \\{\\}");
+    }
+
+    #[test]
+    fn test_bre45() {
+        new_ucmd!()
+            .args(&["a", ":", "a\\{,2\\}"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre46() {
+        new_ucmd!()
+            .args(&["a", ":", "a\\{,\\}"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre47() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{1,x\\}"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Invalid content of \\{\\}");
+    }
+
+    #[test]
+    fn test_bre48() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{1,x"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Unmatched \\{");
+    }
+
+    #[test]
+    fn test_bre49() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{32768\\}"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Regular expression too big\n");
+    }
+
+    #[test]
+    fn test_bre50() {
+        new_ucmd!()
+            .args(&["_", ":", "a\\{1,0\\}"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("Invalid content of \\{\\}");
+    }
+
+    #[test]
+    fn test_bre51() {
+        new_ucmd!()
+            .args(&["acabc", ":", ".*ab\\{0,0\\}c"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre52() {
+        new_ucmd!()
+            .args(&["abcac", ":", "ab\\{0,1\\}c"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre53() {
+        new_ucmd!()
+            .args(&["abbcac", ":", "ab\\{0,3\\}c"])
+            .succeeds()
+            .stdout_only("4\n");
+    }
+
+    #[test]
+    fn test_bre54() {
+        new_ucmd!()
+            .args(&["abcac", ":", ".*ab\\{1,1\\}c"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre55() {
+        new_ucmd!()
+            .args(&["abcac", ":", ".*ab\\{1,3\\}c"])
+            .succeeds()
+            .stdout_only("3\n");
+    }
+
+    #[test]
+    fn test_bre56() {
+        new_ucmd!()
+            .args(&["abbcabc", ":", ".*ab\\{2,2\\}c"])
+            .succeeds()
+            .stdout_only("4\n");
+    }
+
+    #[test]
+    fn test_bre57() {
+        new_ucmd!()
+            .args(&["abbcabc", ":", ".*ab\\{2,4\\}c"])
+            .succeeds()
+            .stdout_only("4\n");
+    }
+
+    #[test]
+    fn test_bre58() {
+        new_ucmd!()
+            .args(&["aa", ":", "a\\{1\\}\\{1\\}"])
+            .succeeds()
+            .stdout_only("1\n");
+    }
+
+    #[test]
+    fn test_bre59() {
+        new_ucmd!()
+            .args(&["aa", ":", "a*\\{1\\}"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre60() {
+        new_ucmd!()
+            .args(&["aa", ":", "a\\{1\\}*"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_bre61() {
+        new_ucmd!()
+            .args(&["acd", ":", "a\\(b\\)?c\\1d"])
+            .fails_with_code(1)
+            .stdout_only("\n");
+    }
+
+    #[test]
+    fn test_bre62() {
+        new_ucmd!()
+            .args(&["--", "-5", ":", "-\\{0,1\\}[0-9]*$"])
+            .succeeds()
+            .stdout_only("2\n");
+    }
+
+    #[test]
+    fn test_fail_c() {
+        new_ucmd!()
+            .args::<&str>(&[])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("missing operand")
+            .stderr_contains("Try")
+            .stderr_contains("for more information");
+    }
+
+    const BIG: &str = "98782897298723498732987928734";
+    const BIG_P1: &str = "98782897298723498732987928735";
+    const BIG_SUM: &str = "197565794597446997465975857469";
+    const BIG_PROD: &str = "9758060798730154302876482828124348356960410232492450771490";
+
+    #[test]
+    fn test_bignum_add() {
+        new_ucmd!()
+            .args(&[BIG, "+", "1"])
+            .succeeds()
+            .stdout_only(format!("{BIG_P1}\n"));
+    }
+
+    #[test]
+    fn test_bignum_add1() {
+        new_ucmd!()
+            .args(&[BIG, "+", BIG_P1])
+            .succeeds()
+            .stdout_only(format!("{BIG_SUM}\n"));
+    }
+
+    #[test]
+    fn test_bignum_sub() {
+        new_ucmd!()
+            .args(&[BIG_P1, "-", "1"])
+            .succeeds()
+            .stdout_only(format!("{BIG}\n"));
+    }
+
+    #[test]
+    fn test_bignum_sub1() {
+        new_ucmd!()
+            .args(&[BIG_SUM, "-", BIG])
+            .succeeds()
+            .stdout_only(format!("{BIG_P1}\n"));
+    }
+
+    #[test]
+    fn test_bignum_mul() {
+        new_ucmd!()
+            .args(&[BIG_P1, "*", BIG])
+            .succeeds()
+            .stdout_only(format!("{BIG_PROD}\n"));
+    }
+
+    #[test]
+    fn test_bignum_div() {
+        new_ucmd!()
+            .args(&[BIG_PROD, "/", BIG])
+            .succeeds()
+            .stdout_only(format!("{BIG_P1}\n"));
+    }
+
+    #[test]
+    fn test_se0() {
+        new_ucmd!()
+            .args(&["9", "9"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: unexpected argument '9'");
+    }
+
+    #[test]
+    fn test_se1() {
+        new_ucmd!()
+            .args(&["2", "a"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: unexpected argument 'a'");
+    }
+
+    #[test]
+    fn test_se2() {
+        new_ucmd!()
+            .args(&["2", "+"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: missing argument after '+'");
+    }
+
+    #[test]
+    fn test_se3() {
+        new_ucmd!()
+            .args(&["2", ":"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: missing argument after ':'");
+    }
+
+    #[test]
+    fn test_se4() {
+        new_ucmd!()
+            .args(&["length"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: missing argument after 'length'");
+    }
+
+    #[test]
+    fn test_se5() {
+        new_ucmd!()
+            .args(&["(", "2"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: expecting ')' after '2'");
+    }
+
+    #[test]
+    fn test_se6() {
+        new_ucmd!()
+            .args(&["(", "2", "a"])
+            .fails_with_code(2)
+            .no_stdout()
+            .stderr_contains("syntax error: expecting ')' instead of 'a'");
+    }
+}
diff --git a/tests/by-util/test_factor.rs b/tests/by-util/test_factor.rs
index 3326a1ace71..2324da2a0ed 100644
--- a/tests/by-util/test_factor.rs
+++ b/tests/by-util/test_factor.rs
@@ -2,49 +2,61 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-#![allow(clippy::unreadable_literal)]
 
-// spell-checker:ignore (methods) hexdigest
+// spell-checker:ignore (methods) hexdigest funcs nprimes
+#![allow(
+    clippy::similar_names,
+    clippy::cast_possible_truncation,
+    clippy::cast_sign_loss
+)]
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
+use std::fmt::Write;
 use std::time::{Duration, SystemTime};
 
-#[path = "../../src/uu/factor/sieve.rs"]
-mod sieve;
-
-use self::sieve::Sieve;
-use rand::distributions::{Distribution, Uniform};
-use rand::{rngs::SmallRng, Rng, SeedableRng};
+use rand::distr::{Distribution, Uniform};
+use rand::{Rng, SeedableRng, rngs::SmallRng};
 
 const NUM_PRIMES: usize = 10000;
 const NUM_TESTS: usize = 100;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_valid_arg_exponents() {
-    new_ucmd!().arg("-h").succeeds().code_is(0);
-    new_ucmd!().arg("--exponents").succeeds().code_is(0);
+    new_ucmd!().arg("-h").succeeds();
+    new_ucmd!().arg("--exponents").succeeds();
+}
+
+#[test]
+fn test_repeated_exponents() {
+    new_ucmd!()
+        .args(&["-hh", "1234", "10240"])
+        .succeeds()
+        .stdout_only("1234: 2 617\n10240: 2^11 5\n")
+        .no_stderr();
 }
 
 #[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};
     use tempfile::TempDir;
+    use uutests::util::AtPath;
     // factor should only flush the buffer at line breaks
     let n_integers = 100_000;
     let mut input_string = String::new();
     for i in 0..=n_integers {
-        input_string.push_str(&(format!("{i} "))[..]);
+        let _ = write!(input_string, "{i} ");
     }
 
     let tmp_dir = TempDir::new().unwrap();
@@ -89,7 +101,7 @@ fn test_first_1000_integers() {
     let n_integers = 1000;
     let mut input_string = String::new();
     for i in 0..=n_integers {
-        input_string.push_str(&(format!("{i} "))[..]);
+        let _ = write!(input_string, "{i} ");
     }
 
     println!("STDIN='{input_string}'");
@@ -113,7 +125,7 @@ fn test_first_1000_integers_with_exponents() {
     let n_integers = 1000;
     let mut input_string = String::new();
     for i in 0..=n_integers {
-        input_string.push_str(&(format!("{i} "))[..]);
+        let _ = write!(input_string, "{i} ");
     }
 
     println!("STDIN='{input_string}'");
@@ -146,10 +158,8 @@ fn test_cli_args() {
 
 #[test]
 fn test_random() {
-    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>>();
+    let log_num_primes = f64::from(u32::try_from(NUM_PRIMES).unwrap()).log2().ceil();
+    let primes = num_prime::nt_funcs::nprimes(NUM_PRIMES);
 
     let rng_seed = SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
@@ -164,7 +174,7 @@ fn test_random() {
         while product < min {
             // log distribution---higher probability for lower numbers
             let factor = loop {
-                let next = rng.gen_range(0_f64..log_num_primes).exp2().floor() as usize;
+                let next = rng.random_range(0_f64..log_num_primes).exp2().floor() as usize;
                 if next < NUM_PRIMES {
                     break primes[next];
                 }
@@ -176,7 +186,7 @@ fn test_random() {
                     factors.push(factor);
                 }
                 None => break,
-            };
+            }
         }
 
         factors.sort_unstable();
@@ -188,11 +198,11 @@ fn test_random() {
     let mut output_string = String::new();
     for _ in 0..NUM_TESTS {
         let (product, factors) = rand_gt(1 << 63);
-        input_string.push_str(&(format!("{product} "))[..]);
+        let _ = write!(input_string, "{product} ");
 
-        output_string.push_str(&(format!("{product}:"))[..]);
+        let _ = write!(output_string, "{product}:");
         for factor in factors {
-            output_string.push_str(&(format!(" {factor}"))[..]);
+            let _ = write!(output_string, " {factor}");
         }
         output_string.push('\n');
     }
@@ -209,7 +219,7 @@ fn test_random_big() {
     println!("rng_seed={rng_seed:?}");
     let mut rng = SmallRng::seed_from_u64(rng_seed);
 
-    let bit_range_1 = Uniform::new(14_usize, 51);
+    let bit_range_1 = Uniform::new(14, 51).unwrap();
     let mut rand_64 = move || {
         // first, choose a random number of bits for the first factor
         let f_bit_1 = bit_range_1.sample(&mut rng);
@@ -219,11 +229,11 @@ fn test_random_big() {
         // we will have a number of additional factors equal to n_facts + 1
         // where n_facts is in [0, floor(rem/14) )  NOTE half-open interval
         // Each prime factor is at least 14 bits, hence floor(rem/14)
-        let n_factors = Uniform::new(0_usize, rem / 14).sample(&mut rng);
+        let n_factors = Uniform::new(0, rem / 14).unwrap().sample(&mut rng);
         // we have to distribute extra_bits among the (n_facts + 1) values
         let extra_bits = rem - (n_factors + 1) * 14;
         // (remember, a Range is a half-open interval)
-        let extra_range = Uniform::new(0_usize, extra_bits + 1);
+        let extra_range = Uniform::new(0, extra_bits + 1).unwrap();
 
         // to generate an even split of this range, generate n-1 random elements
         // in the range, add the desired total value to the end, sort this list,
@@ -255,7 +265,9 @@ fn test_random_big() {
         for bit in f_bits {
             assert!(bit < 37);
             n_bits += 14 + bit;
-            let elm = Uniform::new(0, PRIMES_BY_BITS[bit].len()).sample(&mut rng);
+            let elm = Uniform::new(0, PRIMES_BY_BITS[bit].len())
+                .unwrap()
+                .sample(&mut rng);
             let factor = PRIMES_BY_BITS[bit][elm];
             factors.push(factor);
             product *= factor;
@@ -270,11 +282,11 @@ fn test_random_big() {
     let mut output_string = String::new();
     for _ in 0..NUM_TESTS {
         let (product, factors) = rand_64();
-        input_string.push_str(&(format!("{product} "))[..]);
+        let _ = write!(input_string, "{product} ");
 
-        output_string.push_str(&(format!("{product}:"))[..]);
+        let _ = write!(output_string, "{product}:");
         for factor in factors {
-            output_string.push_str(&(format!(" {factor}"))[..]);
+            let _ = write!(output_string, " {factor}");
         }
         output_string.push('\n');
     }
@@ -287,8 +299,8 @@ fn test_big_primes() {
     let mut input_string = String::new();
     let mut output_string = String::new();
     for prime in PRIMES64 {
-        input_string.push_str(&(format!("{prime} "))[..]);
-        output_string.push_str(&(format!("{prime}: {prime}\n"))[..]);
+        let _ = write!(input_string, "{prime} ");
+        let _ = writeln!(output_string, "{prime}: {prime}");
     }
 
     run(input_string.as_bytes(), output_string.as_bytes());
@@ -304,7 +316,7 @@ fn run(input_string: &[u8], output_string: &[u8]) {
     new_ucmd!()
         .timeout(Duration::from_secs(240))
         .pipe_in(input_string)
-        .run()
+        .succeeds()
         .stdout_is(String::from_utf8(output_string.to_owned()).unwrap());
 }
 
@@ -314,8 +326,8 @@ fn test_primes_with_exponents() {
     let mut output_string = String::new();
     for primes in PRIMES_BY_BITS {
         for &prime in *primes {
-            input_string.push_str(&(format!("{prime} "))[..]);
-            output_string.push_str(&(format!("{prime}: {prime}\n"))[..]);
+            let _ = write!(input_string, "{prime} ");
+            let _ = writeln!(output_string, "{prime}: {prime}");
         }
     }
 
@@ -333,7 +345,7 @@ fn test_primes_with_exponents() {
         .timeout(Duration::from_secs(240))
         .arg("--exponents")
         .pipe_in(input_string)
-        .run()
+        .succeeds()
         .stdout_is(String::from_utf8(output_string.as_bytes().to_owned()).unwrap());
 }
 
@@ -377,55 +389,55 @@ const PRIMES_BY_BITS: &[&[u64]] = &[
 ];
 
 const PRIMES64: &[u64] = &[
-    18446744073709551557,
-    18446744073709551533,
-    18446744073709551521,
-    18446744073709551437,
-    18446744073709551427,
-    18446744073709551359,
-    18446744073709551337,
-    18446744073709551293,
-    18446744073709551263,
-    18446744073709551253,
-    18446744073709551191,
-    18446744073709551163,
-    18446744073709551113,
-    18446744073709550873,
-    18446744073709550791,
-    18446744073709550773,
-    18446744073709550771,
-    18446744073709550719,
-    18446744073709550717,
-    18446744073709550681,
-    18446744073709550671,
-    18446744073709550593,
-    18446744073709550591,
-    18446744073709550539,
-    18446744073709550537,
-    18446744073709550381,
-    18446744073709550341,
-    18446744073709550293,
-    18446744073709550237,
-    18446744073709550147,
-    18446744073709550141,
-    18446744073709550129,
-    18446744073709550111,
-    18446744073709550099,
-    18446744073709550047,
-    18446744073709550033,
-    18446744073709550009,
-    18446744073709549951,
-    18446744073709549861,
-    18446744073709549817,
-    18446744073709549811,
-    18446744073709549777,
-    18446744073709549757,
-    18446744073709549733,
-    18446744073709549667,
-    18446744073709549621,
-    18446744073709549613,
-    18446744073709549583,
-    18446744073709549571,
+    18_446_744_073_709_551_557,
+    18_446_744_073_709_551_533,
+    18_446_744_073_709_551_521,
+    18_446_744_073_709_551_437,
+    18_446_744_073_709_551_427,
+    18_446_744_073_709_551_359,
+    18_446_744_073_709_551_337,
+    18_446_744_073_709_551_293,
+    18_446_744_073_709_551_263,
+    18_446_744_073_709_551_253,
+    18_446_744_073_709_551_191,
+    18_446_744_073_709_551_163,
+    18_446_744_073_709_551_113,
+    18_446_744_073_709_550_873,
+    18_446_744_073_709_550_791,
+    18_446_744_073_709_550_773,
+    18_446_744_073_709_550_771,
+    18_446_744_073_709_550_719,
+    18_446_744_073_709_550_717,
+    18_446_744_073_709_550_681,
+    18_446_744_073_709_550_671,
+    18_446_744_073_709_550_593,
+    18_446_744_073_709_550_591,
+    18_446_744_073_709_550_539,
+    18_446_744_073_709_550_537,
+    18_446_744_073_709_550_381,
+    18_446_744_073_709_550_341,
+    18_446_744_073_709_550_293,
+    18_446_744_073_709_550_237,
+    18_446_744_073_709_550_147,
+    18_446_744_073_709_550_141,
+    18_446_744_073_709_550_129,
+    18_446_744_073_709_550_111,
+    18_446_744_073_709_550_099,
+    18_446_744_073_709_550_047,
+    18_446_744_073_709_550_033,
+    18_446_744_073_709_550_009,
+    18_446_744_073_709_549_951,
+    18_446_744_073_709_549_861,
+    18_446_744_073_709_549_817,
+    18_446_744_073_709_549_811,
+    18_446_744_073_709_549_777,
+    18_446_744_073_709_549_757,
+    18_446_744_073_709_549_733,
+    18_446_744_073_709_549_667,
+    18_446_744_073_709_549_621,
+    18_446_744_073_709_549_613,
+    18_446_744_073_709_549_583,
+    18_446_744_073_709_549_571,
 ];
 
 const PRIMES14: &[u64] = &[
@@ -462,799 +474,1166 @@ const PRIMES16: &[u64] = &[
 ];
 
 const PRIMES17: &[u64] = &[
-    131071, 131063, 131059, 131041, 131023, 131011, 131009, 130987, 130981, 130973, 130969, 130957,
-    130927, 130873, 130859, 130843, 130841, 130829, 130817, 130811, 130807, 130787, 130783, 130769,
-    130729, 130699, 130693, 130687, 130681, 130657, 130651, 130649, 130643, 130639, 130633, 130631,
-    130621, 130619, 130589, 130579, 130553, 130547, 130531, 130523, 130517, 130513, 130489, 130483,
-    130477, 130469, 130457, 130447, 130439, 130423, 130411, 130409, 130399, 130379, 130369, 130367,
-    130363, 130349, 130343, 130337, 130307, 130303, 130279, 130267, 130261, 130259, 130253, 130241,
-    130223, 130211, 130201, 130199, 130183, 130171, 130147, 130127, 130121, 130099, 130087, 130079,
-    130073, 130069, 130057, 130051,
+    131_071, 131_063, 131_059, 131_041, 131_023, 131_011, 131_009, 130_987, 130_981, 130_973,
+    130_969, 130_957, 130_927, 130_873, 130_859, 130_843, 130_841, 130_829, 130_817, 130_811,
+    130_807, 130_787, 130_783, 130_769, 130_729, 130_699, 130_693, 130_687, 130_681, 130_657,
+    130_651, 130_649, 130_643, 130_639, 130_633, 130_631, 130_621, 130_619, 130_589, 130_579,
+    130_553, 130_547, 130_531, 130_523, 130_517, 130_513, 130_489, 130_483, 130_477, 130_469,
+    130_457, 130_447, 130_439, 130_423, 130_411, 130_409, 130_399, 130_379, 130_369, 130_367,
+    130_363, 130_349, 130_343, 130_337, 130_307, 130_303, 130_279, 130_267, 130_261, 130_259,
+    130_253, 130_241, 130_223, 130_211, 130_201, 130_199, 130_183, 130_171, 130_147, 130_127,
+    130_121, 130_099, 130_087, 130_079, 130_073, 130_069, 130_057, 130_051,
 ];
 
 const PRIMES18: &[u64] = &[
-    262139, 262133, 262127, 262121, 262111, 262109, 262103, 262079, 262069, 262051, 262049, 262027,
-    262007, 261983, 261977, 261973, 261971, 261959, 261917, 261887, 261881, 261847, 261823, 261799,
-    261791, 261787, 261773, 261761, 261757, 261739, 261721, 261713, 261707, 261697, 261673, 261643,
-    261641, 261637, 261631, 261619, 261601, 261593, 261587, 261581, 261577, 261563, 261557, 261529,
-    261523, 261509, 261467, 261463, 261451, 261439, 261433, 261431, 261427, 261407, 261389, 261379,
-    261353, 261347, 261337, 261329, 261323, 261301, 261281, 261271, 261251, 261241, 261229, 261223,
-    261169, 261167, 261127,
+    262_139, 262_133, 262_127, 262_121, 262_111, 262_109, 262_103, 262_079, 262_069, 262_051,
+    262_049, 262_027, 262_007, 261_983, 261_977, 261_973, 261_971, 261_959, 261_917, 261_887,
+    261_881, 261_847, 261_823, 261_799, 261_791, 261_787, 261_773, 261_761, 261_757, 261_739,
+    261_721, 261_713, 261_707, 261_697, 261_673, 261_643, 261_641, 261_637, 261_631, 261_619,
+    261_601, 261_593, 261_587, 261_581, 261_577, 261_563, 261_557, 261_529, 261_523, 261_509,
+    261_467, 261_463, 261_451, 261_439, 261_433, 261_431, 261_427, 261_407, 261_389, 261_379,
+    261_353, 261_347, 261_337, 261_329, 261_323, 261_301, 261_281, 261_271, 261_251, 261_241,
+    261_229, 261_223, 261_169, 261_167, 261_127,
 ];
 
 const PRIMES19: &[u64] = &[
-    524287, 524269, 524261, 524257, 524243, 524231, 524221, 524219, 524203, 524201, 524197, 524189,
-    524171, 524149, 524123, 524119, 524113, 524099, 524087, 524081, 524071, 524063, 524057, 524053,
-    524047, 523997, 523987, 523969, 523949, 523937, 523927, 523907, 523903, 523877, 523867, 523847,
-    523829, 523801, 523793, 523777, 523771, 523763, 523759, 523741, 523729, 523717, 523681, 523673,
-    523669, 523667, 523657, 523639, 523637, 523631, 523603, 523597, 523577, 523573, 523571, 523553,
-    523543, 523541, 523519, 523511, 523493, 523489, 523487, 523463, 523459, 523433, 523427, 523417,
-    523403, 523387, 523357, 523351, 523349, 523333, 523307, 523297,
+    524_287, 524_269, 524_261, 524_257, 524_243, 524_231, 524_221, 524_219, 524_203, 524_201,
+    524_197, 524_189, 524_171, 524_149, 524_123, 524_119, 524_113, 524_099, 524_087, 524_081,
+    524_071, 524_063, 524_057, 524_053, 524_047, 523_997, 523_987, 523_969, 523_949, 523_937,
+    523_927, 523_907, 523_903, 523_877, 523_867, 523_847, 523_829, 523_801, 523_793, 523_777,
+    523_771, 523_763, 523_759, 523_741, 523_729, 523_717, 523_681, 523_673, 523_669, 523_667,
+    523_657, 523_639, 523_637, 523_631, 523_603, 523_597, 523_577, 523_573, 523_571, 523_553,
+    523_543, 523_541, 523_519, 523_511, 523_493, 523_489, 523_487, 523_463, 523_459, 523_433,
+    523_427, 523_417, 523_403, 523_387, 523_357, 523_351, 523_349, 523_333, 523_307, 523_297,
 ];
 
 const PRIMES20: &[u64] = &[
-    1048573, 1048571, 1048559, 1048549, 1048517, 1048507, 1048447, 1048433, 1048423, 1048391,
-    1048387, 1048367, 1048361, 1048357, 1048343, 1048309, 1048291, 1048273, 1048261, 1048219,
-    1048217, 1048213, 1048193, 1048189, 1048139, 1048129, 1048127, 1048123, 1048063, 1048051,
-    1048049, 1048043, 1048027, 1048013, 1048009, 1048007, 1047997, 1047989, 1047979, 1047971,
-    1047961, 1047941, 1047929, 1047923, 1047887, 1047883, 1047881, 1047859, 1047841, 1047833,
-    1047821, 1047779, 1047773, 1047763, 1047751, 1047737, 1047721, 1047713, 1047703, 1047701,
-    1047691, 1047689, 1047671, 1047667, 1047653, 1047649, 1047647, 1047589, 1047587, 1047559,
+    1_048_573, 1_048_571, 1_048_559, 1_048_549, 1_048_517, 1_048_507, 1_048_447, 1_048_433,
+    1_048_423, 1_048_391, 1_048_387, 1_048_367, 1_048_361, 1_048_357, 1_048_343, 1_048_309,
+    1_048_291, 1_048_273, 1_048_261, 1_048_219, 1_048_217, 1_048_213, 1_048_193, 1_048_189,
+    1_048_139, 1_048_129, 1_048_127, 1_048_123, 1_048_063, 1_048_051, 1_048_049, 1_048_043,
+    1_048_027, 1_048_013, 1_048_009, 1_048_007, 1_047_997, 1_047_989, 1_047_979, 1_047_971,
+    1_047_961, 1_047_941, 1_047_929, 1_047_923, 1_047_887, 1_047_883, 1_047_881, 1_047_859,
+    1_047_841, 1_047_833, 1_047_821, 1_047_779, 1_047_773, 1_047_763, 1_047_751, 1_047_737,
+    1_047_721, 1_047_713, 1_047_703, 1_047_701, 1_047_691, 1_047_689, 1_047_671, 1_047_667,
+    1_047_653, 1_047_649, 1_047_647, 1_047_589, 1_047_587, 1_047_559,
 ];
 
 const PRIMES21: &[u64] = &[
-    2097143, 2097133, 2097131, 2097097, 2097091, 2097083, 2097047, 2097041, 2097031, 2097023,
-    2097013, 2096993, 2096987, 2096971, 2096959, 2096957, 2096947, 2096923, 2096911, 2096909,
-    2096893, 2096881, 2096873, 2096867, 2096851, 2096837, 2096807, 2096791, 2096789, 2096777,
-    2096761, 2096741, 2096737, 2096713, 2096693, 2096687, 2096681, 2096639, 2096629, 2096621,
-    2096599, 2096597, 2096569, 2096539, 2096533, 2096483, 2096449, 2096431, 2096429, 2096411,
-    2096407, 2096401, 2096399, 2096377, 2096357, 2096291, 2096273, 2096261, 2096233, 2096231,
-    2096221, 2096209, 2096191, 2096183, 2096147,
+    2_097_143, 2_097_133, 2_097_131, 2_097_097, 2_097_091, 2_097_083, 2_097_047, 2_097_041,
+    2_097_031, 2_097_023, 2_097_013, 2_096_993, 2_096_987, 2_096_971, 2_096_959, 2_096_957,
+    2_096_947, 2_096_923, 2_096_911, 2_096_909, 2_096_893, 2_096_881, 2_096_873, 2_096_867,
+    2_096_851, 2_096_837, 2_096_807, 2_096_791, 2_096_789, 2_096_777, 2_096_761, 2_096_741,
+    2_096_737, 2_096_713, 2_096_693, 2_096_687, 2_096_681, 2_096_639, 2_096_629, 2_096_621,
+    2_096_599, 2_096_597, 2_096_569, 2_096_539, 2_096_533, 2_096_483, 2_096_449, 2_096_431,
+    2_096_429, 2_096_411, 2_096_407, 2_096_401, 2_096_399, 2_096_377, 2_096_357, 2_096_291,
+    2_096_273, 2_096_261, 2_096_233, 2_096_231, 2_096_221, 2_096_209, 2_096_191, 2_096_183,
+    2_096_147,
 ];
 
 const PRIMES22: &[u64] = &[
-    4194301, 4194287, 4194277, 4194271, 4194247, 4194217, 4194199, 4194191, 4194187, 4194181,
-    4194173, 4194167, 4194143, 4194137, 4194131, 4194107, 4194103, 4194023, 4194011, 4194007,
-    4193977, 4193971, 4193963, 4193957, 4193939, 4193929, 4193909, 4193869, 4193807, 4193803,
-    4193801, 4193789, 4193759, 4193753, 4193743, 4193701, 4193663, 4193633, 4193573, 4193569,
-    4193551, 4193549, 4193531, 4193513, 4193507, 4193459, 4193447, 4193443, 4193417, 4193411,
-    4193393, 4193389, 4193381, 4193377, 4193369, 4193359, 4193353, 4193327, 4193309, 4193303,
-    4193297,
+    4_194_301, 4_194_287, 4_194_277, 4_194_271, 4_194_247, 4_194_217, 4_194_199, 4_194_191,
+    4_194_187, 4_194_181, 4_194_173, 4_194_167, 4_194_143, 4_194_137, 4_194_131, 4_194_107,
+    4_194_103, 4_194_023, 4_194_011, 4_194_007, 4_193_977, 4_193_971, 4_193_963, 4_193_957,
+    4_193_939, 4_193_929, 4_193_909, 4_193_869, 4_193_807, 4_193_803, 4_193_801, 4_193_789,
+    4_193_759, 4_193_753, 4_193_743, 4_193_701, 4_193_663, 4_193_633, 4_193_573, 4_193_569,
+    4_193_551, 4_193_549, 4_193_531, 4_193_513, 4_193_507, 4_193_459, 4_193_447, 4_193_443,
+    4_193_417, 4_193_411, 4_193_393, 4_193_389, 4_193_381, 4_193_377, 4_193_369, 4_193_359,
+    4_193_353, 4_193_327, 4_193_309, 4_193_303, 4_193_297,
 ];
 
 const PRIMES23: &[u64] = &[
-    8388593, 8388587, 8388581, 8388571, 8388547, 8388539, 8388473, 8388461, 8388451, 8388449,
-    8388439, 8388427, 8388421, 8388409, 8388377, 8388371, 8388319, 8388301, 8388287, 8388283,
-    8388277, 8388239, 8388209, 8388187, 8388113, 8388109, 8388091, 8388071, 8388059, 8388019,
-    8388013, 8387999, 8387993, 8387959, 8387957, 8387947, 8387933, 8387921, 8387917, 8387891,
-    8387879, 8387867, 8387861, 8387857, 8387839, 8387831, 8387809, 8387807, 8387741, 8387737,
-    8387723, 8387707, 8387671, 8387611, 8387609, 8387591,
+    8_388_593, 8_388_587, 8_388_581, 8_388_571, 8_388_547, 8_388_539, 8_388_473, 8_388_461,
+    8_388_451, 8_388_449, 8_388_439, 8_388_427, 8_388_421, 8_388_409, 8_388_377, 8_388_371,
+    8_388_319, 8_388_301, 8_388_287, 8_388_283, 8_388_277, 8_388_239, 8_388_209, 8_388_187,
+    8_388_113, 8_388_109, 8_388_091, 8_388_071, 8_388_059, 8_388_019, 8_388_013, 8_387_999,
+    8_387_993, 8_387_959, 8_387_957, 8_387_947, 8_387_933, 8_387_921, 8_387_917, 8_387_891,
+    8_387_879, 8_387_867, 8_387_861, 8_387_857, 8_387_839, 8_387_831, 8_387_809, 8_387_807,
+    8_387_741, 8_387_737, 8_387_723, 8_387_707, 8_387_671, 8_387_611, 8_387_609, 8_387_591,
 ];
 
 const PRIMES24: &[u64] = &[
-    16777213, 16777199, 16777183, 16777153, 16777141, 16777139, 16777127, 16777121, 16777099,
-    16777049, 16777027, 16776989, 16776973, 16776971, 16776967, 16776961, 16776941, 16776937,
-    16776931, 16776919, 16776901, 16776899, 16776869, 16776857, 16776839, 16776833, 16776817,
-    16776763, 16776731, 16776719, 16776713, 16776691, 16776689, 16776679, 16776659, 16776631,
-    16776623, 16776619, 16776607, 16776593, 16776581, 16776547, 16776521, 16776491, 16776481,
-    16776469, 16776451, 16776401, 16776391, 16776379, 16776371, 16776367, 16776343, 16776337,
-    16776317, 16776313, 16776289, 16776217, 16776211,
+    16_777_213, 16_777_199, 16_777_183, 16_777_153, 16_777_141, 16_777_139, 16_777_127, 16_777_121,
+    16_777_099, 16_777_049, 16_777_027, 16_776_989, 16_776_973, 16_776_971, 16_776_967, 16_776_961,
+    16_776_941, 16_776_937, 16_776_931, 16_776_919, 16_776_901, 16_776_899, 16_776_869, 16_776_857,
+    16_776_839, 16_776_833, 16_776_817, 16_776_763, 16_776_731, 16_776_719, 16_776_713, 16_776_691,
+    16_776_689, 16_776_679, 16_776_659, 16_776_631, 16_776_623, 16_776_619, 16_776_607, 16_776_593,
+    16_776_581, 16_776_547, 16_776_521, 16_776_491, 16_776_481, 16_776_469, 16_776_451, 16_776_401,
+    16_776_391, 16_776_379, 16_776_371, 16_776_367, 16_776_343, 16_776_337, 16_776_317, 16_776_313,
+    16_776_289, 16_776_217, 16_776_211,
 ];
 
 const PRIMES25: &[u64] = &[
-    33554393, 33554383, 33554371, 33554347, 33554341, 33554317, 33554291, 33554273, 33554267,
-    33554249, 33554239, 33554221, 33554201, 33554167, 33554159, 33554137, 33554123, 33554093,
-    33554083, 33554077, 33554051, 33554021, 33554011, 33554009, 33553999, 33553991, 33553969,
-    33553967, 33553909, 33553901, 33553879, 33553837, 33553799, 33553787, 33553771, 33553769,
-    33553759, 33553747, 33553739, 33553727, 33553697, 33553693, 33553679, 33553661, 33553657,
-    33553651, 33553649, 33553633, 33553613, 33553607, 33553577, 33553549, 33553547, 33553537,
-    33553519, 33553517, 33553511, 33553489, 33553463, 33553451, 33553417,
+    33_554_393, 33_554_383, 33_554_371, 33_554_347, 33_554_341, 33_554_317, 33_554_291, 33_554_273,
+    33_554_267, 33_554_249, 33_554_239, 33_554_221, 33_554_201, 33_554_167, 33_554_159, 33_554_137,
+    33_554_123, 33_554_093, 33_554_083, 33_554_077, 33_554_051, 33_554_021, 33_554_011, 33_554_009,
+    33_553_999, 33_553_991, 33_553_969, 33_553_967, 33_553_909, 33_553_901, 33_553_879, 33_553_837,
+    33_553_799, 33_553_787, 33_553_771, 33_553_769, 33_553_759, 33_553_747, 33_553_739, 33_553_727,
+    33_553_697, 33_553_693, 33_553_679, 33_553_661, 33_553_657, 33_553_651, 33_553_649, 33_553_633,
+    33_553_613, 33_553_607, 33_553_577, 33_553_549, 33_553_547, 33_553_537, 33_553_519, 33_553_517,
+    33_553_511, 33_553_489, 33_553_463, 33_553_451, 33_553_417,
 ];
 
 const PRIMES26: &[u64] = &[
-    67108859, 67108837, 67108819, 67108777, 67108763, 67108757, 67108753, 67108747, 67108739,
-    67108729, 67108721, 67108709, 67108693, 67108669, 67108667, 67108661, 67108649, 67108633,
-    67108597, 67108579, 67108529, 67108511, 67108507, 67108493, 67108471, 67108463, 67108453,
-    67108439, 67108387, 67108373, 67108369, 67108351, 67108331, 67108313, 67108303, 67108289,
-    67108271, 67108219, 67108207, 67108201, 67108199, 67108187, 67108183, 67108177, 67108127,
-    67108109, 67108081, 67108049, 67108039, 67108037, 67108033, 67108009, 67108007, 67108003,
-    67107983, 67107977, 67107967, 67107941, 67107919, 67107913, 67107883, 67107881, 67107871,
-    67107863,
+    67_108_859, 67_108_837, 67_108_819, 67_108_777, 67_108_763, 67_108_757, 67_108_753, 67_108_747,
+    67_108_739, 67_108_729, 67_108_721, 67_108_709, 67_108_693, 67_108_669, 67_108_667, 67_108_661,
+    67_108_649, 67_108_633, 67_108_597, 67_108_579, 67_108_529, 67_108_511, 67_108_507, 67_108_493,
+    67_108_471, 67_108_463, 67_108_453, 67_108_439, 67_108_387, 67_108_373, 67_108_369, 67_108_351,
+    67_108_331, 67_108_313, 67_108_303, 67_108_289, 67_108_271, 67_108_219, 67_108_207, 67_108_201,
+    67_108_199, 67_108_187, 67_108_183, 67_108_177, 67_108_127, 67_108_109, 67_108_081, 67_108_049,
+    67_108_039, 67_108_037, 67_108_033, 67_108_009, 67_108_007, 67_108_003, 67_107_983, 67_107_977,
+    67_107_967, 67_107_941, 67_107_919, 67_107_913, 67_107_883, 67_107_881, 67_107_871, 67_107_863,
 ];
 
 const PRIMES27: &[u64] = &[
-    134217689, 134217649, 134217617, 134217613, 134217593, 134217541, 134217529, 134217509,
-    134217497, 134217493, 134217487, 134217467, 134217439, 134217437, 134217409, 134217403,
-    134217401, 134217367, 134217361, 134217353, 134217323, 134217301, 134217277, 134217257,
-    134217247, 134217221, 134217199, 134217173, 134217163, 134217157, 134217131, 134217103,
-    134217089, 134217079, 134217049, 134217047, 134217043, 134217001, 134216987, 134216947,
-    134216939, 134216933, 134216911, 134216899, 134216881, 134216869, 134216867, 134216861,
-    134216837, 134216827, 134216807, 134216801, 134216791, 134216783, 134216777, 134216759,
-    134216737, 134216729,
+    134_217_689,
+    134_217_649,
+    134_217_617,
+    134_217_613,
+    134_217_593,
+    134_217_541,
+    134_217_529,
+    134_217_509,
+    134_217_497,
+    134_217_493,
+    134_217_487,
+    134_217_467,
+    134_217_439,
+    134_217_437,
+    134_217_409,
+    134_217_403,
+    134_217_401,
+    134_217_367,
+    134_217_361,
+    134_217_353,
+    134_217_323,
+    134_217_301,
+    134_217_277,
+    134_217_257,
+    134_217_247,
+    134_217_221,
+    134_217_199,
+    134_217_173,
+    134_217_163,
+    134_217_157,
+    134_217_131,
+    134_217_103,
+    134_217_089,
+    134_217_079,
+    134_217_049,
+    134_217_047,
+    134_217_043,
+    134_217_001,
+    134_216_987,
+    134_216_947,
+    134_216_939,
+    134_216_933,
+    134_216_911,
+    134_216_899,
+    134_216_881,
+    134_216_869,
+    134_216_867,
+    134_216_861,
+    134_216_837,
+    134_216_827,
+    134_216_807,
+    134_216_801,
+    134_216_791,
+    134_216_783,
+    134_216_777,
+    134_216_759,
+    134_216_737,
+    134_216_729,
 ];
 
 const PRIMES28: &[u64] = &[
-    268435399, 268435367, 268435361, 268435337, 268435331, 268435313, 268435291, 268435273,
-    268435243, 268435183, 268435171, 268435157, 268435147, 268435133, 268435129, 268435121,
-    268435109, 268435091, 268435067, 268435043, 268435039, 268435033, 268435019, 268435009,
-    268435007, 268434997, 268434979, 268434977, 268434961, 268434949, 268434941, 268434937,
-    268434857, 268434841, 268434827, 268434821, 268434787, 268434781, 268434779, 268434773,
-    268434731, 268434721, 268434713, 268434707, 268434703, 268434697, 268434659, 268434623,
-    268434619, 268434581, 268434577, 268434563, 268434557, 268434547, 268434511, 268434499,
-    268434479, 268434461,
+    268_435_399,
+    268_435_367,
+    268_435_361,
+    268_435_337,
+    268_435_331,
+    268_435_313,
+    268_435_291,
+    268_435_273,
+    268_435_243,
+    268_435_183,
+    268_435_171,
+    268_435_157,
+    268_435_147,
+    268_435_133,
+    268_435_129,
+    268_435_121,
+    268_435_109,
+    268_435_091,
+    268_435_067,
+    268_435_043,
+    268_435_039,
+    268_435_033,
+    268_435_019,
+    268_435_009,
+    268_435_007,
+    268_434_997,
+    268_434_979,
+    268_434_977,
+    268_434_961,
+    268_434_949,
+    268_434_941,
+    268_434_937,
+    268_434_857,
+    268_434_841,
+    268_434_827,
+    268_434_821,
+    268_434_787,
+    268_434_781,
+    268_434_779,
+    268_434_773,
+    268_434_731,
+    268_434_721,
+    268_434_713,
+    268_434_707,
+    268_434_703,
+    268_434_697,
+    268_434_659,
+    268_434_623,
+    268_434_619,
+    268_434_581,
+    268_434_577,
+    268_434_563,
+    268_434_557,
+    268_434_547,
+    268_434_511,
+    268_434_499,
+    268_434_479,
+    268_434_461,
 ];
 
 const PRIMES29: &[u64] = &[
-    536870909, 536870879, 536870869, 536870849, 536870839, 536870837, 536870819, 536870813,
-    536870791, 536870779, 536870767, 536870743, 536870729, 536870723, 536870717, 536870701,
-    536870683, 536870657, 536870641, 536870627, 536870611, 536870603, 536870599, 536870573,
-    536870569, 536870563, 536870561, 536870513, 536870501, 536870497, 536870473, 536870401,
-    536870363, 536870317, 536870303, 536870297, 536870273, 536870267, 536870239, 536870233,
-    536870219, 536870171, 536870167, 536870153, 536870123, 536870063, 536870057, 536870041,
-    536870027, 536869999, 536869951, 536869943, 536869937, 536869919, 536869901, 536869891,
+    536_870_909,
+    536_870_879,
+    536_870_869,
+    536_870_849,
+    536_870_839,
+    536_870_837,
+    536_870_819,
+    536_870_813,
+    536_870_791,
+    536_870_779,
+    536_870_767,
+    536_870_743,
+    536_870_729,
+    536_870_723,
+    536_870_717,
+    536_870_701,
+    536_870_683,
+    536_870_657,
+    536_870_641,
+    536_870_627,
+    536_870_611,
+    536_870_603,
+    536_870_599,
+    536_870_573,
+    536_870_569,
+    536_870_563,
+    536_870_561,
+    536_870_513,
+    536_870_501,
+    536_870_497,
+    536_870_473,
+    536_870_401,
+    536_870_363,
+    536_870_317,
+    536_870_303,
+    536_870_297,
+    536_870_273,
+    536_870_267,
+    536_870_239,
+    536_870_233,
+    536_870_219,
+    536_870_171,
+    536_870_167,
+    536_870_153,
+    536_870_123,
+    536_870_063,
+    536_870_057,
+    536_870_041,
+    536_870_027,
+    536_869_999,
+    536_869_951,
+    536_869_943,
+    536_869_937,
+    536_869_919,
+    536_869_901,
+    536_869_891,
 ];
 
 const PRIMES30: &[u64] = &[
-    1073741789, 1073741783, 1073741741, 1073741723, 1073741719, 1073741717, 1073741689, 1073741671,
-    1073741663, 1073741651, 1073741621, 1073741567, 1073741561, 1073741527, 1073741503, 1073741477,
-    1073741467, 1073741441, 1073741419, 1073741399, 1073741387, 1073741381, 1073741371, 1073741329,
-    1073741311, 1073741309, 1073741287, 1073741237, 1073741213, 1073741197, 1073741189, 1073741173,
-    1073741101, 1073741077, 1073741047, 1073740963, 1073740951, 1073740933, 1073740909, 1073740879,
-    1073740853, 1073740847, 1073740819, 1073740807,
+    1_073_741_789,
+    1_073_741_783,
+    1_073_741_741,
+    1_073_741_723,
+    1_073_741_719,
+    1_073_741_717,
+    1_073_741_689,
+    1_073_741_671,
+    1_073_741_663,
+    1_073_741_651,
+    1_073_741_621,
+    1_073_741_567,
+    1_073_741_561,
+    1_073_741_527,
+    1_073_741_503,
+    1_073_741_477,
+    1_073_741_467,
+    1_073_741_441,
+    1_073_741_419,
+    1_073_741_399,
+    1_073_741_387,
+    1_073_741_381,
+    1_073_741_371,
+    1_073_741_329,
+    1_073_741_311,
+    1_073_741_309,
+    1_073_741_287,
+    1_073_741_237,
+    1_073_741_213,
+    1_073_741_197,
+    1_073_741_189,
+    1_073_741_173,
+    1_073_741_101,
+    1_073_741_077,
+    1_073_741_047,
+    1_073_740_963,
+    1_073_740_951,
+    1_073_740_933,
+    1_073_740_909,
+    1_073_740_879,
+    1_073_740_853,
+    1_073_740_847,
+    1_073_740_819,
+    1_073_740_807,
 ];
 
 const PRIMES31: &[u64] = &[
-    2147483647, 2147483629, 2147483587, 2147483579, 2147483563, 2147483549, 2147483543, 2147483497,
-    2147483489, 2147483477, 2147483423, 2147483399, 2147483353, 2147483323, 2147483269, 2147483249,
-    2147483237, 2147483179, 2147483171, 2147483137, 2147483123, 2147483077, 2147483069, 2147483059,
-    2147483053, 2147483033, 2147483029, 2147482951, 2147482949, 2147482943, 2147482937, 2147482921,
-    2147482877, 2147482873, 2147482867, 2147482859, 2147482819, 2147482817, 2147482811, 2147482801,
-    2147482763, 2147482739, 2147482697, 2147482693, 2147482681, 2147482663, 2147482661,
+    2_147_483_647,
+    2_147_483_629,
+    2_147_483_587,
+    2_147_483_579,
+    2_147_483_563,
+    2_147_483_549,
+    2_147_483_543,
+    2_147_483_497,
+    2_147_483_489,
+    2_147_483_477,
+    2_147_483_423,
+    2_147_483_399,
+    2_147_483_353,
+    2_147_483_323,
+    2_147_483_269,
+    2_147_483_249,
+    2_147_483_237,
+    2_147_483_179,
+    2_147_483_171,
+    2_147_483_137,
+    2_147_483_123,
+    2_147_483_077,
+    2_147_483_069,
+    2_147_483_059,
+    2_147_483_053,
+    2_147_483_033,
+    2_147_483_029,
+    2_147_482_951,
+    2_147_482_949,
+    2_147_482_943,
+    2_147_482_937,
+    2_147_482_921,
+    2_147_482_877,
+    2_147_482_873,
+    2_147_482_867,
+    2_147_482_859,
+    2_147_482_819,
+    2_147_482_817,
+    2_147_482_811,
+    2_147_482_801,
+    2_147_482_763,
+    2_147_482_739,
+    2_147_482_697,
+    2_147_482_693,
+    2_147_482_681,
+    2_147_482_663,
+    2_147_482_661,
 ];
 
 const PRIMES32: &[u64] = &[
-    4294967291, 4294967279, 4294967231, 4294967197, 4294967189, 4294967161, 4294967143, 4294967111,
-    4294967087, 4294967029, 4294966997, 4294966981, 4294966943, 4294966927, 4294966909, 4294966877,
-    4294966829, 4294966813, 4294966769, 4294966667, 4294966661, 4294966657, 4294966651, 4294966639,
-    4294966619, 4294966591, 4294966583, 4294966553, 4294966477, 4294966447, 4294966441, 4294966427,
-    4294966373, 4294966367, 4294966337, 4294966297,
+    4_294_967_291,
+    4_294_967_279,
+    4_294_967_231,
+    4_294_967_197,
+    4_294_967_189,
+    4_294_967_161,
+    4_294_967_143,
+    4_294_967_111,
+    4_294_967_087,
+    4_294_967_029,
+    4_294_966_997,
+    4_294_966_981,
+    4_294_966_943,
+    4_294_966_927,
+    4_294_966_909,
+    4_294_966_877,
+    4_294_966_829,
+    4_294_966_813,
+    4_294_966_769,
+    4_294_966_667,
+    4_294_966_661,
+    4_294_966_657,
+    4_294_966_651,
+    4_294_966_639,
+    4_294_966_619,
+    4_294_966_591,
+    4_294_966_583,
+    4_294_966_553,
+    4_294_966_477,
+    4_294_966_447,
+    4_294_966_441,
+    4_294_966_427,
+    4_294_966_373,
+    4_294_966_367,
+    4_294_966_337,
+    4_294_966_297,
 ];
 
 const PRIMES33: &[u64] = &[
-    8589934583, 8589934567, 8589934543, 8589934513, 8589934487, 8589934307, 8589934291, 8589934289,
-    8589934271, 8589934237, 8589934211, 8589934207, 8589934201, 8589934187, 8589934151, 8589934141,
-    8589934139, 8589934117, 8589934103, 8589934099, 8589934091, 8589934069, 8589934049, 8589934027,
-    8589934007, 8589933973, 8589933971, 8589933967, 8589933931, 8589933917, 8589933907, 8589933853,
-    8589933827, 8589933823, 8589933787, 8589933773, 8589933733, 8589933731, 8589933721, 8589933683,
-    8589933647, 8589933641, 8589933637, 8589933631, 8589933629, 8589933619, 8589933601, 8589933581,
+    8_589_934_583,
+    8_589_934_567,
+    8_589_934_543,
+    8_589_934_513,
+    8_589_934_487,
+    8_589_934_307,
+    8_589_934_291,
+    8_589_934_289,
+    8_589_934_271,
+    8_589_934_237,
+    8_589_934_211,
+    8_589_934_207,
+    8_589_934_201,
+    8_589_934_187,
+    8_589_934_151,
+    8_589_934_141,
+    8_589_934_139,
+    8_589_934_117,
+    8_589_934_103,
+    8_589_934_099,
+    8_589_934_091,
+    8_589_934_069,
+    8_589_934_049,
+    8_589_934_027,
+    8_589_934_007,
+    8_589_933_973,
+    8_589_933_971,
+    8_589_933_967,
+    8_589_933_931,
+    8_589_933_917,
+    8_589_933_907,
+    8_589_933_853,
+    8_589_933_827,
+    8_589_933_823,
+    8_589_933_787,
+    8_589_933_773,
+    8_589_933_733,
+    8_589_933_731,
+    8_589_933_721,
+    8_589_933_683,
+    8_589_933_647,
+    8_589_933_641,
+    8_589_933_637,
+    8_589_933_631,
+    8_589_933_629,
+    8_589_933_619,
+    8_589_933_601,
+    8_589_933_581,
 ];
 
 const PRIMES34: &[u64] = &[
-    17179869143,
-    17179869107,
-    17179869071,
-    17179869053,
-    17179869041,
-    17179869019,
-    17179868999,
-    17179868977,
-    17179868957,
-    17179868903,
-    17179868899,
-    17179868887,
-    17179868879,
-    17179868873,
-    17179868869,
-    17179868861,
-    17179868843,
-    17179868833,
-    17179868809,
-    17179868807,
-    17179868777,
-    17179868759,
-    17179868729,
-    17179868711,
-    17179868683,
-    17179868681,
-    17179868597,
-    17179868549,
-    17179868543,
-    17179868521,
-    17179868513,
-    17179868479,
-    17179868443,
-    17179868437,
-    17179868429,
-    17179868383,
-    17179868369,
-    17179868357,
-    17179868353,
-    17179868351,
-    17179868333,
-    17179868317,
-    17179868309,
-    17179868297,
-    17179868287,
-    17179868249,
-    17179868243,
-    17179868183,
+    17_179_869_143,
+    17_179_869_107,
+    17_179_869_071,
+    17_179_869_053,
+    17_179_869_041,
+    17_179_869_019,
+    17_179_868_999,
+    17_179_868_977,
+    17_179_868_957,
+    17_179_868_903,
+    17_179_868_899,
+    17_179_868_887,
+    17_179_868_879,
+    17_179_868_873,
+    17_179_868_869,
+    17_179_868_861,
+    17_179_868_843,
+    17_179_868_833,
+    17_179_868_809,
+    17_179_868_807,
+    17_179_868_777,
+    17_179_868_759,
+    17_179_868_729,
+    17_179_868_711,
+    17_179_868_683,
+    17_179_868_681,
+    17_179_868_597,
+    17_179_868_549,
+    17_179_868_543,
+    17_179_868_521,
+    17_179_868_513,
+    17_179_868_479,
+    17_179_868_443,
+    17_179_868_437,
+    17_179_868_429,
+    17_179_868_383,
+    17_179_868_369,
+    17_179_868_357,
+    17_179_868_353,
+    17_179_868_351,
+    17_179_868_333,
+    17_179_868_317,
+    17_179_868_309,
+    17_179_868_297,
+    17_179_868_287,
+    17_179_868_249,
+    17_179_868_243,
+    17_179_868_183,
 ];
 
 const PRIMES35: &[u64] = &[
-    34359738337,
-    34359738319,
-    34359738307,
-    34359738299,
-    34359738289,
-    34359738247,
-    34359738227,
-    34359738121,
-    34359738059,
-    34359738043,
-    34359738011,
-    34359737917,
-    34359737869,
-    34359737849,
-    34359737837,
-    34359737821,
-    34359737813,
-    34359737791,
-    34359737777,
-    34359737771,
-    34359737717,
-    34359737591,
-    34359737567,
-    34359737549,
-    34359737519,
-    34359737497,
-    34359737479,
-    34359737407,
-    34359737393,
-    34359737371,
+    34_359_738_337,
+    34_359_738_319,
+    34_359_738_307,
+    34_359_738_299,
+    34_359_738_289,
+    34_359_738_247,
+    34_359_738_227,
+    34_359_738_121,
+    34_359_738_059,
+    34_359_738_043,
+    34_359_738_011,
+    34_359_737_917,
+    34_359_737_869,
+    34_359_737_849,
+    34_359_737_837,
+    34_359_737_821,
+    34_359_737_813,
+    34_359_737_791,
+    34_359_737_777,
+    34_359_737_771,
+    34_359_737_717,
+    34_359_737_591,
+    34_359_737_567,
+    34_359_737_549,
+    34_359_737_519,
+    34_359_737_497,
+    34_359_737_479,
+    34_359_737_407,
+    34_359_737_393,
+    34_359_737_371,
 ];
 
 const PRIMES36: &[u64] = &[
-    68719476731,
-    68719476719,
-    68719476713,
-    68719476671,
-    68719476619,
-    68719476599,
-    68719476577,
-    68719476563,
-    68719476547,
-    68719476503,
-    68719476493,
-    68719476479,
-    68719476433,
-    68719476407,
-    68719476391,
-    68719476389,
-    68719476377,
-    68719476361,
-    68719476323,
-    68719476307,
-    68719476281,
-    68719476271,
-    68719476257,
-    68719476247,
-    68719476209,
-    68719476197,
-    68719476181,
-    68719476169,
-    68719476157,
-    68719476149,
-    68719476109,
-    68719476053,
-    68719476047,
-    68719476019,
-    68719475977,
-    68719475947,
-    68719475933,
-    68719475911,
-    68719475893,
-    68719475879,
-    68719475837,
-    68719475827,
-    68719475809,
-    68719475791,
-    68719475779,
-    68719475771,
-    68719475767,
-    68719475731,
-    68719475729,
+    68_719_476_731,
+    68_719_476_719,
+    68_719_476_713,
+    68_719_476_671,
+    68_719_476_619,
+    68_719_476_599,
+    68_719_476_577,
+    68_719_476_563,
+    68_719_476_547,
+    68_719_476_503,
+    68_719_476_493,
+    68_719_476_479,
+    68_719_476_433,
+    68_719_476_407,
+    68_719_476_391,
+    68_719_476_389,
+    68_719_476_377,
+    68_719_476_361,
+    68_719_476_323,
+    68_719_476_307,
+    68_719_476_281,
+    68_719_476_271,
+    68_719_476_257,
+    68_719_476_247,
+    68_719_476_209,
+    68_719_476_197,
+    68_719_476_181,
+    68_719_476_169,
+    68_719_476_157,
+    68_719_476_149,
+    68_719_476_109,
+    68_719_476_053,
+    68_719_476_047,
+    68_719_476_019,
+    68_719_475_977,
+    68_719_475_947,
+    68_719_475_933,
+    68_719_475_911,
+    68_719_475_893,
+    68_719_475_879,
+    68_719_475_837,
+    68_719_475_827,
+    68_719_475_809,
+    68_719_475_791,
+    68_719_475_779,
+    68_719_475_771,
+    68_719_475_767,
+    68_719_475_731,
+    68_719_475_729,
 ];
 
 const PRIMES37: &[u64] = &[
-    137438953447,
-    137438953441,
-    137438953427,
-    137438953403,
-    137438953349,
-    137438953331,
-    137438953273,
-    137438953271,
-    137438953121,
-    137438953097,
-    137438953037,
-    137438953009,
-    137438952953,
-    137438952901,
-    137438952887,
-    137438952869,
-    137438952853,
-    137438952731,
-    137438952683,
-    137438952611,
-    137438952529,
-    137438952503,
-    137438952491,
+    137_438_953_447,
+    137_438_953_441,
+    137_438_953_427,
+    137_438_953_403,
+    137_438_953_349,
+    137_438_953_331,
+    137_438_953_273,
+    137_438_953_271,
+    137_438_953_121,
+    137_438_953_097,
+    137_438_953_037,
+    137_438_953_009,
+    137_438_952_953,
+    137_438_952_901,
+    137_438_952_887,
+    137_438_952_869,
+    137_438_952_853,
+    137_438_952_731,
+    137_438_952_683,
+    137_438_952_611,
+    137_438_952_529,
+    137_438_952_503,
+    137_438_952_491,
 ];
 
 const PRIMES38: &[u64] = &[
-    274877906899,
-    274877906857,
-    274877906837,
-    274877906813,
-    274877906791,
-    274877906759,
-    274877906753,
-    274877906717,
-    274877906713,
-    274877906687,
-    274877906647,
-    274877906629,
-    274877906627,
-    274877906573,
-    274877906543,
-    274877906491,
-    274877906477,
-    274877906473,
-    274877906431,
-    274877906419,
-    274877906341,
-    274877906333,
-    274877906327,
-    274877906321,
-    274877906309,
-    274877906267,
-    274877906243,
-    274877906213,
-    274877906209,
-    274877906203,
-    274877906179,
-    274877906167,
-    274877906119,
-    274877906063,
-    274877906053,
-    274877906021,
-    274877905931,
+    274_877_906_899,
+    274_877_906_857,
+    274_877_906_837,
+    274_877_906_813,
+    274_877_906_791,
+    274_877_906_759,
+    274_877_906_753,
+    274_877_906_717,
+    274_877_906_713,
+    274_877_906_687,
+    274_877_906_647,
+    274_877_906_629,
+    274_877_906_627,
+    274_877_906_573,
+    274_877_906_543,
+    274_877_906_491,
+    274_877_906_477,
+    274_877_906_473,
+    274_877_906_431,
+    274_877_906_419,
+    274_877_906_341,
+    274_877_906_333,
+    274_877_906_327,
+    274_877_906_321,
+    274_877_906_309,
+    274_877_906_267,
+    274_877_906_243,
+    274_877_906_213,
+    274_877_906_209,
+    274_877_906_203,
+    274_877_906_179,
+    274_877_906_167,
+    274_877_906_119,
+    274_877_906_063,
+    274_877_906_053,
+    274_877_906_021,
+    274_877_905_931,
 ];
 
 const PRIMES39: &[u64] = &[
-    549755813881,
-    549755813869,
-    549755813821,
-    549755813797,
-    549755813753,
-    549755813723,
-    549755813669,
-    549755813657,
-    549755813647,
-    549755813587,
-    549755813561,
-    549755813513,
-    549755813507,
-    549755813461,
-    549755813417,
-    549755813401,
-    549755813371,
-    549755813359,
-    549755813357,
-    549755813351,
-    549755813339,
-    549755813317,
-    549755813311,
-    549755813281,
-    549755813239,
-    549755813231,
-    549755813213,
-    549755813207,
-    549755813197,
-    549755813183,
-    549755813161,
-    549755813149,
-    549755813147,
-    549755813143,
-    549755813141,
-    549755813059,
-    549755813027,
-    549755813003,
-    549755812951,
-    549755812937,
-    549755812933,
-    549755812889,
-    549755812867,
+    549_755_813_881,
+    549_755_813_869,
+    549_755_813_821,
+    549_755_813_797,
+    549_755_813_753,
+    549_755_813_723,
+    549_755_813_669,
+    549_755_813_657,
+    549_755_813_647,
+    549_755_813_587,
+    549_755_813_561,
+    549_755_813_513,
+    549_755_813_507,
+    549_755_813_461,
+    549_755_813_417,
+    549_755_813_401,
+    549_755_813_371,
+    549_755_813_359,
+    549_755_813_357,
+    549_755_813_351,
+    549_755_813_339,
+    549_755_813_317,
+    549_755_813_311,
+    549_755_813_281,
+    549_755_813_239,
+    549_755_813_231,
+    549_755_813_213,
+    549_755_813_207,
+    549_755_813_197,
+    549_755_813_183,
+    549_755_813_161,
+    549_755_813_149,
+    549_755_813_147,
+    549_755_813_143,
+    549_755_813_141,
+    549_755_813_059,
+    549_755_813_027,
+    549_755_813_003,
+    549_755_812_951,
+    549_755_812_937,
+    549_755_812_933,
+    549_755_812_889,
+    549_755_812_867,
 ];
 
 const PRIMES40: &[u64] = &[
-    1099511627689,
-    1099511627609,
-    1099511627581,
-    1099511627573,
-    1099511627563,
-    1099511627491,
-    1099511627483,
-    1099511627477,
-    1099511627387,
-    1099511627339,
-    1099511627321,
-    1099511627309,
-    1099511627297,
-    1099511627293,
-    1099511627261,
-    1099511627213,
-    1099511627191,
-    1099511627177,
-    1099511627173,
-    1099511627143,
-    1099511627089,
-    1099511626987,
-    1099511626949,
-    1099511626937,
-    1099511626793,
-    1099511626781,
-    1099511626771,
+    1_099_511_627_689,
+    1_099_511_627_609,
+    1_099_511_627_581,
+    1_099_511_627_573,
+    1_099_511_627_563,
+    1_099_511_627_491,
+    1_099_511_627_483,
+    1_099_511_627_477,
+    1_099_511_627_387,
+    1_099_511_627_339,
+    1_099_511_627_321,
+    1_099_511_627_309,
+    1_099_511_627_297,
+    1_099_511_627_293,
+    1_099_511_627_261,
+    1_099_511_627_213,
+    1_099_511_627_191,
+    1_099_511_627_177,
+    1_099_511_627_173,
+    1_099_511_627_143,
+    1_099_511_627_089,
+    1_099_511_626_987,
+    1_099_511_626_949,
+    1_099_511_626_937,
+    1_099_511_626_793,
+    1_099_511_626_781,
+    1_099_511_626_771,
 ];
 
 const PRIMES41: &[u64] = &[
-    2199023255531,
-    2199023255521,
-    2199023255497,
-    2199023255489,
-    2199023255479,
-    2199023255477,
-    2199023255461,
-    2199023255441,
-    2199023255419,
-    2199023255413,
-    2199023255357,
-    2199023255327,
-    2199023255291,
-    2199023255279,
-    2199023255267,
-    2199023255243,
-    2199023255203,
-    2199023255171,
-    2199023255137,
-    2199023255101,
-    2199023255087,
-    2199023255081,
-    2199023255069,
-    2199023255027,
-    2199023255021,
-    2199023254979,
-    2199023254933,
-    2199023254913,
-    2199023254907,
-    2199023254903,
-    2199023254843,
-    2199023254787,
-    2199023254699,
-    2199023254693,
-    2199023254657,
-    2199023254567,
+    2_199_023_255_531,
+    2_199_023_255_521,
+    2_199_023_255_497,
+    2_199_023_255_489,
+    2_199_023_255_479,
+    2_199_023_255_477,
+    2_199_023_255_461,
+    2_199_023_255_441,
+    2_199_023_255_419,
+    2_199_023_255_413,
+    2_199_023_255_357,
+    2_199_023_255_327,
+    2_199_023_255_291,
+    2_199_023_255_279,
+    2_199_023_255_267,
+    2_199_023_255_243,
+    2_199_023_255_203,
+    2_199_023_255_171,
+    2_199_023_255_137,
+    2_199_023_255_101,
+    2_199_023_255_087,
+    2_199_023_255_081,
+    2_199_023_255_069,
+    2_199_023_255_027,
+    2_199_023_255_021,
+    2_199_023_254_979,
+    2_199_023_254_933,
+    2_199_023_254_913,
+    2_199_023_254_907,
+    2_199_023_254_903,
+    2_199_023_254_843,
+    2_199_023_254_787,
+    2_199_023_254_699,
+    2_199_023_254_693,
+    2_199_023_254_657,
+    2_199_023_254_567,
 ];
 
 const PRIMES42: &[u64] = &[
-    4398046511093,
-    4398046511087,
-    4398046511071,
-    4398046511051,
-    4398046511039,
-    4398046510961,
-    4398046510943,
-    4398046510939,
-    4398046510889,
-    4398046510877,
-    4398046510829,
-    4398046510787,
-    4398046510771,
-    4398046510751,
-    4398046510733,
-    4398046510721,
-    4398046510643,
-    4398046510639,
-    4398046510597,
-    4398046510577,
-    4398046510547,
-    4398046510531,
-    4398046510463,
-    4398046510397,
-    4398046510391,
-    4398046510379,
-    4398046510357,
-    4398046510331,
-    4398046510327,
-    4398046510313,
-    4398046510283,
-    4398046510279,
-    4398046510217,
-    4398046510141,
-    4398046510133,
-    4398046510103,
-    4398046510093,
+    4_398_046_511_093,
+    4_398_046_511_087,
+    4_398_046_511_071,
+    4_398_046_511_051,
+    4_398_046_511_039,
+    4_398_046_510_961,
+    4_398_046_510_943,
+    4_398_046_510_939,
+    4_398_046_510_889,
+    4_398_046_510_877,
+    4_398_046_510_829,
+    4_398_046_510_787,
+    4_398_046_510_771,
+    4_398_046_510_751,
+    4_398_046_510_733,
+    4_398_046_510_721,
+    4_398_046_510_643,
+    4_398_046_510_639,
+    4_398_046_510_597,
+    4_398_046_510_577,
+    4_398_046_510_547,
+    4_398_046_510_531,
+    4_398_046_510_463,
+    4_398_046_510_397,
+    4_398_046_510_391,
+    4_398_046_510_379,
+    4_398_046_510_357,
+    4_398_046_510_331,
+    4_398_046_510_327,
+    4_398_046_510_313,
+    4_398_046_510_283,
+    4_398_046_510_279,
+    4_398_046_510_217,
+    4_398_046_510_141,
+    4_398_046_510_133,
+    4_398_046_510_103,
+    4_398_046_510_093,
 ];
 
 const PRIMES43: &[u64] = &[
-    8796093022151,
-    8796093022141,
-    8796093022091,
-    8796093022033,
-    8796093021953,
-    8796093021941,
-    8796093021917,
-    8796093021899,
-    8796093021889,
-    8796093021839,
-    8796093021803,
-    8796093021791,
-    8796093021769,
-    8796093021763,
-    8796093021743,
-    8796093021671,
-    8796093021607,
-    8796093021587,
-    8796093021533,
-    8796093021523,
-    8796093021517,
-    8796093021493,
-    8796093021467,
-    8796093021461,
-    8796093021449,
-    8796093021409,
-    8796093021407,
-    8796093021371,
-    8796093021347,
-    8796093021337,
-    8796093021281,
-    8796093021269,
+    8_796_093_022_151,
+    8_796_093_022_141,
+    8_796_093_022_091,
+    8_796_093_022_033,
+    8_796_093_021_953,
+    8_796_093_021_941,
+    8_796_093_021_917,
+    8_796_093_021_899,
+    8_796_093_021_889,
+    8_796_093_021_839,
+    8_796_093_021_803,
+    8_796_093_021_791,
+    8_796_093_021_769,
+    8_796_093_021_763,
+    8_796_093_021_743,
+    8_796_093_021_671,
+    8_796_093_021_607,
+    8_796_093_021_587,
+    8_796_093_021_533,
+    8_796_093_021_523,
+    8_796_093_021_517,
+    8_796_093_021_493,
+    8_796_093_021_467,
+    8_796_093_021_461,
+    8_796_093_021_449,
+    8_796_093_021_409,
+    8_796_093_021_407,
+    8_796_093_021_371,
+    8_796_093_021_347,
+    8_796_093_021_337,
+    8_796_093_021_281,
+    8_796_093_021_269,
 ];
 
 const PRIMES44: &[u64] = &[
-    17592186044399,
-    17592186044299,
-    17592186044297,
-    17592186044287,
-    17592186044273,
-    17592186044267,
-    17592186044129,
-    17592186044089,
-    17592186044057,
-    17592186044039,
-    17592186043987,
-    17592186043921,
-    17592186043889,
-    17592186043877,
-    17592186043841,
-    17592186043829,
-    17592186043819,
-    17592186043813,
-    17592186043807,
-    17592186043741,
-    17592186043693,
-    17592186043667,
-    17592186043631,
-    17592186043591,
-    17592186043577,
-    17592186043547,
-    17592186043483,
-    17592186043451,
-    17592186043433,
-    17592186043409,
+    17_592_186_044_399,
+    17_592_186_044_299,
+    17_592_186_044_297,
+    17_592_186_044_287,
+    17_592_186_044_273,
+    17_592_186_044_267,
+    17_592_186_044_129,
+    17_592_186_044_089,
+    17_592_186_044_057,
+    17_592_186_044_039,
+    17_592_186_043_987,
+    17_592_186_043_921,
+    17_592_186_043_889,
+    17_592_186_043_877,
+    17_592_186_043_841,
+    17_592_186_043_829,
+    17_592_186_043_819,
+    17_592_186_043_813,
+    17_592_186_043_807,
+    17_592_186_043_741,
+    17_592_186_043_693,
+    17_592_186_043_667,
+    17_592_186_043_631,
+    17_592_186_043_591,
+    17_592_186_043_577,
+    17_592_186_043_547,
+    17_592_186_043_483,
+    17_592_186_043_451,
+    17_592_186_043_433,
+    17_592_186_043_409,
 ];
 
 const PRIMES45: &[u64] = &[
-    35184372088777,
-    35184372088763,
-    35184372088751,
-    35184372088739,
-    35184372088711,
-    35184372088699,
-    35184372088693,
-    35184372088673,
-    35184372088639,
-    35184372088603,
-    35184372088571,
-    35184372088517,
-    35184372088493,
-    35184372088471,
-    35184372088403,
-    35184372088391,
-    35184372088379,
-    35184372088363,
-    35184372088321,
-    35184372088319,
-    35184372088279,
-    35184372088259,
-    35184372088249,
-    35184372088241,
-    35184372088223,
-    35184372088183,
-    35184372088097,
-    35184372088081,
-    35184372088079,
-    35184372088051,
-    35184372088043,
-    35184372088039,
-    35184372087937,
-    35184372087929,
-    35184372087923,
-    35184372087881,
-    35184372087877,
-    35184372087869,
+    35_184_372_088_777,
+    35_184_372_088_763,
+    35_184_372_088_751,
+    35_184_372_088_739,
+    35_184_372_088_711,
+    35_184_372_088_699,
+    35_184_372_088_693,
+    35_184_372_088_673,
+    35_184_372_088_639,
+    35_184_372_088_603,
+    35_184_372_088_571,
+    35_184_372_088_517,
+    35_184_372_088_493,
+    35_184_372_088_471,
+    35_184_372_088_403,
+    35_184_372_088_391,
+    35_184_372_088_379,
+    35_184_372_088_363,
+    35_184_372_088_321,
+    35_184_372_088_319,
+    35_184_372_088_279,
+    35_184_372_088_259,
+    35_184_372_088_249,
+    35_184_372_088_241,
+    35_184_372_088_223,
+    35_184_372_088_183,
+    35_184_372_088_097,
+    35_184_372_088_081,
+    35_184_372_088_079,
+    35_184_372_088_051,
+    35_184_372_088_043,
+    35_184_372_088_039,
+    35_184_372_087_937,
+    35_184_372_087_929,
+    35_184_372_087_923,
+    35_184_372_087_881,
+    35_184_372_087_877,
+    35_184_372_087_869,
 ];
 
 const PRIMES46: &[u64] = &[
-    70368744177643,
-    70368744177607,
-    70368744177601,
-    70368744177587,
-    70368744177497,
-    70368744177467,
-    70368744177427,
-    70368744177377,
-    70368744177359,
-    70368744177353,
-    70368744177331,
-    70368744177289,
-    70368744177283,
-    70368744177271,
-    70368744177257,
-    70368744177227,
-    70368744177167,
-    70368744177113,
-    70368744177029,
-    70368744176959,
-    70368744176921,
-    70368744176909,
-    70368744176879,
-    70368744176867,
-    70368744176833,
-    70368744176827,
-    70368744176807,
-    70368744176779,
-    70368744176777,
-    70368744176729,
-    70368744176719,
-    70368744176711,
+    70_368_744_177_643,
+    70_368_744_177_607,
+    70_368_744_177_601,
+    70_368_744_177_587,
+    70_368_744_177_497,
+    70_368_744_177_467,
+    70_368_744_177_427,
+    70_368_744_177_377,
+    70_368_744_177_359,
+    70_368_744_177_353,
+    70_368_744_177_331,
+    70_368_744_177_289,
+    70_368_744_177_283,
+    70_368_744_177_271,
+    70_368_744_177_257,
+    70_368_744_177_227,
+    70_368_744_177_167,
+    70_368_744_177_113,
+    70_368_744_177_029,
+    70_368_744_176_959,
+    70_368_744_176_921,
+    70_368_744_176_909,
+    70_368_744_176_879,
+    70_368_744_176_867,
+    70_368_744_176_833,
+    70_368_744_176_827,
+    70_368_744_176_807,
+    70_368_744_176_779,
+    70_368_744_176_777,
+    70_368_744_176_729,
+    70_368_744_176_719,
+    70_368_744_176_711,
 ];
 
 const PRIMES47: &[u64] = &[
-    140737488355213,
-    140737488355201,
-    140737488355181,
-    140737488355049,
-    140737488355031,
-    140737488354989,
-    140737488354893,
-    140737488354787,
-    140737488354709,
-    140737488354679,
-    140737488354613,
-    140737488354557,
-    140737488354511,
-    140737488354431,
-    140737488354413,
-    140737488354409,
-    140737488354373,
-    140737488354347,
-    140737488354329,
+    140_737_488_355_213,
+    140_737_488_355_201,
+    140_737_488_355_181,
+    140_737_488_355_049,
+    140_737_488_355_031,
+    140_737_488_354_989,
+    140_737_488_354_893,
+    140_737_488_354_787,
+    140_737_488_354_709,
+    140_737_488_354_679,
+    140_737_488_354_613,
+    140_737_488_354_557,
+    140_737_488_354_511,
+    140_737_488_354_431,
+    140_737_488_354_413,
+    140_737_488_354_409,
+    140_737_488_354_373,
+    140_737_488_354_347,
+    140_737_488_354_329,
 ];
 
 const PRIMES48: &[u64] = &[
-    281474976710597,
-    281474976710591,
-    281474976710567,
-    281474976710563,
-    281474976710509,
-    281474976710491,
-    281474976710467,
-    281474976710423,
-    281474976710413,
-    281474976710399,
-    281474976710339,
-    281474976710327,
-    281474976710287,
-    281474976710197,
-    281474976710143,
-    281474976710131,
-    281474976710129,
-    281474976710107,
-    281474976710089,
-    281474976710087,
-    281474976710029,
-    281474976709987,
-    281474976709891,
-    281474976709859,
-    281474976709831,
-    281474976709757,
-    281474976709741,
-    281474976709711,
-    281474976709649,
-    281474976709637,
+    281_474_976_710_597,
+    281_474_976_710_591,
+    281_474_976_710_567,
+    281_474_976_710_563,
+    281_474_976_710_509,
+    281_474_976_710_491,
+    281_474_976_710_467,
+    281_474_976_710_423,
+    281_474_976_710_413,
+    281_474_976_710_399,
+    281_474_976_710_339,
+    281_474_976_710_327,
+    281_474_976_710_287,
+    281_474_976_710_197,
+    281_474_976_710_143,
+    281_474_976_710_131,
+    281_474_976_710_129,
+    281_474_976_710_107,
+    281_474_976_710_089,
+    281_474_976_710_087,
+    281_474_976_710_029,
+    281_474_976_709_987,
+    281_474_976_709_891,
+    281_474_976_709_859,
+    281_474_976_709_831,
+    281_474_976_709_757,
+    281_474_976_709_741,
+    281_474_976_709_711,
+    281_474_976_709_649,
+    281_474_976_709_637,
 ];
 
 const PRIMES49: &[u64] = &[
-    562949953421231,
-    562949953421201,
-    562949953421189,
-    562949953421173,
-    562949953421131,
-    562949953421111,
-    562949953421099,
-    562949953421047,
-    562949953421029,
-    562949953420973,
-    562949953420871,
-    562949953420867,
-    562949953420837,
-    562949953420793,
-    562949953420747,
-    562949953420741,
-    562949953420733,
-    562949953420727,
-    562949953420609,
-    562949953420571,
-    562949953420559,
-    562949953420553,
-    562949953420523,
-    562949953420507,
-    562949953420457,
-    562949953420403,
-    562949953420373,
-    562949953420369,
-    562949953420343,
-    562949953420303,
-    562949953420297,
+    562_949_953_421_231,
+    562_949_953_421_201,
+    562_949_953_421_189,
+    562_949_953_421_173,
+    562_949_953_421_131,
+    562_949_953_421_111,
+    562_949_953_421_099,
+    562_949_953_421_047,
+    562_949_953_421_029,
+    562_949_953_420_973,
+    562_949_953_420_871,
+    562_949_953_420_867,
+    562_949_953_420_837,
+    562_949_953_420_793,
+    562_949_953_420_747,
+    562_949_953_420_741,
+    562_949_953_420_733,
+    562_949_953_420_727,
+    562_949_953_420_609,
+    562_949_953_420_571,
+    562_949_953_420_559,
+    562_949_953_420_553,
+    562_949_953_420_523,
+    562_949_953_420_507,
+    562_949_953_420_457,
+    562_949_953_420_403,
+    562_949_953_420_373,
+    562_949_953_420_369,
+    562_949_953_420_343,
+    562_949_953_420_303,
+    562_949_953_420_297,
 ];
 
 const PRIMES50: &[u64] = &[
-    1125899906842597,
-    1125899906842589,
-    1125899906842573,
-    1125899906842553,
-    1125899906842511,
-    1125899906842507,
-    1125899906842493,
-    1125899906842463,
-    1125899906842429,
-    1125899906842391,
-    1125899906842357,
-    1125899906842283,
-    1125899906842273,
-    1125899906842247,
-    1125899906842201,
-    1125899906842177,
-    1125899906842079,
-    1125899906842033,
-    1125899906842021,
-    1125899906842013,
-    1125899906841973,
-    1125899906841971,
-    1125899906841959,
-    1125899906841949,
-    1125899906841943,
-    1125899906841917,
-    1125899906841901,
-    1125899906841883,
-    1125899906841859,
-    1125899906841811,
-    1125899906841803,
-    1125899906841751,
-    1125899906841713,
-    1125899906841673,
-    1125899906841653,
-    1125899906841623,
-    1125899906841613,
+    1_125_899_906_842_597,
+    1_125_899_906_842_589,
+    1_125_899_906_842_573,
+    1_125_899_906_842_553,
+    1_125_899_906_842_511,
+    1_125_899_906_842_507,
+    1_125_899_906_842_493,
+    1_125_899_906_842_463,
+    1_125_899_906_842_429,
+    1_125_899_906_842_391,
+    1_125_899_906_842_357,
+    1_125_899_906_842_283,
+    1_125_899_906_842_273,
+    1_125_899_906_842_247,
+    1_125_899_906_842_201,
+    1_125_899_906_842_177,
+    1_125_899_906_842_079,
+    1_125_899_906_842_033,
+    1_125_899_906_842_021,
+    1_125_899_906_842_013,
+    1_125_899_906_841_973,
+    1_125_899_906_841_971,
+    1_125_899_906_841_959,
+    1_125_899_906_841_949,
+    1_125_899_906_841_943,
+    1_125_899_906_841_917,
+    1_125_899_906_841_901,
+    1_125_899_906_841_883,
+    1_125_899_906_841_859,
+    1_125_899_906_841_811,
+    1_125_899_906_841_803,
+    1_125_899_906_841_751,
+    1_125_899_906_841_713,
+    1_125_899_906_841_673,
+    1_125_899_906_841_653,
+    1_125_899_906_841_623,
+    1_125_899_906_841_613,
 ];
+
+#[test]
+fn fails_on_directory() {
+    new_ucmd!().pipe_in(".").fails();
+}
+
+#[test]
+fn succeeds_with_numbers_larger_than_u64() {
+    new_ucmd!()
+        .arg("158909489063877810457")
+        .succeeds()
+        .stdout_is("158909489063877810457: 3401347 3861211 12099721\n");
+    new_ucmd!()
+        .arg("222087527029934481871")
+        .succeeds()
+        .stdout_is("222087527029934481871: 15601 26449 111427 4830277\n");
+    new_ucmd!()
+        .arg("12847291069740315094892340035")
+        .succeeds()
+        .stdout_is(
+            "12847291069740315094892340035: \
+            5 4073 18899 522591721 63874247821\n",
+        );
+}
+
+#[test]
+fn succeeds_with_numbers_larger_than_u128() {
+    new_ucmd!()
+        .arg("-h")
+        .arg("340282366920938463463374607431768211456")
+        .succeeds()
+        .stdout_is("340282366920938463463374607431768211456: 2^128\n");
+    new_ucmd!()
+        .arg("+170141183460469231731687303715884105729")
+        .succeeds()
+        .stdout_is(
+            "170141183460469231731687303715884105729: \
+                 3 56713727820156410577229101238628035243\n",
+        );
+}
+
+#[test]
+fn succeeds_with_numbers_larger_than_u256() {
+    new_ucmd!()
+        .arg("-h")
+        .arg(
+            "115792089237316195423570985008687907853\
+            269984665640564039457584007913129639936",
+        )
+        .succeeds()
+        .stdout_is(
+            "115792089237316195423570985008687907853\
+                269984665640564039457584007913129639936: 2^256\n",
+        );
+}
diff --git a/tests/by-util/test_false.rs b/tests/by-util/test_false.rs
index 01916ec622a..fafd9e6a2c2 100644
--- a/tests/by-util/test_false.rs
+++ b/tests/by-util/test_false.rs
@@ -2,21 +2,22 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use regex::Regex;
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 use std::fs::OpenOptions;
-
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 #[test]
-fn test_exit_code() {
-    new_ucmd!().fails();
+fn test_no_args() {
+    new_ucmd!().fails().no_output();
 }
 
 #[test]
 fn test_version() {
-    new_ucmd!()
-        .args(&["--version"])
-        .fails()
-        .stdout_contains("false");
+    let re = Regex::new(r"^false .*\d+\.\d+\.\d+\n$").unwrap();
+
+    new_ucmd!().args(&["--version"]).fails().stdout_matches(&re);
 }
 
 #[test]
@@ -30,7 +31,7 @@ fn test_help() {
 #[test]
 fn test_short_options() {
     for option in ["-h", "-V"] {
-        new_ucmd!().arg(option).fails().stdout_is("");
+        new_ucmd!().arg(option).fails().no_output();
     }
 }
 
@@ -39,7 +40,7 @@ fn test_conflict() {
     new_ucmd!()
         .args(&["--help", "--version"])
         .fails()
-        .stdout_is("");
+        .no_output();
 }
 
 #[test]
diff --git a/tests/by-util/test_fmt.rs b/tests/by-util/test_fmt.rs
index 7d23cbd52f1..8d851d5ce44 100644
--- a/tests/by-util/test_fmt.rs
+++ b/tests/by-util/test_fmt.rs
@@ -2,11 +2,18 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_invalid_input() {
+    new_ucmd!().arg(".").fails_with_code(1);
 }
 
 #[test]
@@ -19,7 +26,7 @@ fn test_fmt() {
 
 #[test]
 fn test_fmt_quick() {
-    for param in ["-q", "--quick"] {
+    for param in ["-q", "--quick", "-qq"] {
         new_ucmd!()
             .args(&["one-word-per-line.txt", param])
             .succeeds()
@@ -33,7 +40,45 @@ fn test_fmt_width() {
         new_ucmd!()
             .args(&["one-word-per-line.txt", param, "10"])
             .succeeds()
-            .stdout_is("this is\na file\nwith one\nword per\nline\n");
+            .stdout_is("this is a\nfile with\none word\nper line\n");
+    }
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-w50", "--width", "10"])
+        .succeeds()
+        .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_fmt_width_invalid() {
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-w", "apple"])
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_is("fmt: invalid width: 'apple'\n");
+    // an invalid width can be successfully overwritten later:
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-w", "apple", "-w10"])
+        .succeeds()
+        .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_fmt_positional_width() {
+    new_ucmd!()
+        .args(&["-10", "one-word-per-line.txt"])
+        .succeeds()
+        .stdout_is("this is a\nfile with\none word\nper line\n");
+}
+
+#[test]
+fn test_small_width() {
+    for width in ["0", "1", "2", "3"] {
+        for param in ["-w", "--width"] {
+            new_ucmd!()
+                .args(&[param, width, "one-word-per-line.txt"])
+                .succeeds()
+                .stdout_is("this\nis\na\nfile\nwith\none\nword\nper\nline\n");
+        }
     }
 }
 
@@ -42,13 +87,43 @@ 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)
+            .fails_with_code(1)
             .stderr_is("fmt: invalid width: '2501': Numerical result out of range\n");
     }
+    // However, as a temporary value it is okay:
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-w2501", "--width", "10"])
+        .succeeds()
+        .stdout_is("this is a\nfile with\none word\nper line\n");
 }
 
-#[ignore]
+#[test]
+fn test_fmt_invalid_width() {
+    for param in ["-w", "--width"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", param, "invalid"])
+            .fails_with_code(1)
+            .stderr_contains("invalid width: 'invalid'");
+    }
+}
+
+#[test]
+fn test_fmt_positional_width_not_first() {
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-10"])
+        .fails_with_code(1)
+        .stderr_contains("fmt: invalid option -- 1; -WIDTH is recognized only when it is the first\noption; use -w N instead");
+}
+
+#[test]
+fn test_fmt_width_not_valid_number() {
+    new_ucmd!()
+        .args(&["-25x", "one-word-per-line.txt"])
+        .fails_with_code(1)
+        .stderr_contains("fmt: invalid width: '25x'");
+}
+
+#[ignore = "our 'goal' algorithm is very different from GNU; fix this!"]
 #[test]
 fn test_fmt_goal() {
     for param in ["-g", "--goal"] {
@@ -57,6 +132,10 @@ fn test_fmt_goal() {
             .succeeds()
             .stdout_is("this is a\nfile with one\nword per line\n");
     }
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-g40", "-g7"])
+        .succeeds()
+        .stdout_is("this is a\nfile with one\nword per line\n");
 }
 
 #[test]
@@ -64,12 +143,86 @@ fn test_fmt_goal_too_big() {
     for param in ["-g", "--goal"] {
         new_ucmd!()
             .args(&["one-word-per-line.txt", "--width=75", param, "76"])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
+            .stderr_is("fmt: GOAL cannot be greater than WIDTH.\n");
+    }
+}
+
+#[test]
+fn test_fmt_goal_bigger_than_default_width_of_75() {
+    for param in ["-g", "--goal"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", param, "76"])
+            .fails_with_code(1)
             .stderr_is("fmt: GOAL cannot be greater than WIDTH.\n");
     }
 }
 
+#[ignore = "our 'goal' algorithm is very different from GNU; fix this!"]
+#[test]
+fn test_fmt_too_big_goal_sometimes_okay() {
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "--width=75", "-g76", "-g10"])
+        .succeeds()
+        .stdout_is("this is a\nfile with one\nword per line\n");
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-g76", "-g10"])
+        .succeeds()
+        .stdout_is("this is a\nfile with one\nword per line\n");
+}
+
+#[test]
+fn test_fmt_goal_too_small_to_check_negative_minlength() {
+    for param in ["-g", "--goal"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", "--width=75", param, "10"])
+            .succeeds()
+            .stdout_is("this is a file with one word per line\n");
+    }
+}
+
+#[test]
+fn test_fmt_non_existent_file() {
+    new_ucmd!()
+        .args(&["non-existing"])
+        .fails_with_code(1)
+        .stderr_is("fmt: cannot open 'non-existing' for reading: No such file or directory\n");
+}
+
+#[test]
+fn test_fmt_invalid_goal() {
+    for param in ["-g", "--goal"] {
+        new_ucmd!()
+            .args(&["one-word-per-line.txt", param, "invalid"])
+            .fails_with_code(1)
+            // GNU complains about "invalid width", which is confusing.
+            // We intentionally deviate from GNU, and show a more helpful message:
+            .stderr_contains("invalid goal: 'invalid'");
+    }
+}
+
+#[test]
+fn test_fmt_invalid_goal_override() {
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-g", "apple", "-g", "74"])
+        .succeeds()
+        .stdout_is("this is a file with one word per line\n");
+}
+
+#[test]
+fn test_fmt_invalid_goal_width_priority() {
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-g", "apple", "-w", "banana"])
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_is("fmt: invalid width: 'banana'\n");
+    new_ucmd!()
+        .args(&["one-word-per-line.txt", "-w", "banana", "-g", "apple"])
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_is("fmt: invalid width: 'banana'\n");
+}
+
 #[test]
 fn test_fmt_set_goal_not_contain_width() {
     for param in ["-g", "--goal"] {
@@ -79,3 +232,74 @@ fn test_fmt_set_goal_not_contain_width() {
             .stdout_is("this is a file with one word per line\n");
     }
 }
+
+#[test]
+fn split_does_not_reflow() {
+    for arg in ["-s", "-ss", "--split-only"] {
+        new_ucmd!()
+            .arg("one-word-per-line.txt")
+            .arg(arg)
+            .succeeds()
+            .stdout_is_fixture("one-word-per-line.txt");
+    }
+}
+
+#[test]
+fn prefix_minus() {
+    for prefix_args in [
+        vec!["-p-"],
+        vec!["-p", "-"],
+        vec!["--prefix=-"],
+        vec!["--prefix", "-"],
+        vec!["--pref=-"],
+        vec!["--pref", "-"],
+        // Test self-overriding:
+        vec!["--prefix==", "--prefix=-"],
+    ] {
+        new_ucmd!()
+            .args(&prefix_args)
+            .arg("prefixed-one-word-per-line.txt")
+            .succeeds()
+            .stdout_is_fixture("prefixed-one-word-per-line_p-.txt");
+    }
+}
+
+#[test]
+fn prefix_equal() {
+    for prefix_args in [
+        // FIXME: #6353 vec!["-p="],
+        vec!["-p", "="],
+        vec!["--prefix=="],
+        vec!["--prefix", "="],
+        vec!["--pref=="],
+        vec!["--pref", "="],
+        // Test self-overriding:
+        vec!["--prefix=-", "--prefix=="],
+    ] {
+        new_ucmd!()
+            .args(&prefix_args)
+            .arg("prefixed-one-word-per-line.txt")
+            .succeeds()
+            .stdout_is_fixture("prefixed-one-word-per-line_p=.txt");
+    }
+}
+
+#[test]
+fn prefix_equal_skip_prefix_equal_two() {
+    for prefix_args in [
+        // FIXME: #6353 vec!["--prefix==", "-P=2"],
+        vec!["--prefix==", "-P", "=2"],
+        vec!["--prefix==", "--skip-prefix==2"],
+        vec!["--prefix==", "--skip-prefix", "=2"],
+        vec!["--prefix==", "--skip-pref==2"],
+        vec!["--prefix==", "--skip-pref", "=2"],
+        // Test self-overriding:
+        vec!["--prefix==", "--skip-pref", "asdf", "-P", "=2"],
+    ] {
+        new_ucmd!()
+            .args(&prefix_args)
+            .arg("prefixed-one-word-per-line.txt")
+            .succeeds()
+            .stdout_is_fixture("prefixed-one-word-per-line_p=_P=2.txt");
+    }
+}
diff --git a/tests/by-util/test_fold.rs b/tests/by-util/test_fold.rs
index 6895f51b6e4..d916a9c77ce 100644
--- a/tests/by-util/test_fold.rs
+++ b/tests/by-util/test_fold.rs
@@ -2,18 +2,20 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_default_80_column_wrap() {
     new_ucmd!()
         .arg("lorem_ipsum.txt")
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_80_column.expected");
 }
 
@@ -21,7 +23,7 @@ fn test_default_80_column_wrap() {
 fn test_40_column_hard_cutoff() {
     new_ucmd!()
         .args(&["-w", "40", "lorem_ipsum.txt"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_40_column_hard.expected");
 }
 
@@ -29,7 +31,7 @@ fn test_40_column_hard_cutoff() {
 fn test_40_column_word_boundary() {
     new_ucmd!()
         .args(&["-s", "-w", "40", "lorem_ipsum.txt"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_40_column_word.expected");
 }
 
@@ -37,7 +39,7 @@ fn test_40_column_word_boundary() {
 fn test_default_wrap_with_newlines() {
     new_ucmd!()
         .arg("lorem_ipsum_new_line.txt")
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_new_line_80_column.expected");
 }
 
diff --git a/tests/by-util/test_groups.rs b/tests/by-util/test_groups.rs
index 47cb89249b3..984caef39a5 100644
--- a/tests/by-util/test_groups.rs
+++ b/tests/by-util/test_groups.rs
@@ -5,21 +5,24 @@
 
 //spell-checker: ignore coreutil
 
-use crate::common::util::{check_coreutil_version, expected_result, whoami, TestScenario};
+use uutests::new_ucmd;
+use uutests::unwrap_or_return;
+use uutests::util::{TestScenario, check_coreutil_version, expected_result, whoami};
+use uutests::util_name;
 
 const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
 
 #[test]
 #[cfg(unix)]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 #[cfg(unix)]
 fn test_groups() {
     let ts = TestScenario::new(util_name!());
-    let result = ts.ucmd().run();
+    let result = ts.ucmd().succeeds();
     let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
 
     result
@@ -34,7 +37,7 @@ fn test_groups_username() {
     let test_users = [&whoami()[..]];
 
     let ts = TestScenario::new(util_name!());
-    let result = ts.ucmd().args(&test_users).run();
+    let result = ts.ucmd().args(&test_users).succeeds();
     let exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
 
     result
@@ -53,7 +56,7 @@ fn test_groups_username_multiple() {
     let test_users = ["root", "man", "postfix", "sshd", &whoami()];
 
     let ts = TestScenario::new(util_name!());
-    let result = ts.ucmd().args(&test_users).run();
+    let result = ts.ucmd().args(&test_users).fails();
     let exp_result = unwrap_or_return!(expected_result(&ts, &test_users));
 
     result
diff --git a/tests/by-util/test_hashsum.rs b/tests/by-util/test_hashsum.rs
index 31471495b07..12b18b83d0e 100644
--- a/tests/by-util/test_hashsum.rs
+++ b/tests/by-util/test_hashsum.rs
@@ -2,7 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 // spell-checker:ignore checkfile, nonames, testf, ntestf
 macro_rules! get_hash(
     ($str:expr) => (
@@ -14,24 +17,25 @@ macro_rules! test_digest {
     ($($id:ident $t:ident $size:expr)*) => ($(
 
     mod $id {
-        use crate::common::util::*;
+        use uutests::util::*;
         static DIGEST_ARG: &'static str = concat!("--", stringify!($t));
         static BITS_ARG: &'static str = concat!("--bits=", stringify!($size));
         static EXPECTED_FILE: &'static str = concat!(stringify!($id), ".expected");
         static CHECK_FILE: &'static str = concat!(stringify!($id), ".checkfile");
+        static INPUT_FILE: &'static str = "input.txt";
 
         #[test]
         fn test_single_file() {
             let ts = TestScenario::new("hashsum");
             assert_eq!(ts.fixtures.read(EXPECTED_FILE),
-                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("input.txt").succeeds().no_stderr().stdout_str()));
+                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg(INPUT_FILE).succeeds().no_stderr().stdout_str()));
         }
 
         #[test]
         fn test_stdin() {
             let ts = TestScenario::new("hashsum");
             assert_eq!(ts.fixtures.read(EXPECTED_FILE),
-                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).pipe_in_fixture("input.txt").succeeds().no_stderr().stdout_str()));
+                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).pipe_in_fixture(INPUT_FILE).succeeds().no_stderr().stdout_str()));
         }
 
         #[test]
@@ -41,7 +45,7 @@ macro_rules! test_digest {
             if DIGEST_ARG == "--b3sum" {
                 // Option only available on b3sum
                 assert_eq!(format!("{0}\n{0}\n", ts.fixtures.read(EXPECTED_FILE)),
-                       ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("--no-names").arg("input.txt").arg("-").pipe_in_fixture("input.txt")
+                       ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("--no-names").arg(INPUT_FILE).arg("-").pipe_in_fixture(INPUT_FILE)
                        .succeeds().no_stderr().stdout_str()
                        );
                 }
@@ -50,6 +54,9 @@ macro_rules! test_digest {
         #[test]
         fn test_check() {
             let ts = TestScenario::new("hashsum");
+            println!("File content='{}'", ts.fixtures.read(INPUT_FILE));
+            println!("Check file='{}'", ts.fixtures.read(CHECK_FILE));
+
             ts.ucmd()
                 .args(&[DIGEST_ARG, BITS_ARG, "--check", CHECK_FILE])
                 .succeeds()
@@ -61,13 +68,16 @@ macro_rules! test_digest {
         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()));
+                       get_hash!(ts.ucmd().arg(DIGEST_ARG).arg(BITS_ARG).arg("--zero").arg(INPUT_FILE).succeeds().no_stderr().stdout_str()));
         }
 
 
         #[cfg(windows)]
         #[test]
         fn test_text_mode() {
+            use uutests::new_ucmd;
+            use uutests::util_name;
+
             // TODO Replace this with hard-coded files that store the
             // expected output of text mode on an input file that has
             // "\r\n" line endings.
@@ -80,7 +90,7 @@ macro_rules! test_digest {
             // The asterisk indicates that the digest was computed in
             // binary mode.
             let n = expected.len();
-            let expected = [&expected[..n - 3], &[b' ', b'-', b'\n']].concat();
+            let expected = [&expected[..n - 3], b" -\n"].concat();
             new_ucmd!()
                 .args(&[DIGEST_ARG, BITS_ARG, "-t"])
                 .pipe_in("a\r\nb\r\nc\r\n")
@@ -129,6 +139,40 @@ fn test_check_sha1() {
         .stderr_is("");
 }
 
+#[test]
+fn test_check_md5_ignore_missing() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+    at.write(
+        "testf.sha1",
+        "14758f1afd44c09b7992073ccf00b43d  testf\n14758f1afd44c09b7992073ccf00b43d  testf2\n",
+    );
+    scene
+        .ccmd("md5sum")
+        .arg("-c")
+        .arg(at.subdir.join("testf.sha1"))
+        .fails()
+        .stdout_contains("testf2: FAILED open or read");
+
+    scene
+        .ccmd("md5sum")
+        .arg("-c")
+        .arg("--ignore-missing")
+        .arg(at.subdir.join("testf.sha1"))
+        .succeeds()
+        .stdout_is("testf: OK\n")
+        .stderr_is("");
+
+    scene
+        .ccmd("md5sum")
+        .arg("--ignore-missing")
+        .arg(at.subdir.join("testf.sha1"))
+        .fails()
+        .stderr_contains("the --ignore-missing option is meaningful only when verifying checksums");
+}
+
 #[test]
 fn test_check_b2sum_length_option_0() {
     let scene = TestScenario::new(util_name!());
@@ -146,6 +190,22 @@ fn test_check_b2sum_length_option_0() {
         .stdout_only("testf: OK\n");
 }
 
+#[test]
+fn test_check_b2sum_length_duplicate() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("testf", "foobar\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=123")
+        .arg("--length=128")
+        .arg("testf")
+        .succeeds()
+        .stdout_contains("d6d45901dec53e65d2b55fb6e2ab67b0");
+}
+
 #[test]
 fn test_check_b2sum_length_option_8() {
     let scene = TestScenario::new(util_name!());
@@ -174,8 +234,7 @@ fn test_invalid_b2sum_length_option_not_multiple_of_8() {
         .ccmd("b2sum")
         .arg("--length=9")
         .arg(at.subdir.join("testf"))
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -189,8 +248,55 @@ fn test_invalid_b2sum_length_option_too_large() {
         .ccmd("b2sum")
         .arg("--length=513")
         .arg(at.subdir.join("testf"))
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
+}
+
+#[test]
+fn test_check_b2sum_tag_output() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=0")
+        .arg("--tag")
+        .arg("f")
+        .succeeds()
+        .stdout_only("BLAKE2b (f) = 786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--length=128")
+        .arg("--tag")
+        .arg("f")
+        .succeeds()
+        .stdout_only("BLAKE2b-128 (f) = cae66941d9efbd404e4d88758ea67670\n");
+}
+
+#[test]
+fn test_check_b2sum_verify() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("a", "a\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--tag")
+        .arg("a")
+        .succeeds()
+        .stdout_only("BLAKE2b (a) = bedfbb90d858c2d67b7ee8f7523be3d3b54004ef9e4f02f2ad79a1d05bfdfe49b81e3c92ebf99b504102b6bf003fa342587f5b3124c205f55204e8c4b4ce7d7c\n");
+
+    scene
+        .ccmd("b2sum")
+        .arg("--tag")
+        .arg("-l")
+        .arg("128")
+        .arg("a")
+        .succeeds()
+        .stdout_only("BLAKE2b-128 (a) = b93e0fc7bb21633c08bba07c5e71dc00\n");
 }
 
 #[test]
@@ -208,9 +314,9 @@ fn test_check_file_not_found_warning() {
         .ccmd("sha1sum")
         .arg("-c")
         .arg(at.subdir.join("testf.sha1"))
-        .succeeds()
-        .stdout_is("sha1sum: testf: No such file or directory\ntestf: FAILED open or read\n")
-        .stderr_is("sha1sum: warning: 1 listed file could not be read\n");
+        .fails()
+        .stdout_is("testf: FAILED open or read\n")
+        .stderr_is("sha1sum: testf: No such file or directory\nsha1sum: 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.
@@ -264,6 +370,30 @@ fn test_check_md5sum() {
     }
 }
 
+// GNU also supports one line sep
+#[test]
+fn test_check_md5sum_only_one_space() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    for f in ["a", " b", "c"] {
+        at.write(f, &format!("{f}\n"));
+    }
+    at.write(
+        "check.md5sum",
+        "60b725f10c9c85c70d97880dfe8191b3 a\n\
+        bf35d7536c785cf06730d5a40301eba2  b\n\
+        2cd6ee2c70b0bde53fbe6cac3c8b8bb1 c\n",
+    );
+    scene
+        .ccmd("md5sum")
+        .arg("--strict")
+        .arg("-c")
+        .arg("check.md5sum")
+        .succeeds()
+        .stdout_only("a: OK\n b: OK\nc: OK\n");
+}
+
 #[test]
 fn test_check_md5sum_reverse_bsd() {
     let scene = TestScenario::new(util_name!());
@@ -276,11 +406,11 @@ fn test_check_md5sum_reverse_bsd() {
         }
         at.write(
             "check.md5sum",
-            "60b725f10c9c85c70d97880dfe8191b3 a\n\
-             bf35d7536c785cf06730d5a40301eba2  b\n\
-             f5b61709718c1ecf8db1aea8547d4698 *c\n\
-             b064a020db8018f18ff5ae367d01b212 dd\n\
-             d784fa8b6d98d27699781bd9a7cf19f0  ",
+            "60b725f10c9c85c70d97880dfe8191b3  a\n\
+             bf35d7536c785cf06730d5a40301eba2   b\n\
+             f5b61709718c1ecf8db1aea8547d4698  *c\n\
+             b064a020db8018f18ff5ae367d01b212  dd\n\
+             d784fa8b6d98d27699781bd9a7cf19f0   ",
         );
         scene
             .ccmd("md5sum")
@@ -298,9 +428,9 @@ fn test_check_md5sum_reverse_bsd() {
         }
         at.write(
             "check.md5sum",
-            "60b725f10c9c85c70d97880dfe8191b3 a\n\
-             bf35d7536c785cf06730d5a40301eba2  b\n\
-             b064a020db8018f18ff5ae367d01b212 dd",
+            "60b725f10c9c85c70d97880dfe8191b3  a\n\
+             bf35d7536c785cf06730d5a40301eba2   b\n\
+             b064a020db8018f18ff5ae367d01b212  dd",
         );
         scene
             .ccmd("md5sum")
@@ -347,13 +477,26 @@ fn test_check_md5sum_mixed_format() {
         .arg("--strict")
         .arg("-c")
         .arg("check.md5sum")
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_conflicting_arg() {
+    new_ucmd!()
+        .arg("--tag")
+        .arg("--check")
+        .arg("--md5")
+        .fails_with_code(1);
+    new_ucmd!()
+        .arg("--tag")
+        .arg("--text")
+        .arg("--md5")
+        .fails_with_code(1);
 }
 
 #[test]
@@ -371,3 +514,548 @@ fn test_tag() {
             "SHA256 (foobar) = 1f2ec52b774368781bed1d1fb140a92e0eb6348090619c9291f9a5a3c8e8d151\n",
         );
 }
+
+#[test]
+#[cfg(not(windows))]
+fn test_with_escape_filename() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    let filename = "a\nb";
+    at.touch(filename);
+    let result = scene.ccmd("md5sum").arg("--text").arg(filename).succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout {stdout}");
+    assert!(stdout.starts_with('\\'));
+    assert!(stdout.trim().ends_with("a\\nb"));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_with_escape_filename_zero_text() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    let filename = "a\nb";
+    at.touch(filename);
+    let result = scene
+        .ccmd("md5sum")
+        .arg("--text")
+        .arg("--zero")
+        .arg(filename)
+        .succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout {stdout}");
+    assert!(!stdout.starts_with('\\'));
+    assert!(stdout.contains("a\nb"));
+}
+
+#[test]
+fn test_check_empty_line() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write(
+        "in.md5",
+        "d41d8cd98f00b204e9800998ecf8427e  f\n\nd41d8cd98f00b204e9800998ecf8427e  f\ninvalid\n\n",
+    );
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_check_with_escape_filename() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+
+    let filename = "a\nb";
+    at.touch(filename);
+    let result = scene.ccmd("md5sum").arg("--tag").arg(filename).succeeds();
+    let stdout = result.stdout_str();
+    println!("stdout {stdout}");
+    assert!(stdout.starts_with("\\MD5"));
+    assert!(stdout.contains("a\\nb"));
+    at.write("check.md5", stdout);
+    let result = scene
+        .ccmd("md5sum")
+        .arg("--strict")
+        .arg("-c")
+        .arg("check.md5")
+        .succeeds();
+    result.stdout_is("\\a\\nb: OK\n");
+}
+
+#[test]
+fn test_check_strict_error() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write(
+        "in.md5",
+        "ERR\nERR\nd41d8cd98f00b204e9800998ecf8427e  f\nERR\n",
+    );
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--strict")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_contains("WARNING: 3 lines are improperly formatted");
+}
+
+#[test]
+fn test_check_warn() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write(
+        "in.md5",
+        "d41d8cd98f00b204e9800998ecf8427e  f\nd41d8cd98f00b204e9800998ecf8427e  f\ninvalid\n",
+    );
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--warn")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stderr_contains("in.md5: 3: improperly formatted MD5 checksum line")
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+
+    // with strict, we should fail the execution
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--strict")
+        .arg(at.subdir.join("in.md5"))
+        .fails();
+}
+
+#[test]
+fn test_check_status() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "MD5(f)= d41d8cd98f00b204e9800998ecf8427f\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--status")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .no_output();
+}
+
+#[test]
+fn test_check_status_code() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f  f\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--status")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_is("")
+        .stdout_is("");
+}
+
+#[test]
+fn test_sha1_with_md5sum_should_fail() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("f.sha1", "SHA1 (f) = d41d8cd98f00b204e9800998ecf8427e\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("f.sha1"))
+        .fails()
+        .stderr_contains("f.sha1: no properly formatted checksum lines found")
+        .stderr_does_not_contain("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+// Disabled on Windows because of the "*"
+#[cfg(not(windows))]
+fn test_check_one_two_space_star() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("empty");
+
+    // with one space, the "*" is removed
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e *empty\n");
+
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stdout_is("empty: OK\n");
+
+    // with two spaces, the "*" is not removed
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e  *empty\n");
+    // First should fail as *empty doesn't exit
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stdout_is("*empty: FAILED open or read\n");
+
+    at.touch("*empty");
+    // Should pass as we have the file
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stdout_is("*empty: OK\n");
+}
+
+#[test]
+// Disabled on Windows because of the "*"
+#[cfg(not(windows))]
+fn test_check_space_star_or_not() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("a");
+    at.touch("*c");
+
+    // with one space, the "*" is removed
+    at.write(
+        "in.md5",
+        "d41d8cd98f00b204e9800998ecf8427e *c\n
+        d41d8cd98f00b204e9800998ecf8427e a\n",
+    );
+
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stdout_contains("c: FAILED")
+        .stdout_does_not_contain("a: FAILED")
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+
+    at.write(
+        "in.md5",
+        "d41d8cd98f00b204e9800998ecf8427e a\n
+            d41d8cd98f00b204e9800998ecf8427e *c\n",
+    );
+
+    // First should fail as *empty doesn't exit
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stdout_contains("a: OK")
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+fn test_check_no_backslash_no_space() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "MD5(f)= d41d8cd98f00b204e9800998ecf8427e\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stdout_is("f: OK\n");
+}
+
+#[test]
+fn test_incomplete_format() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "MD5 (\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_contains("no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_start_error() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "ERR\nd41d8cd98f00b204e9800998ecf8427e  f\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--strict")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stdout_is("f: OK\n")
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+fn test_check_check_ignore_no_file() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f  missing\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("--ignore-missing")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_contains("in.md5: no file was verified");
+}
+
+#[test]
+fn test_check_directory_error() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("d");
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f  d\n");
+    #[cfg(not(windows))]
+    let err_msg = "md5sum: d: Is a directory\n";
+    #[cfg(windows)]
+    let err_msg = "md5sum: d: Permission denied\n";
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_contains(err_msg);
+}
+
+#[test]
+fn test_check_quiet() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e  f\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--quiet")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .no_output();
+
+    // incorrect md5
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427f  f\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--quiet")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stdout_contains("f: FAILED")
+        .stderr_contains("WARNING: 1 computed checksum did NOT match");
+
+    scene
+        .ccmd("md5sum")
+        .arg("--quiet")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_contains("md5sum: the --quiet option is meaningful only when verifying checksums");
+    scene
+        .ccmd("md5sum")
+        .arg("--strict")
+        .arg(at.subdir.join("in.md5"))
+        .fails()
+        .stderr_contains("md5sum: the --strict option is meaningful only when verifying checksums");
+}
+
+#[test]
+fn test_star_to_start() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("f");
+    at.write("in.md5", "d41d8cd98f00b204e9800998ecf8427e *f\n");
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg(at.subdir.join("in.md5"))
+        .succeeds()
+        .stdout_only("f: OK\n");
+}
+
+#[test]
+fn test_check_b2sum_strict_check() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("f");
+
+    let checksums = [
+        "2e  f\n",
+        "e4a6a0577479b2b4  f\n",
+        "cae66941d9efbd404e4d88758ea67670  f\n",
+        "246c0442cd564aced8145b8b60f1370aa7  f\n",
+        "0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8  f\n",
+        "4ded8c5fc8b12f3273f877ca585a44ad6503249a2b345d6d9c0e67d85bcb700db4178c0303e93b8f4ad758b8e2c9fd8b3d0c28e585f1928334bb77d36782e8  f\n",
+        "786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce  f\n",
+    ];
+
+    at.write("ck", &checksums.join(""));
+
+    let output = "f: OK\n".to_string().repeat(checksums.len());
+
+    scene
+        .ccmd("b2sum")
+        .arg("-c")
+        .arg(at.subdir.join("ck"))
+        .succeeds()
+        .stdout_only(&output);
+
+    scene
+        .ccmd("b2sum")
+        .arg("--strict")
+        .arg("-c")
+        .arg(at.subdir.join("ck"))
+        .succeeds()
+        .stdout_only(&output);
+}
+
+#[test]
+fn test_check_md5_comment_line() {
+    // A comment in a checksum file shall be discarded unnoticed.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo", "foo-content\n");
+    at.write(
+        "MD5SUM",
+        "\
+        # This is a comment\n\
+        8411029f3f5b781026a93db636aca721  foo\n\
+        # next comment is empty\n#",
+    );
+
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("MD5SUM")
+        .succeeds()
+        .stdout_contains("foo: OK")
+        .no_stderr();
+}
+
+#[test]
+fn test_check_md5_comment_only() {
+    // A file only filled with comments is equivalent to an empty file,
+    // and therefore produces an error.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo", "foo-content\n");
+    at.write("MD5SUM", "# This is a comment\n");
+
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("MD5SUM")
+        .fails()
+        .stderr_contains("no properly formatted checksum lines found");
+}
+
+#[test]
+fn test_check_md5_comment_leading_space() {
+    // A file only filled with comments is equivalent to an empty file,
+    // and therefore produces an error.
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("foo", "foo-content\n");
+    at.write(
+        "MD5SUM",
+        " # This is a comment\n\
+        8411029f3f5b781026a93db636aca721  foo\n",
+    );
+
+    scene
+        .ccmd("md5sum")
+        .arg("--check")
+        .arg("MD5SUM")
+        .succeeds()
+        .stdout_contains("foo: OK")
+        .stderr_contains("WARNING: 1 line is improperly formatted");
+}
+
+#[test]
+fn test_sha256_binary() {
+    let ts = TestScenario::new(util_name!());
+    assert_eq!(
+        ts.fixtures.read("binary.sha256.expected"),
+        get_hash!(
+            ts.ucmd()
+                .arg("--sha256")
+                .arg("--bits=256")
+                .arg("binary.png")
+                .succeeds()
+                .no_stderr()
+                .stdout_str()
+        )
+    );
+}
+
+#[test]
+fn test_sha256_stdin_binary() {
+    let ts = TestScenario::new(util_name!());
+    assert_eq!(
+        ts.fixtures.read("binary.sha256.expected"),
+        get_hash!(
+            ts.ucmd()
+                .arg("--sha256")
+                .arg("--bits=256")
+                .pipe_in_fixture("binary.png")
+                .succeeds()
+                .no_stderr()
+                .stdout_str()
+        )
+    );
+}
+
+#[test]
+fn test_check_sha256_binary() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .args(&[
+            "--sha256",
+            "--bits=256",
+            "--check",
+            "binary.sha256.checkfile",
+        ])
+        .succeeds()
+        .no_stderr()
+        .stdout_is("binary.png: OK\n");
+}
diff --git a/tests/by-util/test_head.rs b/tests/by-util/test_head.rs
index 65aeca4377c..9cd690c73f8 100644
--- a/tests/by-util/test_head.rs
+++ b/tests/by-util/test_head.rs
@@ -4,21 +4,31 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (words) bogusfile emptyfile abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstu
-
-use crate::common::util::TestScenario;
-
+// spell-checker:ignore (words) seekable
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+use std::io::Read;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 static INPUT: &str = "lorem_ipsum.txt";
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_stdin_default() {
     new_ucmd!()
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_default.expected");
 }
 
@@ -27,7 +37,7 @@ fn test_stdin_1_line_obsolete() {
     new_ucmd!()
         .args(&["-1"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_1_line.expected");
 }
 
@@ -36,7 +46,7 @@ fn test_stdin_1_line() {
     new_ucmd!()
         .args(&["-n", "1"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_1_line.expected");
 }
 
@@ -45,7 +55,7 @@ fn test_stdin_negative_23_line() {
     new_ucmd!()
         .args(&["-n", "-23"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_1_line.expected");
 }
 
@@ -54,7 +64,7 @@ fn test_stdin_5_chars() {
     new_ucmd!()
         .args(&["-c", "5"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_5_chars.expected");
 }
 
@@ -62,7 +72,7 @@ fn test_stdin_5_chars() {
 fn test_single_default() {
     new_ucmd!()
         .arg(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_default.expected");
 }
 
@@ -70,7 +80,7 @@ fn test_single_default() {
 fn test_single_1_line_obsolete() {
     new_ucmd!()
         .args(&["-1", INPUT])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_1_line.expected");
 }
 
@@ -78,7 +88,7 @@ fn test_single_1_line_obsolete() {
 fn test_single_1_line() {
     new_ucmd!()
         .args(&["-n", "1", INPUT])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_1_line.expected");
 }
 
@@ -86,7 +96,7 @@ fn test_single_1_line() {
 fn test_single_5_chars() {
     new_ucmd!()
         .args(&["-c", "5", INPUT])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_5_chars.expected");
 }
 
@@ -94,15 +104,13 @@ fn test_single_5_chars() {
 fn test_verbose() {
     new_ucmd!()
         .args(&["-v", INPUT])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_verbose.expected");
 }
 
 #[test]
-#[ignore]
 fn test_spams_newline() {
-    //this test is does not mirror what GNU does
-    new_ucmd!().pipe_in("a").succeeds().stdout_is("a\n");
+    new_ucmd!().pipe_in("a").succeeds().stdout_is("a");
 }
 
 #[test]
@@ -110,7 +118,7 @@ fn test_byte_syntax() {
     new_ucmd!()
         .args(&["-1c"])
         .pipe_in("abc")
-        .run()
+        .succeeds()
         .stdout_is("a");
 }
 
@@ -119,7 +127,7 @@ fn test_line_syntax() {
     new_ucmd!()
         .args(&["-n", "2048m"])
         .pipe_in("a\n")
-        .run()
+        .succeeds()
         .stdout_is("a\n");
 }
 
@@ -128,7 +136,7 @@ fn test_zero_terminated_syntax() {
     new_ucmd!()
         .args(&["-z", "-n", "1"])
         .pipe_in("x\0y")
-        .run()
+        .succeeds()
         .stdout_is("x\0");
 }
 
@@ -137,7 +145,7 @@ fn test_zero_terminated_syntax_2() {
     new_ucmd!()
         .args(&["-z", "-n", "2"])
         .pipe_in("x\0y")
-        .run()
+        .succeeds()
         .stdout_is("x\0y");
 }
 
@@ -146,7 +154,7 @@ fn test_zero_terminated_negative_lines() {
     new_ucmd!()
         .args(&["-z", "-n", "-1"])
         .pipe_in("x\0y\0z\0")
-        .run()
+        .succeeds()
         .stdout_is("x\0y\0");
 }
 
@@ -155,10 +163,27 @@ fn test_negative_byte_syntax() {
     new_ucmd!()
         .args(&["--bytes=-2"])
         .pipe_in("a\n")
-        .run()
+        .succeeds()
         .stdout_is("");
 }
 
+#[test]
+fn test_negative_bytes_greater_than_input_size_stdin() {
+    new_ucmd!()
+        .args(&["-c", "-2"])
+        .pipe_in("a")
+        .succeeds()
+        .no_output();
+}
+
+#[test]
+fn test_negative_bytes_greater_than_input_size_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.write_bytes("f", b"a");
+    ts.ucmd().args(&["-c", "-2", "f"]).succeeds().no_output();
+}
+
 #[test]
 fn test_negative_zero_lines() {
     new_ucmd!()
@@ -217,14 +242,14 @@ fn test_multiple_nonexistent_files() {
 fn test_sequence_fixture() {
     new_ucmd!()
         .args(&["-n", "-10", "sequence"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("sequence.expected");
 }
 #[test]
 fn test_file_backwards() {
     new_ucmd!()
         .args(&["-c", "-10", "lorem_ipsum.txt"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_backwards_file.expected");
 }
 
@@ -232,7 +257,7 @@ fn test_file_backwards() {
 fn test_zero_terminated() {
     new_ucmd!()
         .args(&["-z", "zero_terminated.txt"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("zero_terminated.expected");
 }
 
@@ -296,22 +321,20 @@ fn test_bad_utf8_lines() {
 fn test_head_invalid_num() {
     new_ucmd!()
         .args(&["-c", "1024R", "emptyfile.txt"])
-        .fails()
-        .stderr_is("head: invalid number of bytes: '1024R'\n");
+        .succeeds()
+        .no_output();
     new_ucmd!()
         .args(&["-n", "1024R", "emptyfile.txt"])
-        .fails()
-        .stderr_is("head: invalid number of lines: '1024R'\n");
-    #[cfg(not(target_pointer_width = "128"))]
+        .succeeds()
+        .no_output();
     new_ucmd!()
         .args(&["-c", "1Y", "emptyfile.txt"])
-        .fails()
-        .stderr_is("head: invalid number of bytes: '1Y': Value too large for defined data type\n");
-    #[cfg(not(target_pointer_width = "128"))]
+        .succeeds()
+        .no_output();
     new_ucmd!()
         .args(&["-n", "1Y", "emptyfile.txt"])
-        .fails()
-        .stderr_is("head: invalid number of lines: '1Y': Value too large for defined data type\n");
+        .succeeds()
+        .no_output();
     #[cfg(target_pointer_width = "32")]
     {
         let sizes = ["1000G", "10T"];
@@ -323,10 +346,7 @@ fn test_head_invalid_num() {
     {
         let sizes = ["-1000G", "-10T"];
         for size in &sizes {
-            new_ucmd!()
-                .args(&["-c", size])
-                .fails()
-                .stderr_is("head: out of range integral type conversion attempted: number of bytes is too large\n");
+            new_ucmd!().args(&["-c", size]).succeeds().no_output();
         }
     }
     new_ucmd!()
@@ -362,7 +382,7 @@ fn test_presume_input_pipe_default() {
     new_ucmd!()
         .args(&["---presume-input-pipe"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_default.expected");
 }
 
@@ -371,6 +391,415 @@ fn test_presume_input_pipe_5_chars() {
     new_ucmd!()
         .args(&["-c", "5", "---presume-input-pipe"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("lorem_ipsum_5_chars.expected");
 }
+
+#[test]
+fn test_all_but_last_bytes_large_file_piped() {
+    // Validate print-all-but-last-n-bytes with a large piped-in (i.e. non-seekable) file.
+    let scene = TestScenario::new(util_name!());
+    let fixtures = &scene.fixtures;
+
+    // First, create all our fixtures.
+    let seq_20000_file_name = "seq_20000";
+    let seq_19000_file_name = "seq_19000";
+    let seq_19001_20000_file_name = "seq_19001_20000";
+    scene
+        .cmd("seq")
+        .arg("20000")
+        .set_stdout(fixtures.make_file(seq_20000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .arg("19000")
+        .set_stdout(fixtures.make_file(seq_19000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .args(&["19001", "20000"])
+        .set_stdout(fixtures.make_file(seq_19001_20000_file_name))
+        .succeeds();
+
+    let seq_19001_20000_file_length = fixtures
+        .open(seq_19001_20000_file_name)
+        .metadata()
+        .unwrap()
+        .len();
+    scene
+        .ucmd()
+        .args(&["-c", &format!("-{seq_19001_20000_file_length}")])
+        .pipe_in_fixture(seq_20000_file_name)
+        .succeeds()
+        .stdout_only_fixture(seq_19000_file_name);
+}
+
+#[test]
+fn test_all_but_last_lines_large_file() {
+    // Create our fixtures on the fly. We need the input file to be at least double
+    // the size of BUF_SIZE as specified in head.rs. Go for something a bit bigger
+    // than that.
+    let scene = TestScenario::new(util_name!());
+    let fixtures = &scene.fixtures;
+    let seq_20000_file_name = "seq_20000";
+    let seq_1000_file_name = "seq_1000";
+    scene
+        .cmd("seq")
+        .arg("20000")
+        .set_stdout(fixtures.make_file(seq_20000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .arg("1000")
+        .set_stdout(fixtures.make_file(seq_1000_file_name))
+        .succeeds();
+
+    // Now run our tests.
+    scene
+        .ucmd()
+        .args(&["-n", "-19000", seq_20000_file_name])
+        .succeeds()
+        .stdout_only_fixture("seq_1000");
+
+    scene
+        .ucmd()
+        .args(&["-n", "-20000", seq_20000_file_name])
+        .succeeds()
+        .stdout_only_fixture("emptyfile.txt");
+
+    scene
+        .ucmd()
+        .args(&["-n", "-20001", seq_20000_file_name])
+        .succeeds()
+        .stdout_only_fixture("emptyfile.txt");
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+#[test]
+fn test_validate_stdin_offset_lines() {
+    // A handful of unix-only tests to validate behavior when reading from stdin on a seekable
+    // file. GNU-compatibility requires that the stdin file be left such that if another
+    // process is invoked on the same stdin file after head has run, the subsequent file should
+    // start reading from the byte after the last byte printed by head.
+    // Since this is unix-only requirement, keep this as a separate test rather than adding a
+    // conditionally-compiled segment to multiple tests.
+    //
+    // Test scenarios...
+    // 1 - Print the first n lines
+    // 2 - Print all-but the last n lines
+    // 3 - Print all but the last n lines, large file.
+    let scene = TestScenario::new(util_name!());
+    let fixtures = &scene.fixtures;
+
+    // Test 1 - Print the first n lines
+    fixtures.write("f1", "a\nb\nc\n");
+    let file = fixtures.open("f1");
+    let mut file_shadow = file.try_clone().unwrap();
+    scene
+        .ucmd()
+        .args(&["-n", "1"])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only("a\n");
+    let mut bytes_remaining_in_stdin = vec![];
+    assert_eq!(
+        file_shadow
+            .read_to_end(&mut bytes_remaining_in_stdin)
+            .unwrap(),
+        4
+    );
+    assert_eq!(
+        String::from_utf8(bytes_remaining_in_stdin).unwrap(),
+        "b\nc\n"
+    );
+
+    // Test 2 - Print all-but the last n lines
+    fixtures.write("f2", "a\nb\nc\n");
+    let file = fixtures.open("f2");
+    let mut file_shadow = file.try_clone().unwrap();
+    scene
+        .ucmd()
+        .args(&["-n", "-1"])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only("a\nb\n");
+    let mut bytes_remaining_in_stdin = vec![];
+    assert_eq!(
+        file_shadow
+            .read_to_end(&mut bytes_remaining_in_stdin)
+            .unwrap(),
+        2
+    );
+    assert_eq!(String::from_utf8(bytes_remaining_in_stdin).unwrap(), "c\n");
+
+    // Test 3 - Print all but the last n lines, large input file.
+    // First, create all our fixtures.
+    let seq_20000_file_name = "seq_20000";
+    let seq_1000_file_name = "seq_1000";
+    let seq_1001_20000_file_name = "seq_1001_20000";
+    scene
+        .cmd("seq")
+        .arg("20000")
+        .set_stdout(fixtures.make_file(seq_20000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .arg("1000")
+        .set_stdout(fixtures.make_file(seq_1000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .args(&["1001", "20000"])
+        .set_stdout(fixtures.make_file(seq_1001_20000_file_name))
+        .succeeds();
+
+    let file = fixtures.open(seq_20000_file_name);
+    let file_shadow = file.try_clone().unwrap();
+    scene
+        .ucmd()
+        .args(&["-n", "-19000"])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only_fixture(seq_1000_file_name);
+    scene
+        .cmd("cat")
+        .set_stdin(file_shadow)
+        .succeeds()
+        .stdout_only_fixture(seq_1001_20000_file_name);
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+#[test]
+fn test_validate_stdin_offset_bytes() {
+    // A handful of unix-only tests to validate behavior when reading from stdin on a seekable
+    // file. GNU-compatibility requires that the stdin file be left such that if another
+    // process is invoked on the same stdin file after head has run, the subsequent file should
+    // start reading from the byte after the last byte printed by head.
+    // Since this is unix-only requirement, keep this as a separate test rather than adding a
+    // conditionally-compiled segment to multiple tests.
+    //
+    // Test scenarios...
+    // 1 - Print the first n bytes
+    // 2 - Print all-but the last n bytes
+    // 3 - Print all-but the last n bytes, with n=0 (i.e. print everything)
+    // 4 - Print all but the last n bytes, large file.
+    let scene = TestScenario::new(util_name!());
+    let fixtures = &scene.fixtures;
+
+    // Test 1 - Print the first n bytes
+    fixtures.write("f1", "abc\ndef\n");
+    let file = fixtures.open("f1");
+    let mut file_shadow = file.try_clone().unwrap();
+    scene
+        .ucmd()
+        .args(&["-c", "2"])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only("ab");
+    let mut bytes_remaining_in_stdin = vec![];
+    assert_eq!(
+        file_shadow
+            .read_to_end(&mut bytes_remaining_in_stdin)
+            .unwrap(),
+        6
+    );
+    assert_eq!(
+        String::from_utf8(bytes_remaining_in_stdin).unwrap(),
+        "c\ndef\n"
+    );
+
+    // Test 2 - Print all-but the last n bytes
+    fixtures.write("f2", "abc\ndef\n");
+    let file = fixtures.open("f2");
+    let mut file_shadow = file.try_clone().unwrap();
+    scene
+        .ucmd()
+        .args(&["-c", "-3"])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only("abc\nd");
+    let mut bytes_remaining_in_stdin = vec![];
+    assert_eq!(
+        file_shadow
+            .read_to_end(&mut bytes_remaining_in_stdin)
+            .unwrap(),
+        3
+    );
+    assert_eq!(String::from_utf8(bytes_remaining_in_stdin).unwrap(), "ef\n");
+
+    // Test 3 - Print all-but the last n bytes, n=0 (i.e. print everything)
+    fixtures.write("f3", "abc\ndef\n");
+    let file = fixtures.open("f3");
+    let mut file_shadow = file.try_clone().unwrap();
+    scene
+        .ucmd()
+        .args(&["-c", "-0"])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only("abc\ndef\n");
+    let mut bytes_remaining_in_stdin = vec![];
+    assert_eq!(
+        file_shadow
+            .read_to_end(&mut bytes_remaining_in_stdin)
+            .unwrap(),
+        0
+    );
+    assert_eq!(String::from_utf8(bytes_remaining_in_stdin).unwrap(), "");
+
+    // Test 4 - Print all but the last n bytes, large input file.
+    // First, create all our fixtures.
+    let seq_20000_file_name = "seq_20000";
+    let seq_19000_file_name = "seq_19000";
+    let seq_19001_20000_file_name = "seq_19001_20000";
+    scene
+        .cmd("seq")
+        .arg("20000")
+        .set_stdout(fixtures.make_file(seq_20000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .arg("19000")
+        .set_stdout(fixtures.make_file(seq_19000_file_name))
+        .succeeds();
+    scene
+        .cmd("seq")
+        .args(&["19001", "20000"])
+        .set_stdout(fixtures.make_file(seq_19001_20000_file_name))
+        .succeeds();
+
+    let file = fixtures.open(seq_20000_file_name);
+    let file_shadow = file.try_clone().unwrap();
+    let seq_19001_20000_file_length = fixtures
+        .open(seq_19001_20000_file_name)
+        .metadata()
+        .unwrap()
+        .len();
+    scene
+        .ucmd()
+        .args(&["-c", &format!("-{seq_19001_20000_file_length}")])
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only_fixture(seq_19000_file_name);
+    scene
+        .cmd("cat")
+        .set_stdin(file_shadow)
+        .succeeds()
+        .stdout_only_fixture(seq_19001_20000_file_name);
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_version() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/proc/version"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_modules() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/proc/modules"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+#[test]
+fn test_read_backwards_lines_proc_fs_modules() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["--lines", "-1", "/proc/modules"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(!result.stdout().is_empty());
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "android"),
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
+))]
+#[test]
+fn test_read_backwards_bytes_sys_kernel_profiling() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/sys/kernel/profiling"];
+    let result = ts.ucmd().args(&args).succeeds();
+    let stdout_str = result.stdout_str();
+    assert_eq!(stdout_str.len(), 1);
+    assert!(stdout_str == "0" || stdout_str == "1");
+}
+
+#[test]
+fn test_value_too_large() {
+    const MAX: u64 = u64::MAX;
+
+    new_ucmd!()
+        .args(&["-n", format!("{MAX}0").as_str(), "lorem_ipsum.txt"])
+        .succeeds();
+}
+
+#[test]
+fn test_all_but_last_lines() {
+    new_ucmd!()
+        .args(&["-n", "-15", "lorem_ipsum.txt"])
+        .succeeds()
+        .stdout_is_fixture("lorem_ipsum_backwards_15_lines.expected");
+}
+
+#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
+#[test]
+fn test_write_to_dev_full() {
+    use std::fs::OpenOptions;
+
+    for append in [true, false] {
+        {
+            let dev_full = OpenOptions::new()
+                .write(true)
+                .append(append)
+                .open("/dev/full")
+                .unwrap();
+
+            new_ucmd!()
+                .pipe_in_fixture(INPUT)
+                .set_stdout(dev_full)
+                .fails()
+                .stderr_contains("error writing 'standard output': No space left on device");
+        }
+    }
+}
diff --git a/tests/by-util/test_hostid.rs b/tests/by-util/test_hostid.rs
index e9336116bca..198061b1999 100644
--- a/tests/by-util/test_hostid.rs
+++ b/tests/by-util/test_hostid.rs
@@ -2,11 +2,21 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
 use regex::Regex;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_normal() {
     let re = Regex::new(r"^[0-9a-f]{8}").unwrap();
     new_ucmd!().succeeds().stdout_matches(&re);
 }
+
+#[test]
+fn test_invalid_flag() {
+    new_ucmd!()
+        .arg("--invalid-argument")
+        .fails_with_code(1)
+        .no_stdout();
+}
diff --git a/tests/by-util/test_hostname.rs b/tests/by-util/test_hostname.rs
index 84cb73e2ecf..1611a590a2a 100644
--- a/tests/by-util/test_hostname.rs
+++ b/tests/by-util/test_hostname.rs
@@ -2,7 +2,9 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_hostname() {
@@ -14,8 +16,8 @@ fn test_hostname() {
     assert!(ls_default_res.stdout().len() >= ls_domain_res.stdout().len());
 }
 
-// FixME: fails for "MacOS" and "freebsd" "failed to lookup address information: Name does not resolve"
-#[cfg(not(any(target_os = "macos", target_os = "freebsd")))]
+// FixME: fails for "MacOS" => "failed to lookup address information"
+#[cfg(not(target_os = "macos"))]
 #[test]
 fn test_hostname_ip() {
     let result = new_ucmd!().arg("-i").succeeds();
@@ -35,5 +37,5 @@ fn test_hostname_full() {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
diff --git a/tests/by-util/test_id.rs b/tests/by-util/test_id.rs
index 5c2a67199c6..7a7d5e9a169 100644
--- a/tests/by-util/test_id.rs
+++ b/tests/by-util/test_id.rs
@@ -5,22 +5,25 @@
 
 // spell-checker:ignore (ToDO) coreutil
 
-use crate::common::util::{check_coreutil_version, expected_result, is_ci, whoami, TestScenario};
+use uutests::new_ucmd;
+use uutests::unwrap_or_return;
+use uutests::util::{TestScenario, check_coreutil_version, expected_result, is_ci, whoami};
+use uutests::util_name;
 
 const VERSION_MIN_MULTIPLE_USERS: &str = "8.31"; // this feature was introduced in GNU's coreutils 8.31
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
-#[cfg(unix)]
+#[allow(unused_mut)]
 fn test_id_no_specified_user() {
     let ts = TestScenario::new(util_name!());
     let result = ts.ucmd().run();
     let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
-    let mut _exp_stdout = exp_result.stdout_str().to_string();
+    let mut exp_stdout = exp_result.stdout_str().to_string();
 
     #[cfg(not(feature = "feat_selinux"))]
     {
@@ -29,18 +32,17 @@ fn test_id_no_specified_user() {
         // uid=1001(runner) gid=121(docker) groups=121(docker),4(adm),101(systemd-journal) \
         // context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
         if let Some(context_offset) = exp_result.stdout_str().find(" context=") {
-            _exp_stdout.replace_range(context_offset.._exp_stdout.len() - 1, "");
+            exp_stdout.replace_range(context_offset..exp_stdout.len() - 1, "");
         }
     }
 
     result
-        .stdout_is(_exp_stdout)
+        .stdout_is(exp_stdout)
         .stderr_is(exp_result.stderr_str())
         .code_is(exp_result.code());
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_single_user() {
     let test_users = [&whoami()[..]];
 
@@ -92,7 +94,6 @@ fn test_id_single_user() {
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_single_user_non_existing() {
     let args = &["hopefully_non_existing_username"];
     let ts = TestScenario::new(util_name!());
@@ -110,7 +111,6 @@ fn test_id_single_user_non_existing() {
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_name() {
     let ts = TestScenario::new(util_name!());
     for opt in ["--user", "--group", "--groups"] {
@@ -129,7 +129,6 @@ fn test_id_name() {
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_real() {
     let ts = TestScenario::new(util_name!());
     for opt in ["--user", "--group", "--groups"] {
@@ -144,27 +143,16 @@ fn test_id_real() {
 }
 
 #[test]
-#[cfg(all(unix, not(any(target_os = "linux", target_os = "android"))))]
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
 fn test_id_pretty_print() {
     // `-p` is BSD only and not supported on GNU's `id`
     let username = whoami();
-
     let result = new_ucmd!().arg("-p").run();
-    if result.stdout_str().trim().is_empty() {
-        // this fails only on: "MinRustV (ubuntu-latest, feat_os_unix)"
-        // `rustc 1.40.0 (73528e339 2019-12-16)`
-        // run: /home/runner/work/coreutils/coreutils/target/debug/coreutils id -p
-        // thread 'test_id::test_id_pretty_print' panicked at 'Command was expected to succeed.
-        // stdout =
-        // stderr = ', tests/common/util.rs:157:13
-        println!("test skipped:");
-    } else {
-        result.success().stdout_contains(username);
-    }
+    result.success().stdout_contains(username);
 }
 
 #[test]
-#[cfg(all(unix, not(any(target_os = "linux", target_os = "android"))))]
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
 fn test_id_password_style() {
     // `-P` is BSD only and not supported on GNU's `id`
     let username = whoami();
@@ -173,7 +161,6 @@ fn test_id_password_style() {
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_multiple_users() {
     unwrap_or_return!(check_coreutil_version(
         util_name!(),
@@ -231,7 +218,6 @@ fn test_id_multiple_users() {
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_multiple_users_non_existing() {
     unwrap_or_return!(check_coreutil_version(
         util_name!(),
@@ -299,16 +285,19 @@ fn test_id_multiple_users_non_existing() {
 }
 
 #[test]
-#[cfg(unix)]
+fn test_id_name_or_real_with_default_format() {
+    for flag in ["-n", "--name", "-r", "--real"] {
+        new_ucmd!()
+            .arg(flag)
+            .fails()
+            .stderr_only("id: printing only names or real IDs requires -u, -g, or -G\n");
+    }
+}
+
+#[test]
 fn test_id_default_format() {
     let ts = TestScenario::new(util_name!());
     for opt1 in ["--name", "--real"] {
-        // id: cannot print only names or real IDs in default format
-        let args = [opt1];
-        ts.ucmd()
-            .args(&args)
-            .fails()
-            .stderr_only(unwrap_or_return!(expected_result(&ts, &args)).stderr_str());
         for opt2 in ["--user", "--group", "--groups"] {
             // u/g/G n/r
             let args = [opt2, opt1];
@@ -327,26 +316,41 @@ fn test_id_default_format() {
             .args(&args)
             .succeeds()
             .stdout_only(unwrap_or_return!(expected_result(&ts, &args)).stdout_str());
+        let args = [opt2, opt2];
+        ts.ucmd()
+            .args(&args)
+            .succeeds()
+            .stdout_only(unwrap_or_return!(expected_result(&ts, &args)).stdout_str());
+    }
+}
+
+#[test]
+fn test_id_zero_with_default_format() {
+    for z_flag in ["-z", "--zero"] {
+        new_ucmd!()
+            .arg(z_flag)
+            .fails()
+            .stderr_only("id: option --zero not permitted in default format\n");
+    }
+}
+
+#[test]
+fn test_id_zero_with_name_or_real() {
+    for z_flag in ["-z", "--zero"] {
+        for flag in ["-n", "--name", "-r", "--real"] {
+            new_ucmd!()
+                .args(&[z_flag, flag])
+                .fails()
+                .stderr_only("id: printing only names or real IDs requires -u, -g, or -G\n");
+        }
     }
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_zero() {
     let ts = TestScenario::new(util_name!());
     for z_flag in ["-z", "--zero"] {
-        // id: option --zero not permitted in default format
-        ts.ucmd()
-            .args(&[z_flag])
-            .fails()
-            .stderr_only(unwrap_or_return!(expected_result(&ts, &[z_flag])).stderr_str());
         for opt1 in ["--name", "--real"] {
-            // id: cannot print only names or real IDs in default format
-            let args = [opt1, z_flag];
-            ts.ucmd()
-                .args(&args)
-                .fails()
-                .stderr_only(unwrap_or_return!(expected_result(&ts, &args)).stderr_str());
             for opt2 in ["--user", "--group", "--groups"] {
                 // u/g/G n/r z
                 let args = [opt2, z_flag, opt1];
@@ -372,9 +376,8 @@ fn test_id_zero() {
 #[test]
 #[cfg(feature = "feat_selinux")]
 fn test_id_context() {
-    use selinux::{self, KernelSupport};
-    if selinux::kernel_support() == KernelSupport::Unsupported {
-        println!("test skipped: Kernel has no support for SElinux context",);
+    if !uucore::selinux::is_selinux_enabled() {
+        println!("test skipped: Kernel has no support for SElinux context");
         return;
     }
     let ts = TestScenario::new(util_name!());
@@ -431,7 +434,6 @@ fn test_id_context() {
 }
 
 #[test]
-#[cfg(unix)]
 fn test_id_no_specified_user_posixly() {
     // gnu/tests/id/no-context.sh
 
@@ -447,12 +449,24 @@ fn test_id_no_specified_user_posixly() {
         feature = "feat_selinux"
     ))]
     {
-        use selinux::{self, KernelSupport};
-        if selinux::kernel_support() == KernelSupport::Unsupported {
-            println!("test skipped: Kernel has no support for SElinux context",);
-        } else {
+        if uucore::selinux::is_selinux_enabled() {
             let result = ts.ucmd().succeeds();
             assert!(result.stdout_str().contains("context="));
+        } else {
+            println!("test skipped: Kernel has no support for SElinux context");
         }
     }
 }
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_id_pretty_print_password_record() {
+    // `-p` is BSD only and not supported on GNU's `id`.
+    // `-P` is our own extension, and not supported by either GNU nor BSD.
+    // These must conflict, because they both set the output format.
+    new_ucmd!()
+        .arg("-p")
+        .arg("-P")
+        .fails()
+        .stderr_contains("the argument '-p' cannot be used with '-P'");
+}
diff --git a/tests/by-util/test_install.rs b/tests/by-util/test_install.rs
index 7387748c619..c402f353788 100644
--- a/tests/by-util/test_install.rs
+++ b/tests/by-util/test_install.rs
@@ -2,20 +2,25 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) helloworld nodir objdump n'source
+// spell-checker:ignore (words) helloworld nodir objdump n'source nconfined
 
-use crate::common::util::{is_ci, TestScenario};
+#[cfg(not(target_os = "openbsd"))]
 use filetime::FileTime;
-use std::os::unix::fs::PermissionsExt;
-#[cfg(not(any(windows, target_os = "freebsd")))]
+use std::fs;
+use std::os::unix::fs::{MetadataExt, PermissionsExt};
+#[cfg(not(windows))]
 use std::process::Command;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::thread::sleep;
 use uucore::process::{getegid, geteuid};
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::{TestScenario, is_ci, run_ucmd_as_root};
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -65,24 +70,6 @@ fn test_install_failing_not_dir() {
         .stderr_contains("not a directory");
 }
 
-#[test]
-fn test_install_unimplemented_arg() {
-    let (at, mut ucmd) = at_and_ucmd!();
-    let dir = "target_dir";
-    let file = "source_file";
-    let context_arg = "--context";
-
-    at.touch(file);
-    at.mkdir(dir);
-    ucmd.arg(context_arg)
-        .arg(file)
-        .arg(dir)
-        .fails()
-        .stderr_contains("Unimplemented");
-
-    assert!(!at.file_exists(format!("{dir}/{file}")));
-}
-
 #[test]
 fn test_install_ancestors_directories() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -488,8 +475,7 @@ fn test_install_failing_omitting_directory() {
         .arg(file1)
         .arg(dir1)
         .arg(dir3)
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("omitting directory");
     assert!(at.file_exists(format!("{dir3}/{file1}")));
 
@@ -498,8 +484,7 @@ fn test_install_failing_omitting_directory() {
         .ucmd()
         .arg(dir1)
         .arg(dir3)
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("omitting directory");
 }
 
@@ -516,12 +501,12 @@ fn test_install_failing_no_such_file() {
     ucmd.arg(file1)
         .arg(file2)
         .arg(dir1)
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("No such file or directory");
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_install_copy_then_compare_file() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -574,7 +559,7 @@ fn test_install_copy_then_compare_file_with_extra_mode() {
 
     let mut file2_meta = at.metadata(file2);
     let before = FileTime::from_last_modification_time(&file2_meta);
-    sleep(std::time::Duration::from_millis(1000));
+    sleep(std::time::Duration::from_millis(100));
 
     scene
         .ucmd()
@@ -589,9 +574,9 @@ fn test_install_copy_then_compare_file_with_extra_mode() {
     file2_meta = at.metadata(file2);
     let after_install_sticky = FileTime::from_last_modification_time(&file2_meta);
 
-    assert!(before != after_install_sticky);
+    assert_ne!(before, after_install_sticky);
 
-    sleep(std::time::Duration::from_millis(1000));
+    sleep(std::time::Duration::from_millis(100));
 
     // dest file still 1644, so need_copy ought to return `true`
     scene
@@ -605,17 +590,21 @@ fn test_install_copy_then_compare_file_with_extra_mode() {
     file2_meta = at.metadata(file2);
     let after_install_sticky_again = FileTime::from_last_modification_time(&file2_meta);
 
-    assert!(after_install_sticky != after_install_sticky_again);
+    assert_ne!(after_install_sticky, after_install_sticky_again);
 }
 
 const STRIP_TARGET_FILE: &str = "helloworld_installed";
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(all(not(windows), not(target_os = "freebsd")))]
 const SYMBOL_DUMP_PROGRAM: &str = "objdump";
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(target_os = "freebsd")]
+const SYMBOL_DUMP_PROGRAM: &str = "llvm-objdump";
+#[cfg(not(windows))]
 const STRIP_SOURCE_FILE_SYMBOL: &str = "main";
 
 fn strip_source_file() -> &'static str {
-    if cfg!(target_os = "macos") {
+    if cfg!(target_os = "freebsd") {
+        "helloworld_freebsd"
+    } else if cfg!(target_os = "macos") {
         "helloworld_macos"
     } else if cfg!(target_arch = "arm") || cfg!(target_arch = "aarch64") {
         "helloworld_android"
@@ -625,8 +614,7 @@ fn strip_source_file() -> &'static str {
 }
 
 #[test]
-// FixME: Freebsd fails on 'No such file or directory'
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_install_and_strip() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -649,8 +637,7 @@ fn test_install_and_strip() {
 }
 
 #[test]
-// FixME: Freebsd fails on 'No such file or directory'
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_install_and_strip_with_program() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -674,6 +661,102 @@ fn test_install_and_strip_with_program() {
     assert!(!stdout.contains(STRIP_SOURCE_FILE_SYMBOL));
 }
 
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_install_and_strip_with_program_hyphen() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    let content = r#"#!/bin/sh
+    printf -- '%s\n' "$1" | grep '^[^-]'
+    "#;
+    at.write("no-hyphen", content);
+    scene.ccmd("chmod").arg("+x").arg("no-hyphen").succeeds();
+
+    at.touch("src");
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("./no-hyphen")
+        .arg("--")
+        .arg("src")
+        .arg("-dest")
+        .succeeds()
+        .no_stderr()
+        .stdout_is("./-dest\n");
+
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--strip-program")
+        .arg("./no-hyphen")
+        .arg("--")
+        .arg("src")
+        .arg("./-dest")
+        .succeeds()
+        .no_stderr()
+        .stdout_is("./-dest\n");
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_install_on_invalid_link_at_destination() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    at.mkdir("src");
+    at.mkdir("dest");
+    let src_dir = at.plus("src");
+    let dst_dir = at.plus("dest");
+
+    at.touch("test.sh");
+    at.symlink_file(
+        "/opt/FakeDestination",
+        &dst_dir.join("test.sh").to_string_lossy(),
+    );
+    scene.ccmd("chmod").arg("+x").arg("test.sh").succeeds();
+    at.symlink_file("test.sh", &src_dir.join("test.sh").to_string_lossy());
+
+    scene
+        .ucmd()
+        .current_dir(&src_dir)
+        .arg(src_dir.join("test.sh"))
+        .arg(dst_dir.join("test.sh"))
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_install_on_invalid_link_at_destination_and_dev_null_at_source() {
+    let scene = TestScenario::new(util_name!());
+
+    let at = &scene.fixtures;
+    at.mkdir("src");
+    at.mkdir("dest");
+    let src_dir = at.plus("src");
+    let dst_dir = at.plus("dest");
+
+    at.touch("test.sh");
+    at.symlink_file(
+        "/opt/FakeDestination",
+        &dst_dir.join("test.sh").to_string_lossy(),
+    );
+    scene.ccmd("chmod").arg("+x").arg("test.sh").succeeds();
+    at.symlink_file("test.sh", &src_dir.join("test.sh").to_string_lossy());
+
+    scene
+        .ucmd()
+        .current_dir(&src_dir)
+        .arg("/dev/null")
+        .arg(dst_dir.join("test.sh"))
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+}
+
 #[test]
 #[cfg(not(windows))]
 fn test_install_and_strip_with_invalid_program() {
@@ -861,7 +944,7 @@ fn test_install_dir() {
     at.mkdir(dir);
     ucmd.arg(file1)
         .arg(file2)
-        .arg(&format!("--target-directory={dir}"))
+        .arg(format!("--target-directory={dir}"))
         .succeeds()
         .no_stderr();
 
@@ -1290,8 +1373,7 @@ fn test_install_missing_arguments() {
 
     scene
         .ucmd()
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .usage_error("missing file operand");
 
     scene
@@ -1499,6 +1581,7 @@ fn test_install_chown_directory_invalid() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_install_compare_option() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -1528,13 +1611,409 @@ fn test_install_compare_option() {
     scene
         .ucmd()
         .args(&["-C", "--preserve-timestamps", first, second])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("Options --compare and --preserve-timestamps are mutually exclusive");
     scene
         .ucmd()
         .args(&["-C", "--strip", "--strip-program=echo", first, second])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("Options --compare and --strip are mutually exclusive");
 }
+
+#[test]
+// Matches part of tests/install/basic-1
+fn test_t_exist_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source1 = "file";
+    let target_dir = "sub4/";
+    let target_file = "sub4/file_exists";
+
+    at.touch(source1);
+    at.mkdir(target_dir);
+    at.touch(target_file);
+
+    scene
+        .ucmd()
+        .arg("-t")
+        .arg(target_file)
+        .arg("-Dv")
+        .arg(source1)
+        .fails()
+        .stderr_contains("failed to access 'sub4/file_exists': Not a directory");
+}
+
+#[test]
+fn test_target_file_ends_with_slash() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source = "source_file";
+    let target_dir = "dir";
+    let target_file = "dir/target_file";
+    let target_file_slash = format!("{target_file}/");
+
+    at.touch(source);
+    at.mkdir(target_dir);
+    at.touch(target_file);
+
+    scene
+        .ucmd()
+        .arg("-t")
+        .arg(target_file_slash)
+        .arg("-D")
+        .arg(source)
+        .fails()
+        .stderr_contains("failed to access 'dir/target_file/': Not a directory");
+}
+
+#[test]
+fn test_install_root_combined() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("a");
+    at.touch("c");
+
+    let run_and_check = |args: &[&str], target: &str, expected_uid: u32, expected_gid: u32| {
+        if let Ok(result) = run_ucmd_as_root(&ts, args) {
+            result.success();
+            assert!(at.file_exists(target));
+
+            let metadata = fs::metadata(at.plus(target)).unwrap();
+            assert_eq!(metadata.uid(), expected_uid);
+            assert_eq!(metadata.gid(), expected_gid);
+        } else {
+            print!("Test skipped; requires root user");
+        }
+    };
+
+    run_and_check(&["-Cv", "-o1", "-g1", "a", "b"], "b", 1, 1);
+    run_and_check(&["-Cv", "-o2", "-g1", "a", "b"], "b", 2, 1);
+    run_and_check(&["-Cv", "-o2", "-g2", "a", "b"], "b", 2, 2);
+
+    run_and_check(&["-Cv", "-o2", "c", "d"], "d", 2, 0);
+    run_and_check(&["-Cv", "c", "d"], "d", 0, 0);
+    run_and_check(&["-Cv", "c", "d"], "d", 0, 0);
+}
+
+#[test]
+#[cfg(unix)]
+fn test_install_from_fifo() {
+    use std::fs::OpenOptions;
+    use std::io::Write;
+    use std::thread;
+
+    let pipe_name = "pipe";
+    let target_name = "target";
+    let test_string = "Hello, world!\n";
+
+    let s = TestScenario::new(util_name!());
+    s.fixtures.mkfifo(pipe_name);
+    assert!(s.fixtures.is_fifo(pipe_name));
+
+    let proc = s.ucmd().arg(pipe_name).arg(target_name).run_no_wait();
+
+    let pipe_path = s.fixtures.plus(pipe_name);
+    let thread = thread::spawn(move || {
+        let mut pipe = OpenOptions::new()
+            .write(true)
+            .create(false)
+            .open(pipe_path)
+            .unwrap();
+        pipe.write_all(test_string.as_bytes()).unwrap();
+    });
+
+    proc.wait().unwrap();
+    thread.join().unwrap();
+
+    assert!(s.fixtures.file_exists(target_name));
+    assert_eq!(s.fixtures.read(target_name), test_string);
+}
+
+#[test]
+#[cfg(unix)]
+fn test_install_from_stdin() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let target = "target";
+    let test_string = "Hello, World!\n";
+
+    ucmd.arg("/dev/fd/0")
+        .arg(target)
+        .pipe_in(test_string)
+        .succeeds();
+
+    assert!(at.file_exists(target));
+    assert_eq!(at.read(target), test_string);
+}
+
+#[test]
+fn test_install_failing_copy_file_to_target_contain_subdir_with_same_name() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let dir1 = "dir1";
+
+    at.touch(file);
+    at.mkdir_all(&format!("{dir1}/{file}"));
+    ucmd.arg(file)
+        .arg(dir1)
+        .fails()
+        .stderr_contains("cannot overwrite directory");
+}
+
+#[test]
+fn test_install_same_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+
+    at.touch(file);
+    ucmd.arg(file)
+        .arg(".")
+        .fails()
+        .stderr_contains("'file' and './file' are the same file");
+}
+
+#[test]
+fn test_install_symlink_same_file() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let target_dir = "target_dir";
+    let target_link = "target_link";
+
+    at.mkdir(target_dir);
+    at.touch(format!("{target_dir}/{file}"));
+    at.symlink_file(target_dir, target_link);
+    ucmd.arg(format!("{target_dir}/{file}"))
+        .arg(target_link)
+        .fails()
+        .stderr_contains(format!(
+            "'{target_dir}/{file}' and '{target_link}/{file}' are the same file"
+        ));
+}
+
+#[test]
+fn test_install_no_target_directory_failing_cannot_overwrite() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let file = "file";
+    let dir = "dir";
+
+    at.touch(file);
+    at.mkdir(dir);
+    scene
+        .ucmd()
+        .arg("-T")
+        .arg(file)
+        .arg(dir)
+        .fails()
+        .stderr_contains("cannot overwrite directory 'dir' with non-directory");
+
+    assert!(!at.dir_exists("dir/file"));
+}
+
+#[test]
+fn test_install_no_target_directory_failing_omitting_directory() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dir1 = "dir1";
+    let dir2 = "dir2";
+
+    at.mkdir(dir1);
+    at.mkdir(dir2);
+    scene
+        .ucmd()
+        .arg("-T")
+        .arg(dir1)
+        .arg(dir2)
+        .fails()
+        .stderr_contains("omitting directory 'dir1'");
+}
+
+#[test]
+fn test_install_no_target_directory_creating_leading_dirs_with_single_source_and_target_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let source1 = "file";
+    let target_dir = "missing_target_dir/";
+
+    at.touch(source1);
+
+    // installing a single file into a missing directory will fail, when -D is used w/o -t parameter
+    scene
+        .ucmd()
+        .arg("-TD")
+        .arg(source1)
+        .arg(at.plus(target_dir))
+        .fails()
+        .stderr_contains("missing_target_dir/' is not a directory");
+
+    assert!(!at.dir_exists(target_dir));
+}
+
+#[test]
+fn test_install_no_target_directory_failing_combine_with_target_directory() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let file = "file";
+    let dir1 = "dir1";
+
+    at.touch(file);
+    at.mkdir(dir1);
+    scene
+        .ucmd()
+        .arg("-T")
+        .arg(file)
+        .arg("-t")
+        .arg(dir1)
+        .fails()
+        .stderr_contains(
+            "Options --target-directory and --no-target-directory are mutually exclusive",
+        );
+}
+
+#[test]
+fn test_install_no_target_directory_failing_usage_with_target_directory() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let file = "file";
+
+    at.touch(file);
+    scene
+        .ucmd()
+        .arg("-T")
+        .arg(file)
+        .arg("-t")
+        .fails()
+        .stderr_contains(
+            "a value is required for '--target-directory <DIRECTORY>' but none was supplied",
+        )
+        .stderr_contains("For more information, try '--help'");
+}
+
+#[test]
+fn test_install_no_target_multiple_sources_and_target_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file1 = "file1";
+    let file2 = "file2";
+    let dir1 = "dir1";
+    let dir2 = "dir2";
+
+    at.touch(file1);
+    at.touch(file2);
+    at.mkdir(dir1);
+    at.mkdir(dir2);
+
+    // installing multiple files into a missing directory will fail, when -D is used w/o -t parameter
+    scene
+        .ucmd()
+        .arg("-T")
+        .arg(file1)
+        .arg(file2)
+        .arg(dir1)
+        .fails()
+        .stderr_contains("extra operand 'dir1'")
+        .stderr_contains("[OPTION]... [FILE]...");
+
+    scene
+        .ucmd()
+        .arg("-T")
+        .arg(file1)
+        .arg(file2)
+        .arg(dir1)
+        .arg(dir2)
+        .fails()
+        .stderr_contains("extra operand 'dir1'")
+        .stderr_contains("[OPTION]... [FILE]...");
+}
+
+#[test]
+fn test_install_no_target_basic() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "file";
+    let dir = "dir";
+
+    at.touch(file);
+    at.mkdir(dir);
+    ucmd.arg("-T")
+        .arg(file)
+        .arg(format!("{dir}/{file}"))
+        .succeeds()
+        .no_stderr();
+
+    assert!(at.file_exists(file));
+    assert!(at.file_exists(format!("{dir}/{file}")));
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_selinux() {
+    use std::process::Command;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let src = "orig";
+    at.touch(src);
+
+    let dest = "orig.2";
+
+    let args = ["-Z", "--context=unconfined_u:object_r:user_tmp_t:s0"];
+    for arg in args {
+        new_ucmd!()
+            .arg(arg)
+            .arg("-v")
+            .arg(at.plus_as_string(src))
+            .arg(at.plus_as_string(dest))
+            .succeeds()
+            .stdout_contains("orig' -> '");
+
+        let getfattr_output = Command::new("getfattr")
+            .arg(at.plus_as_string(dest))
+            .arg("-n")
+            .arg("security.selinux")
+            .output()
+            .expect("Failed to run `getfattr` on the destination file");
+        println!("{:?}", getfattr_output);
+        assert!(
+            getfattr_output.status.success(),
+            "getfattr did not run successfully: {}",
+            String::from_utf8_lossy(&getfattr_output.stderr)
+        );
+
+        let stdout = String::from_utf8_lossy(&getfattr_output.stdout);
+        assert!(
+            stdout.contains("unconfined_u"),
+            "Expected 'foo' not found in getfattr output:\n{stdout}"
+        );
+        at.remove(&at.plus_as_string(dest));
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_selinux_invalid_args() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let src = "orig";
+    at.touch(src);
+    let dest = "orig.2";
+
+    let args = [
+        "--context=a",
+        "--context=unconfined_u:object_r:user_tmp_t:s0:a",
+        "--context=nconfined_u:object_r:user_tmp_t:s0",
+    ];
+    for arg in args {
+        new_ucmd!()
+            .arg(arg)
+            .arg("-v")
+            .arg(at.plus_as_string(src))
+            .arg(at.plus_as_string(dest))
+            .fails()
+            .stderr_contains("failed to set default file creation");
+
+        at.remove(&at.plus_as_string(dest));
+    }
+}
diff --git a/tests/by-util/test_join.rs b/tests/by-util/test_join.rs
index e2e5dc8688b..e9924eea9ae 100644
--- a/tests/by-util/test_join.rs
+++ b/tests/by-util/test_join.rs
@@ -4,17 +4,19 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (words) autoformat nocheck
 
-use crate::common::util::TestScenario;
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 use std::fs::OpenOptions;
 #[cfg(unix)]
 use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
 #[cfg(windows)]
 use std::{ffi::OsString, os::windows::ffi::OsStringExt};
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -58,6 +60,25 @@ fn default_arguments() {
         .stdout_only_fixture("default.expected");
 }
 
+#[test]
+fn only_whitespace_separators_merge() {
+    new_ucmd!()
+        .arg("contiguous_separators.txt")
+        .arg("-")
+        .pipe_in(" a  ,c ")
+        .succeeds()
+        .stdout_only("a ,,,b ,c \n");
+
+    new_ucmd!()
+        .arg("contiguous_separators.txt")
+        .arg("-t")
+        .arg(",")
+        .arg("-")
+        .pipe_in(" a  ,c ")
+        .succeeds()
+        .stdout_only(" a  ,,,b,c \n");
+}
+
 #[test]
 fn different_fields() {
     new_ucmd!()
@@ -208,9 +229,9 @@ fn tab_multi_character() {
         .arg("semicolon_fields_1.txt")
         .arg("semicolon_fields_2.txt")
         .arg("-t")
-        .arg("�")
+        .arg("ab")
         .fails()
-        .stderr_is("join: multi-character tab �\n");
+        .stderr_is("join: multi-character tab ab\n");
 }
 
 #[test]
@@ -335,7 +356,7 @@ fn wrong_line_order() {
         .arg("fields_4.txt")
         .fails()
         .stdout_contains("7 g f 4 fg")
-        .stderr_is(&format!(
+        .stderr_is(format!(
             "{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order\n",
             ts.bin_path.to_string_lossy(),
             ts.util_name
@@ -347,7 +368,7 @@ fn wrong_line_order() {
         .arg("fields_4.txt")
         .fails()
         .stdout_does_not_contain("7 g f 4 fg")
-        .stderr_is(&format!(
+        .stderr_is(format!(
             "{0}: fields_4.txt:5: is not sorted: 11 g 5 gh\n",
             ts.util_name
         ));
@@ -361,7 +382,7 @@ fn both_files_wrong_line_order() {
         .arg("fields_5.txt")
         .fails()
         .stdout_contains("5 e 3 ef")
-        .stderr_is(&format!(
+        .stderr_is(format!(
             "{0} {1}: fields_5.txt:4: is not sorted: 3\n{0} {1}: fields_4.txt:5: is not sorted: 11 g 5 gh\n{0} {1}: input is not in sorted order\n",
             ts.bin_path.to_string_lossy(),
             ts.util_name
@@ -373,7 +394,7 @@ fn both_files_wrong_line_order() {
         .arg("fields_5.txt")
         .fails()
         .stdout_does_not_contain("5 e 3 ef")
-        .stderr_is(&format!(
+        .stderr_is(format!(
             "{0}: fields_5.txt:4: is not sorted: 3\n",
             ts.util_name
         ));
@@ -437,14 +458,22 @@ fn non_unicode() {
 
     #[cfg(unix)]
     {
-        let invalid_utf8: u8 = 167;
+        let non_utf8_byte: u8 = 167;
         new_ucmd!()
             .arg("-t")
-            .arg(OsStr::from_bytes(&[invalid_utf8]))
+            .arg(OsStr::from_bytes(&[non_utf8_byte]))
             .arg("non-unicode_1.bin")
             .arg("non-unicode_2.bin")
             .succeeds()
             .stdout_only_fixture("non-unicode_sep.expected");
+
+        new_ucmd!()
+            .arg("-t")
+            .arg(OsStr::from_bytes(&[non_utf8_byte, non_utf8_byte]))
+            .arg("non-unicode_1.bin")
+            .arg("non-unicode_2.bin")
+            .fails()
+            .stderr_is("join: non-UTF-8 multi-byte tab\n");
     }
 
     #[cfg(windows)]
@@ -462,6 +491,16 @@ fn non_unicode() {
     }
 }
 
+#[test]
+fn multibyte_sep() {
+    new_ucmd!()
+        .arg("-t§")
+        .arg("multibyte_sep_1.txt")
+        .arg("multibyte_sep_2.txt")
+        .succeeds()
+        .stdout_only_fixture("multibyte_sep.expected");
+}
+
 #[test]
 fn null_field_separators() {
     new_ucmd!()
diff --git a/tests/by-util/test_kill.rs b/tests/by-util/test_kill.rs
index a9094ecf6a7..c163d47b836 100644
--- a/tests/by-util/test_kill.rs
+++ b/tests/by-util/test_kill.rs
@@ -2,10 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+// spell-checker:ignore IAMNOTASIGNAL
 use regex::Regex;
 use std::os::unix::process::ExitStatusExt;
 use std::process::{Child, Command};
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 // A child process the tests will try to kill.
 struct Target {
@@ -51,7 +54,7 @@ impl Drop for Target {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -62,7 +65,8 @@ fn test_kill_list_all_signals() {
         .succeeds()
         .stdout_contains("KILL")
         .stdout_contains("TERM")
-        .stdout_contains("HUP");
+        .stdout_contains("HUP")
+        .stdout_contains("EXIT");
 }
 
 #[test]
@@ -79,7 +83,50 @@ fn test_kill_list_all_signals_as_table() {
         .succeeds()
         .stdout_contains("KILL")
         .stdout_contains("TERM")
-        .stdout_contains("HUP");
+        .stdout_contains("HUP")
+        .stdout_contains("EXIT");
+}
+
+#[test]
+fn test_kill_table_starts_at_0() {
+    new_ucmd!()
+        .arg("-t")
+        .succeeds()
+        .stdout_matches(&Regex::new("^\\s?0\\sEXIT").unwrap());
+}
+
+#[test]
+fn test_kill_table_lists_all_vertically() {
+    // Check for a few signals.  Do not try to be comprehensive.
+    let command = new_ucmd!().arg("-t").succeeds();
+    let signals = command
+        .stdout_str()
+        .split('\n')
+        .filter_map(|line| line.trim().split(' ').nth(1))
+        .collect::<Vec<&str>>();
+
+    assert!(signals.contains(&"KILL"));
+    assert!(signals.contains(&"TERM"));
+    assert!(signals.contains(&"HUP"));
+    assert!(signals.contains(&"EXIT"));
+}
+
+#[test]
+fn test_kill_list_one_signal_from_number() {
+    new_ucmd!()
+        .arg("-l")
+        .arg("9")
+        .succeeds()
+        .stdout_only("KILL\n");
+}
+
+#[test]
+fn test_kill_list_one_signal_from_invalid_number() {
+    new_ucmd!()
+        .arg("-l")
+        .arg("99")
+        .fails()
+        .stderr_contains("'99': invalid signal");
 }
 
 #[test]
@@ -92,14 +139,65 @@ fn test_kill_list_one_signal_from_name() {
         .stdout_matches(&Regex::new("\\b9\\b").unwrap());
 }
 
+#[test]
+fn test_kill_list_one_signal_ignore_case() {
+    // Use SIGKILL because it is 9 on all unixes.
+    new_ucmd!()
+        .arg("-l")
+        .arg("KiLl")
+        .succeeds()
+        .stdout_matches(&Regex::new("\\b9\\b").unwrap());
+}
+
+#[test]
+fn test_kill_list_unknown_must_match_input_case() {
+    new_ucmd!()
+        .arg("-l")
+        .arg("IaMnOtAsIgNaL")
+        .fails()
+        .stderr_contains("IaMnOtAsIgNaL");
+}
+
+#[test]
+fn test_kill_list_all_vertically() {
+    // Check for a few signals.  Do not try to be comprehensive.
+    let command = new_ucmd!().arg("-l").succeeds();
+    let signals = command.stdout_str().split('\n').collect::<Vec<&str>>();
+    assert!(signals.contains(&"KILL"));
+    assert!(signals.contains(&"TERM"));
+    assert!(signals.contains(&"HUP"));
+    assert!(signals.contains(&"EXIT"));
+}
+
+#[test]
+fn test_kill_list_two_signal_from_name() {
+    new_ucmd!()
+        .arg("-l")
+        .arg("INT")
+        .arg("KILL")
+        .succeeds()
+        .stdout_matches(&Regex::new("\\d\n\\d").unwrap());
+}
+
+#[test]
+fn test_kill_list_three_signal_first_unknown() {
+    new_ucmd!()
+        .arg("-l")
+        .arg("IAMNOTASIGNAL")
+        .arg("INT")
+        .arg("KILL")
+        .fails()
+        .stderr_contains("'IAMNOTASIGNAL': invalid signal")
+        .stdout_matches(&Regex::new("\\d\n\\d").unwrap());
+}
+
 #[test]
 fn test_kill_set_bad_signal_name() {
-    // spell-checker:disable-line
     new_ucmd!()
         .arg("-s")
-        .arg("IAMNOTASIGNAL") // spell-checker:disable-line
+        .arg("IAMNOTASIGNAL")
         .fails()
-        .stderr_contains("unknown signal");
+        .stderr_contains("'IAMNOTASIGNAL': invalid signal");
 }
 
 #[test]
@@ -121,12 +219,24 @@ fn test_kill_with_signal_number_old_form() {
 
 #[test]
 fn test_kill_with_signal_name_old_form() {
-    let mut target = Target::new();
+    for arg in ["-Kill", "-KILL"] {
+        let mut target = Target::new();
+        new_ucmd!()
+            .arg(arg)
+            .arg(format!("{}", target.pid()))
+            .succeeds();
+        assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+    }
+}
+
+#[test]
+fn test_kill_with_lower_case_signal_name_old_form() {
+    let target = Target::new();
     new_ucmd!()
-        .arg("-KILL")
+        .arg("-kill")
         .arg(format!("{}", target.pid()))
-        .succeeds();
-    assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+        .fails()
+        .stderr_contains("unexpected argument");
 }
 
 #[test]
@@ -161,6 +271,17 @@ fn test_kill_with_signal_name_new_form() {
     assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
 }
 
+#[test]
+fn test_kill_with_signal_name_new_form_ignore_case() {
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("KiLl")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+}
+
 #[test]
 fn test_kill_with_signal_prefixed_name_new_form() {
     let mut target = Target::new();
@@ -171,3 +292,108 @@ fn test_kill_with_signal_prefixed_name_new_form() {
         .succeeds();
     assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
 }
+
+#[test]
+fn test_kill_with_signal_prefixed_name_new_form_ignore_case() {
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("SiGKiLl")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(libc::SIGKILL));
+}
+
+#[test]
+fn test_kill_with_signal_name_new_form_unknown_must_match_input_case() {
+    let target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("IaMnOtAsIgNaL")
+        .arg(format!("{}", target.pid()))
+        .fails()
+        .stderr_contains("'IaMnOtAsIgNaL': invalid signal");
+}
+
+#[test]
+fn test_kill_no_pid_provided() {
+    new_ucmd!()
+        .fails()
+        .stderr_contains("no process ID specified");
+}
+
+#[test]
+fn test_kill_with_signal_exit_new_form() {
+    let target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("EXIT")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+}
+
+#[test]
+fn test_kill_with_signal_number_hidden_compatibility_option() {
+    let mut target = Target::new();
+    new_ucmd!()
+        .arg("-n")
+        .arg("9")
+        .arg(format!("{}", target.pid()))
+        .succeeds();
+    assert_eq!(target.wait_for_signal(), Some(9));
+}
+
+#[test]
+fn test_kill_with_signal_and_list() {
+    let target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("EXIT")
+        .arg(format!("{}", target.pid()))
+        .arg("-l")
+        .fails();
+}
+
+#[test]
+fn test_kill_with_list_lower_bits() {
+    new_ucmd!()
+        .arg("-l")
+        .arg("128")
+        .succeeds()
+        .stdout_contains("EXIT");
+
+    new_ucmd!()
+        .arg("-l")
+        .arg("143")
+        .succeeds()
+        .stdout_contains("TERM");
+
+    new_ucmd!()
+        .arg("-l")
+        .arg("256")
+        .succeeds()
+        .stdout_contains("EXIT");
+
+    new_ucmd!()
+        .arg("-l")
+        .arg("2304")
+        .succeeds()
+        .stdout_contains("EXIT");
+}
+
+#[test]
+fn test_kill_with_list_lower_bits_unrecognized() {
+    new_ucmd!().arg("-l").arg("111").fails();
+    new_ucmd!().arg("-l").arg("384").fails();
+}
+
+#[test]
+fn test_kill_with_signal_and_table() {
+    let target = Target::new();
+    new_ucmd!()
+        .arg("-s")
+        .arg("EXIT")
+        .arg(format!("{}", target.pid()))
+        .arg("-t")
+        .fails();
+}
diff --git a/tests/by-util/test_link.rs b/tests/by-util/test_link.rs
index 8d48931c424..d95ada98699 100644
--- a/tests/by-util/test_link.rs
+++ b/tests/by-util/test_link.rs
@@ -2,11 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[cfg(not(target_os = "android"))]
diff --git a/tests/by-util/test_ln.rs b/tests/by-util/test_ln.rs
index dc31f726116..9ef25ef087c 100644
--- a/tests/by-util/test_ln.rs
+++ b/tests/by-util/test_ln.rs
@@ -2,12 +2,17 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+#![allow(clippy::similar_names)]
+
 use std::path::PathBuf;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -335,11 +340,13 @@ fn test_symlink_overwrite_dir_fail() {
     at.touch(path_a);
     at.mkdir(path_b);
 
-    assert!(!ucmd
-        .args(&["-s", "-T", path_a, path_b])
-        .fails()
-        .stderr_str()
-        .is_empty());
+    assert!(
+        !ucmd
+            .args(&["-s", "-T", path_a, path_b])
+            .fails()
+            .stderr_str()
+            .is_empty()
+    );
 }
 
 #[test]
@@ -389,11 +396,13 @@ fn test_symlink_target_only() {
 
     at.mkdir(dir);
 
-    assert!(!ucmd
-        .args(&["-s", "-t", dir])
-        .fails()
-        .stderr_str()
-        .is_empty());
+    assert!(
+        !ucmd
+            .args(&["-s", "-t", dir])
+            .fails()
+            .stderr_str()
+            .is_empty()
+    );
 }
 
 #[test]
@@ -420,7 +429,7 @@ fn test_symlink_implicit_target_dir() {
 fn test_symlink_to_dir_2args() {
     let (at, mut ucmd) = at_and_ucmd!();
     let filename = "test_symlink_to_dir_2args_file";
-    let from_file = &format!("{}/{}", at.as_string(), filename);
+    let from_file = &format!("{}/{filename}", at.as_string());
     let to_dir = "test_symlink_to_dir_2args_to_dir";
     let to_file = &format!("{to_dir}/{filename}");
 
@@ -484,7 +493,7 @@ fn test_symlink_relative_path() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-s", "-v", &p.to_string_lossy(), link])
         .succeeds()
-        .stdout_only(format!("'{}' -> '{}'\n", link, &p.to_string_lossy()));
+        .stdout_only(format!("'{link}' -> '{}'\n", p.to_string_lossy()));
     assert!(at.is_symlink(link));
     assert_eq!(at.resolve_link(link), p.to_string_lossy());
 }
@@ -547,6 +556,67 @@ fn test_symlink_no_deref_dir() {
     assert_eq!(at.resolve_link(link), dir1);
 }
 
+#[test]
+fn test_symlink_no_deref_file_in_destination_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file1 = "foo";
+    let file2 = "bar";
+
+    let dest = "baz";
+
+    let link1 = "baz/foo";
+    let link2 = "baz/bar";
+
+    at.touch(file1);
+    at.touch(file2);
+    at.mkdir(dest);
+
+    assert!(at.file_exists(file1));
+    assert!(at.file_exists(file2));
+    assert!(at.dir_exists(dest));
+
+    // -n and -f should work alone
+    scene
+        .ucmd()
+        .args(&["-sn", file1, dest])
+        .succeeds()
+        .no_stderr();
+    assert!(at.is_symlink(link1));
+    assert_eq!(at.resolve_link(link1), file1);
+
+    scene
+        .ucmd()
+        .args(&["-sf", file1, dest])
+        .succeeds()
+        .no_stderr();
+    assert!(at.is_symlink(link1));
+    assert_eq!(at.resolve_link(link1), file1);
+
+    // -n alone should fail if destination exists already (it should now)
+    scene.ucmd().args(&["-sn", file1, dest]).fails();
+
+    // -nf should also work
+    scene
+        .ucmd()
+        .args(&["-snf", file1, dest])
+        .succeeds()
+        .no_stderr();
+    assert!(at.is_symlink(link1));
+    assert_eq!(at.resolve_link(link1), file1);
+
+    scene
+        .ucmd()
+        .args(&["-snf", file1, file2, dest])
+        .succeeds()
+        .no_stderr();
+    assert!(at.is_symlink(link1));
+    assert_eq!(at.resolve_link(link1), file1);
+    assert!(at.is_symlink(link2));
+    assert_eq!(at.resolve_link(link2), file2);
+}
+
 #[test]
 fn test_symlink_no_deref_file() {
     let scene = TestScenario::new(util_name!());
@@ -713,9 +783,59 @@ fn test_symlink_remove_existing_same_src_and_dest() {
     at.touch("a");
     at.write("a", "sample");
     ucmd.args(&["-sf", "a", "a"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("'a' and 'a' are the same file");
     assert!(at.file_exists("a") && !at.symlink_exists("a"));
     assert_eq!(at.read("a"), "sample");
 }
+
+#[test]
+#[cfg(not(target_os = "android"))]
+fn test_ln_seen_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+
+    #[cfg(not(unix))]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c\\f' with 'b/f'")
+    );
+    #[cfg(unix)]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c/f' with 'b/f'")
+    );
+
+    assert!(at.plus("c").join("f").exists());
+    // b/f still exists
+    assert!(at.plus("b").join("f").exists());
+    // a/f still exists
+    assert!(at.plus("a").join("f").exists());
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        // Check inode numbers
+        let inode_a_f = at.plus("a").join("f").metadata().unwrap().ino();
+        let inode_b_f = at.plus("b").join("f").metadata().unwrap().ino();
+        let inode_c_f = at.plus("c").join("f").metadata().unwrap().ino();
+
+        assert_eq!(
+            inode_a_f, inode_c_f,
+            "Inode numbers of a/f and c/f should be equal"
+        );
+        assert_ne!(
+            inode_b_f, inode_c_f,
+            "Inode numbers of b/f and c/f should not be equal"
+        );
+    }
+}
diff --git a/tests/by-util/test_logname.rs b/tests/by-util/test_logname.rs
index 8833975556d..c0f763bb628 100644
--- a/tests/by-util/test_logname.rs
+++ b/tests/by-util/test_logname.rs
@@ -2,12 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::{is_ci, TestScenario};
 use std::env;
+use uutests::new_ucmd;
+use uutests::util::{TestScenario, is_ci};
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_ls.rs b/tests/by-util/test_ls.rs
index f1815035834..58bd538e457 100644
--- a/tests/by-util/test_ls.rs
+++ b/tests/by-util/test_ls.rs
@@ -2,31 +2,41 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff
+// spell-checker:ignore (words) READMECAREFULLY birthtime doesntexist oneline somebackup lrwx somefile somegroup somehiddenbackup somehiddenfile tabsize aaaaaaaa bbbb cccc dddddddd ncccc neee naaaaa nbcdef nfffff dired subdired tmpfs mdir COLORTERM mexe bcdef mfoo
+// spell-checker:ignore (words) fakeroot setcap drwxr
+#![allow(
+    clippy::similar_names,
+    clippy::too_many_lines,
+    clippy::cast_possible_truncation
+)]
 
-#[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;
+#[cfg(not(target_os = "openbsd"))]
 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;
 #[cfg(not(windows))]
 use std::path::PathBuf;
 use std::thread::sleep;
 use std::time::Duration;
+use uutests::new_ucmd;
+#[cfg(unix)]
+use uutests::unwrap_or_return;
+use uutests::util::TestScenario;
+#[cfg(any(unix, feature = "feat_selinux"))]
+use uutests::util::expected_result;
+use uutests::{at_and_ucmd, util_name};
 
 const LONG_ARGS: &[&str] = &[
     "-l",
     "--long",
     "--format=long",
+    "--format=lon",
     "--for=long",
     "--format=verbose",
     "--for=verbose",
@@ -35,6 +45,7 @@ const LONG_ARGS: &[&str] = &[
 const ACROSS_ARGS: &[&str] = &[
     "-x",
     "--format=across",
+    "--format=acr",
     "--format=horizontal",
     "--for=across",
     "--for=horizontal",
@@ -44,11 +55,83 @@ const COMMA_ARGS: &[&str] = &["-m", "--format=commas", "--for=commas"];
 
 const COLUMN_ARGS: &[&str] = &["-C", "--format=columns", "--for=columns"];
 
+#[test]
+fn test_invalid_flag() {
+    new_ucmd!()
+        .arg("--invalid-argument")
+        .fails_with_code(2)
+        .no_stdout();
+}
+
+#[test]
+fn test_invalid_value_returns_1() {
+    // Invalid values to flags *sometimes* result in error code 1:
+    for flag in [
+        "--classify",
+        "--color",
+        "--format",
+        "--hyperlink",
+        "--indicator-style",
+        "--quoting-style",
+        "--sort",
+        "--time",
+    ] {
+        new_ucmd!()
+            .arg(format!("{flag}=definitely_invalid_value"))
+            .fails_with_code(1)
+            .no_stdout();
+    }
+}
+
+#[test]
+fn test_invalid_value_returns_2() {
+    // Invalid values to flags *sometimes* result in error code 2:
+    for flag in ["--block-size", "--width", "--tab-size"] {
+        new_ucmd!()
+            .arg(format!("{flag}=definitely_invalid_value"))
+            .fails_with_code(2)
+            .no_stdout();
+    }
+}
+
+#[test]
+fn test_invalid_value_time_style() {
+    // This is the only flag which does not raise an error if it is invalid but not actually used:
+    new_ucmd!()
+        .arg("--time-style=definitely_invalid_value")
+        .succeeds()
+        .no_stderr();
+    // If it is used, error:
+    new_ucmd!()
+        .arg("-g")
+        .arg("--time-style=definitely_invalid_value")
+        .fails_with_code(2)
+        .no_stdout();
+    // If it only looks temporarily like it might be used, no error:
+    new_ucmd!()
+        .arg("-l")
+        .arg("--time-style=definitely_invalid_value")
+        .arg("--format=single-column")
+        .succeeds()
+        .no_stderr();
+}
+
 #[test]
 fn test_ls_ls() {
     new_ucmd!().succeeds();
 }
 
+#[test]
+fn test_ls_help() {
+    // Because we have to work around a lot of clap's error handling and
+    // modify the exit-code, this is actually non-trivial.
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .stdout_contains("--version")
+        .no_stderr();
+}
+
 #[test]
 fn test_ls_i() {
     new_ucmd!().arg("-i").succeeds();
@@ -73,15 +156,35 @@ fn test_ls_ordering() {
         .stdout_matches(&Regex::new("some-dir1:\\ntotal 0").unwrap());
 }
 
+#[cfg(all(
+    unix,
+    feature = "df",
+    not(any(target_os = "freebsd", target_os = "openbsd"))
+))]
+fn get_filesystem_type(scene: &TestScenario, path: &Path) -> String {
+    let mut cmd = scene.ccmd("df");
+    cmd.args(&["-PT"]).arg(path);
+    let output = cmd.succeeds();
+    let stdout_str = String::from_utf8_lossy(output.stdout());
+    println!("output of stat call ({cmd:?}):\n{stdout_str}");
+    let regex_str = r"Filesystem\s+Type\s+.+[\r\n]+([^\s]+)\s+(?<fstype>[^\s]+)\s+";
+    let regex = Regex::new(regex_str).unwrap();
+    let m = regex.captures(&stdout_str).unwrap();
+    let fstype = m["fstype"].to_owned();
+    println!("detected fstype: {fstype}");
+    fstype
+}
+
 #[cfg(all(feature = "truncate", feature = "dd"))]
-#[test] // FIXME: fix this test for FreeBSD
+#[test] // FIXME: fix this test for FreeBSD and OpenBSD
+#[cfg(not(target_os = "openbsd"))]
 fn test_ls_allocation_size() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
     at.mkdir("some-dir1");
     at.touch("some-dir1/empty-file");
 
-    #[cfg(unix)]
+    #[cfg(all(unix, feature = "df"))]
     {
         scene
             .ccmd("truncate")
@@ -115,13 +218,24 @@ fn test_ls_allocation_size() {
             .succeeds()
             .stdout_matches(&Regex::new("[^ ] 2 [^ ]").unwrap());
 
+        #[cfg(not(target_os = "freebsd"))]
+        let (zero_file_size_4k, zero_file_size_1k, zero_file_size_8k, zero_file_size_4m) =
+            match get_filesystem_type(&scene, &scene.fixtures.subdir).as_str() {
+                // apparently f2fs (flash friendly fs) accepts small overhead for better performance
+                "f2fs" => (4100, 1025, 8200, "4.1M"),
+                _ => (4096, 1024, 8192, "4.0M"),
+            };
+
         #[cfg(not(target_os = "freebsd"))]
         scene
             .ucmd()
             .arg("-s1")
             .arg("some-dir1")
             .succeeds()
-            .stdout_is("total 4096\n   0 empty-file\n   0 file-with-holes\n4096 zero-file\n");
+            .stdout_is(format!(
+                "total {zero_file_size_4k}\n   0 empty-file\n   0 file-with-holes\n\
+                {zero_file_size_4k} zero-file\n"
+            ));
 
         scene
             .ucmd()
@@ -138,7 +252,7 @@ fn test_ls_allocation_size() {
             .arg("some-dir1")
             .succeeds()
             .stdout_contains("0 empty-file")
-            .stdout_contains("4096 zero-file");
+            .stdout_contains(format!("{zero_file_size_4k} zero-file"));
 
         // Test alignment of different block sized files
         let res = scene.ucmd().arg("-si1").arg("some-dir1").succeeds();
@@ -185,10 +299,10 @@ fn test_ls_allocation_size() {
             .arg("-s1")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 1024")
+            .stdout_contains(format!("total {zero_file_size_1k}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("1024 zero-file");
+            .stdout_contains(format!("{zero_file_size_1k} zero-file"));
 
         #[cfg(not(target_os = "freebsd"))]
         scene
@@ -210,10 +324,10 @@ fn test_ls_allocation_size() {
             .arg("-s1")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 1024")
+            .stdout_contains(format!("total {zero_file_size_1k}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("1024 zero-file");
+            .stdout_contains(format!("{zero_file_size_1k} zero-file"));
 
         #[cfg(not(target_os = "freebsd"))]
         scene
@@ -222,10 +336,10 @@ fn test_ls_allocation_size() {
             .arg("-s1")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 8192")
+            .stdout_contains(format!("total {zero_file_size_8k}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("8192 zero-file");
+            .stdout_contains(format!("{zero_file_size_8k} zero-file"));
 
         // -k should make 'ls' ignore the env var
         #[cfg(not(target_os = "freebsd"))]
@@ -235,10 +349,10 @@ fn test_ls_allocation_size() {
             .arg("-s1k")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 4096")
+            .stdout_contains(format!("total {zero_file_size_4k}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("4096 zero-file");
+            .stdout_contains(format!("{zero_file_size_4k} zero-file"));
 
         // but manually specified blocksize overrides -k
         #[cfg(not(target_os = "freebsd"))]
@@ -248,10 +362,10 @@ fn test_ls_allocation_size() {
             .arg("--block-size=4K")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 1024")
+            .stdout_contains(format!("total {zero_file_size_1k}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("1024 zero-file");
+            .stdout_contains(format!("{zero_file_size_1k} zero-file"));
 
         #[cfg(not(target_os = "freebsd"))]
         scene
@@ -260,10 +374,10 @@ fn test_ls_allocation_size() {
             .arg("--block-size=4K")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 1024")
+            .stdout_contains(format!("total {zero_file_size_1k}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("1024 zero-file");
+            .stdout_contains(format!("{zero_file_size_1k} zero-file"));
 
         // si option should always trump the human-readable option
         #[cfg(not(target_os = "freebsd"))]
@@ -285,10 +399,10 @@ fn test_ls_allocation_size() {
             .arg("--block-size=human-readable")
             .arg("some-dir1")
             .succeeds()
-            .stdout_contains("total 4.0M")
+            .stdout_contains(format!("total {zero_file_size_4m}"))
             .stdout_contains("0 empty-file")
             .stdout_contains("0 file-with-holes")
-            .stdout_contains("4.0M zero-file");
+            .stdout_contains(format!("{zero_file_size_4m} zero-file"));
 
         #[cfg(not(target_os = "freebsd"))]
         scene
@@ -387,8 +501,7 @@ fn test_ls_io_errors() {
         .ucmd()
         .arg("-1")
         .arg("some-dir1")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_contains("cannot open directory")
         .stderr_contains("Permission denied");
 
@@ -396,8 +509,7 @@ fn test_ls_io_errors() {
         .ucmd()
         .arg("-Li")
         .arg("some-dir2")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("cannot access")
         .stderr_contains("No such file or directory")
         .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
@@ -412,8 +524,7 @@ fn test_ls_io_errors() {
         .ucmd()
         .arg("-laR")
         .arg("some-dir3")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("some-dir4")
         .stderr_contains("cannot open directory")
         .stderr_contains("Permission denied")
@@ -431,50 +542,53 @@ fn test_ls_io_errors() {
 
     #[cfg(unix)]
     {
+        use std::os::fd::AsRawFd;
+
         at.touch("some-dir4/bad-fd.txt");
-        let fd1 = at.open("some-dir4/bad-fd.txt").into_raw_fd();
-        let fd2 = dup(dbg!(fd1)).unwrap();
+        let fd1 = at.open("some-dir4/bad-fd.txt");
+        let fd2 = dup(dbg!(&fd1)).unwrap();
         close(fd1).unwrap();
 
         // on the mac and in certain Linux containers bad fds are typed as dirs,
         // however sometimes bad fds are typed as links and directory entry on links won't fail
-        if PathBuf::from(format!("/dev/fd/{fd2}")).is_dir() {
+        if PathBuf::from(format!("/dev/fd/{}", fd2.as_raw_fd())).is_dir() {
             scene
                 .ucmd()
                 .arg("-alR")
-                .arg(format!("/dev/fd/{fd2}"))
+                .arg(format!("/dev/fd/{}", fd2.as_raw_fd()))
                 .fails()
                 .stderr_contains(format!(
-                    "cannot open directory '/dev/fd/{fd2}': Bad file descriptor"
+                    "cannot open directory '/dev/fd/{}': Bad file descriptor",
+                    fd2.as_raw_fd()
                 ))
-                .stdout_does_not_contain(format!("{fd2}:\n"));
+                .stdout_does_not_contain(format!("{}:\n", fd2.as_raw_fd()));
 
             scene
                 .ucmd()
                 .arg("-RiL")
-                .arg(format!("/dev/fd/{fd2}"))
+                .arg(format!("/dev/fd/{}", fd2.as_raw_fd()))
                 .fails()
-                .stderr_contains(format!("cannot open directory '/dev/fd/{fd2}': Bad file descriptor"))
+                .stderr_contains(format!("cannot open directory '/dev/fd/{}': Bad file descriptor", fd2.as_raw_fd()))
                 // don't double print bad fd errors
-                .stderr_does_not_contain(format!("ls: cannot open directory '/dev/fd/{fd2}': Bad file descriptor\nls: cannot open directory '/dev/fd/{fd2}': Bad file descriptor"));
+                .stderr_does_not_contain(format!("ls: cannot open directory '/dev/fd/{0}': Bad file descriptor\nls: cannot open directory '/dev/fd/{0}': Bad file descriptor", fd2.as_raw_fd()));
         } else {
             scene
                 .ucmd()
                 .arg("-alR")
-                .arg(format!("/dev/fd/{fd2}"))
+                .arg(format!("/dev/fd/{}", fd2.as_raw_fd()))
                 .succeeds();
 
             scene
                 .ucmd()
                 .arg("-RiL")
-                .arg(format!("/dev/fd/{fd2}"))
+                .arg(format!("/dev/fd/{}", fd2.as_raw_fd()))
                 .succeeds();
         }
 
         scene
             .ucmd()
             .arg("-alL")
-            .arg(format!("/dev/fd/{fd2}"))
+            .arg(format!("/dev/fd/{}", fd2.as_raw_fd()))
             .succeeds();
 
         let _ = close(fd2);
@@ -724,7 +838,7 @@ fn test_ls_columns() {
 
     for option in COLUMN_ARGS {
         let result = scene.ucmd().arg(option).succeeds();
-        result.stdout_only("test-columns-1  test-columns-2  test-columns-3  test-columns-4\n");
+        result.stdout_only("test-columns-1\ttest-columns-2\ttest-columns-3\ttest-columns-4\n");
     }
 
     for option in COLUMN_ARGS {
@@ -733,7 +847,7 @@ fn test_ls_columns() {
             .arg("-w=40")
             .arg(option)
             .succeeds()
-            .stdout_only("test-columns-1  test-columns-3\ntest-columns-2  test-columns-4\n");
+            .stdout_only("test-columns-1\ttest-columns-3\ntest-columns-2\ttest-columns-4\n");
     }
 
     // On windows we are always able to get the terminal size, so we can't simulate falling back to the
@@ -746,7 +860,7 @@ fn test_ls_columns() {
                 .env("COLUMNS", "40")
                 .arg(option)
                 .succeeds()
-                .stdout_only("test-columns-1  test-columns-3\ntest-columns-2  test-columns-4\n");
+                .stdout_only("test-columns-1\ttest-columns-3\ntest-columns-2\ttest-columns-4\n");
         }
 
         scene
@@ -754,7 +868,7 @@ fn test_ls_columns() {
             .env("COLUMNS", "garbage")
             .arg("-C")
             .succeeds()
-            .stdout_is("test-columns-1  test-columns-2  test-columns-3  test-columns-4\n")
+            .stdout_is("test-columns-1\ttest-columns-2\ttest-columns-3\ttest-columns-4\n")
             .stderr_is("ls: ignoring invalid width in environment variable COLUMNS: 'garbage'\n");
     }
     scene
@@ -864,11 +978,11 @@ fn test_ls_zero() {
         .succeeds()
         .stdout_only("\"0-test-zero\"\x00\"2-test-zero\"\x00\"3-test-zero\"\x00");
 
-    scene
-        .ucmd()
-        .args(&["--zero", "--color=always"])
-        .succeeds()
-        .stdout_only("\x1b[1;34m0-test-zero\x1b[0m\x002-test-zero\x003-test-zero\x00");
+    let result = scene.ucmd().args(&["--zero", "--color=always"]).succeeds();
+    assert_eq!(
+        result.stdout_str(),
+        "\u{1b}[0m\u{1b}[01;34m0-test-zero\x1b[0m\x002-test-zero\x003-test-zero\x00"
+    );
 
     scene
         .ucmd()
@@ -895,6 +1009,8 @@ fn test_ls_zero() {
         let ignored_opts = [
             "--quoting-style=c",
             "--color=always",
+            "--color=alway",
+            "--color=al",
             "-m",
             "--hide-control-chars",
         ];
@@ -921,13 +1037,11 @@ fn test_ls_zero() {
                 "\"0-test-zero\"\x00\"1\\ntest-zero\"\x00\"2-test-zero\"\x00\"3-test-zero\"\x00",
             );
 
-        scene
-            .ucmd()
-            .args(&["--zero", "--color=always"])
-            .succeeds()
-            .stdout_only(
-                "\x1b[1;34m0-test-zero\x1b[0m\x001\ntest-zero\x002-test-zero\x003-test-zero\x00",
-            );
+        let result = scene.ucmd().args(&["--zero", "--color=always"]).succeeds();
+        assert_eq!(
+            result.stdout_str(),
+            "\u{1b}[0m\u{1b}[01;34m0-test-zero\x1b[0m\x001\ntest-zero\x002-test-zero\x003-test-zero\x00",
+        );
 
         scene
             .ucmd()
@@ -979,42 +1093,54 @@ fn test_ls_long() {
     let at = &scene.fixtures;
     at.touch(at.plus_as_string("test-long"));
 
+    #[cfg(not(windows))]
+    let regex = r"[-bcCdDlMnpPsStTx?]([r-][w-][xt-]){3}.*";
+    #[cfg(windows)]
+    let regex = r"[-dl](r[w-]x){3}.*";
+
+    let re = &Regex::new(regex).unwrap();
+
     for arg in LONG_ARGS {
         let result = scene.ucmd().arg(arg).arg("test-long").succeeds();
-        #[cfg(not(windows))]
-        result.stdout_matches(&Regex::new(r"[-bcCdDlMnpPsStTx?]([r-][w-][xt-]){3}.*").unwrap());
-
-        #[cfg(windows)]
-        result.stdout_matches(&Regex::new(r"[-dl](r[w-]x){3}.*").unwrap());
+        result.stdout_matches(re);
     }
 }
 
 #[cfg(not(windows))]
 #[test]
+#[cfg(not(feature = "feat_selinux"))]
+// Disabled on the SELinux runner for now
 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.mkdir(at.plus_as_string("test-long-dir"));
     at.touch(at.plus_as_string("test-long-dir/test-long-file"));
-    at.mkdir(&at.plus_as_string("test-long-dir/test-long-dir"));
+    at.mkdir(at.plus_as_string("test-long-dir/test-long-dir"));
 
-    for arg in LONG_ARGS {
-        // Assuming sane username do not have spaces within them.
-        // A line of the output should be:
-        // One of the characters -bcCdDlMnpPsStTx?
-        // rwx, with - for missing permissions, thrice.
-        // Zero or one "." for indicating a file with security context
-        // A number, preceded by column whitespace, and followed by a single space.
-        // A username, currently [^ ], followed by column whitespace, twice (or thrice for Hurd).
-        // A number, followed by a single space.
-        // A month, followed by a single space.
-        // A day, preceded by column whitespace, and followed by a single space.
-        // Either a year or a time, currently [0-9:]+, preceded by column whitespace,
-        // and followed by a single space.
-        // Whatever comes after is irrelevant to this specific test.
-        scene.ucmd().arg(arg).arg("test-long-dir").succeeds().stdout_matches(&Regex::new(
+    // Assuming sane username do not have spaces within them.
+    // A line of the output should be:
+    // One of the characters -bcCdDlMnpPsStTx?
+    // rwx, with - for missing permissions, thrice.
+    // Zero or one "." for indicating a file with security context
+    // A number, preceded by column whitespace, and followed by a single space.
+    // A username, currently [^ ], followed by column whitespace, twice (or thrice for Hurd).
+    // A number, followed by a single space.
+    // A month, followed by a single space.
+    // A day, preceded by column whitespace, and followed by a single space.
+    // Either a year or a time, currently [0-9:]+, preceded by column whitespace,
+    // and followed by a single space.
+    // Whatever comes after is irrelevant to this specific test.
+    let re = &Regex::new(
             r"\n[-bcCdDlMnpPsStTx?]([r-][w-][xt-]){3}\.? +\d+ [^ ]+ +[^ ]+( +[^ ]+)? +\d+ [A-Z][a-z]{2} {0,2}\d{0,2} {0,2}[0-9:]+ "
-        ).unwrap());
+        ).unwrap();
+
+    for arg in LONG_ARGS {
+        scene
+            .ucmd()
+            .arg(arg)
+            .arg("test-long-dir")
+            .succeeds()
+            .stdout_matches(re);
     }
 
     // This checks for the line with the .. entry. The uname and group should be digits.
@@ -1023,6 +1149,21 @@ fn test_ls_long_format() {
     ).unwrap());
 }
 
+#[test]
+fn test_ls_long_padding_of_size_column_with_multiple_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("dir");
+    at.touch("dir/a");
+    at.touch("dir/b");
+
+    ucmd.arg("-l")
+        .arg("dir")
+        .succeeds()
+        .stdout_contains(" 0 ")
+        .stdout_does_not_contain("  0 ");
+}
+
 /// This test tests `ls -laR --color`.
 /// This test is mainly about coloring, but, the recursion, symlink `->` processing,
 /// and `.` and `..` being present in `-a` all need to work for the test to pass.
@@ -1030,6 +1171,7 @@ fn test_ls_long_format() {
 #[cfg(all(feature = "ln", feature = "mkdir", feature = "touch"))]
 #[test]
 #[cfg(all(feature = "ln", feature = "mkdir", feature = "touch"))]
+#[allow(clippy::items_after_statements)]
 fn test_ls_long_symlink_color() {
     // If you break this test after breaking mkdir, touch, or ln, do not be alarmed!
     // This test is made for ls, but it attempts to run those utils in the process.
@@ -1187,12 +1329,21 @@ fn test_ls_long_symlink_color() {
     }
 
     fn capture_colored_string(input: &str) -> (Color, Name) {
-        let colored_name = Regex::new(r"\x1b\[([0-9;]+)m(.+)\x1b\[0m").unwrap();
+        // Input can be:
+        // \u{1b}[0m\u{1b}[01;36mln-dir3\u{1b}[0m
+        // \u{1b}[0m\u{1b}[01;34m./dir1/dir2/dir3\u{1b}[0m
+        // \u{1b}[0m\u{1b}[01;36mln-file-invalid\u{1b}[0m
+        // \u{1b}[01;36mdir1/invalid-target\u{1b}[0m
+        let colored_name = Regex::new(r"(?:\x1b\[0m\x1b)?\[([0-9;]+)m(.+)\x1b\[0m").unwrap();
         match colored_name.captures(input) {
-            Some(captures) => (
-                captures.get(1).unwrap().as_str().to_string(),
-                captures.get(2).unwrap().as_str().to_string(),
-            ),
+            Some(captures) => {
+                dbg!(captures.get(1).unwrap().as_str().to_string());
+                dbg!(captures.get(2).unwrap().as_str().to_string());
+                (
+                    captures.get(1).unwrap().as_str().to_string(),
+                    captures.get(2).unwrap().as_str().to_string(),
+                )
+            }
             None => (String::new(), input.to_string()),
         }
     }
@@ -1247,7 +1398,46 @@ fn test_ls_long_symlink_color() {
     }
 }
 
+/// This test is for "ls -l --color=auto|--color=always"
+/// We use "--color=always" as the colors are the same regardless of the color option being "auto" or "always"
+/// tests whether the specific color of the target and the `dangling_symlink` are equal and checks
+/// whether checks whether ls outputs the correct path for the symlink and the file it points to and applies the color code to it.
+#[test]
+fn test_ls_long_dangling_symlink_color() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("dir1");
+    at.symlink_dir("foo", "dir1/dangling_symlink");
+    let result = ts
+        .ucmd()
+        .arg("-l")
+        .arg("--color=always")
+        .arg("dir1/dangling_symlink")
+        .succeeds();
+
+    let stdout = result.stdout_str();
+    // stdout contains output like in the below sequence. We match for the color i.e. 01;36
+    // \x1b[0m\x1b[01;36mdir1/dangling_symlink\x1b[0m -> \x1b[01;36mfoo\x1b[0m
+    let color_regex = Regex::new(r"(\d\d;)\d\dm").unwrap();
+    // colors_vec[0] contains the symlink color and style and colors_vec[1] contains the color and style of the file the
+    // symlink points to.
+    let colors_vec: Vec<_> = color_regex
+        .find_iter(stdout)
+        .map(|color| color.as_str())
+        .collect();
+
+    assert_eq!(colors_vec[0], colors_vec[1]);
+    // constructs the string of file path with the color code
+    let symlink_color_name = colors_vec[0].to_owned() + "dir1/dangling_symlink\x1b";
+    let target_color_name = colors_vec[1].to_owned() + at.plus_as_string("foo\x1b").as_str();
+
+    assert!(stdout.contains(&symlink_color_name));
+    assert!(stdout.contains(&target_color_name));
+}
+
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_ls_long_total_size() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -1292,6 +1482,8 @@ fn test_ls_long_total_size() {
 }
 
 #[test]
+#[cfg(not(feature = "feat_selinux"))]
+// Disabled on the SELinux runner for now
 fn test_ls_long_formats() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -1476,6 +1668,24 @@ fn test_ls_deref() {
         .succeeds();
     assert!(re.is_match(result.stdout_str().trim()));
 
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--color=neve") // spell-checker:disable-line
+        .arg("test-long")
+        .arg("test-long.link")
+        .succeeds();
+    assert!(re.is_match(result.stdout_str().trim()));
+
+    let result = scene
+        .ucmd()
+        .arg("-l")
+        .arg("--color=n")
+        .arg("test-long")
+        .arg("test-long.link")
+        .succeeds();
+    assert!(re.is_match(result.stdout_str().trim()));
+
     let result = scene
         .ucmd()
         .arg("-L")
@@ -1507,7 +1717,7 @@ fn test_ls_group_directories_first() {
         .ucmd()
         .arg("-1a")
         .arg("--group-directories-first")
-        .run();
+        .succeeds();
     assert_eq!(
         result.stdout_str().split('\n').collect::<Vec<_>>(),
         dots.into_iter()
@@ -1521,10 +1731,12 @@ fn test_ls_group_directories_first() {
         .ucmd()
         .arg("-1ar")
         .arg("--group-directories-first")
-        .run();
+        .succeeds();
     assert_eq!(
         result.stdout_str().split('\n').collect::<Vec<_>>(),
-        (dirnames.into_iter().rev())
+        dirnames
+            .into_iter()
+            .rev()
             .chain(dots.into_iter().rev())
             .chain(filenames.into_iter().rev())
             .chain([""].into_iter())
@@ -1535,8 +1747,8 @@ fn test_ls_group_directories_first() {
         .ucmd()
         .arg("-1aU")
         .arg("--group-directories-first")
-        .run();
-    let result2 = scene.ucmd().arg("-1aU").run();
+        .succeeds();
+    let result2 = scene.ucmd().arg("-1aU").succeeds();
     assert_eq!(result.stdout_str(), result2.stdout_str());
 }
 #[test]
@@ -1551,6 +1763,10 @@ fn test_ls_sort_none() {
     // Order is not specified so we just check that it doesn't
     // give any errors.
     scene.ucmd().arg("--sort=none").succeeds();
+    scene.ucmd().arg("--sort=non").succeeds();
+    scene.ucmd().arg("--sort=no").succeeds();
+    // scene.ucmd().arg("--sort=n").succeeds();
+    // We refuse to accept "--sort=n", since this is too confusable with "--sort=name", which is our own extension.
     scene.ucmd().arg("-U").succeeds();
 }
 
@@ -1568,6 +1784,16 @@ fn test_ls_sort_name() {
         .arg("--sort=name")
         .succeeds()
         .stdout_is("test-1\ntest-2\ntest-3\n");
+    scene
+        .ucmd()
+        .arg("--sort=nam")
+        .succeeds()
+        .stdout_is("test-1\ntest-2\ntest-3\n");
+    scene
+        .ucmd()
+        .arg("--sort=na")
+        .succeeds()
+        .stdout_is("test-1\ntest-2\ntest-3\n");
 
     let scene_dot = TestScenario::new(util_name!());
     let at = &scene_dot.fixtures;
@@ -1604,6 +1830,16 @@ fn test_ls_sort_width() {
         .arg("--sort=width")
         .succeeds()
         .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
+    scene
+        .ucmd()
+        .arg("--sort=widt") // spell-checker:disable-line
+        .succeeds()
+        .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
+    scene
+        .ucmd()
+        .arg("--sort=w")
+        .succeeds()
+        .stdout_is("d\nzz\nabc\nbbb\neee\ncccc\naaaaa\nbcdef\nfffff\n");
 }
 
 #[test]
@@ -1632,6 +1868,12 @@ fn test_ls_order_size() {
     let result = scene.ucmd().arg("--sort=size").succeeds();
     result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
 
+    let result = scene.ucmd().arg("--sort=siz").succeeds();
+    result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+
+    let result = scene.ucmd().arg("--sort=s").succeeds();
+    result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+
     let result = scene.ucmd().arg("--sort=size").arg("-r").succeeds();
     result.stdout_only("test-1\ntest-2\ntest-3\ntest-4\n");
 }
@@ -1671,7 +1913,7 @@ fn test_ls_order_birthtime() {
     at.make_file("test-birthtime-2").sync_all().unwrap();
     at.open("test-birthtime-1");
 
-    let result = scene.ucmd().arg("--time=birth").arg("-t").run();
+    let result = scene.ucmd().arg("--time=birth").arg("-t").succeeds();
 
     #[cfg(not(windows))]
     assert_eq!(result.stdout_str(), "test-birthtime-2\ntest-birthtime-1\n");
@@ -1737,7 +1979,11 @@ fn test_ls_styles() {
         .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();
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("--time-style=invalid")
+        .fails_with_code(2);
 
     //Overwrite options tests
     scene
@@ -1831,7 +2077,14 @@ fn test_ls_order_time() {
 
     // 3 was accessed last in the read
     // So the order should be 2 3 4 1
-    for arg in ["-u", "--time=atime", "--time=access", "--time=use"] {
+    for arg in [
+        "-u",
+        "--time=atime",
+        "--time=atim", // spell-checker:disable-line
+        "--time=a",
+        "--time=access",
+        "--time=use",
+    ] {
         let result = scene.ucmd().arg("-t").arg(arg).succeeds();
         at.open("test-3").metadata().unwrap().accessed().unwrap();
         at.open("test-4").metadata().unwrap().accessed().unwrap();
@@ -1858,6 +2111,30 @@ fn test_ls_order_time() {
     }
 }
 
+#[test]
+fn test_ls_order_mtime() {
+    use std::time::SystemTime;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let f3 = at.make_file("test-3");
+    f3.set_modified(SystemTime::now()).unwrap();
+    let f4 = at.make_file("test-4");
+    f4.set_modified(SystemTime::now()).unwrap();
+    let f1 = at.make_file("test-1");
+    f1.set_modified(SystemTime::now()).unwrap();
+    let f2 = at.make_file("test-2");
+    f2.set_modified(SystemTime::now()).unwrap();
+
+    let result = scene.ucmd().arg("-t").arg("--time=mtime").succeeds();
+    result.stdout_only("test-2\ntest-1\ntest-4\ntest-3\n");
+    f3.set_modified(SystemTime::now()).unwrap();
+
+    f4.set_modified(SystemTime::now()).unwrap();
+    let result = scene.ucmd().arg("-t").arg("--time=mtime").succeeds();
+    result.stdout_only("test-4\ntest-3\ntest-2\ntest-1\n");
+}
+
 #[test]
 fn test_ls_non_existing() {
     new_ucmd!().arg("doesntexist").fails();
@@ -1928,6 +2205,492 @@ fn test_ls_recursive() {
     result.stdout_contains("a\\b:\nb");
 }
 
+#[test]
+fn test_ls_recursive_1() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("x");
+    at.mkdir("y");
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.mkdir("a/1");
+    at.mkdir("a/2");
+    at.mkdir("a/3");
+    at.touch("f");
+    at.touch("a/1/I");
+    at.touch("a/1/II");
+    #[cfg(unix)]
+    let out = "a:\n1\n2\n3\n\na/1:\nI\nII\n\na/2:\n\na/3:\n\nb:\n\nc:\n";
+    #[cfg(windows)]
+    let out = "a:\n1\n2\n3\n\na\\1:\nI\nII\n\na\\2:\n\na\\3:\n\nb:\n\nc:\n";
+    scene
+        .ucmd()
+        .arg("-R1")
+        .arg("a")
+        .arg("b")
+        .arg("c")
+        .succeeds()
+        .stdout_is(out);
+}
+
+/// The quoting module regroups tests that check the behavior of ls when
+/// quoting and escaping special characters with different quoting styles.
+#[cfg(unix)]
+mod quoting {
+    use super::TestScenario;
+    use uutests::util_name;
+
+    /// Create a directory with "dirname", then for each check, assert that the
+    /// output is correct.
+    fn check_quoting_dirname(dirname: &str, checks: &[(&str, &str, &str)], extra_args: &[&str]) {
+        for (qt_style, regular_mode, dir_mode) in checks {
+            let scene = TestScenario::new(util_name!());
+            let at = &scene.fixtures;
+            at.mkdir(dirname);
+
+            let expected = format!(
+                "{}:\n{regular_mode}\n\n{dir_mode}:\n",
+                match *qt_style {
+                    "shell-always" | "shell-escape-always" => "'.'",
+                    "c" => "\".\"",
+                    _ => ".",
+                },
+            );
+
+            scene
+                .ucmd()
+                .arg("-R")
+                .arg(format!("--quoting-style={qt_style}"))
+                .args(extra_args)
+                .succeeds()
+                .stdout_is(expected);
+        }
+    }
+
+    #[test]
+    fn test_ls_quoting_simple() {
+        check_quoting_dirname(
+            // Control case
+            "dirname",
+            &[
+                ("literal", "dirname", "./dirname"),
+                ("shell", "dirname", "./dirname"),
+                ("shell-always", "'dirname'", "'./dirname'"),
+                ("shell-escape", "dirname", "./dirname"),
+                ("shell-escape-always", "'dirname'", "'./dirname'"),
+                ("c", "\"dirname\"", "\"./dirname\""),
+                ("escape", "dirname", "./dirname"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_space() {
+        check_quoting_dirname(
+            // Space character
+            "dir name",
+            &[
+                ("literal", "dir name", "./dir name"),
+                ("shell", "'dir name'", "'./dir name'"),
+                ("shell-always", "'dir name'", "'./dir name'"),
+                ("shell-escape", "'dir name'", "'./dir name'"),
+                ("shell-escape-always", "'dir name'", "'./dir name'"),
+                ("c", "\"dir name\"", "\"./dir name\""),
+                ("escape", "dir\\ name", "./dir name"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_dollar() {
+        check_quoting_dirname(
+            // Dollar character
+            "dir$name",
+            &[
+                ("literal", "dir$name", "./dir$name"),
+                ("shell", "'dir$name'", "'./dir$name'"),
+                ("shell-always", "'dir$name'", "'./dir$name'"),
+                ("shell-escape", "'dir$name'", "'./dir$name'"),
+                ("shell-escape-always", "'dir$name'", "'./dir$name'"),
+                ("c", "\"dir$name\"", "\"./dir$name\""),
+                ("escape", "dir$name", "./dir$name"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_single_quote() {
+        check_quoting_dirname(
+            // Single quote character
+            "dir'name",
+            &[
+                ("literal", "dir'name", "./dir'name"),
+                ("shell", "\"dir'name\"", "\"./dir'name\""),
+                ("shell-always", "\"dir'name\"", "\"./dir'name\""),
+                ("shell-escape", "\"dir'name\"", "\"./dir'name\""),
+                ("shell-escape-always", "\"dir'name\"", "\"./dir'name\""),
+                ("c", "\"dir'name\"", "\"./dir'name\""),
+                ("escape", "dir'name", "./dir'name"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_double_quote() {
+        check_quoting_dirname(
+            // Double quote character
+            "dir\"name",
+            &[
+                ("literal", "dir\"name", "./dir\"name"),
+                ("shell", "'dir\"name'", "'./dir\"name'"),
+                ("shell-always", "'dir\"name'", "'./dir\"name'"),
+                ("shell-escape", "'dir\"name'", "'./dir\"name'"),
+                ("shell-escape-always", "'dir\"name'", "'./dir\"name'"),
+                ("c", "\"dir\\\"name\"", "\"./dir\\\"name\""),
+                ("escape", "dir\"name", "./dir\"name"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_colon() {
+        check_quoting_dirname(
+            // Colon character
+            "dir:name",
+            &[
+                ("literal", "dir:name", "./dir:name"),
+                ("shell", "dir:name", "'./dir:name'"),
+                ("shell-always", "'dir:name'", "'./dir:name'"),
+                ("shell-escape", "dir:name", "'./dir:name'"),
+                ("shell-escape-always", "'dir:name'", "'./dir:name'"),
+                ("c", "\"dir:name\"", "\"./dir\\:name\""),
+                ("escape", "dir:name", "./dir\\:name"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_backslash() {
+        check_quoting_dirname(
+            // Backslash character
+            "dir\\name",
+            &[
+                ("literal", "dir\\name", "./dir\\name"),
+                ("shell", "'dir\\name'", "'./dir\\name'"),
+                ("shell-always", "'dir\\name'", "'./dir\\name'"),
+                ("shell-escape", "'dir\\name'", "'./dir\\name'"),
+                ("shell-escape-always", "'dir\\name'", "'./dir\\name'"),
+                ("c", "\"dir\\\\name\"", "\"./dir\\\\name\""),
+                ("escape", "dir\\\\name", "./dir\\\\name"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_linefeed() {
+        check_quoting_dirname(
+            // Linefeed character
+            "dir\nname",
+            &[
+                ("literal", "dir\nname", "./dir\nname"),
+                ("shell", "'dir\nname'", "'./dir\nname'"),
+                ("shell-always", "'dir\nname'", "'./dir\nname'"),
+                ("shell-escape", "'dir'$'\\n''name'", "'./dir'$'\\n''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\n''name'",
+                    "'./dir'$'\\n''name'",
+                ),
+                ("c", "\"dir\\nname\"", "\"./dir\\nname\""),
+                ("escape", "dir\\nname", "./dir\\nname"),
+            ],
+            &[],
+        );
+
+        check_quoting_dirname(
+            // Linefeed character WITH hide-control-chars
+            "dir\nname",
+            &[
+                ("literal", "dir?name", "./dir?name"),
+                ("shell", "'dir?name'", "'./dir?name'"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\n''name'", "'./dir'$'\\n''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\n''name'",
+                    "'./dir'$'\\n''name'",
+                ),
+                ("c", "\"dir\\nname\"", "\"./dir\\nname\""),
+                ("escape", "dir\\nname", "./dir\\nname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_tabulation() {
+        check_quoting_dirname(
+            // Tabulation character
+            "dir\tname",
+            &[
+                ("literal", "dir\tname", "./dir\tname"),
+                ("shell", "'dir\tname'", "'./dir\tname'"),
+                ("shell-always", "'dir\tname'", "'./dir\tname'"),
+                ("shell-escape", "'dir'$'\\t''name'", "'./dir'$'\\t''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\t''name'",
+                    "'./dir'$'\\t''name'",
+                ),
+                ("c", "\"dir\\tname\"", "\"./dir\\tname\""),
+                ("escape", "dir\\tname", "./dir\\tname"),
+            ],
+            &[],
+        );
+
+        check_quoting_dirname(
+            // Tabulation character
+            "dir\tname",
+            &[
+                ("literal", "dir?name", "./dir?name"),
+                ("shell", "'dir?name'", "'./dir?name'"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\t''name'", "'./dir'$'\\t''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\t''name'",
+                    "'./dir'$'\\t''name'",
+                ),
+                ("c", "\"dir\\tname\"", "\"./dir\\tname\""),
+                ("escape", "dir\\tname", "./dir\\tname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_carriage_return() {
+        check_quoting_dirname(
+            // Carriage return character
+            "dir\rname",
+            &[
+                ("literal", "dir?name", "./dir?name"),
+                ("shell", "'dir?name'", "'./dir?name'"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\r''name'", "'./dir'$'\\r''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\r''name'",
+                    "'./dir'$'\\r''name'",
+                ),
+                ("c", "\"dir\\rname\"", "\"./dir\\rname\""),
+                ("escape", "dir\\rname", "./dir\\rname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_bell() {
+        check_quoting_dirname(
+            // Bell character
+            "dir\x07name",
+            &[
+                ("shell", "dir?name", "./dir?name"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\a''name'", "'./dir'$'\\a''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\a''name'",
+                    "'./dir'$'\\a''name'",
+                ),
+                ("c", "\"dir\\aname\"", "\"./dir\\aname\""),
+                ("escape", "dir\\aname", "./dir\\aname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_backspace() {
+        check_quoting_dirname(
+            // Backspace character
+            "dir\x08name",
+            &[
+                ("shell", "dir?name", "./dir?name"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\b''name'", "'./dir'$'\\b''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\b''name'",
+                    "'./dir'$'\\b''name'",
+                ),
+                ("c", "\"dir\\bname\"", "\"./dir\\bname\""),
+                ("escape", "dir\\bname", "./dir\\bname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_vertical_tab() {
+        check_quoting_dirname(
+            // Vertical tab character
+            "dir\x0bname",
+            &[
+                ("shell", "dir?name", "./dir?name"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\v''name'", "'./dir'$'\\v''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\v''name'",
+                    "'./dir'$'\\v''name'",
+                ),
+                ("c", "\"dir\\vname\"", "\"./dir\\vname\""),
+                ("escape", "dir\\vname", "./dir\\vname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_formfeed() {
+        check_quoting_dirname(
+            // Form feed character
+            "dir\x0cname",
+            &[
+                ("shell", "dir?name", "./dir?name"),
+                ("shell-always", "'dir?name'", "'./dir?name'"),
+                ("shell-escape", "'dir'$'\\f''name'", "'./dir'$'\\f''name'"),
+                (
+                    "shell-escape-always",
+                    "'dir'$'\\f''name'",
+                    "'./dir'$'\\f''name'",
+                ),
+                ("c", "\"dir\\fname\"", "\"./dir\\fname\""),
+                ("escape", "dir\\fname", "./dir\\fname"),
+            ],
+            &["--hide-control-chars"],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_open_bracket() {
+        check_quoting_dirname(
+            "[-open_bracket",
+            &[
+                ("shell", "'[-open_bracket'", "'./[-open_bracket'"),
+                ("shell-always", "'[-open_bracket'", "'./[-open_bracket'"),
+                ("shell-escape", "'[-open_bracket'", "'./[-open_bracket'"),
+                (
+                    "shell-escape-always",
+                    "'[-open_bracket'",
+                    "'./[-open_bracket'",
+                ),
+                ("c", "\"[-open_bracket\"", "\"./[-open_bracket\""),
+                ("escape", "[-open_bracket", "./[-open_bracket"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_close_bracket() {
+        check_quoting_dirname(
+            "]-close_bracket",
+            &[
+                ("shell", "]-close_bracket", "./]-close_bracket"),
+                ("shell-always", "']-close_bracket'", "'./]-close_bracket'"),
+                ("shell-escape", "]-close_bracket", "./]-close_bracket"),
+                (
+                    "shell-escape-always",
+                    "']-close_bracket'",
+                    "'./]-close_bracket'",
+                ),
+                ("c", "\"]-close_bracket\"", "\"./]-close_bracket\""),
+                ("escape", "]-close_bracket", "./]-close_bracket"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_open_brace() {
+        check_quoting_dirname(
+            "{-open_brace",
+            &[
+                ("shell", "{-open_brace", "./{-open_brace"),
+                ("shell-always", "'{-open_brace'", "'./{-open_brace'"),
+                ("shell-escape", "{-open_brace", "./{-open_brace"),
+                ("shell-escape-always", "'{-open_brace'", "'./{-open_brace'"),
+                ("c", "\"{-open_brace\"", "\"./{-open_brace\""),
+                ("escape", "{-open_brace", "./{-open_brace"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_close_brace() {
+        check_quoting_dirname(
+            "}-close_brace",
+            &[
+                ("shell", "}-close_brace", "./}-close_brace"),
+                ("shell-always", "'}-close_brace'", "'./}-close_brace'"),
+                ("shell-escape", "}-close_brace", "./}-close_brace"),
+                (
+                    "shell-escape-always",
+                    "'}-close_brace'",
+                    "'./}-close_brace'",
+                ),
+                ("c", "\"}-close_brace\"", "\"./}-close_brace\""),
+                ("escape", "}-close_brace", "./}-close_brace"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_caret() {
+        check_quoting_dirname(
+            "^-caret",
+            &[
+                ("shell", "'^-caret'", "'./^-caret'"),
+                ("shell-always", "'^-caret'", "'./^-caret'"),
+                ("shell-escape", "'^-caret'", "'./^-caret'"),
+                ("shell-escape-always", "'^-caret'", "'./^-caret'"),
+                ("c", "\"^-caret\"", "\"./^-caret\""),
+                ("escape", "^-caret", "./^-caret"),
+            ],
+            &[],
+        );
+    }
+
+    #[test]
+    fn test_ls_quoting_equal() {
+        check_quoting_dirname(
+            "=-equal",
+            &[
+                ("shell", "'=-equal'", "'./=-equal'"),
+                ("shell-always", "'=-equal'", "'./=-equal'"),
+                ("shell-escape", "'=-equal'", "'./=-equal'"),
+                ("shell-escape-always", "'=-equal'", "'./=-equal'"),
+                ("c", "\"=-equal\"", "\"./=-equal\""),
+                ("escape", "=-equal", "./=-equal"),
+            ],
+            &[],
+        );
+    }
+}
+
 #[test]
 fn test_ls_color() {
     let scene = TestScenario::new(util_name!());
@@ -1937,7 +2700,7 @@ fn test_ls_color() {
         .join("nested_dir")
         .to_string_lossy()
         .to_string();
-    at.mkdir(&nested_dir);
+    at.mkdir(nested_dir);
     at.mkdir("z");
     let nested_file = Path::new("a")
         .join("nested_file")
@@ -1946,9 +2709,9 @@ fn test_ls_color() {
     at.touch(nested_file);
     at.touch("test-color");
 
-    let a_with_colors = "\x1b[1;34ma\x1b[0m";
-    let z_with_colors = "\x1b[1;34mz\x1b[0m";
-    let nested_dir_with_colors = "\x1b[1;34mnested_dir\x1b[0m"; // spell-checker:disable-line
+    let a_with_colors = "\x1b[0m\x1b[01;34ma\x1b[0m";
+    let z_with_colors = "\x1b[01;34mz\x1b[0m\n";
+    let nested_dir_with_colors = "\x1b[0m\x1b[01;34mnested_dir\x1b[0m\x0anested_file"; // spell-checker:disable-line
 
     // Color is disabled by default
     let result = scene.ucmd().succeeds();
@@ -1957,12 +2720,9 @@ fn test_ls_color() {
 
     // Color should be enabled
     for param in ["--color", "--col", "--color=always", "--col=always"] {
-        scene
-            .ucmd()
-            .arg(param)
-            .succeeds()
-            .stdout_contains(a_with_colors)
-            .stdout_contains(z_with_colors);
+        let result = scene.ucmd().arg(param).succeeds();
+        assert!(result.stdout_str().contains(a_with_colors));
+        assert!(result.stdout_str().contains(z_with_colors));
     }
 
     // Color should be disabled
@@ -1971,12 +2731,8 @@ fn test_ls_color() {
     assert!(!result.stdout_str().contains(z_with_colors));
 
     // Nested dir should be shown and colored
-    scene
-        .ucmd()
-        .arg("--color")
-        .arg("a")
-        .succeeds()
-        .stdout_contains(nested_dir_with_colors);
+    let result = scene.ucmd().arg("--color").arg("a").succeeds();
+    assert!(result.stdout_str().contains(nested_dir_with_colors));
 
     // No output
     scene
@@ -1988,17 +2744,24 @@ fn test_ls_color() {
 
     // The colors must not mess up the grid layout
     at.touch("b");
-    scene
+    let result = scene
         .ucmd()
         .arg("--color")
         .arg("-w=15")
         .arg("-C")
-        .succeeds()
-        .stdout_only(format!("{a_with_colors}  test-color\nb  {z_with_colors}\n"));
+        .succeeds();
+    let expected = format!("{a_with_colors}  test-color\x0ab  {z_with_colors}");
+    assert_eq!(
+        result.stdout_str().escape_default().to_string(),
+        expected.escape_default().to_string()
+    );
+    assert_eq!(result.stdout_str(), expected);
 }
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(feature = "feat_selinux"))]
+// Disabled on the SELinux runner for now
 fn test_ls_inode() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
@@ -2059,12 +2822,16 @@ fn test_ls_indicator_style() {
     for opt in [
         "--indicator-style=classify",
         "--ind=classify",
+        "--indicator-style=clas", // spell-checker:disable-line
+        "--indicator-style=c",
         "--indicator-style=file-type",
         "--ind=file-type",
         "--indicator-style=slash",
         "--ind=slash",
         "--classify",
         "--classify=always",
+        "--classify=alway",
+        "--classify=al",
         "--classify=yes",
         "--classify=force",
         "--class",
@@ -2079,10 +2846,13 @@ fn test_ls_indicator_style() {
     // Classify, Indicator options should not contain any indicators when value is none.
     for opt in [
         "--indicator-style=none",
+        "--indicator-style=n",
         "--ind=none",
         "--classify=none",
         "--classify=never",
+        "--classify=non",
         "--classify=no",
+        "--classify=n",
     ] {
         // Verify that there are no indicators for any of the file types.
         scene
@@ -2173,7 +2943,7 @@ fn test_ls_indicator_style() {
     }
 }
 
-#[cfg(not(any(target_vendor = "apple", target_os = "windows")))] // Truncate not available on mac or win
+#[cfg(not(any(target_vendor = "apple", target_os = "windows", target_os = "openbsd")))] // Truncate not available on mac or win
 #[test]
 fn test_ls_human_si() {
     let scene = TestScenario::new(util_name!());
@@ -2205,7 +2975,7 @@ fn test_ls_human_si() {
         .arg("-s")
         .arg("+1000k")
         .arg(file1)
-        .run();
+        .succeeds();
 
     scene
         .ucmd()
@@ -2396,6 +3166,12 @@ fn test_ls_version_sort() {
         expected
     );
 
+    let result = scene.ucmd().arg("-1").arg("--sort=v").succeeds();
+    assert_eq!(
+        result.stdout_str().split('\n').collect::<Vec<_>>(),
+        expected
+    );
+
     let result = scene.ucmd().arg("-a1v").succeeds();
     expected.insert(expected.len() - 1, "..");
     expected.insert(0, ".");
@@ -2419,29 +3195,48 @@ fn test_ls_quoting_style() {
     {
         at.touch("one\ntwo");
         at.touch("one\\two");
-        // Default is shell-escape
+
+        // Default is literal, when stdout is not a TTY...
         scene
             .ucmd()
             .arg("--hide-control-chars")
             .arg("one\ntwo")
             .succeeds()
-            .stdout_only("'one'$'\\n''two'\n");
+            .stdout_only("one?two\n");
+
+        // ... Otherwise, it is shell-escape
+        #[cfg(unix)]
+        scene
+            .ucmd()
+            .arg("--hide-control-chars")
+            .arg("one\ntwo")
+            .terminal_simulation(true)
+            .succeeds()
+            .stdout_only("'one'$'\\n''two'\r\n");
 
         for (arg, correct) in [
             ("--quoting-style=literal", "one?two"),
+            ("--quoting-style=litera", "one?two"), // spell-checker:disable-line
+            ("--quoting-style=li", "one?two"),
             ("-N", "one?two"),
             ("--literal", "one?two"),
             ("--l", "one?two"),
             ("--quoting-style=c", "\"one\\ntwo\""),
+            ("--quoting-style=c-", "\"one\\ntwo\""),
+            ("--quoting-style=c-maybe", "\"one\\ntwo\""),
             ("-Q", "\"one\\ntwo\""),
             ("--quote-name", "\"one\\ntwo\""),
             ("--quoting-style=escape", "one\\ntwo"),
+            ("--quoting-style=escap", "one\\ntwo"), // spell-checker:disable-line
             ("-b", "one\\ntwo"),
             ("--escape", "one\\ntwo"),
             ("--quoting-style=shell-escape", "'one'$'\\n''two'"),
             ("--quoting-style=shell-escape-always", "'one'$'\\n''two'"),
-            ("--quoting-style=shell", "one?two"),
+            ("--quoting-style=shell-escape-alway", "'one'$'\\n''two'"),
+            ("--quoting-style=shell-escape-a", "'one'$'\\n''two'"),
+            ("--quoting-style=shell", "'one?two'"),
             ("--quoting-style=shell-always", "'one?two'"),
+            ("--quoting-style=shell-a", "'one?two'"),
         ] {
             scene
                 .ucmd()
@@ -2457,7 +3252,7 @@ fn test_ls_quoting_style() {
             ("-N", "one\ntwo"),
             ("--literal", "one\ntwo"),
             ("--l", "one\ntwo"),
-            ("--quoting-style=shell", "one\ntwo"), // FIXME: GNU ls quotes this case
+            ("--quoting-style=shell", "'one\ntwo'"),
             ("--quoting-style=shell-always", "'one\ntwo'"),
         ] {
             scene
@@ -2508,11 +3303,21 @@ fn test_ls_quoting_style() {
         }
     }
 
+    // No-TTY
+    scene
+        .ucmd()
+        .arg("one two")
+        .succeeds()
+        .stdout_only("one two\n");
+
+    // TTY
+    #[cfg(unix)]
     scene
         .ucmd()
         .arg("one two")
+        .terminal_simulation(true)
         .succeeds()
-        .stdout_only("'one two'\n");
+        .stdout_only("'one two'\r\n");
 
     for (arg, correct) in [
         ("--quoting-style=literal", "one two"),
@@ -2565,17 +3370,158 @@ fn test_ls_quoting_style() {
 }
 
 #[test]
-fn test_ls_quoting_and_color() {
+fn test_ls_quoting_style_env_var_default() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
+    at.touch(at.plus_as_string("foo-1"));
+    at.touch(at.plus_as_string("bar-2"));
 
-    at.touch("one two");
+    // If no quoting style argument is provided, the QUOTING_STYLE environment variable
+    // shall be used.
+
+    let correct_c = "\"bar-2\"\n\"foo-1\"";
+    scene
+        .ucmd()
+        .env("QUOTING_STYLE", "c")
+        .succeeds()
+        .stdout_only(format!("{correct_c}\n"));
+}
+
+#[test]
+fn test_ls_quoting_style_arg_overrides_env_var() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch(at.plus_as_string("foo-1"));
+    at.touch(at.plus_as_string("bar-2"));
+
+    // The quoting style given by the env variable should be
+    // overridden by any escape style provided by argument.
+    for (arg, correct) in [
+        ("--quoting-style=literal", "foo-1"),
+        ("-N", "foo-1"),
+        ("--quoting-style=escape", "foo-1"),
+        ("-b", "foo-1"),
+        ("--quoting-style=shell-escape", "foo-1"),
+        ("--quoting-style=shell-escape-always", "'foo-1'"),
+        ("--quoting-style=shell", "foo-1"),
+        ("--quoting-style=shell-always", "'foo-1'"),
+    ] {
+        scene
+            .ucmd()
+            .env("QUOTING_STYLE", "c")
+            .arg("--hide-control-chars")
+            .arg(arg)
+            .arg("foo-1")
+            .succeeds()
+            .stdout_only(format!("{correct}\n"));
+    }
+
+    // Another loop to check for the C quoting style that is used as a default above.
+    for (arg, correct) in [
+        ("--quoting-style=c", "\"foo-1\""),
+        ("-Q", "\"foo-1\""),
+        ("--quote-name", "\"foo-1\""),
+    ] {
+        scene
+            .ucmd()
+            .env("QUOTING_STYLE", "literal")
+            .arg("--hide-control-chars")
+            .arg(arg)
+            .arg("foo-1")
+            .succeeds()
+            .stdout_only(format!("{correct}\n"));
+    }
+}
+
+#[test]
+fn test_ls_quoting_and_color() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("one two");
+
+    // No-TTY
+    scene
+        .ucmd()
+        .arg("--color")
+        .arg("one two")
+        .succeeds()
+        .stdout_only("one two\n");
+
+    // TTY
+    #[cfg(unix)]
     scene
         .ucmd()
         .arg("--color")
         .arg("one two")
+        .terminal_simulation(true)
+        .succeeds()
+        .stdout_only("'one two'\r\n");
+}
+
+#[test]
+fn test_ls_align_unquoted() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("elf two");
+    at.touch("foobar");
+    at.touch("CAPS");
+    at.touch("'quoted'");
+
+    // In TTY
+    #[cfg(unix)]
+    scene
+        .ucmd()
+        .arg("--color")
+        .terminal_simulation(true)
+        .succeeds()
+        .stdout_only("\"'quoted'\"   CAPS  'elf two'   foobar\r\n");
+    //                                  ^      ^          ^
+    //                                  space  no-space   space
+
+    // The same should happen with format columns/across
+    // and shell quoting style, except for the `\r` at the end.
+    for format in &["--format=column", "--format=across"] {
+        scene
+            .ucmd()
+            .arg("--color")
+            .arg(format)
+            .arg("--quoting-style=shell")
+            .succeeds()
+            .stdout_only("\"'quoted'\"   CAPS  'elf two'   foobar\n");
+        //                                  ^      ^          ^
+        //                                  space  no-space   space
+    }
+}
+
+#[test]
+fn test_ls_align_unquoted_multiline() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.touch("one");
+    at.touch("two");
+    at.touch("three_long");
+    at.touch("four_long");
+    at.touch("five");
+    at.touch("s ix");
+    at.touch("s even");
+    at.touch("eight_long_long");
+    at.touch("nine");
+    at.touch("ten");
+
+    // In TTY
+    #[cfg(unix)]
+    scene
+        .ucmd()
+        .arg("--color")
+        .terminal_simulation(true)
         .succeeds()
-        .stdout_only("'one two'\n");
+        .stdout_only(concat!(
+            " eight_long_long   four_long   one      's ix'   three_long\r\n",
+            " five              nine       's even'   ten     two\r\n"
+        ));
 }
 
 #[test]
@@ -3069,13 +4015,13 @@ fn test_ls_sort_extension() {
         "", // because of '\n' at the end of the output
     ];
 
-    let result = scene.ucmd().arg("-1aX").run();
+    let result = scene.ucmd().arg("-1aX").succeeds();
     assert_eq!(
         result.stdout_str().split('\n').collect::<Vec<_>>(),
         expected,
     );
 
-    let result = scene.ucmd().arg("-1a").arg("--sort=extension").run();
+    let result = scene.ucmd().arg("-1a").arg("--sort=extension").succeeds();
     assert_eq!(
         result.stdout_str().split('\n').collect::<Vec<_>>(),
         expected,
@@ -3097,29 +4043,30 @@ fn test_ls_path() {
     at.touch(path);
 
     let expected_stdout = &format!("{path}\n");
-    scene.ucmd().arg(path).run().stdout_is(expected_stdout);
+    scene.ucmd().arg(path).succeeds().stdout_is(expected_stdout);
 
     let expected_stdout = &format!("./{path}\n");
     scene
         .ucmd()
         .arg(format!("./{path}"))
-        .run()
+        .succeeds()
         .stdout_is(expected_stdout);
 
-    let abs_path = format!("{}/{}", at.as_string(), path);
-    let expected_stdout = if cfg!(windows) {
-        format!("\'{abs_path}\'\n")
-    } else {
-        format!("{abs_path}\n")
-    };
-    scene.ucmd().arg(&abs_path).run().stdout_is(expected_stdout);
+    let abs_path = format!("{}/{path}", at.as_string());
+    let expected_stdout = format!("{abs_path}\n");
+
+    scene
+        .ucmd()
+        .arg(&abs_path)
+        .succeeds()
+        .stdout_is(expected_stdout);
 
     let expected_stdout = format!("{path}\n{file1}\n");
     scene
         .ucmd()
         .arg(file1)
         .arg(path)
-        .run()
+        .succeeds()
         .stdout_is(expected_stdout);
 }
 
@@ -3135,14 +4082,12 @@ fn test_ls_dangling_symlinks() {
         .ucmd()
         .arg("-L")
         .arg("temp_dir/dangle")
-        .fails()
-        .code_is(2);
+        .fails_with_code(2);
     scene
         .ucmd()
         .arg("-H")
         .arg("temp_dir/dangle")
-        .fails()
-        .code_is(2);
+        .fails_with_code(2);
 
     scene
         .ucmd()
@@ -3154,8 +4099,7 @@ fn test_ls_dangling_symlinks() {
         .ucmd()
         .arg("-Li")
         .arg("temp_dir")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("cannot access")
         .stderr_contains("No such file or directory")
         .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
@@ -3164,8 +4108,7 @@ fn test_ls_dangling_symlinks() {
         .ucmd()
         .arg("-LZ")
         .arg("temp_dir")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("cannot access")
         .stderr_contains("No such file or directory")
         .stdout_contains(if cfg!(windows) { "dangle" } else { "? dangle" });
@@ -3174,8 +4117,7 @@ fn test_ls_dangling_symlinks() {
         .ucmd()
         .arg("-Ll")
         .arg("temp_dir")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_contains("l?????????");
 
     #[cfg(unix)]
@@ -3183,8 +4125,7 @@ fn test_ls_dangling_symlinks() {
         // Check padding is the same for real files and dangling links, in non-long formats
         at.touch("temp_dir/real_file");
 
-        let real_file_res = scene.ucmd().arg("-Li1").arg("temp_dir").fails();
-        real_file_res.code_is(1);
+        let real_file_res = scene.ucmd().arg("-Li1").arg("temp_dir").fails_with_code(1);
         let real_file_stdout_len = String::from_utf8(real_file_res.stdout().to_owned())
             .ok()
             .unwrap()
@@ -3195,8 +4136,7 @@ fn test_ls_dangling_symlinks() {
             .unwrap()
             .len();
 
-        let dangle_file_res = scene.ucmd().arg("-Li1").arg("temp_dir").fails();
-        dangle_file_res.code_is(1);
+        let dangle_file_res = scene.ucmd().arg("-Li1").arg("temp_dir").fails_with_code(1);
         let dangle_stdout_len = String::from_utf8(dangle_file_res.stdout().to_owned())
             .ok()
             .unwrap()
@@ -3214,14 +4154,13 @@ fn test_ls_dangling_symlinks() {
 #[test]
 #[cfg(feature = "feat_selinux")]
 fn test_ls_context1() {
-    use selinux::{self, KernelSupport};
-    if selinux::kernel_support() == KernelSupport::Unsupported {
-        println!("test skipped: Kernel has no support for SElinux context",);
+    if !uucore::selinux::is_selinux_enabled() {
+        println!("test skipped: Kernel has no support for SElinux context");
         return;
     }
 
     let file = "test_ls_context_file";
-    let expected = format!("unconfined_u:object_r:user_tmp_t:s0 {}\n", file);
+    let expected = format!("unconfined_u:object_r:user_tmp_t:s0 {file}\n");
     let (at, mut ucmd) = at_and_ucmd!();
     at.touch(file);
     ucmd.args(&["-Z", file]).succeeds().stdout_is(expected);
@@ -3230,9 +4169,8 @@ fn test_ls_context1() {
 #[test]
 #[cfg(feature = "feat_selinux")]
 fn test_ls_context2() {
-    use selinux::{self, KernelSupport};
-    if selinux::kernel_support() == KernelSupport::Unsupported {
-        println!("test skipped: Kernel has no support for SElinux context",);
+    if !uucore::selinux::is_selinux_enabled() {
+        println!("test skipped: Kernel has no support for SElinux context");
         return;
     }
     let ts = TestScenario::new(util_name!());
@@ -3244,12 +4182,31 @@ fn test_ls_context2() {
     }
 }
 
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_ls_context_long() {
+    if !uucore::selinux::is_selinux_enabled() {
+        return;
+    }
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("foo");
+    for c_flag in ["-Zl", "-Zal"] {
+        let result = scene.ucmd().args(&[c_flag, "foo"]).succeeds();
+
+        let line: Vec<_> = result.stdout_str().split(' ').collect();
+        assert!(line[0].ends_with('.'));
+        assert!(line[4].starts_with("unconfined_u"));
+        let s: Vec<_> = line[4].split(':').collect();
+        assert!(s.len() == 4);
+    }
+}
+
 #[test]
 #[cfg(feature = "feat_selinux")]
 fn test_ls_context_format() {
-    use selinux::{self, KernelSupport};
-    if selinux::kernel_support() == KernelSupport::Unsupported {
-        println!("test skipped: Kernel has no support for SElinux context",);
+    if !uucore::selinux::is_selinux_enabled() {
+        println!("test skipped: Kernel has no support for SElinux context");
         return;
     }
     let ts = TestScenario::new(util_name!());
@@ -3265,7 +4222,7 @@ fn test_ls_context_format() {
         // "verbose",
         "vertical",
     ] {
-        let format = format!("--format={}", word);
+        let format = format!("--format={word}");
         ts.ucmd()
             .args(&["-Z", format.as_str(), "/"])
             .succeeds()
@@ -3368,8 +4325,7 @@ fn test_ls_dereference_looped_symlinks_recursive() {
     at.relative_symlink_dir("../loop", "loop/sub");
 
     ucmd.args(&["-RL", "loop"])
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_contains("not listing already-listed directory");
 }
 
@@ -3377,13 +4333,12 @@ fn test_ls_dereference_looped_symlinks_recursive() {
 fn test_dereference_dangling_color() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.relative_symlink_file("wat", "nonexistent");
-    let out_exp = ucmd.args(&["--color"]).run().stdout_move_str();
+    let out_exp = ucmd.args(&["--color"]).succeeds().stdout_move_str();
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.relative_symlink_file("wat", "nonexistent");
     ucmd.args(&["-L", "--color"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("No such file or directory")
         .stdout_is(out_exp);
 }
@@ -3393,7 +4348,7 @@ fn test_dereference_symlink_dir_color() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("dir1");
     at.mkdir("dir1/link");
-    let out_exp = ucmd.args(&["--color", "dir1"]).run().stdout_move_str();
+    let out_exp = ucmd.args(&["--color", "dir1"]).succeeds().stdout_move_str();
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("dir1");
@@ -3409,7 +4364,7 @@ fn test_dereference_symlink_file_color() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("dir1");
     at.touch("dir1/link");
-    let out_exp = ucmd.args(&["--color", "dir1"]).run().stdout_move_str();
+    let out_exp = ucmd.args(&["--color", "dir1"]).succeeds().stdout_move_str();
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("dir1");
@@ -3429,28 +4384,52 @@ fn test_tabsize_option() {
     scene.ucmd().arg("-T").fails();
 }
 
-#[ignore = "issue #3624"]
 #[test]
 fn test_tabsize_formatting() {
-    let (at, mut ucmd) = at_and_ucmd!();
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
 
     at.touch("aaaaaaaa");
     at.touch("bbbb");
     at.touch("cccc");
     at.touch("dddddddd");
 
-    ucmd.args(&["-T", "4"])
+    scene
+        .ucmd()
+        .args(&["-x", "-w18", "-T4"])
+        .succeeds()
+        .stdout_is("aaaaaaaa  bbbb\ncccc\t  dddddddd\n");
+
+    scene
+        .ucmd()
+        .args(&["-C", "-w18", "-T4"])
+        .succeeds()
+        .stdout_is("aaaaaaaa  cccc\nbbbb\t  dddddddd\n");
+
+    scene
+        .ucmd()
+        .args(&["-x", "-w18", "-T2"])
+        .succeeds()
+        .stdout_is("aaaaaaaa\tbbbb\ncccc\t\t\tdddddddd\n");
+
+    scene
+        .ucmd()
+        .args(&["-C", "-w18", "-T2"])
         .succeeds()
-        .stdout_is("aaaaaaaa bbbb\ncccc\t dddddddd");
+        .stdout_is("aaaaaaaa\tcccc\nbbbb\t\t\tdddddddd\n");
 
-    ucmd.args(&["-T", "2"])
+    scene
+        .ucmd()
+        .args(&["-x", "-w18", "-T0"])
         .succeeds()
-        .stdout_is("aaaaaaaa bbbb\ncccc\t\t dddddddd");
+        .stdout_is("aaaaaaaa  bbbb\ncccc      dddddddd\n");
 
     // use spaces
-    ucmd.args(&["-T", "0"])
+    scene
+        .ucmd()
+        .args(&["-C", "-w18", "-T0"])
         .succeeds()
-        .stdout_is("aaaaaaaa bbbb\ncccc     dddddddd");
+        .stdout_is("aaaaaaaa  cccc\nbbbb      dddddddd\n");
 }
 
 #[cfg(any(
@@ -3482,8 +4461,8 @@ fn test_device_number() {
     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 (major, minor) = (major(blk_dev_number), minor(blk_dev_number));
+    let major_minor_str = format!("{major}, {minor}");
 
     let scene = TestScenario::new(util_name!());
     scene
@@ -3503,3 +4482,1237 @@ fn test_invalid_utf8() {
     at.touch(filename);
     ucmd.succeeds();
 }
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_ls_perm_io_errors() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("d");
+    at.symlink_file("/", "d/s");
+    at.touch("d/f");
+
+    scene.ccmd("chmod").arg("600").arg("d").succeeds();
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("d")
+        .fails_with_code(1)
+        .stderr_contains("Permission denied")
+        .stdout_contains("total 0")
+        .stdout_contains("l????????? ? ? ? ?            ? s")
+        .stdout_contains("-????????? ? ? ? ?            ? f");
+}
+
+#[test]
+fn test_ls_dired_implies_long() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("--dired")
+        .succeeds()
+        .stdout_does_not_contain("//DIRED//")
+        .stdout_contains("  total 0")
+        .stdout_contains("//DIRED-OPTIONS// --quoting-style");
+}
+
+#[test]
+fn test_ls_dired_hyperlink() {
+    // we will have link but not the DIRED output
+    // note that the order matters
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("dir");
+    at.touch("dir/a");
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("--hyperlink")
+        .arg("-R")
+        .succeeds()
+        .stdout_contains("file://")
+        .stdout_contains("-rw") // we should have the long output
+        // even if dired isn't actually run
+        .stdout_does_not_contain("//DIRED//");
+    // dired is passed after hyperlink
+    // so we will have DIRED output
+    scene
+        .ucmd()
+        .arg("--hyperlink")
+        .arg("--dired")
+        .arg("-R")
+        .succeeds()
+        .stdout_does_not_contain("file://")
+        .stdout_contains("//DIRED//");
+}
+
+#[test]
+fn test_ls_dired_order_format() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("dir");
+    at.touch("dir/a");
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("--format=vertical")
+        .arg("-R")
+        .succeeds()
+        .stdout_does_not_contain("//DIRED//");
+    scene
+        .ucmd()
+        .arg("--format=vertical")
+        .arg("--dired")
+        .arg("-R")
+        .succeeds()
+        .stdout_contains("//DIRED//");
+}
+
+#[test]
+fn test_ls_dired_and_zero_are_incompatible() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("-l")
+        .arg("--zero")
+        .fails_with_code(2)
+        .stderr_contains("--dired and --zero are incompatible");
+}
+
+#[test]
+fn test_ls_dired_recursive() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("-l")
+        .arg("-R")
+        .succeeds()
+        .stdout_does_not_contain("//DIRED//")
+        .stdout_contains("  total 0")
+        .stdout_contains("//SUBDIRED// 2 3")
+        .stdout_contains("//DIRED-OPTIONS// --quoting-style");
+}
+
+#[test]
+fn test_ls_dired_outputs_parent_offset() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("dir");
+    at.mkdir("dir/a");
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("dir")
+        .arg("-R")
+        .succeeds()
+        .stdout_contains("//DIRED//");
+}
+
+#[test]
+fn test_ls_dired_outputs_same_date_time_format() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("dir");
+    at.mkdir("dir/a");
+    let binding = scene.ucmd().arg("-l").arg("dir").succeeds();
+    let long_output_str = binding.stdout_str();
+    let split_lines: Vec<&str> = long_output_str.split('\n').collect();
+    // the second line should contain the long output which includes date
+    let list_line = split_lines.get(1).unwrap();
+    // should be same as the dired output
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("dir")
+        .arg("-R")
+        .succeeds()
+        .stdout_contains(list_line);
+}
+
+#[test]
+fn test_ls_dired_recursive_multiple() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("d");
+    at.mkdir("d/d1");
+    at.mkdir("d/d2");
+    at.touch("d/d2/a");
+    at.touch("d/d2/c2");
+    at.touch("d/d1/f1");
+    at.touch("d/d1/file-long");
+
+    let mut cmd = scene.ucmd();
+    cmd.arg("--dired").arg("-l").arg("-R").arg("d");
+
+    let result = cmd.succeeds();
+
+    let output = result.stdout_str().to_string();
+    println!("Output:\n{output}");
+
+    let dired_line = output
+        .lines()
+        .find(|&line| line.starts_with("//DIRED//"))
+        .unwrap();
+    let positions: Vec<usize> = dired_line
+        .split_whitespace()
+        .skip(1)
+        .map(|s| s.parse().unwrap())
+        .collect();
+    println!("Parsed byte positions: {positions:?}");
+    assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
+
+    let filenames: Vec<String> = positions
+        .chunks(2)
+        .map(|chunk| {
+            let start_pos = chunk[0];
+            let end_pos = chunk[1];
+            let filename = String::from_utf8(output.as_bytes()[start_pos..=end_pos].to_vec())
+                .unwrap()
+                .trim()
+                .to_string();
+            println!("Extracted filename: {filename}");
+            filename
+        })
+        .collect();
+
+    println!("Extracted filenames: {filenames:?}");
+    assert_eq!(filenames, vec!["d1", "d2", "f1", "file-long", "a", "c2"]);
+}
+
+#[test]
+fn test_ls_dired_simple() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    scene
+        .ucmd()
+        .arg("--dired")
+        .arg("-l")
+        .succeeds()
+        .stdout_contains("  total 0");
+
+    at.mkdir("d");
+    at.touch("d/a1");
+    let mut cmd = scene.ucmd();
+    cmd.arg("--dired").arg("-l").arg("d");
+    let result = cmd.succeeds();
+    result.stdout_contains("  total 0");
+    println!("    result.stdout = {:#?}", result.stdout_str());
+
+    let dired_line = result
+        .stdout_str()
+        .lines()
+        .find(|&line| line.starts_with("//DIRED//"))
+        .unwrap();
+    let positions: Vec<usize> = dired_line
+        .split_whitespace()
+        .skip(1)
+        .map(|s| s.parse().unwrap())
+        .collect();
+
+    assert_eq!(positions.len(), 2);
+
+    let start_pos = positions[0];
+    let end_pos = positions[1];
+
+    // Extract the filename using the positions
+    let filename =
+        String::from_utf8(result.stdout_str().as_bytes()[start_pos..end_pos].to_vec()).unwrap();
+
+    assert_eq!(filename, "a1");
+}
+
+#[test]
+fn test_ls_dired_complex() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("d");
+    at.mkdir("d/d");
+    at.touch("d/a1");
+    at.touch("d/a22");
+    at.touch("d/a333");
+    at.touch("d/a4444");
+
+    let mut cmd = scene.ucmd();
+    cmd.arg("--dired").arg("-l").arg("d");
+    let result = cmd.succeeds();
+
+    // Number of blocks. We run this test only if the default size of a newly created directory is
+    // 4096 bytes to prevent it from failing where this is not the case (e.g. using tmpfs for /tmp).
+    #[cfg(target_os = "linux")]
+    if at.metadata("d/d").len() == 4096 {
+        result.stdout_contains("  total 4");
+    }
+
+    let output = result.stdout_str().to_string();
+    println!("Output:\n{output}");
+
+    let dired_line = output
+        .lines()
+        .find(|&line| line.starts_with("//DIRED//"))
+        .unwrap();
+    let positions: Vec<usize> = dired_line
+        .split_whitespace()
+        .skip(1)
+        .map(|s| s.parse().unwrap())
+        .collect();
+    println!("{positions:?}");
+    println!("Parsed byte positions: {positions:?}");
+    assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
+
+    let filenames: Vec<String> = positions
+        .chunks(2)
+        .map(|chunk| {
+            let start_pos = chunk[0];
+            let end_pos = chunk[1];
+            let filename = String::from_utf8(output.as_bytes()[start_pos..=end_pos].to_vec())
+                .unwrap()
+                .trim()
+                .to_string();
+            println!("Extracted filename: {filename}");
+            filename
+        })
+        .collect();
+
+    println!("Extracted filenames: {filenames:?}");
+    assert_eq!(filenames, vec!["a1", "a22", "a333", "a4444", "d"]);
+}
+
+#[test]
+fn test_ls_subdired_complex() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("dir1");
+    at.mkdir("dir1/d");
+    at.mkdir("dir1/c2");
+    at.touch("dir1/a1");
+    at.touch("dir1/a22");
+    at.touch("dir1/a333");
+    at.touch("dir1/c2/a4444");
+
+    let mut cmd = scene.ucmd();
+    cmd.arg("--dired").arg("-l").arg("-R").arg("dir1");
+    let result = cmd.succeeds();
+
+    let output = result.stdout_str().to_string();
+    println!("Output:\n{output}");
+
+    let dired_line = output
+        .lines()
+        .find(|&line| line.starts_with("//SUBDIRED//"))
+        .unwrap();
+    let positions: Vec<usize> = dired_line
+        .split_whitespace()
+        .skip(1)
+        .map(|s| s.parse().unwrap())
+        .collect();
+    println!("Parsed byte positions: {positions:?}");
+    assert_eq!(positions.len() % 2, 0); // Ensure there's an even number of positions
+
+    let dirnames: Vec<String> = positions
+        .chunks(2)
+        .map(|chunk| {
+            let start_pos = chunk[0];
+            let end_pos = chunk[1];
+            let dirname =
+                String::from_utf8(output.as_bytes()[start_pos..end_pos].to_vec()).unwrap();
+            println!("Extracted dirname: {dirname}");
+            dirname
+        })
+        .collect();
+
+    println!("Extracted dirnames: {dirnames:?}");
+    #[cfg(unix)]
+    assert_eq!(dirnames, vec!["dir1", "dir1/c2", "dir1/d"]);
+    #[cfg(windows)]
+    assert_eq!(dirnames, vec!["dir1", "dir1\\c2", "dir1\\d"]);
+}
+
+#[test]
+fn test_ls_cf_output_should_be_delimited_by_tab() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("e");
+    at.mkdir("e/a2345");
+    at.mkdir("e/b");
+
+    ucmd.args(&["-CF", "e"])
+        .succeeds()
+        .stdout_is("a2345/\tb/\n");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_posixly_correct_and_block_size_env_vars() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("POSIXLY_CORRECT", "some_value")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 1024 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("LS_BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .env("BLOCKSIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 8")
+        .stdout_contains(" 1024 ");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_posixly_correct_and_block_size_env_vars_with_k() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("POSIXLY_CORRECT", "some_value")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("LS_BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("BLOCK_SIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 2 ");
+
+    scene
+        .ucmd()
+        .arg("-l")
+        .arg("-k")
+        .env("BLOCKSIZE", "512")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+}
+
+#[test]
+fn test_ls_invalid_block_size() {
+    new_ucmd!()
+        .arg("--block-size=invalid")
+        .fails_with_code(2)
+        .no_stdout()
+        .stderr_is("ls: invalid --block-size argument 'invalid'\n");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_ls_invalid_block_size_in_env_var() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    scene
+        .ucmd()
+        .arg("-og")
+        .env("LS_BLOCK_SIZE", "invalid")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1 1 "); // hardlink count + file size
+
+    scene
+        .ucmd()
+        .arg("-og")
+        .env("BLOCK_SIZE", "invalid")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1 1 "); // hardlink count + file size
+
+    scene
+        .ucmd()
+        .arg("-og")
+        .env("BLOCKSIZE", "invalid")
+        .succeeds()
+        .stdout_contains_line("total 4")
+        .stdout_contains(" 1024 ");
+}
+
+#[cfg(all(unix, feature = "dd"))]
+#[test]
+#[cfg(not(target_os = "openbsd"))]
+fn test_ls_block_size_override() {
+    let scene = TestScenario::new(util_name!());
+
+    scene
+        .ccmd("dd")
+        .arg("if=/dev/zero")
+        .arg("of=file")
+        .arg("bs=1024")
+        .arg("count=1")
+        .succeeds();
+
+    // --si "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--block-size=512")
+        .arg("--si")
+        .succeeds()
+        .stdout_contains_line("total 4.1k");
+
+    // --block-size "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--si")
+        .arg("--block-size=512")
+        .succeeds()
+        .stdout_contains_line("total 8");
+
+    // --human-readable "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--block-size=512")
+        .arg("--human-readable")
+        .succeeds()
+        .stdout_contains_line("total 4.0K");
+
+    // --block-size "wins"
+    scene
+        .ucmd()
+        .arg("-s")
+        .arg("--human-readable")
+        .arg("--block-size=512")
+        .succeeds()
+        .stdout_contains_line("total 8");
+}
+
+#[test]
+fn test_ls_block_size_override_self() {
+    new_ucmd!()
+        .arg("--block-size=512")
+        .arg("--block-size=512")
+        .succeeds();
+
+    new_ucmd!()
+        .arg("--human-readable")
+        .arg("--human-readable")
+        .succeeds();
+
+    new_ucmd!().arg("--si").arg("--si").succeeds();
+}
+
+#[test]
+fn test_ls_hyperlink() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let file = "a.txt";
+
+    at.touch(file);
+
+    let path = at.root_dir_resolved();
+    let separator = std::path::MAIN_SEPARATOR_STR;
+
+    let result = scene.ucmd().arg("--hyperlink").succeeds();
+    assert!(result.stdout_str().contains("\x1b]8;;file://"));
+    assert!(
+        result
+            .stdout_str()
+            .contains(&format!("{path}{separator}{file}\x07{file}\x1b]8;;\x07"))
+    );
+
+    let result = scene.ucmd().arg("--hyperlink=always").succeeds();
+    assert!(result.stdout_str().contains("\x1b]8;;file://"));
+    assert!(
+        result
+            .stdout_str()
+            .contains(&format!("{path}{separator}{file}\x07{file}\x1b]8;;\x07"))
+    );
+
+    for argument in [
+        "--hyperlink=never",
+        "--hyperlink=neve", // spell-checker:disable-line
+        "--hyperlink=ne",
+        "--hyperlink=n",
+    ] {
+        scene
+            .ucmd()
+            .arg(argument)
+            .succeeds()
+            .stdout_is(format!("{file}\n"));
+    }
+}
+
+// spell-checker: disable
+#[test]
+fn test_ls_hyperlink_encode_link() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        at.touch("back\\slash");
+        at.touch("ques?tion");
+    }
+    at.touch("encoded%3Fquestion");
+    at.touch("sp ace");
+
+    let result = ucmd.arg("--hyperlink").succeeds();
+    #[cfg(not(target_os = "windows"))]
+    {
+        assert!(
+            result
+                .stdout_str()
+                .contains("back%5cslash\x07back\\slash\x1b]8;;\x07")
+        );
+        assert!(
+            result
+                .stdout_str()
+                .contains("ques%3ftion\x07ques?tion\x1b]8;;\x07")
+        );
+    }
+    assert!(
+        result
+            .stdout_str()
+            .contains("encoded%253Fquestion\x07encoded%3Fquestion\x1b]8;;\x07")
+    );
+    assert!(
+        result
+            .stdout_str()
+            .contains("sp%20ace\x07sp ace\x1b]8;;\x07")
+    );
+}
+// spell-checker: enable
+
+#[test]
+fn test_ls_hyperlink_dirs() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dir_a = "a";
+    let dir_b = "b";
+
+    at.mkdir(dir_a);
+    at.mkdir(dir_b);
+
+    let path = at.root_dir_resolved();
+    let separator = std::path::MAIN_SEPARATOR_STR;
+
+    let result = scene
+        .ucmd()
+        .arg("--hyperlink")
+        .arg(dir_a)
+        .arg(dir_b)
+        .succeeds();
+
+    assert!(result.stdout_str().contains("\x1b]8;;file://"));
+    assert!(
+        result
+            .stdout_str()
+            .lines()
+            .next()
+            .unwrap()
+            .contains(&format!("{path}{separator}{dir_a}\x07{dir_a}\x1b]8;;\x07:"))
+    );
+    assert_eq!(result.stdout_str().lines().nth(1).unwrap(), "");
+    assert!(
+        result
+            .stdout_str()
+            .lines()
+            .nth(2)
+            .unwrap()
+            .contains(&format!("{path}{separator}{dir_b}\x07{dir_b}\x1b]8;;\x07:"))
+    );
+}
+
+#[test]
+fn test_ls_hyperlink_recursive_dirs() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let path = at.root_dir_resolved();
+    let separator = std::path::MAIN_SEPARATOR_STR;
+
+    let dir_a = "a";
+    let dir_b = "b";
+    at.mkdir(dir_a);
+    at.mkdir(format!("{dir_a}/{dir_b}"));
+
+    let result = scene
+        .ucmd()
+        .arg("--hyperlink")
+        .arg("--recursive")
+        .arg(dir_a)
+        .succeeds();
+
+    macro_rules! assert_hyperlink {
+        ($line:expr, $expected:expr) => {
+            assert!(matches!($line, Some(l) if l.starts_with("\x1b]8;;file://") && l.ends_with($expected)));
+        };
+    }
+
+    let mut lines = result.stdout_str().lines();
+    assert_hyperlink!(
+        lines.next(),
+        &format!("{path}{separator}{dir_a}\x07{dir_a}\x1b]8;;\x07:")
+    );
+    assert_hyperlink!(
+        lines.next(),
+        &format!("{path}{separator}{dir_a}{separator}{dir_b}\x07{dir_b}\x1b]8;;\x07")
+    );
+    assert!(matches!(lines.next(), Some(l) if l.is_empty()));
+    assert_hyperlink!(
+        lines.next(),
+        &format!(
+            "{path}{separator}{dir_a}{separator}{dir_b}\x07{dir_a}{separator}{dir_b}\x1b]8;;\x07:"
+        )
+    );
+}
+
+#[test]
+fn test_ls_color_do_not_reset() {
+    let scene: TestScenario = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("example");
+    at.mkdir("example/a");
+    at.mkdir("example/b");
+
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .arg("example/")
+        .succeeds();
+    // the second color code should not have a reset
+    assert_eq!(
+        result.stdout_str().escape_default().to_string(),
+        "\\u{1b}[0m\\u{1b}[01;34ma\\u{1b}[0m\\n\\u{1b}[01;34mb\\u{1b}[0m\\n"
+    );
+}
+
+#[cfg(all(unix, feature = "chmod"))]
+#[test]
+fn test_term_colorterm() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("exe");
+    scene.ccmd("chmod").arg("+x").arg("exe").succeeds();
+
+    // Should show colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("TERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "\\u{1b}[0m\\u{1b}[01;32mexe\\u{1b}[0m"
+    );
+
+    // Should show colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("COLORTERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "\\u{1b}[0m\\u{1b}[01;32mexe\\u{1b}[0m"
+    );
+
+    // No colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("TERM", "")
+        .env("COLORTERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "exe"
+    );
+
+    // No colors
+    let result = scene
+        .ucmd()
+        .arg("--color=always")
+        .env("LS_COLORS", "")
+        .env("TERM", "dumb")
+        .env("COLORTERM", "")
+        .succeeds();
+    assert_eq!(
+        result.stdout_str().trim().escape_default().to_string(),
+        "exe"
+    );
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+#[test]
+fn test_acl_display() {
+    use std::process::Command;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("with_acl");
+    let path_with_acl = at.plus_as_string("with_acl");
+    at.mkdir("without_acl");
+
+    // calling the command directly. xattr requires some dev packages to be installed
+    // and it adds a complex dependency just for a test
+    match Command::new("setfacl")
+        .args(["-d", "-m", "group::rwx", &path_with_acl])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfacl failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfacl failed with {e}");
+            return;
+        }
+    }
+
+    // Expected output (we just look for `+` presence and absence in the first column):
+    // ...
+    // drwxr-xr-x+  2 user group   40 Apr 21 12:44 with_acl
+    // drwxr-xr-x  2 user group   40 Apr 21 12:44 without_acl
+    let re_with_acl = Regex::new(r"[a-z-]*\+ .*with_acl").unwrap();
+    let re_without_acl = Regex::new(r"[a-z-]* .*without_acl").unwrap();
+
+    scene
+        .ucmd()
+        .args(&["-la", &at.as_string()])
+        .succeeds()
+        .stdout_matches(&re_with_acl)
+        .stdout_matches(&re_without_acl);
+}
+
+// Make sure that "ls --color" correctly applies color "normal" to text and
+// files. Specifically, it should use the NORMAL setting to format non-file name
+// output and file names that don't have a designated color (unless the FILE
+// setting is also configured).
+#[cfg(unix)]
+#[test]
+#[cfg(not(feature = "feat_selinux"))]
+// Disabled on the SELinux runner for now
+fn test_ls_color_norm() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("exe");
+    at.set_mode("exe", 0o755);
+    at.touch("no_color");
+    at.set_mode("no_color", 0o444);
+    let colors = "no=7:ex=01;32";
+    let strip = |input: &str| {
+        let re = Regex::new(r"-r.*norm").unwrap();
+        re.replace_all(input, "norm").to_string()
+    };
+
+    //  Uncolored file names should inherit NORMAL attributes.
+    let expected = "\x1b[0m\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n\x1b[07mnorm no_color\x1b[0m"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", colors)
+        .env("TIME_STYLE", "+norm")
+        .arg("-gGU")
+        .arg("--color")
+        .arg("exe")
+        .arg("no_color")
+        .succeeds()
+        .stdout_str_apply(strip)
+        .stdout_contains(expected);
+
+    let expected = "\x1b[0m\x1b[07m\x1b[0m\x1b[01;32mexe\x1b[0m  \x1b[07mno_color\x1b[0m\n"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", colors)
+        .env("TIME_STYLE", "+norm")
+        .arg("-xU")
+        .arg("--color")
+        .arg("exe")
+        .arg("no_color")
+        .succeeds()
+        .stdout_contains(expected);
+
+    let expected =
+        "\x1b[0m\x1b[07mnorm no_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+
+    scene
+        .ucmd()
+        .env("LS_COLORS", colors)
+        .env("TIME_STYLE", "+norm")
+        .arg("-gGU")
+        .arg("--color")
+        .arg("no_color")
+        .arg("exe")
+        .succeeds()
+        .stdout_str_apply(strip)
+        .stdout_contains(expected);
+
+    let expected = "\x1b[0m\x1b[07mno_color\x1b[0m  \x1b[07m\x1b[0m\x1b[01;32mexe\x1b[0m"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", colors)
+        .env("TIME_STYLE", "+norm")
+        .arg("-xU")
+        .arg("--color")
+        .arg("no_color")
+        .arg("exe")
+        .succeeds()
+        .stdout_contains(expected);
+
+    //  NORMAL does not override FILE
+    let expected = "\x1b[0m\x1b[07mnorm \x1b[0m\x1b[01mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", format!("{colors}:fi=1"))
+        .env("TIME_STYLE", "+norm")
+        .arg("-gGU")
+        .arg("--color")
+        .arg("no_color")
+        .arg("exe")
+        .succeeds()
+        .stdout_str_apply(strip)
+        .stdout_contains(expected);
+
+    // uncolored ordinary files that do _not_ inherit from NORMAL.
+    let expected =
+        "\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", format!("{colors}:fi="))
+        .env("TIME_STYLE", "+norm")
+        .arg("-gGU")
+        .arg("--color")
+        .arg("no_color")
+        .arg("exe")
+        .succeeds()
+        .stdout_str_apply(strip)
+        .stdout_contains(expected);
+
+    let expected =
+        "\x1b[0m\x1b[07mnorm \x1b[0mno_color\x1b[0m\n\x1b[07mnorm \x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", format!("{colors}:fi=0"))
+        .env("TIME_STYLE", "+norm")
+        .arg("-gGU")
+        .arg("--color")
+        .arg("no_color")
+        .arg("exe")
+        .succeeds()
+        .stdout_str_apply(strip)
+        .stdout_contains(expected);
+
+    //  commas (-m), indicator chars (-F) and the "total" line, do not currently
+    //  use NORMAL attributes
+    let expected = "\x1b[0m\x1b[07mno_color\x1b[0m, \x1b[07m\x1b[0m\x1b[01;32mexe\x1b[0m\n"; // spell-checker:disable-line
+    scene
+        .ucmd()
+        .env("LS_COLORS", colors)
+        .env("TIME_STYLE", "+norm")
+        .arg("-mU")
+        .arg("--color")
+        .arg("no_color")
+        .arg("exe")
+        .succeeds()
+        .stdout_contains(expected);
+}
+
+#[test]
+fn test_ls_color_clear_to_eol() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    // we create file with a long name
+    at.touch("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.foo");
+    let result = scene
+        .ucmd()
+        .env("TERM", "xterm")
+        // set the columns to something small so that the text would wrap around
+        .env("COLUMNS", "80")
+        // set the background to green and text to red
+        .env("LS_COLORS", "*.foo=0;31;42")
+        .env("TIME_STYLE", "+T")
+        .arg("-og")
+        .arg("--color")
+        .arg("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.foo")
+        .succeeds();
+    // check that the wrapped name contains clear to end of line code
+    // cspell:disable-next-line
+    result.stdout_contains("\x1b[0m\x1b[31;42mzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.foo\x1b[0m\x1b[K");
+}
+
+#[test]
+fn test_suffix_case_sensitivity() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("img1.jpg");
+    at.touch("IMG2.JPG");
+    at.touch("img3.JpG");
+    at.touch("file1.z");
+    at.touch("file2.Z");
+
+    // *.jpg is specified only once so any suffix that has .jpg should match
+    // without caring about the letter case
+    let result = scene
+        .ucmd()
+        .env("LS_COLORS", "*.jpg=01;35:*.Z=01;31")
+        .arg("-U1")
+        .arg("--color=always")
+        .arg("img1.jpg")
+        .arg("IMG2.JPG")
+        .arg("file1.z")
+        .arg("file2.Z")
+        .succeeds();
+    result.stdout_contains(
+        /* cSpell:disable */
+        "\x1b[0m\x1b[01;35mimg1.jpg\x1b[0m\n\
+                \x1b[01;35mIMG2.JPG\x1b[0m\n\
+                \x1b[01;31mfile1.z\x1b[0m\n\
+                \x1b[01;31mfile2.Z\x1b[0m",
+        /* cSpell:enable */
+    );
+
+    // *.jpg is specified more than once with different cases and style, so
+    // case should matter here
+    let result = scene
+        .ucmd()
+        .env("LS_COLORS", "*.jpg=01;35:*.JPG=01;35;46")
+        .arg("-U1")
+        .arg("--color=always")
+        .arg("img1.jpg")
+        .arg("IMG2.JPG")
+        .arg("img3.JpG")
+        .succeeds();
+    result.stdout_contains(
+        /* cSpell:disable */
+        "\x1b[0m\x1b[01;35mimg1.jpg\x1b[0m\n\
+                \x1b[01;35;46mIMG2.JPG\x1b[0m\n\
+                img3.JpG",
+        /* cSpell:enable */
+    );
+
+    // *.jpg is specified more than once with different cases but style is same, so
+    // case can ignored
+    let result = scene
+        .ucmd()
+        .env("LS_COLORS", "*.jpg=01;35:*.JPG=01;35")
+        .arg("-U1")
+        .arg("--color=always")
+        .arg("img1.jpg")
+        .arg("IMG2.JPG")
+        .arg("img3.JpG")
+        .succeeds();
+    result.stdout_contains(
+        /* cSpell:disable */
+        "\x1b[0m\x1b[01;35mimg1.jpg\x1b[0m\n\
+                \x1b[01;35mIMG2.JPG\x1b[0m\n\
+                \x1b[01;35mimg3.JpG\x1b[0m",
+        /* cSpell:enable */
+    );
+
+    // last *.jpg gets more priority resulting in same style across
+    // different cases specified, so case can ignored
+    let result = scene
+        .ucmd()
+        .env("LS_COLORS", "*.jpg=01;35:*.jpg=01;35;46:*.JPG=01;35;46")
+        .arg("-U1")
+        .arg("--color=always")
+        .arg("img1.jpg")
+        .arg("IMG2.JPG")
+        .arg("img3.JpG")
+        .succeeds();
+    result.stdout_contains(
+        /* cSpell:disable */
+        "\x1b[0m\x1b[01;35;46mimg1.jpg\x1b[0m\n\
+                \x1b[01;35;46mIMG2.JPG\x1b[0m\n\
+                \x1b[01;35;46mimg3.JpG\x1b[0m",
+        /* cSpell:enable */
+    );
+
+    // last *.jpg gets more priority resulting in different style across
+    // different cases specified, so case matters
+    let result = scene
+        .ucmd()
+        .env("LS_COLORS", "*.jpg=01;35;46:*.jpg=01;35:*.JPG=01;35;46")
+        .arg("-U1")
+        .arg("--color=always")
+        .arg("img1.jpg")
+        .arg("IMG2.JPG")
+        .arg("img3.JpG")
+        .succeeds();
+    result.stdout_contains(
+        /* cSpell:disable */
+        "\x1b[0m\x1b[01;35mimg1.jpg\x1b[0m\n\
+                \x1b[01;35;46mIMG2.JPG\x1b[0m\n\
+                img3.JpG",
+        /* cSpell:enable */
+    );
+}
+
+#[cfg(all(unix, target_os = "linux"))]
+#[test]
+fn test_ls_capabilities() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    // Test must be run as root (or with `sudo -E`)
+    // fakeroot setcap cap_net_bind_service=ep /tmp/file_name
+    // doesn't trigger an error and fails silently
+    if scene.cmd("whoami").run().stdout_str() != "root\n" {
+        return;
+    }
+    at.mkdir("test");
+    at.mkdir("test/dir");
+    at.touch("test/cap_pos");
+    at.touch("test/dir/cap_neg");
+    at.touch("test/dir/cap_pos");
+
+    let files = ["test/cap_pos", "test/dir/cap_pos"];
+    for file in &files {
+        scene
+            .cmd("sudo")
+            .args(&[
+                "-E",
+                "--non-interactive",
+                "setcap",
+                "cap_net_bind_service=ep",
+                at.plus(file).to_str().unwrap(),
+            ])
+            .succeeds();
+    }
+
+    let ls_colors = "di=:ca=30;41";
+
+    scene
+        .ucmd()
+        .env("LS_COLORS", ls_colors)
+        .arg("--color=always")
+        .arg("test/cap_pos")
+        .arg("test/dir")
+        .succeeds()
+        .stdout_contains("\x1b[30;41mtest/cap_pos") // spell-checker:disable-line
+        .stdout_contains("\x1b[30;41mcap_pos") // spell-checker:disable-line
+        .stdout_does_not_contain("0;41mtest/dir/cap_neg"); // spell-checker:disable-line
+}
+
+#[cfg(feature = "test_risky_names")]
+#[test]
+fn test_non_unicode_names() {
+    // more extensive unit tests for correct escaping etc. are in the quoting_style module
+    let scene = TestScenario::new(util_name!());
+    let target_file = uucore::os_str_from_bytes(b"some-dir1/\xC0.file")
+        .expect("Only unix platforms can test non-unicode names");
+    let target_dir = uucore::os_str_from_bytes(b"some-dir1/\xC0.dir")
+        .expect("Only unix platforms can test non-unicode names");
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+    at.touch(target_file);
+    at.mkdir(target_dir);
+
+    scene
+        .ucmd()
+        .arg("--quoting-style=shell-escape")
+        .arg("some-dir1")
+        .succeeds()
+        .stdout_contains("''$'\\300''.dir'")
+        .stdout_contains("''$'\\300''.file'");
+
+    scene
+        .ucmd()
+        .arg("--quoting-style=literal")
+        .arg("--show-control-chars")
+        .arg("some-dir1")
+        .succeeds()
+        .stdout_is_bytes(b"\xC0.dir\n\xC0.file\n");
+}
+
+#[test]
+fn test_time_style_timezone_name() {
+    let re_custom_format = Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d* UTC f\n").unwrap();
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("f");
+    ucmd.env("TZ", "UTC0")
+        .args(&["-l", "--time-style=+%Z"])
+        .succeeds()
+        .stdout_matches(&re_custom_format);
+}
+
+#[test]
+fn test_unknown_format_specifier() {
+    let re_custom_format = Regex::new(r"[a-z-]* \d* [\w.]* [\w.]* \d+ \d{4} %0 \d{9} f\n").unwrap();
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("f");
+    ucmd.args(&["-l", "--time-style=+%Y %0 %N"])
+        .succeeds()
+        .stdout_matches(&re_custom_format);
+}
diff --git a/tests/by-util/test_mkdir.rs b/tests/by-util/test_mkdir.rs
index 8a6eae27bdc..56b4297caf5 100644
--- a/tests/by-util/test_mkdir.rs
+++ b/tests/by-util/test_mkdir.rs
@@ -2,47 +2,50 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore bindgen testtest
+
+#![allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+
 #[cfg(not(windows))]
-use libc::{mode_t, umask};
-use once_cell::sync::Lazy;
+use libc::mode_t;
 #[cfg(not(windows))]
 use std::os::unix::fs::PermissionsExt;
-use std::sync::Mutex;
-
-// 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(()));
+#[cfg(not(windows))]
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    let _guard = TEST_MUTEX.lock();
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_no_arg() {
+    new_ucmd!()
+        .fails_with_code(1)
+        .stderr_contains("error: the following required arguments were not provided:");
 }
 
 #[test]
 fn test_mkdir_mkdir() {
-    let _guard = TEST_MUTEX.lock();
     new_ucmd!().arg("test_dir").succeeds();
 }
 
 #[test]
 fn test_mkdir_verbose() {
-    let _guard = TEST_MUTEX.lock();
     let expected = "mkdir: created directory 'test_dir'\n";
     new_ucmd!()
         .arg("test_dir")
         .arg("-v")
-        .run()
+        .succeeds()
         .stdout_is(expected);
 }
 
 #[test]
 fn test_mkdir_dup_dir() {
-    let _guard = TEST_MUTEX.lock();
-
     let scene = TestScenario::new(util_name!());
     let test_dir = "test_dir";
 
@@ -52,32 +55,39 @@ fn test_mkdir_dup_dir() {
 
 #[test]
 fn test_mkdir_mode() {
-    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!());
     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("-p").arg("-p").arg(test_dir).succeeds();
     scene.ucmd().arg("--parent").arg(test_dir).succeeds();
+    scene
+        .ucmd()
+        .arg("--parent")
+        .arg("--parent")
+        .arg(test_dir)
+        .succeeds();
     scene.ucmd().arg("--parents").arg(test_dir).succeeds();
+    scene
+        .ucmd()
+        .arg("--parents")
+        .arg("--parents")
+        .arg(test_dir)
+        .succeeds();
 }
 
 #[test]
 fn test_mkdir_no_parent() {
-    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!());
     let test_dir = "test_dir";
 
@@ -88,13 +98,16 @@ fn test_mkdir_dup_dir_parent() {
 #[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();
+    ucmd.arg("-p")
+        .arg("a/b")
+        .umask(default_umask)
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
 
     assert!(at.dir_exists("a"));
     // parents created by -p have permissions set to "=rwx,u+wx"
@@ -108,35 +121,28 @@ fn test_mkdir_parent_mode() {
         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 parent_a_perms = at.metadata("a").permissions().mode();
 
     let default_umask: mode_t = 0o160;
-    let original_umask = unsafe { umask(default_umask) };
 
     ucmd.arg("-p")
         .arg("a/b/c")
+        .umask(default_umask)
         .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_eq!(at.metadata("a").permissions().mode(), parent_a_perms);
     assert!(at.dir_exists("a/b"));
     assert_eq!(
         at.metadata("a/b").permissions().mode() as mode_t,
@@ -147,16 +153,31 @@ fn test_mkdir_parent_mode_check_existing_parent() {
         at.metadata("a/b/c").permissions().mode() as mode_t,
         (!default_umask & 0o777) + 0o40000
     );
+}
 
-    unsafe {
-        umask(original_umask);
-    }
+#[cfg(not(windows))]
+#[test]
+fn test_mkdir_parent_mode_skip_existing_last_component_chmod() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("a");
+    at.mkdir("a/b");
+    at.set_mode("a/b", 0);
+
+    let default_umask: mode_t = 0o160;
+
+    ucmd.arg("-p")
+        .arg("a/b")
+        .umask(default_umask)
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+
+    assert_eq!(at.metadata("a/b").permissions().mode() as mode_t, 0o40000);
 }
 
 #[test]
 fn test_mkdir_dup_file() {
-    let _guard = TEST_MUTEX.lock();
-
     let scene = TestScenario::new(util_name!());
     let test_file = "test_file.txt";
 
@@ -171,7 +192,6 @@ fn test_mkdir_dup_file() {
 #[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";
 
@@ -183,24 +203,23 @@ fn test_symbolic_mode() {
 #[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";
 
     let default_umask = 0o022;
-    let original_umask = unsafe { umask(default_umask) };
 
-    ucmd.arg("-m").arg("-w").arg(test_dir).succeeds();
+    ucmd.arg("-m")
+        .arg("-w")
+        .arg(test_dir)
+        .umask(default_umask)
+        .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";
 
@@ -211,7 +230,6 @@ fn test_multi_symbolic() {
 
 #[test]
 fn test_recursive_reporting() {
-    let _guard = TEST_MUTEX.lock();
     let test_dir = "test_dir/test_dir_a/test_dir_b";
 
     new_ucmd!()
@@ -237,9 +255,62 @@ fn test_recursive_reporting() {
 }
 
 #[test]
-fn test_mkdir_trailing_dot() {
-    let _guard = TEST_MUTEX.lock();
+// Windows don't have acl entries
+// TODO Enable and modify this for macos when xattr processing for macos is added.
+// TODO Enable and modify this for freebsd when xattr processing for freebsd is enabled.
+#[cfg(target_os = "linux")]
+fn test_mkdir_acl() {
+    use std::{collections::HashMap, ffi::OsString};
 
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("a");
+
+    let mut map: HashMap<OsString, Vec<u8>> = HashMap::new();
+    // posix_acl entries are in the form of
+    // struct posix_acl_entry{
+    //  tag: u16,
+    //  perm: u16,
+    //  id: u32,
+    // }
+    // the fields are serialized in little endian.
+    // The entries are preceded by a header of value of 0x0002
+    // Reference: `<https://github.com/torvalds/linux/blob/master/include/uapi/linux/posix_acl_xattr.h>`
+    // The id is undefined i.e. -1 which in u32 is 0xFFFFFFFF and tag and perm bits as given in the
+    // header file.
+    // Reference: `<https://github.com/torvalds/linux/blob/master/include/uapi/linux/posix_acl.h>`
+    //
+    //
+    // There is a bindgen bug which generates the ACL_OTHER constant whose value is 0x20 into 32.
+    // which when the bug is fixed will need to be changed back to 20 from 32 in the vec 'xattr_val'.
+    //
+    // Reference `<https://github.com/rust-lang/rust-bindgen/issues/2926>`
+    //
+    // The xattr_val vector is the header 0x0002 followed by tag and permissions for user_obj , tag
+    // and permissions and for group_obj and finally the tag and permissions for ACL_OTHER. Each
+    // entry has undefined id as mentioned above.
+    //
+    //
+
+    let xattr_val: Vec<u8> = vec![
+        2, 0, 0, 0, 1, 0, 7, 0, 255, 255, 255, 255, 4, 0, 7, 0, 255, 255, 255, 255, 32, 0, 5, 0,
+        255, 255, 255, 255,
+    ];
+
+    map.insert(OsString::from("system.posix_acl_default"), xattr_val);
+
+    uucore::fsxattr::apply_xattrs(at.plus("a"), map).unwrap();
+
+    ucmd.arg("-p").arg("a/b").umask(0x077).succeeds();
+
+    let perms = at.metadata("a/b").permissions().mode();
+
+    // 0x770 would be user:rwx,group:rwx permissions
+    assert_eq!(perms, 16893);
+}
+
+#[test]
+fn test_mkdir_trailing_dot() {
     new_ucmd!().arg("-p").arg("-v").arg("test_dir").succeeds();
 
     new_ucmd!()
@@ -265,20 +336,13 @@ 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_dir).succeeds();
+        ucmd.arg(test_dir).umask(umask_set).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 {
-            umask(original_umask);
-        } // set umask back to original
     }
 
     for i in 0o0..0o027 {
@@ -286,3 +350,68 @@ fn test_umask_compliance() {
         test_single_case(i as mode_t);
     }
 }
+
+#[test]
+fn test_empty_argument() {
+    new_ucmd!()
+        .arg("")
+        .fails()
+        .stderr_only("mkdir: cannot create directory '': No such file or directory\n");
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_selinux() {
+    use std::process::Command;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dest = "test_dir_a";
+    let args = ["-Z", "--context=unconfined_u:object_r:user_tmp_t:s0"];
+    for arg in args {
+        new_ucmd!()
+            .arg(arg)
+            .arg("-v")
+            .arg(at.plus_as_string(dest))
+            .succeeds()
+            .stdout_contains("created directory");
+
+        let getfattr_output = Command::new("getfattr")
+            .arg(at.plus_as_string(dest))
+            .arg("-n")
+            .arg("security.selinux")
+            .output()
+            .expect("Failed to run `getfattr` on the destination file");
+
+        assert!(
+            getfattr_output.status.success(),
+            "getfattr did not run successfully: {}",
+            String::from_utf8_lossy(&getfattr_output.stderr)
+        );
+
+        let stdout = String::from_utf8_lossy(&getfattr_output.stdout);
+        assert!(
+            stdout.contains("unconfined_u"),
+            "Expected '{}' not found in getfattr output:\n{}",
+            "unconfined_u",
+            stdout
+        );
+        at.rmdir(dest);
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_selinux_invalid() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dest = "test_dir_a";
+    new_ucmd!()
+        .arg("--context=testtest")
+        .arg(at.plus_as_string(dest))
+        .fails()
+        .no_stdout()
+        .stderr_contains("failed to set default file creation context to 'testtest':");
+    // invalid context, so, no directory
+    assert!(!at.dir_exists(dest));
+}
diff --git a/tests/by-util/test_mkfifo.rs b/tests/by-util/test_mkfifo.rs
index 731b6c1d5cd..721b559ae36 100644
--- a/tests/by-util/test_mkfifo.rs
+++ b/tests/by-util/test_mkfifo.rs
@@ -2,11 +2,16 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore nconfined
+
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -52,3 +57,112 @@ fn test_create_one_fifo_already_exists() {
         .fails()
         .stderr_is("mkfifo: cannot create fifo 'abcdef': File exists\n");
 }
+
+#[test]
+fn test_create_fifo_with_mode_and_umask() {
+    use uucore::fs::display_permissions;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let test_fifo_creation = |mode: &str, umask: u16, expected: &str| {
+        scene
+            .ucmd()
+            .arg("-m")
+            .arg(mode)
+            .arg(format!("fifo_test_{mode}"))
+            .umask(libc::mode_t::from(umask))
+            .succeeds();
+
+        let metadata = std::fs::metadata(at.subdir.join(format!("fifo_test_{mode}"))).unwrap();
+        let permissions = display_permissions(&metadata, true);
+        assert_eq!(permissions, expected.to_string());
+    };
+
+    test_fifo_creation("734", 0o077, "prwx-wxr--"); // spell-checker:disable-line
+    test_fifo_creation("706", 0o777, "prwx---rw-"); // spell-checker:disable-line
+}
+
+#[test]
+fn test_create_fifo_with_umask() {
+    use uucore::fs::display_permissions;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let test_fifo_creation = |umask: u16, expected: &str| {
+        scene
+            .ucmd()
+            .arg("fifo_test")
+            .umask(libc::mode_t::from(umask))
+            .succeeds();
+
+        let metadata = std::fs::metadata(at.subdir.join("fifo_test")).unwrap();
+        let permissions = display_permissions(&metadata, true);
+        assert_eq!(permissions, expected.to_string());
+        at.remove("fifo_test");
+    };
+
+    test_fifo_creation(0o022, "prw-r--r--"); // spell-checker:disable-line
+    test_fifo_creation(0o777, "p---------"); // spell-checker:disable-line
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_mkfifo_selinux() {
+    use std::process::Command;
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dest = "test_file";
+    let args = [
+        "-Z",
+        "--context",
+        "--context=unconfined_u:object_r:user_tmp_t:s0",
+    ];
+    for arg in args {
+        ts.ucmd().arg(arg).arg(dest).succeeds();
+        assert!(at.is_fifo("test_file"));
+
+        let getfattr_output = Command::new("getfattr")
+            .arg(at.plus_as_string(dest))
+            .arg("-n")
+            .arg("security.selinux")
+            .output()
+            .expect("Failed to run `getfattr` on the destination file");
+        println!("{:?}", getfattr_output);
+        assert!(
+            getfattr_output.status.success(),
+            "getfattr did not run successfully: {}",
+            String::from_utf8_lossy(&getfattr_output.stderr)
+        );
+
+        let stdout = String::from_utf8_lossy(&getfattr_output.stdout);
+        assert!(
+            stdout.contains("unconfined_u"),
+            "Expected 'foo' not found in getfattr output:\n{stdout}"
+        );
+        at.remove(&at.plus_as_string(dest));
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_mkfifo_selinux_invalid() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dest = "orig";
+
+    let args = [
+        "--context=a",
+        "--context=unconfined_u:object_r:user_tmp_t:s0:a",
+        "--context=nconfined_u:object_r:user_tmp_t:s0",
+    ];
+    for arg in args {
+        new_ucmd!()
+            .arg(arg)
+            .arg(dest)
+            .fails()
+            .stderr_contains("failed to");
+        if at.file_exists(dest) {
+            at.remove(dest);
+        }
+    }
+}
diff --git a/tests/by-util/test_mknod.rs b/tests/by-util/test_mknod.rs
index 2d83d250d84..daefe6cdadc 100644
--- a/tests/by-util/test_mknod.rs
+++ b/tests/by-util/test_mknod.rs
@@ -2,15 +2,22 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore nconfined
+
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
-#[cfg(not(windows))]
-fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+fn test_mknod_invalid_arg() {
+    new_ucmd!()
+        .arg("--foo")
+        .fails_with_code(1)
+        .no_stdout()
+        .stderr_contains("unexpected argument '--foo' found");
 }
 
-#[cfg(not(windows))]
 #[test]
 fn test_mknod_help() {
     new_ucmd!()
@@ -21,18 +28,18 @@ fn test_mknod_help() {
 }
 
 #[test]
-#[cfg(not(windows))]
 fn test_mknod_version() {
-    assert!(new_ucmd!()
-        .arg("--version")
-        .succeeds()
-        .no_stderr()
-        .stdout_str()
-        .starts_with("mknod"));
+    assert!(
+        new_ucmd!()
+            .arg("--version")
+            .succeeds()
+            .no_stderr()
+            .stdout_str()
+            .starts_with("mknod")
+    );
 }
 
 #[test]
-#[cfg(not(windows))]
 fn test_mknod_fifo_default_writable() {
     let ts = TestScenario::new(util_name!());
     ts.ucmd().arg("test_file").arg("p").succeeds();
@@ -41,7 +48,6 @@ fn test_mknod_fifo_default_writable() {
 }
 
 #[test]
-#[cfg(not(windows))]
 fn test_mknod_fifo_mnemonic_usage() {
     let ts = TestScenario::new(util_name!());
     ts.ucmd().arg("test_file").arg("pipe").succeeds();
@@ -49,7 +55,6 @@ fn test_mknod_fifo_mnemonic_usage() {
 }
 
 #[test]
-#[cfg(not(windows))]
 fn test_mknod_fifo_read_only() {
     let ts = TestScenario::new(util_name!());
     ts.ucmd()
@@ -63,7 +68,6 @@ fn test_mknod_fifo_read_only() {
 }
 
 #[test]
-#[cfg(not(windows))]
 fn test_mknod_fifo_invalid_extra_operand() {
     new_ucmd!()
         .arg("test_file")
@@ -75,20 +79,17 @@ fn test_mknod_fifo_invalid_extra_operand() {
 }
 
 #[test]
-#[cfg(not(windows))]
 fn test_mknod_character_device_requires_major_and_minor() {
     new_ucmd!()
         .arg("test_file")
         .arg("c")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("Special files require major and minor device numbers.");
     new_ucmd!()
         .arg("test_file")
         .arg("c")
         .arg("1")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("Special files require major and minor device numbers.");
     new_ucmd!()
         .arg("test_file")
@@ -107,17 +108,6 @@ fn test_mknod_character_device_requires_major_and_minor() {
 }
 
 #[test]
-#[cfg(not(windows))]
-fn test_mknod_invalid_arg() {
-    new_ucmd!()
-        .arg("--foo")
-        .fails()
-        .no_stdout()
-        .stderr_contains("unexpected argument '--foo' found");
-}
-
-#[test]
-#[cfg(not(windows))]
 fn test_mknod_invalid_mode() {
     new_ucmd!()
         .arg("--mode")
@@ -129,3 +119,77 @@ fn test_mknod_invalid_mode() {
         .code_is(1)
         .stderr_contains("invalid mode");
 }
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_mknod_selinux() {
+    use std::process::Command;
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    let dest = "test_file";
+    let args = [
+        "-Z",
+        "--context",
+        "--context=unconfined_u:object_r:user_tmp_t:s0",
+    ];
+    for arg in args {
+        ts.ucmd()
+            .arg(arg)
+            .arg("-m")
+            .arg("a=r")
+            .arg(dest)
+            .arg("p")
+            .succeeds();
+        assert!(ts.fixtures.is_fifo("test_file"));
+        assert!(ts.fixtures.metadata("test_file").permissions().readonly());
+
+        let getfattr_output = Command::new("getfattr")
+            .arg(at.plus_as_string(dest))
+            .arg("-n")
+            .arg("security.selinux")
+            .output()
+            .expect("Failed to run `getfattr` on the destination file");
+        println!("{:?}", getfattr_output);
+        assert!(
+            getfattr_output.status.success(),
+            "getfattr did not run successfully: {}",
+            String::from_utf8_lossy(&getfattr_output.stderr)
+        );
+
+        let stdout = String::from_utf8_lossy(&getfattr_output.stdout);
+        assert!(
+            stdout.contains("unconfined_u"),
+            "Expected '{}' not found in getfattr output:\n{}",
+            "foo",
+            stdout
+        );
+        at.remove(&at.plus_as_string(dest));
+    }
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_mknod_selinux_invalid() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dest = "orig";
+
+    let args = [
+        "--context=a",
+        "--context=unconfined_u:object_r:user_tmp_t:s0:a",
+        "--context=nconfined_u:object_r:user_tmp_t:s0",
+    ];
+    for arg in args {
+        new_ucmd!()
+            .arg(arg)
+            .arg("-m")
+            .arg("a=r")
+            .arg(dest)
+            .arg("p")
+            .fails()
+            .stderr_contains("failed to");
+        if at.file_exists(dest) {
+            at.remove(dest);
+        }
+    }
+}
diff --git a/tests/by-util/test_mktemp.rs b/tests/by-util/test_mktemp.rs
index 611a42e43c8..35c27dff6f3 100644
--- a/tests/by-util/test_mktemp.rs
+++ b/tests/by-util/test_mktemp.rs
@@ -4,13 +4,16 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (words) gpghome
 
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 use uucore::display::Quotable;
 
-use std::path::PathBuf;
 #[cfg(not(windows))]
 use std::path::MAIN_SEPARATOR;
+use std::path::PathBuf;
 use tempfile::tempdir;
 
 #[cfg(unix)]
@@ -21,8 +24,8 @@ static TEST_TEMPLATE2: &str = "temp";
 static TEST_TEMPLATE3: &str = "tempX";
 static TEST_TEMPLATE4: &str = "tempXX";
 static TEST_TEMPLATE5: &str = "tempXXX";
-static TEST_TEMPLATE6: &str = "tempXXXlate"; // spell-checker:disable-line
-static TEST_TEMPLATE7: &str = "XXXtemplate"; // spell-checker:disable-line
+static TEST_TEMPLATE6: &str = "tempXXXlate";
+static TEST_TEMPLATE7: &str = "XXXtemplate";
 #[cfg(unix)]
 static TEST_TEMPLATE8: &str = "tempXXXl/ate";
 #[cfg(windows)]
@@ -54,9 +57,8 @@ macro_rules! assert_suffix_matches_template {
         let suffix = &$s[n - m..n];
         assert!(
             matches_template($template, suffix),
-            "\"{}\" does not end with \"{}\"",
+            "\"{}\" does not end with \"{suffix}\"",
             $template,
-            suffix
         );
     }};
 }
@@ -629,7 +631,7 @@ fn test_too_few_xs_suffix() {
     new_ucmd!()
         .args(&["--suffix=X", "aXX"])
         .fails()
-        .stderr_only("mktemp: too few X's in template 'aXXX'\n");
+        .stderr_only("mktemp: too few X's in template 'aXX'\n");
 }
 
 #[test]
@@ -637,15 +639,14 @@ fn test_too_few_xs_suffix_directory() {
     new_ucmd!()
         .args(&["-d", "--suffix=X", "aXX"])
         .fails()
-        .stderr_only("mktemp: too few X's in template 'aXXX'\n");
+        .stderr_only("mktemp: too few X's in template 'aXX'\n");
 }
 
 #[test]
 fn test_too_many_arguments() {
     new_ucmd!()
         .args(&["-q", "a", "b"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .usage_error("too many templates");
 }
 
@@ -778,13 +779,11 @@ fn test_nonexistent_tmpdir_env_var() {
         let stderr = result.stderr_str();
         assert!(
             stderr.starts_with("mktemp: failed to create file via template"),
-            "{}",
-            stderr
+            "{stderr}",
         );
         assert!(
             stderr.ends_with("no\\such\\dir\\tmp.XXXXXXXXXX': No such file or directory\n"),
-            "{}",
-            stderr
+            "{stderr}",
         );
     }
 
@@ -797,13 +796,11 @@ fn test_nonexistent_tmpdir_env_var() {
         let stderr = result.stderr_str();
         assert!(
             stderr.starts_with("mktemp: failed to create directory via template"),
-            "{}",
-            stderr
+            "{stderr}",
         );
         assert!(
             stderr.ends_with("no\\such\\dir\\tmp.XXXXXXXXXX': No such file or directory\n"),
-            "{}",
-            stderr
+            "{stderr}",
         );
     }
 }
@@ -821,13 +818,11 @@ fn test_nonexistent_dir_prefix() {
         let stderr = result.stderr_str();
         assert!(
             stderr.starts_with("mktemp: failed to create file via template"),
-            "{}",
-            stderr
+            "{stderr}",
         );
         assert!(
             stderr.ends_with("d\\XXX': No such file or directory\n"),
-            "{}",
-            stderr
+            "{stderr}",
         );
     }
 
@@ -842,13 +837,11 @@ fn test_nonexistent_dir_prefix() {
         let stderr = result.stderr_str();
         assert!(
             stderr.starts_with("mktemp: failed to create directory via template"),
-            "{}",
-            stderr
+            "{stderr}",
         );
         assert!(
             stderr.ends_with("d\\XXX': No such file or directory\n"),
-            "{}",
-            stderr
+            "{stderr}",
         );
     }
 }
diff --git a/tests/by-util/test_more.rs b/tests/by-util/test_more.rs
index b6ded2298d8..56aae882c93 100644
--- a/tests/by-util/test_more.rs
+++ b/tests/by-util/test_more.rs
@@ -2,39 +2,58 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
-use is_terminal::IsTerminal;
 
+use std::io::IsTerminal;
+
+use uutests::{at_and_ucmd, new_ucmd, util::TestScenario, util_name};
+
+#[cfg(unix)]
 #[test]
-fn test_more_no_arg() {
-    // Reading from stdin is now supported, so this must succeed
+fn test_no_arg() {
     if std::io::stdout().is_terminal() {
-        new_ucmd!().succeeds();
+        new_ucmd!()
+            .terminal_simulation(true)
+            .fails()
+            .stderr_contains("more: bad usage");
     }
 }
 
 #[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("-u").succeeds();
-        new_ucmd!().arg("--plain").succeeds();
+        let args_list: Vec<&[&str]> = vec![
+            &["-c"],
+            &["--clean-print"],
+            &["-p"],
+            &["--print-over"],
+            &["-s"],
+            &["--squeeze"],
+            &["-u"],
+            &["--plain"],
+            &["-n", "10"],
+            &["--lines", "0"],
+            &["--number", "0"],
+            &["-F", "10"],
+            &["--from-line", "0"],
+            &["-P", "something"],
+            &["--pattern", "-1"],
+        ];
+        for args in args_list {
+            test_alive(args);
+        }
+    }
+}
 
-        new_ucmd!().arg("-n").arg("10").succeeds();
-        new_ucmd!().arg("--lines").arg("0").succeeds();
-        new_ucmd!().arg("--number").arg("0").succeeds();
+fn test_alive(args: &[&str]) {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_file";
+    at.touch(file);
 
-        new_ucmd!().arg("-F").arg("10").succeeds();
-        new_ucmd!().arg("--from-line").arg("0").succeeds();
-    }
+    ucmd.args(args)
+        .arg(file)
+        .run_no_wait()
+        .make_assertion()
+        .is_alive();
 }
 
 #[test]
@@ -50,66 +69,52 @@ fn test_invalid_arg() {
 }
 
 #[test]
-fn test_argument_from_file() {
+fn test_file_arg() {
+    // Run the test only if there's a valid terminal, else do nothing
+    // Maybe we could capture the error, i.e. "Device not found" in that case
+    // but I am leaving this for later
     if std::io::stdout().is_terminal() {
-        let scene = TestScenario::new(util_name!());
-        let at = &scene.fixtures;
-
-        let file = "test_file";
-
-        at.write(file, "1\n2");
+        // Directory as argument
+        let mut ucmd = TestScenario::new(util_name!()).ucmd();
+        ucmd.arg(".")
+            .succeeds()
+            .stderr_contains("'.' is a directory.");
 
-        // output all lines
-        scene
-            .ucmd()
-            .arg("-F")
-            .arg("0")
-            .arg(file)
+        // Single argument errors
+        let (at, mut ucmd) = at_and_ucmd!();
+        at.mkdir_all("folder");
+        ucmd.arg("folder")
             .succeeds()
-            .no_stderr()
-            .stdout_contains("1")
-            .stdout_contains("2");
+            .stderr_contains("is a directory");
 
-        // output only the second line
-        scene
-            .ucmd()
-            .arg("-F")
-            .arg("2")
-            .arg(file)
+        ucmd = TestScenario::new(util_name!()).ucmd();
+        ucmd.arg("nonexistent_file")
             .succeeds()
-            .no_stderr()
-            .stdout_contains("2")
-            .stdout_does_not_contain("1");
-    }
-}
+            .stderr_contains("No such file or directory");
 
-#[test]
-fn test_more_dir_arg() {
-    // Run the test only if there's a valid terminal, else do nothing
-    // Maybe we could capture the error, i.e. "Device not found" in that case
-    // but I am leaving this for later
-    if std::io::stdout().is_terminal() {
-        new_ucmd!()
-            .arg(".")
-            .fails()
-            .usage_error("'.' is a directory.");
+        // Multiple nonexistent files
+        ucmd = TestScenario::new(util_name!()).ucmd();
+        ucmd.arg("file2")
+            .arg("file3")
+            .succeeds()
+            .stderr_contains("file2")
+            .stderr_contains("file3");
     }
 }
 
 #[test]
 #[cfg(target_family = "unix")]
-fn test_more_invalid_file_perms() {
-    use std::fs::{set_permissions, Permissions};
-    use std::os::unix::fs::PermissionsExt;
-
+fn test_invalid_file_perms() {
     if std::io::stdout().is_terminal() {
+        use std::fs::{Permissions, set_permissions};
+        use std::os::unix::fs::PermissionsExt;
+
         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)
+            .succeeds()
             .stderr_contains("permission denied");
     }
 }
diff --git a/tests/by-util/test_mv.rs b/tests/by-util/test_mv.rs
index eb8a30ac4e5..577f6a75899 100644
--- a/tests/by-util/test_mv.rs
+++ b/tests/by-util/test_mv.rs
@@ -2,37 +2,43 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+//
+// spell-checker:ignore mydir
 use filetime::FileTime;
-use std::thread::sleep;
-use std::time::Duration;
+use rstest::rstest;
+use std::io::Write;
+#[cfg(not(windows))]
+use std::path::Path;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::{at_and_ucmd, util_name};
 
 #[test]
-fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+fn test_mv_invalid_arg() {
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
-fn test_mv_rename_dir() {
+fn test_mv_missing_dest() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let dir1 = "test_mv_rename_dir";
-    let dir2 = "test_mv_rename_dir2";
+    let dir = "dir";
 
-    at.mkdir(dir1);
-
-    ucmd.arg(dir1).arg(dir2).succeeds().no_stderr();
+    at.mkdir(dir);
 
-    assert!(at.dir_exists(dir2));
+    ucmd.arg(dir).fails();
 }
 
 #[test]
-fn test_mv_fail() {
+fn test_mv_rename_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
     let dir1 = "test_mv_rename_dir";
+    let dir2 = "test_mv_rename_dir2";
 
     at.mkdir(dir1);
 
-    ucmd.arg(dir1).fails();
+    ucmd.arg(dir1).arg(dir2).succeeds().no_stderr();
+
+    assert!(at.dir_exists(dir2));
 }
 
 #[test]
@@ -47,6 +53,22 @@ fn test_mv_rename_file() {
     assert!(at.file_exists(file2));
 }
 
+#[test]
+fn test_mv_with_source_file_opened_and_target_file_exists() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let src = "source_file_opened";
+    let dst = "target_file_exists";
+
+    let f = at.make_file(src);
+
+    at.touch(dst);
+
+    ucmd.arg(src).arg(dst).succeeds().no_stderr().no_stdout();
+
+    drop(f);
+}
+
 #[test]
 fn test_mv_move_file_into_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -131,7 +153,7 @@ fn test_mv_move_file_between_dirs() {
 
     assert!(at.file_exists(format!("{dir1}/{file}")));
 
-    ucmd.arg(&format!("{dir1}/{file}"))
+    ucmd.arg(format!("{dir1}/{file}"))
         .arg(dir2)
         .succeeds()
         .no_stderr();
@@ -297,9 +319,9 @@ fn test_mv_interactive_no_clobber_force_last_arg_wins() {
 
     scene
         .ucmd()
-        .args(&[file_a, file_b, "-f", "-i", "-n"])
-        .fails()
-        .stderr_is(format!("mv: not replacing '{file_b}'\n"));
+        .args(&[file_a, file_b, "-f", "-i", "-n", "--debug"])
+        .succeeds()
+        .stdout_contains("skipped 'b.txt'");
 
     scene
         .ucmd()
@@ -350,9 +372,9 @@ fn test_mv_no_clobber() {
     ucmd.arg("-n")
         .arg(file_a)
         .arg(file_b)
-        .fails()
-        .code_is(1)
-        .stderr_only(format!("mv: not replacing '{file_b}'\n"));
+        .arg("--debug")
+        .succeeds()
+        .stdout_contains("skipped 'test_mv_no_clobber_file_b");
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
@@ -401,7 +423,7 @@ fn test_mv_same_file() {
     ucmd.arg(file_a)
         .arg(file_a)
         .fails()
-        .stderr_is(format!("mv: '{file_a}' and '{file_a}' are the same file\n",));
+        .stderr_is(format!("mv: '{file_a}' and '{file_a}' are the same file\n"));
 }
 
 #[test]
@@ -418,7 +440,7 @@ fn test_mv_same_hardlink() {
     ucmd.arg(file_a)
         .arg(file_b)
         .fails()
-        .stderr_is(format!("mv: '{file_a}' and '{file_b}' are the same file\n",));
+        .stderr_is(format!("mv: '{file_a}' and '{file_b}' are the same file\n"));
 }
 
 #[test]
@@ -436,7 +458,7 @@ fn test_mv_same_symlink() {
     ucmd.arg(file_b)
         .arg(file_a)
         .fails()
-        .stderr_is(format!("mv: '{file_b}' and '{file_a}' are the same file\n",));
+        .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);
@@ -466,7 +488,31 @@ fn test_mv_same_symlink() {
         .arg(file_c)
         .arg(file_a)
         .fails()
-        .stderr_is(format!("mv: '{file_c}' and '{file_a}' are the same file\n",));
+        .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_broken_symlink() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.symlink_file("missing-target", "broken");
+
+    ucmd.arg("broken")
+        .arg("broken")
+        .fails()
+        .stderr_is("mv: 'broken' and 'broken' are the same file\n");
+}
+
+#[test]
+#[cfg(all(unix, not(target_os = "android")))]
+fn test_mv_symlink_into_target() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.mkdir("dir");
+    at.symlink_file("dir", "dir-link");
+
+    ucmd.arg("dir-link").arg("dir").succeeds();
 }
 
 #[test]
@@ -570,6 +616,30 @@ fn test_mv_simple_backup() {
     assert!(at.file_exists(format!("{file_b}~")));
 }
 
+#[test]
+fn test_mv_simple_backup_for_directory() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_a = "test_mv_simple_backup_dir_a";
+    let dir_b = "test_mv_simple_backup_dir_b";
+
+    at.mkdir(dir_a);
+    at.mkdir(dir_b);
+    at.touch(format!("{dir_a}/file_a"));
+    at.touch(format!("{dir_b}/file_b"));
+    ucmd.arg("-T")
+        .arg("-b")
+        .arg(dir_a)
+        .arg(dir_b)
+        .succeeds()
+        .no_stderr();
+
+    assert!(!at.dir_exists(dir_a));
+    assert!(at.dir_exists(dir_b));
+    assert!(at.dir_exists(&format!("{dir_b}~")));
+    assert!(at.file_exists(format!("{dir_b}/file_a")));
+    assert!(at.file_exists(format!("{dir_b}~/file_b")));
+}
+
 #[test]
 fn test_mv_simple_backup_with_file_extension() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -861,14 +931,16 @@ fn test_mv_backup_off() {
 }
 
 #[test]
-fn test_mv_backup_no_clobber_conflicting_options() {
-    new_ucmd!()
-        .arg("--backup")
-        .arg("--no-clobber")
-        .arg("file1")
-        .arg("file2")
-        .fails()
-        .usage_error("options --backup and --no-clobber are mutually exclusive");
+fn test_mv_backup_conflicting_options() {
+    for conflicting_opt in ["--no-clobber", "--update=none-fail", "--update=none"] {
+        new_ucmd!()
+            .arg("--backup")
+            .arg(conflicting_opt)
+            .arg("file1")
+            .arg("file2")
+            .fails()
+            .usage_error("cannot combine --backup with -n/--no-clobber or --update=none-fail");
+    }
 }
 
 #[test]
@@ -886,7 +958,12 @@ fn test_mv_update_option() {
     filetime::set_file_times(at.plus_as_string(file_a), now, now).unwrap();
     filetime::set_file_times(at.plus_as_string(file_b), now, later).unwrap();
 
-    scene.ucmd().arg("--update").arg(file_a).arg(file_b).run();
+    scene
+        .ucmd()
+        .arg("--update")
+        .arg(file_a)
+        .arg(file_b)
+        .succeeds();
 
     assert!(at.file_exists(file_a));
     assert!(at.file_exists(file_b));
@@ -903,6 +980,20 @@ fn test_mv_update_option() {
     assert!(!at.file_exists(file_b));
 }
 
+#[test]
+fn test_mv_update_with_dest_ending_with_slash() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "source";
+    let dest = "destination/";
+
+    at.mkdir("source");
+
+    ucmd.arg("--update").arg(source).arg(dest).succeeds();
+
+    assert!(!at.dir_exists(source));
+    assert!(at.dir_exists(dest));
+}
+
 #[test]
 fn test_mv_arg_update_none() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -956,9 +1047,9 @@ fn test_mv_arg_update_older_dest_not_older() {
     let old_content = "file1 content\n";
     let new_content = "file2 content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -983,9 +1074,9 @@ fn test_mv_arg_update_none_then_all() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -1011,9 +1102,9 @@ fn test_mv_arg_update_all_then_none() {
     let old_content = "old content\n";
     let new_content = "new content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -1037,9 +1128,9 @@ fn test_mv_arg_update_older_dest_older() {
     let old_content = "file1 content\n";
     let new_content = "file2 content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -1053,6 +1144,30 @@ fn test_mv_arg_update_older_dest_older() {
     assert_eq!(at.read(old), new_content);
 }
 
+#[test]
+fn test_mv_arg_update_older_dest_older_interactive() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let old = "old";
+    let new = "new";
+    let old_content = "file1 content\n";
+    let new_content = "file2 content\n";
+
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
+
+    at.write(new, new_content);
+
+    ucmd.arg(new)
+        .arg(old)
+        .arg("--interactive")
+        .arg("--update=older")
+        .fails()
+        .stderr_contains("overwrite 'old'?")
+        .no_stdout();
+}
+
 #[test]
 fn test_mv_arg_update_short_overwrite() {
     // same as --update=older
@@ -1063,9 +1178,9 @@ fn test_mv_arg_update_short_overwrite() {
     let old_content = "file1 content\n";
     let new_content = "file2 content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -1089,9 +1204,9 @@ fn test_mv_arg_update_short_no_overwrite() {
     let old_content = "file1 content\n";
     let new_content = "file2 content\n";
 
-    at.write(old, old_content);
-
-    sleep(Duration::from_secs(1));
+    let mut f = at.make_file(old);
+    f.write_all(old_content.as_bytes()).unwrap();
+    f.set_modified(std::time::UNIX_EPOCH).unwrap();
 
     at.write(new, new_content);
 
@@ -1156,6 +1271,32 @@ fn test_mv_overwrite_dir() {
     assert!(at.dir_exists(dir_b));
 }
 
+#[test]
+fn test_mv_no_target_dir_with_dest_not_existing() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_a = "a";
+    let dir_b = "b";
+
+    at.mkdir(dir_a);
+    ucmd.arg("-T").arg(dir_a).arg(dir_b).succeeds().no_output();
+
+    assert!(!at.dir_exists(dir_a));
+    assert!(at.dir_exists(dir_b));
+}
+
+#[test]
+fn test_mv_no_target_dir_with_dest_not_existing_and_ending_with_slash() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_a = "a";
+    let dir_b = "b/";
+
+    at.mkdir(dir_a);
+    ucmd.arg("-T").arg(dir_a).arg(dir_b).succeeds().no_output();
+
+    assert!(!at.dir_exists(dir_a));
+    assert!(at.dir_exists(dir_b));
+}
+
 #[test]
 fn test_mv_overwrite_nonempty_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -1240,13 +1381,15 @@ fn test_mv_errors() {
     // $ at.mkdir dir && at.touch file
     // $ mv dir file
     // err == mv: cannot overwrite non-directory 'file' with directory 'dir'
-    assert!(!scene
-        .ucmd()
-        .arg(dir)
-        .arg(file_a)
-        .fails()
-        .stderr_str()
-        .is_empty());
+    assert!(
+        !scene
+            .ucmd()
+            .arg(dir)
+            .arg(file_a)
+            .fails()
+            .stderr_str()
+            .is_empty()
+    );
 }
 
 #[test]
@@ -1311,33 +1454,17 @@ fn test_mv_interactive_error() {
     // $ at.mkdir dir && at.touch file
     // $ mv -i dir file
     // err == mv: cannot overwrite non-directory 'file' with directory 'dir'
-    assert!(!scene
-        .ucmd()
-        .arg("-i")
-        .arg(dir)
-        .arg(file_a)
-        .pipe_in("y")
-        .fails()
-        .stderr_str()
-        .is_empty());
-}
-
-#[test]
-fn test_mv_info_self() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
-    let dir1 = "dir1";
-    let dir2 = "dir2";
-    at.mkdir(dir1);
-    at.mkdir(dir2);
-
-    scene
-        .ucmd()
-        .arg(dir1)
-        .arg(dir2)
-        .arg(dir2)
-        .fails()
-        .stderr_contains("mv: cannot move 'dir2' to a subdirectory of itself, 'dir2/dir2'");
+    assert!(
+        !scene
+            .ucmd()
+            .arg("-i")
+            .arg(dir)
+            .arg(file_a)
+            .pipe_in("y")
+            .fails()
+            .stderr_str()
+            .is_empty()
+    );
 }
 
 #[test]
@@ -1350,7 +1477,7 @@ fn test_mv_arg_interactive_skipped() {
         .ignore_stdin_write_error()
         .fails()
         .stderr_is("mv: overwrite 'b'? ")
-        .stdout_is("skipped 'b'\n");
+        .no_stdout();
 }
 
 #[test]
@@ -1358,9 +1485,9 @@ 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");
+    ucmd.args(&["-vin", "a", "b", "--debug"])
+        .succeeds()
+        .stdout_contains("skipped 'b'");
 }
 
 #[test]
@@ -1378,16 +1505,256 @@ fn test_mv_into_self_data() {
     at.touch(file1);
     at.touch(file2);
 
-    let result = scene.ucmd().arg(file1).arg(sub_dir).arg(sub_dir).run();
+    scene
+        .ucmd()
+        .arg(file1)
+        .arg(sub_dir)
+        .arg(sub_dir)
+        .fails_with_code(1);
 
     // sub_dir exists, file1 has been moved, file2 still exists.
-    result.code_is(1);
-
     assert!(at.dir_exists(sub_dir));
     assert!(at.file_exists(file1_result_location));
     assert!(at.file_exists(file2));
     assert!(!at.file_exists(file1));
 }
+
+#[rstest]
+#[case(vec!["mydir"], vec!["mydir", "mydir"], "mv: cannot move 'mydir' to a subdirectory of itself, 'mydir/mydir'")]
+#[case(vec!["mydir"], vec!["mydir/", "mydir/"], "mv: cannot move 'mydir/' to a subdirectory of itself, 'mydir/mydir'")]
+#[case(vec!["mydir"], vec!["./mydir", "mydir", "mydir/"], "mv: cannot move './mydir' to a subdirectory of itself, 'mydir/mydir'")]
+#[case(vec!["mydir"], vec!["mydir/", "mydir/mydir_2/"], "mv: cannot move 'mydir/' to a subdirectory of itself, 'mydir/mydir_2/'")]
+#[case(vec!["mydir/mydir_2"], vec!["mydir", "mydir/mydir_2"], "mv: cannot move 'mydir' to a subdirectory of itself, 'mydir/mydir_2/mydir'\n")]
+#[case(vec!["mydir/mydir_2"], vec!["mydir/", "mydir/mydir_2/"], "mv: cannot move 'mydir/' to a subdirectory of itself, 'mydir/mydir_2/mydir'\n")]
+#[case(vec!["mydir", "mydir_2"], vec!["mydir/", "mydir_2/", "mydir_2/"], "mv: cannot move 'mydir_2/' to a subdirectory of itself, 'mydir_2/mydir_2'")]
+#[case(vec!["mydir"], vec!["mydir/", "mydir"], "mv: cannot move 'mydir/' to a subdirectory of itself, 'mydir/mydir'")]
+#[case(vec!["mydir"], vec!["-T", "mydir", "mydir"], "mv: 'mydir' and 'mydir' are the same file")]
+#[case(vec!["mydir"], vec!["mydir/", "mydir/../"], "mv: 'mydir/' and 'mydir/../mydir' are the same file")]
+fn test_mv_directory_self(
+    #[case] dirs: Vec<&str>,
+    #[case] args: Vec<&str>,
+    #[case] expected_error: &str,
+) {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    for dir in dirs {
+        at.mkdir_all(dir);
+    }
+    scene
+        .ucmd()
+        .args(&args)
+        .fails()
+        .stderr_contains(expected_error);
+}
+
+#[test]
+fn test_mv_dir_into_dir_with_source_name_a_prefix_of_target_name() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let source = "test";
+    let target = "test2";
+
+    at.mkdir(source);
+    at.mkdir(target);
+
+    ucmd.arg(source).arg(target).succeeds().no_output();
+
+    assert!(at.dir_exists(&format!("{target}/{source}")));
+}
+
+#[test]
+fn test_mv_file_into_dir_where_both_are_files() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("a");
+    at.touch("b");
+    scene
+        .ucmd()
+        .arg("a")
+        .arg("b/")
+        .fails()
+        .stderr_contains("mv: failed to access 'b/': Not a directory");
+}
+
+#[test]
+fn test_mv_seen_file() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("c").fails();
+
+    #[cfg(not(unix))]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c\\f' with 'b/f'")
+    );
+    #[cfg(unix)]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c/f' with 'b/f'")
+    );
+
+    // a/f has been moved into c/f
+    assert!(at.plus("c").join("f").exists());
+    // b/f still exists
+    assert!(at.plus("b").join("f").exists());
+    // a/f no longer exists
+    assert!(!at.plus("a").join("f").exists());
+}
+
+#[test]
+fn test_mv_seen_multiple_files_to_directory() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.mkdir("b");
+    at.mkdir("c");
+    at.write("a/f", "a");
+    at.write("b/f", "b");
+    at.write("b/g", "g");
+
+    let result = ts.ucmd().arg("a/f").arg("b/f").arg("b/g").arg("c").fails();
+    #[cfg(not(unix))]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c\\f' with 'b/f'")
+    );
+    #[cfg(unix)]
+    assert!(
+        result
+            .stderr_str()
+            .contains("will not overwrite just-created 'c/f' with 'b/f'")
+    );
+
+    assert!(!at.plus("a").join("f").exists());
+    assert!(at.plus("b").join("f").exists());
+    assert!(!at.plus("b").join("g").exists());
+    assert!(at.plus("c").join("f").exists());
+    assert!(at.plus("c").join("g").exists());
+}
+
+#[test]
+fn test_mv_dir_into_file_where_both_are_files() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("a");
+    at.touch("b");
+    scene
+        .ucmd()
+        .arg("a/")
+        .arg("b")
+        .fails()
+        .stderr_contains("mv: cannot stat 'a/': Not a directory");
+}
+
+#[test]
+fn test_mv_dir_into_path_slash() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("a");
+    scene.ucmd().arg("a").arg("e/").succeeds();
+    assert!(at.dir_exists("e"));
+    at.mkdir("b");
+    at.mkdir("f");
+    scene.ucmd().arg("b").arg("f/").succeeds();
+    assert!(at.dir_exists("f/b"));
+}
+
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "openbsd"))))]
+#[test]
+fn test_acl() {
+    use std::process::Command;
+
+    use uutests::util::compare_xattrs;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let path1 = "a";
+    let path2 = "b";
+    let file = "a/file";
+    let file_target = "b/file";
+    at.mkdir(path1);
+    at.mkdir(path2);
+    at.touch(file);
+
+    let path = at.plus_as_string(file);
+    // calling the command directly. xattr requires some dev packages to be installed
+    // and it adds a complex dependency just for a test
+    match Command::new("setfacl")
+        .args(["-m", "group::rwx", path1])
+        .status()
+        .map(|status| status.code())
+    {
+        Ok(Some(0)) => {}
+        Ok(_) => {
+            println!("test skipped: setfacl failed");
+            return;
+        }
+        Err(e) => {
+            println!("test skipped: setfacl failed with {e}");
+            return;
+        }
+    }
+
+    scene.ucmd().arg(&path).arg(path2).succeeds();
+
+    assert!(compare_xattrs(&file, &file_target));
+}
+
+#[test]
+#[cfg(windows)]
+fn test_move_should_not_fallback_to_copy() {
+    use std::os::windows::fs::OpenOptionsExt;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let locked_file = "a_file_is_locked";
+    let locked_file_path = at.plus(locked_file);
+    let file = std::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .share_mode(
+            uucore::windows_sys::Win32::Storage::FileSystem::FILE_SHARE_READ
+                | uucore::windows_sys::Win32::Storage::FileSystem::FILE_SHARE_WRITE,
+        )
+        .open(locked_file_path);
+
+    let target_file = "target_file";
+    ucmd.arg(locked_file).arg(target_file).fails();
+
+    assert!(at.file_exists(locked_file));
+    assert!(!at.file_exists(target_file));
+
+    drop(file);
+}
+
+#[test]
+#[cfg(unix)]
+fn test_move_should_not_fallback_to_copy() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let readonly_dir = "readonly_dir";
+    let locked_file = "readonly_dir/a_file_is_locked";
+    at.mkdir(readonly_dir);
+    at.touch(locked_file);
+    at.set_mode(readonly_dir, 0o555);
+
+    let target_file = "target_file";
+    ucmd.arg(locked_file).arg(target_file).fails();
+
+    assert!(at.file_exists(locked_file));
+    assert!(!at.file_exists(target_file));
+}
+
 // Todo:
 
 // $ at.touch a b
@@ -1400,3 +1767,129 @@ fn test_mv_into_self_data() {
 // $ mv -v a b
 // mv: try to overwrite 'b', overriding mode 0444 (r--r--r--)? y
 // 'a' -> 'b'
+
+#[cfg(target_os = "linux")]
+mod inter_partition_copying {
+    use std::fs::{read_to_string, set_permissions, write};
+    use std::os::unix::fs::{PermissionsExt, symlink};
+    use tempfile::TempDir;
+    use uutests::util::TestScenario;
+    use uutests::util_name;
+
+    // Ensure that the copying code used in an inter-partition move unlinks the destination symlink.
+    #[test]
+    pub(crate) fn test_mv_unlinks_dest_symlink() {
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+
+        // create a file in the current partition.
+        at.write("src", "src contents");
+
+        // create a folder in another partition.
+        let other_fs_tempdir =
+            TempDir::new_in("/dev/shm/").expect("Unable to create temp directory");
+
+        // create a file inside that folder.
+        let other_fs_file_path = other_fs_tempdir.path().join("other_fs_file");
+        write(&other_fs_file_path, "other fs file contents")
+            .expect("Unable to write to other_fs_file");
+
+        // create a symlink to the file inside the same directory.
+        let symlink_path = other_fs_tempdir.path().join("symlink_to_file");
+        symlink(&other_fs_file_path, &symlink_path).expect("Unable to create symlink_to_file");
+
+        // mv src to symlink in another partition
+        scene
+            .ucmd()
+            .arg("src")
+            .arg(symlink_path.to_str().unwrap())
+            .succeeds();
+
+        // make sure that src got removed.
+        assert!(!at.file_exists("src"));
+
+        // make sure symlink got unlinked
+        assert!(!symlink_path.is_symlink());
+
+        // make sure that file contents in other_fs_file didn't change.
+        assert_eq!(
+            read_to_string(&other_fs_file_path).expect("Unable to read other_fs_file"),
+            "other fs file contents"
+        );
+
+        // make sure that src file contents got copied into new file created in symlink_path
+        assert_eq!(
+            read_to_string(&symlink_path).expect("Unable to read other_fs_file"),
+            "src contents"
+        );
+    }
+
+    // In an inter-partition move if unlinking the destination symlink fails, ensure
+    // that it would output the proper error message.
+    #[test]
+    pub(crate) fn test_mv_unlinks_dest_symlink_error_message() {
+        use uutests::util::TestScenario;
+        let scene = TestScenario::new(util_name!());
+        let at = &scene.fixtures;
+
+        // create a file in the current partition.
+        at.write("src", "src contents");
+
+        // create a folder in another partition.
+        let other_fs_tempdir =
+            TempDir::new_in("/dev/shm/").expect("Unable to create temp directory");
+
+        // create a file inside that folder.
+        let other_fs_file_path = other_fs_tempdir.path().join("other_fs_file");
+        write(&other_fs_file_path, "other fs file contents")
+            .expect("Unable to write to other_fs_file");
+
+        // create a symlink to the file inside the same directory.
+        let symlink_path = other_fs_tempdir.path().join("symlink_to_file");
+        symlink(&other_fs_file_path, &symlink_path).expect("Unable to create symlink_to_file");
+
+        // disable write for the target folder so that when mv tries to remove the
+        // the destination symlink inside the target directory it would fail.
+        set_permissions(other_fs_tempdir.path(), PermissionsExt::from_mode(0o555))
+            .expect("Unable to set permissions for temp directory");
+
+        // mv src to symlink in another partition
+        scene
+            .ucmd()
+            .arg("src")
+            .arg(symlink_path.to_str().unwrap())
+            .fails()
+            .stderr_contains("inter-device move failed:")
+            .stderr_contains("Permission denied");
+    }
+}
+
+#[test]
+fn test_mv_error_msg_with_multiple_sources_that_does_not_exist() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("d");
+    scene
+        .ucmd()
+        .arg("a")
+        .arg("b/")
+        .arg("d")
+        .fails()
+        .stderr_contains("mv: cannot stat 'a': No such file or directory")
+        .stderr_contains("mv: cannot stat 'b/': No such file or directory");
+}
+
+#[cfg(not(windows))]
+#[ignore = "requires access to a different filesystem"]
+#[test]
+fn test_special_file_different_filesystem() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkfifo("f");
+    // TODO Use `TestScenario::mount_temp_fs()` for this purpose and
+    // un-ignore this test.
+    std::fs::create_dir("/dev/shm/tmp").unwrap();
+    ucmd.args(&["f", "/dev/shm/tmp"]).succeeds().no_output();
+    assert!(!at.file_exists("f"));
+    assert!(Path::new("/dev/shm/tmp/f").exists());
+    std::fs::remove_dir_all("/dev/shm/tmp").unwrap();
+}
diff --git a/tests/by-util/test_nice.rs b/tests/by-util/test_nice.rs
index 994b0e85660..b53a4118b08 100644
--- a/tests/by-util/test_nice.rs
+++ b/tests/by-util/test_nice.rs
@@ -2,8 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore libc's
-use crate::common::util::TestScenario;
+// spell-checker:ignore libc's setpriority
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 #[cfg(not(target_os = "android"))]
@@ -11,7 +13,7 @@ fn test_get_current_niceness() {
     // 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()
+        .succeeds()
         .stdout_is(format!("{}\n", unsafe { libc::nice(0) }));
 }
 
@@ -23,10 +25,11 @@ fn test_negative_adjustment() {
     // the OS.  If it gets denied, then we know a negative value was parsed
     // correctly.
 
-    let res = new_ucmd!().args(&["-n", "-1", "true"]).run();
-    assert!(res
-        .stderr_str()
-        .starts_with("nice: warning: setpriority: Permission denied")); // spell-checker:disable-line
+    let res = new_ucmd!().args(&["-n", "-1", "true"]).succeeds();
+    assert!(
+        res.stderr_str()
+            .starts_with("nice: warning: setpriority: Permission denied")
+    ); // spell-checker:disable-line
 }
 
 #[test]
@@ -39,14 +42,14 @@ fn test_adjustment_with_no_command_should_error() {
 
 #[test]
 fn test_command_with_no_adjustment() {
-    new_ucmd!().args(&["echo", "a"]).run().stdout_is("a\n");
+    new_ucmd!().args(&["echo", "a"]).succeeds().stdout_is("a\n");
 }
 
 #[test]
 fn test_command_with_no_args() {
     new_ucmd!()
         .args(&["-n", "19", "echo"])
-        .run()
+        .succeeds()
         .stdout_is("\n");
 }
 
@@ -54,7 +57,7 @@ fn test_command_with_no_args() {
 fn test_command_with_args() {
     new_ucmd!()
         .args(&["-n", "19", "echo", "a", "b", "c"])
-        .run()
+        .succeeds()
         .stdout_is("a b c\n");
 }
 
@@ -62,20 +65,20 @@ fn test_command_with_args() {
 fn test_command_where_command_takes_n_flag() {
     new_ucmd!()
         .args(&["-n", "19", "echo", "-n", "a"])
-        .run()
+        .succeeds()
         .stdout_is("a");
 }
 
 #[test]
 fn test_invalid_argument() {
-    new_ucmd!().arg("--invalid").fails().code_is(125);
+    new_ucmd!().arg("--invalid").fails_with_code(125);
 }
 
 #[test]
 fn test_bare_adjustment() {
     new_ucmd!()
         .args(&["-1", "echo", "-n", "a"])
-        .run()
+        .succeeds()
         .stdout_is("a");
 }
 
diff --git a/tests/by-util/test_nl.rs b/tests/by-util/test_nl.rs
index b58c0c206fb..7e9fb7c14a2 100644
--- a/tests/by-util/test_nl.rs
+++ b/tests/by-util/test_nl.rs
@@ -2,19 +2,23 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore binvalid finvalid hinvalid iinvalid linvalid ninvalid vinvalid winvalid
-use crate::common::util::TestScenario;
+//
+// spell-checker:ignore binvalid finvalid hinvalid iinvalid linvalid nabcabc nabcabcabc ninvalid vinvalid winvalid dabc näää
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_stdin_no_newline() {
     new_ucmd!()
         .pipe_in("No Newline")
-        .run()
+        .succeeds()
         .stdout_is("     1\tNo Newline\n");
 }
 
@@ -23,7 +27,7 @@ fn test_stdin_newline() {
     new_ucmd!()
         .args(&["-s", "-", "-w", "1"])
         .pipe_in("Line One\nLine Two\n")
-        .run()
+        .succeeds()
         .stdout_is("1-Line One\n2-Line Two\n");
 }
 
@@ -31,7 +35,7 @@ fn test_stdin_newline() {
 fn test_padding_without_overflow() {
     new_ucmd!()
         .args(&["-i", "1000", "-s", "x", "-n", "rz", "simple.txt"])
-        .run()
+        .succeeds()
         .stdout_is(
             "000001xL1\n001001xL2\n002001xL3\n003001xL4\n004001xL5\n005001xL6\n006001xL7\n0070\
              01xL8\n008001xL9\n009001xL10\n010001xL11\n011001xL12\n012001xL13\n013001xL14\n014\
@@ -43,7 +47,7 @@ fn test_padding_without_overflow() {
 fn test_padding_with_overflow() {
     new_ucmd!()
         .args(&["-i", "1000", "-s", "x", "-n", "rz", "-w", "4", "simple.txt"])
-        .run()
+        .succeeds()
         .stdout_is(
             "0001xL1\n1001xL2\n2001xL3\n3001xL4\n4001xL5\n5001xL6\n6001xL7\n7001xL8\n8001xL9\n\
              9001xL10\n10001xL11\n11001xL12\n12001xL13\n13001xL14\n14001xL15\n",
@@ -72,7 +76,7 @@ fn test_sections_and_styles() {
             .args(&[
                 "-s", "|", "-n", "ln", "-w", "3", "-b", "a", "-l", "5", fixture,
             ])
-            .run()
+            .succeeds()
             .stdout_is(output);
     }
     // spell-checker:enable
@@ -284,6 +288,31 @@ fn test_join_blank_lines() {
     }
 }
 
+#[test]
+fn test_join_blank_lines_multiple_files() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.write("a.txt", "\n\n");
+    at.write("b.txt", "\n\n");
+    at.write("c.txt", "\n\n");
+
+    for arg in ["-l3", "--join-blank-lines=3"] {
+        scene
+            .ucmd()
+            .args(&[arg, "--body-numbering=a", "a.txt", "b.txt", "c.txt"])
+            .succeeds()
+            .stdout_is(concat!(
+                "       \n",
+                "       \n",
+                "     1\t\n",
+                "       \n",
+                "       \n",
+                "     2\t\n",
+            ));
+    }
+}
+
 #[test]
 fn test_join_blank_lines_zero() {
     for arg in ["-l0", "--join-blank-lines=0"] {
@@ -311,6 +340,32 @@ fn test_default_body_numbering() {
         .stdout_is("     1\ta\n       \n     2\tb\n");
 }
 
+#[test]
+fn test_default_body_numbering_multiple_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.write("a.txt", "a");
+    at.write("b.txt", "b");
+    at.write("c.txt", "c");
+
+    ucmd.args(&["a.txt", "b.txt", "c.txt"])
+        .succeeds()
+        .stdout_is("     1\ta\n     2\tb\n     3\tc\n");
+}
+
+#[test]
+fn test_default_body_numbering_multiple_files_and_stdin() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.write("a.txt", "a");
+    at.write("c.txt", "c");
+
+    ucmd.args(&["a.txt", "-", "c.txt"])
+        .pipe_in("b")
+        .succeeds()
+        .stdout_is("     1\ta\n     2\tb\n     3\tc\n");
+}
+
 #[test]
 fn test_body_numbering_all_lines_without_delimiter() {
     for arg in ["-ba", "--body-numbering=a"] {
@@ -486,3 +541,116 @@ fn test_line_number_overflow() {
         .stdout_is(format!("{}\ta\n", i64::MIN))
         .stderr_is("nl: line number overflow\n");
 }
+
+#[test]
+fn test_line_number_no_overflow() {
+    new_ucmd!()
+        .arg(format!("--starting-line-number={}", i64::MAX))
+        .pipe_in("a\n\\:\\:\nb")
+        .succeeds()
+        .stdout_is(format!("{0}\ta\n\n{0}\tb\n", i64::MAX));
+
+    new_ucmd!()
+        .arg(format!("--starting-line-number={}", i64::MIN))
+        .arg("--line-increment=-1")
+        .pipe_in("a\n\\:\\:\nb")
+        .succeeds()
+        .stdout_is(format!("{0}\ta\n\n{0}\tb\n", i64::MIN));
+}
+
+#[test]
+fn test_section_delimiter() {
+    for arg in ["-dabc", "--section-delimiter=abc"] {
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\nabcabcabc\nb") // header section
+            .succeeds()
+            .stdout_is("     1\ta\n\n       b\n");
+
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\nabcabc\nb") // body section
+            .succeeds()
+            .stdout_is("     1\ta\n\n     1\tb\n");
+
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\nabc\nb") // footer section
+            .succeeds()
+            .stdout_is("     1\ta\n\n       b\n");
+    }
+}
+
+#[test]
+fn test_one_char_section_delimiter_expansion() {
+    for arg in ["-da", "--section-delimiter=a"] {
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\na:a:a:\nb") // header section
+            .succeeds()
+            .stdout_is("     1\ta\n\n       b\n");
+
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\na:a:\nb") // body section
+            .succeeds()
+            .stdout_is("     1\ta\n\n     1\tb\n");
+
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\na:\nb") // footer section
+            .succeeds()
+            .stdout_is("     1\ta\n\n       b\n");
+    }
+}
+
+#[test]
+fn test_non_ascii_one_char_section_delimiter() {
+    for arg in ["-dä", "--section-delimiter=ä"] {
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\näää\nb") // header section
+            .succeeds()
+            .stdout_is("     1\ta\n\n       b\n");
+
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\nää\nb") // body section
+            .succeeds()
+            .stdout_is("     1\ta\n\n     1\tb\n");
+
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\nä\nb") // footer section
+            .succeeds()
+            .stdout_is("     1\ta\n\n       b\n");
+    }
+}
+
+#[test]
+fn test_empty_section_delimiter() {
+    for arg in ["-d ''", "--section-delimiter=''"] {
+        new_ucmd!()
+            .arg(arg)
+            .pipe_in("a\n\nb")
+            .succeeds()
+            .stdout_is("     1\ta\n       \n     2\tb\n");
+    }
+}
+
+#[test]
+fn test_directory_as_input() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir = "dir";
+    let file = "file";
+    let content = "aaa";
+
+    at.mkdir(dir);
+    at.write(file, content);
+
+    ucmd.arg(dir)
+        .arg(file)
+        .fails()
+        .stderr_is(format!("nl: {dir}: Is a directory\n"))
+        .stdout_contains(content);
+}
diff --git a/tests/by-util/test_nohup.rs b/tests/by-util/test_nohup.rs
index b014c31aa08..d58a7e24de9 100644
--- a/tests/by-util/test_nohup.rs
+++ b/tests/by-util/test_nohup.rs
@@ -2,8 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+// spell-checker:ignore winsize Openpty openpty xpixel ypixel ptyprocess
+#[cfg(not(target_os = "openbsd"))]
 use std::thread::sleep;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 // General observation: nohup.out will not be created in tests run by cargo test
 // because stdin/stdout is not attached to a TTY.
@@ -11,7 +16,7 @@ use std::thread::sleep;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(125);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
 }
 
 #[test]
@@ -31,3 +36,32 @@ fn test_nohup_multiple_args_and_flags() {
     assert!(at.file_exists("file1"));
     assert!(at.file_exists("file2"));
 }
+
+#[test]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "freebsd",
+    target_vendor = "apple"
+))]
+fn test_nohup_with_pseudo_terminal_emulation_on_stdin_stdout_stderr_get_replaced() {
+    let ts = TestScenario::new(util_name!());
+    let result = ts
+        .ucmd()
+        .terminal_simulation(true)
+        .args(&["sh", "is_a_tty.sh"])
+        .succeeds();
+
+    assert_eq!(
+        String::from_utf8_lossy(result.stderr()).trim(),
+        "nohup: ignoring input and appending output to 'nohup.out'"
+    );
+
+    sleep(std::time::Duration::from_millis(10));
+
+    // this proves that nohup was exchanging the stdio file descriptors
+    assert_eq!(
+        std::fs::read_to_string(ts.fixtures.plus_as_string("nohup.out")).unwrap(),
+        "stdin is not a tty\nstdout is not a tty\nstderr is not a tty\n"
+    );
+}
diff --git a/tests/by-util/test_nproc.rs b/tests/by-util/test_nproc.rs
index 22523352b5f..c06eed8f0c4 100644
--- a/tests/by-util/test_nproc.rs
+++ b/tests/by-util/test_nproc.rs
@@ -3,11 +3,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore incorrectnumber
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_numfmt.rs b/tests/by-util/test_numfmt.rs
index 2c2e95d0bb1..806e29d9a8d 100644
--- a/tests/by-util/test_numfmt.rs
+++ b/tests/by-util/test_numfmt.rs
@@ -2,13 +2,15 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// spell-checker:ignore (paths) gnutest
+// spell-checker:ignore (paths) gnutest ronna quetta
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -32,7 +34,7 @@ fn test_from_si() {
     new_ucmd!()
         .args(&["--from=si"])
         .pipe_in("1000\n1.1M\n0.1G")
-        .run()
+        .succeeds()
         .stdout_is("1000\n1100000\n100000000\n");
 }
 
@@ -41,7 +43,7 @@ fn test_from_iec() {
     new_ucmd!()
         .args(&["--from=iec"])
         .pipe_in("1024\n1.1M\n0.1G")
-        .run()
+        .succeeds()
         .stdout_is("1024\n1153434\n107374183\n");
 }
 
@@ -50,23 +52,24 @@ fn test_from_iec_i() {
     new_ucmd!()
         .args(&["--from=iec-i"])
         .pipe_in("1.1Mi\n0.1Gi")
-        .run()
+        .succeeds()
         .stdout_is("1153434\n107374183\n");
 }
 
 #[test]
 fn test_from_iec_i_requires_suffix() {
-    let numbers = vec!["1024", "10M"];
+    new_ucmd!()
+        .args(&["--from=iec-i", "10M"])
+        .fails_with_code(2)
+        .stderr_is("numfmt: missing 'i' suffix in input: '10M' (e.g Ki/Mi/Gi)\n");
+}
 
-    for number in numbers {
-        new_ucmd!()
-            .args(&["--from=iec-i", number])
-            .fails()
-            .code_is(2)
-            .stderr_is(format!(
-                "numfmt: missing 'i' suffix in input: '{number}' (e.g Ki/Mi/Gi)\n"
-            ));
-    }
+#[test]
+fn test_from_iec_i_without_suffix_are_bytes() {
+    new_ucmd!()
+        .args(&["--from=iec-i", "1024"])
+        .succeeds()
+        .stdout_is("1024\n");
 }
 
 #[test]
@@ -74,7 +77,7 @@ fn test_from_auto() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("1K\n1Ki")
-        .run()
+        .succeeds()
         .stdout_is("1000\n1024\n");
 }
 
@@ -83,8 +86,8 @@ fn test_to_si() {
     new_ucmd!()
         .args(&["--to=si"])
         .pipe_in("1000\n1100000\n100000000")
-        .run()
-        .stdout_is("1.0K\n1.1M\n100M\n");
+        .succeeds()
+        .stdout_is("1.0k\n1.1M\n100M\n");
 }
 
 #[test]
@@ -92,7 +95,7 @@ fn test_to_iec() {
     new_ucmd!()
         .args(&["--to=iec"])
         .pipe_in("1024\n1153434\n107374182")
-        .run()
+        .succeeds()
         .stdout_is("1.0K\n1.2M\n103M\n");
 }
 
@@ -101,7 +104,7 @@ fn test_to_iec_i() {
     new_ucmd!()
         .args(&["--to=iec-i"])
         .pipe_in("1024\n1153434\n107374182")
-        .run()
+        .succeeds()
         .stdout_is("1.0Ki\n1.2Mi\n103Mi\n");
 }
 
@@ -109,7 +112,7 @@ fn test_to_iec_i() {
 fn test_input_from_free_arguments() {
     new_ucmd!()
         .args(&["--from=si", "1K", "1.1M", "0.1G"])
-        .run()
+        .succeeds()
         .stdout_is("1000\n1100000\n100000000\n");
 }
 
@@ -118,7 +121,7 @@ fn test_padding() {
     new_ucmd!()
         .args(&["--from=si", "--padding=8"])
         .pipe_in("1K\n1.1M\n0.1G")
-        .run()
+        .succeeds()
         .stdout_is("    1000\n 1100000\n100000000\n");
 }
 
@@ -127,7 +130,7 @@ fn test_negative_padding() {
     new_ucmd!()
         .args(&["--from=si", "--padding=-8"])
         .pipe_in("1K\n1.1M\n0.1G")
-        .run()
+        .succeeds()
         .stdout_is("1000    \n1100000 \n100000000\n");
 }
 
@@ -136,7 +139,7 @@ fn test_header() {
     new_ucmd!()
         .args(&["--from=si", "--header=2"])
         .pipe_in("header\nheader2\n1K\n1.1M\n0.1G")
-        .run()
+        .succeeds()
         .stdout_is("header\nheader2\n1000\n1100000\n100000000\n");
 }
 
@@ -145,7 +148,7 @@ fn test_header_default() {
     new_ucmd!()
         .args(&["--from=si", "--header"])
         .pipe_in("header\n1K\n1.1M\n0.1G")
-        .run()
+        .succeeds()
         .stdout_is("header\n1000\n1100000\n100000000\n");
 }
 
@@ -153,7 +156,7 @@ fn test_header_default() {
 fn test_header_error_if_non_numeric() {
     new_ucmd!()
         .args(&["--header=two"])
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid header value 'two'\n");
 }
 
@@ -161,7 +164,7 @@ fn test_header_error_if_non_numeric() {
 fn test_header_error_if_0() {
     new_ucmd!()
         .args(&["--header=0"])
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid header value '0'\n");
 }
 
@@ -169,7 +172,7 @@ fn test_header_error_if_0() {
 fn test_header_error_if_negative() {
     new_ucmd!()
         .args(&["--header=-3"])
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid header value '-3'\n");
 }
 
@@ -178,25 +181,28 @@ fn test_negative() {
     new_ucmd!()
         .args(&["--from=si"])
         .pipe_in("-1000\n-1.1M\n-0.1G")
-        .run()
+        .succeeds()
         .stdout_is("-1000\n-1100000\n-100000000\n");
     new_ucmd!()
         .args(&["--to=iec-i"])
         .pipe_in("-1024\n-1153434\n-107374182")
-        .run()
+        .succeeds()
         .stdout_is("-1.0Ki\n-1.2Mi\n-103Mi\n");
 }
 
 #[test]
 fn test_negative_zero() {
-    new_ucmd!().pipe_in("-0\n-0.0").run().stdout_is("0\n0.0\n");
+    new_ucmd!()
+        .pipe_in("-0\n-0.0")
+        .succeeds()
+        .stdout_is("0\n0.0\n");
 }
 
 #[test]
 fn test_no_op() {
     new_ucmd!()
         .pipe_in("1024\n1234567")
-        .run()
+        .succeeds()
         .stdout_is("1024\n1234567\n");
 }
 
@@ -205,7 +211,7 @@ fn test_normalize() {
     new_ucmd!()
         .args(&["--from=si", "--to=si"])
         .pipe_in("10000000K\n0.001K")
-        .run()
+        .succeeds()
         .stdout_is("10G\n1\n");
 }
 
@@ -213,7 +219,7 @@ fn test_normalize() {
 fn test_si_to_iec() {
     new_ucmd!()
         .args(&["--from=si", "--to=iec", "15334263563K"])
-        .run()
+        .succeeds()
         .stdout_is("14T\n");
 }
 
@@ -222,7 +228,7 @@ fn test_should_report_invalid_empty_number_on_empty_stdin() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("\n")
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid number: ''\n");
 }
 
@@ -231,28 +237,40 @@ fn test_should_report_invalid_empty_number_on_blank_stdin() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("  \t  \n")
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid number: ''\n");
 }
 
 #[test]
-fn test_should_report_invalid_suffix_on_stdin() {
-    for c in b'a'..=b'z' {
-        new_ucmd!()
-            .args(&["--from=auto"])
-            .pipe_in(format!("1{}", c as char))
-            .run()
-            .stderr_is(format!(
-                "numfmt: invalid suffix in input: '1{}'\n",
-                c as char
-            ));
+fn test_suffixes() {
+    // TODO add support for ronna (R) and quetta (Q)
+    let valid_suffixes = ['K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' /*'R' , 'Q'*/];
+
+    for c in ('A'..='Z').chain('a'..='z') {
+        let args = ["--from=si", "--to=si", &format!("1{c}")];
+
+        if valid_suffixes.contains(&c) {
+            let s = if c == 'K' { 'k' } else { c };
+            new_ucmd!()
+                .args(&args)
+                .succeeds()
+                .stdout_only(format!("1.0{s}\n"));
+        } else {
+            new_ucmd!()
+                .args(&args)
+                .fails_with_code(2)
+                .stderr_only(format!("numfmt: invalid suffix in input: '1{c}'\n"));
+        }
     }
+}
 
+#[test]
+fn test_should_report_invalid_suffix_on_nan() {
     // GNU numfmt reports this one as “invalid number�
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("NaN")
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid suffix in input: 'NaN'\n");
 }
 
@@ -262,7 +280,7 @@ fn test_should_report_invalid_number_with_interior_junk() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("1x0K")
-        .run()
+        .fails()
         .stderr_is("numfmt: invalid number: '1x0K'\n");
 }
 
@@ -271,14 +289,14 @@ fn test_should_skip_leading_space_from_stdin() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in(" 2Ki")
-        .run()
+        .succeeds()
         .stdout_is("2048\n");
 
     // multi-line
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("\t1Ki\n  2K")
-        .run()
+        .succeeds()
         .stdout_is("1024\n2000\n");
 }
 
@@ -287,7 +305,7 @@ fn test_should_convert_only_first_number_in_line() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("1Ki 2M 3G")
-        .run()
+        .succeeds()
         .stdout_is("1024 2M 3G\n");
 }
 
@@ -296,13 +314,13 @@ fn test_leading_whitespace_should_imply_padding() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("   1K")
-        .run()
+        .succeeds()
         .stdout_is(" 1000\n");
 
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("    202Ki")
-        .run()
+        .succeeds()
         .stdout_is("   206848\n");
 }
 
@@ -311,7 +329,7 @@ fn test_should_calculate_implicit_padding_per_line() {
     new_ucmd!()
         .args(&["--from=auto"])
         .pipe_in("   1Ki\n        2K")
-        .run()
+        .succeeds()
         .stdout_is("  1024\n      2000\n");
 }
 
@@ -319,7 +337,7 @@ fn test_should_calculate_implicit_padding_per_line() {
 fn test_leading_whitespace_in_free_argument_should_imply_padding() {
     new_ucmd!()
         .args(&["--from=auto", "   1Ki"])
-        .run()
+        .succeeds()
         .stdout_is("  1024\n");
 }
 
@@ -327,7 +345,7 @@ fn test_leading_whitespace_in_free_argument_should_imply_padding() {
 fn test_should_calculate_implicit_padding_per_free_argument() {
     new_ucmd!()
         .args(&["--from=auto", "   1Ki", "        2K"])
-        .run()
+        .succeeds()
         .stdout_is("  1024\n      2000\n");
 }
 
@@ -488,7 +506,7 @@ fn test_delimiter_to_si() {
         .args(&["-d=,", "--to=si"])
         .pipe_in("1234,56")
         .succeeds()
-        .stdout_only("1.3K,56\n");
+        .stdout_only("1.3k,56\n");
 }
 
 #[test]
@@ -497,7 +515,7 @@ fn test_delimiter_skips_leading_whitespace() {
         .args(&["-d=,", "--to=si"])
         .pipe_in("     \t               1234,56")
         .succeeds()
-        .stdout_only("1.3K,56\n");
+        .stdout_only("1.3k,56\n");
 }
 
 #[test]
@@ -506,7 +524,7 @@ fn test_delimiter_preserves_leading_whitespace_in_unselected_fields() {
         .args(&["-d=|", "--to=si"])
         .pipe_in("             1000|   2000")
         .succeeds()
-        .stdout_only("1.0K|   2000\n");
+        .stdout_only("1.0k|   2000\n");
 }
 
 #[test]
@@ -534,7 +552,7 @@ fn test_delimiter_with_padding() {
         .args(&["-d=|", "--to=si", "--padding=5"])
         .pipe_in("1000|2000")
         .succeeds()
-        .stdout_only(" 1.0K|2000\n");
+        .stdout_only(" 1.0k|2000\n");
 }
 
 #[test]
@@ -543,17 +561,21 @@ fn test_delimiter_with_padding_and_fields() {
         .args(&["-d=|", "--to=si", "--padding=5", "--field=-"])
         .pipe_in("1000|2000")
         .succeeds()
-        .stdout_only(" 1.0K| 2.0K\n");
+        .stdout_only(" 1.0k| 2.0k\n");
 }
 
 #[test]
 fn test_round() {
     for (method, exp) in [
-        ("from-zero", ["9.1K", "-9.1K", "9.1K", "-9.1K"]),
-        ("towards-zero", ["9.0K", "-9.0K", "9.0K", "-9.0K"]),
-        ("up", ["9.1K", "-9.0K", "9.1K", "-9.0K"]),
-        ("down", ["9.0K", "-9.1K", "9.0K", "-9.1K"]),
-        ("nearest", ["9.0K", "-9.0K", "9.1K", "-9.1K"]),
+        ("from-zero", ["9.1k", "-9.1k", "9.1k", "-9.1k"]),
+        ("from-zer", ["9.1k", "-9.1k", "9.1k", "-9.1k"]),
+        ("f", ["9.1k", "-9.1k", "9.1k", "-9.1k"]),
+        ("towards-zero", ["9.0k", "-9.0k", "9.0k", "-9.0k"]),
+        ("up", ["9.1k", "-9.0k", "9.1k", "-9.0k"]),
+        ("down", ["9.0k", "-9.1k", "9.0k", "-9.1k"]),
+        ("nearest", ["9.0k", "-9.0k", "9.1k", "-9.1k"]),
+        ("near", ["9.0k", "-9.0k", "9.1k", "-9.1k"]),
+        ("n", ["9.0k", "-9.0k", "9.1k", "-9.1k"]),
     ] {
         new_ucmd!()
             .args(&[
@@ -629,7 +651,7 @@ fn test_transform_with_suffix_on_input() {
         .args(&["--suffix=b", "--to=si"])
         .pipe_in("2000b")
         .succeeds()
-        .stdout_only("2.0Kb\n");
+        .stdout_only("2.0kb\n");
 }
 
 #[test]
@@ -638,7 +660,7 @@ fn test_transform_without_suffix_on_input() {
         .args(&["--suffix=b", "--to=si"])
         .pipe_in("2000")
         .succeeds()
-        .stdout_only("2.0Kb\n");
+        .stdout_only("2.0kb\n");
 }
 
 #[test]
@@ -647,7 +669,7 @@ fn test_transform_with_suffix_and_delimiter() {
         .args(&["--suffix=b", "--to=si", "-d=|"])
         .pipe_in("1000b|2000|3000")
         .succeeds()
-        .stdout_only("1.0Kb|2000|3000\n");
+        .stdout_only("1.0kb|2000|3000\n");
 }
 
 #[test]
@@ -661,12 +683,16 @@ fn test_suffix_with_padding() {
 
 #[test]
 fn test_invalid_stdin_number_returns_status_2() {
-    new_ucmd!().pipe_in("hello").fails().code_is(2);
+    new_ucmd!().pipe_in("hello").fails_with_code(2);
 }
 
 #[test]
 fn test_invalid_stdin_number_in_middle_of_input() {
-    new_ucmd!().pipe_in("100\nhello\n200").fails().code_is(2);
+    new_ucmd!()
+        .pipe_in("100\nhello\n200")
+        .ignore_stdin_write_error()
+        .fails_with_code(2)
+        .stdout_is("100\n");
 }
 
 #[test]
@@ -693,8 +719,7 @@ fn test_invalid_stdin_number_with_abort_returns_status_2() {
     new_ucmd!()
         .args(&["--invalid=abort"])
         .pipe_in("4Q")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only("numfmt: invalid suffix in input: '4Q'\n");
 }
 
@@ -703,8 +728,7 @@ fn test_invalid_stdin_number_with_fail_returns_status_2() {
     new_ucmd!()
         .args(&["--invalid=fail"])
         .pipe_in("4Q")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stdout_is("4Q\n")
         .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
 }
@@ -730,8 +754,7 @@ fn test_invalid_arg_number_with_ignore_returns_status_0() {
 fn test_invalid_arg_number_with_abort_returns_status_2() {
     new_ucmd!()
         .args(&["--invalid=abort", "4Q"])
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only("numfmt: invalid suffix in input: '4Q'\n");
 }
 
@@ -739,8 +762,7 @@ fn test_invalid_arg_number_with_abort_returns_status_2() {
 fn test_invalid_arg_number_with_fail_returns_status_2() {
     new_ucmd!()
         .args(&["--invalid=fail", "4Q"])
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stdout_is("4Q\n")
         .stderr_is("numfmt: invalid suffix in input: '4Q'\n");
 }
@@ -751,8 +773,7 @@ fn test_invalid_argument_returns_status_1() {
         .args(&["--header=hello"])
         .pipe_in("53478")
         .ignore_stdin_write_error()
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -763,8 +784,7 @@ fn test_invalid_padding_value() {
         new_ucmd!()
             .arg(format!("--padding={padding_value}"))
             .arg("5")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(format!("invalid padding value '{padding_value}'"));
     }
 }
@@ -794,8 +814,7 @@ fn test_invalid_unit_size() {
         for invalid_size in &invalid_sizes {
             new_ucmd!()
                 .arg(format!("--{command}-unit={invalid_size}"))
-                .fails()
-                .code_is(1)
+                .fails_with_code(1)
                 .stderr_contains(format!("invalid unit size: '{invalid_size}'"));
         }
     }
@@ -808,8 +827,7 @@ fn test_valid_but_forbidden_suffix() {
     for number in numbers {
         new_ucmd!()
             .arg(number)
-            .fails()
-            .code_is(2)
+            .fails_with_code(2)
             .stderr_contains(format!(
                 "rejecting suffix in input: '{number}' (consider using --from)"
             ));
@@ -984,8 +1002,7 @@ fn test_format_without_percentage_directive() {
     for invalid_format in invalid_formats {
         new_ucmd!()
             .arg(format!("--format={invalid_format}"))
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(format!("format '{invalid_format}' has no % directive"));
     }
 }
@@ -996,8 +1013,7 @@ fn test_format_with_percentage_directive_at_end() {
 
     new_ucmd!()
         .arg(format!("--format={invalid_format}"))
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains(format!("format '{invalid_format}' ends in %"));
 }
 
@@ -1007,8 +1023,7 @@ fn test_format_with_too_many_percentage_directives() {
 
     new_ucmd!()
         .arg(format!("--format={invalid_format}"))
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains(format!(
             "format '{invalid_format}' has too many % directives"
         ));
@@ -1021,8 +1036,7 @@ fn test_format_with_invalid_format() {
     for invalid_format in invalid_formats {
         new_ucmd!()
             .arg(format!("--format={invalid_format}"))
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(format!(
                 "invalid format '{invalid_format}', directive must be %[0]['][-][N][.][N]f"
             ));
@@ -1034,8 +1048,7 @@ fn test_format_with_width_overflow() {
     let invalid_format = "%18446744073709551616f";
     new_ucmd!()
         .arg(format!("--format={invalid_format}"))
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains(format!(
             "invalid format '{invalid_format}' (width overflow)"
         ));
@@ -1048,8 +1061,7 @@ fn test_format_with_invalid_precision() {
     for invalid_format in invalid_formats {
         new_ucmd!()
             .arg(format!("--format={invalid_format}"))
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(format!("invalid precision in format '{invalid_format}'"));
     }
 }
@@ -1058,7 +1070,51 @@ fn test_format_with_invalid_precision() {
 fn test_format_grouping_conflicts_with_to_option() {
     new_ucmd!()
         .args(&["--format=%'f", "--to=si"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("grouping cannot be combined with --to");
 }
+
+#[test]
+fn test_zero_terminated_command_line_args() {
+    new_ucmd!()
+        .args(&["--zero-terminated", "--to=si", "1000"])
+        .succeeds()
+        .stdout_is("1.0k\x00");
+
+    new_ucmd!()
+        .args(&["-z", "--to=si", "1000"])
+        .succeeds()
+        .stdout_is("1.0k\x00");
+
+    new_ucmd!()
+        .args(&["-z", "--to=si", "1000", "2000"])
+        .succeeds()
+        .stdout_is("1.0k\x002.0k\x00");
+}
+
+#[test]
+fn test_zero_terminated_input() {
+    let values = vec![
+        ("1000", "1.0k\x00"),
+        ("1000\x00", "1.0k\x00"),
+        ("1000\x002000\x00", "1.0k\x002.0k\x00"),
+    ];
+
+    for (input, expected) in values {
+        new_ucmd!()
+            .args(&["-z", "--to=si"])
+            .pipe_in(input)
+            .succeeds()
+            .stdout_is(expected);
+    }
+}
+
+#[test]
+fn test_zero_terminated_embedded_newline() {
+    new_ucmd!()
+        .args(&["-z", "--from=si", "--field=-"])
+        .pipe_in("1K\n2K\x003K\n4K\x00")
+        .succeeds()
+        // Newlines get replaced by a single space
+        .stdout_is("1000 2000\x003000 4000\x00");
+}
diff --git a/tests/by-util/test_od.rs b/tests/by-util/test_od.rs
index 78c4e1b0439..d8c22dc8297 100644
--- a/tests/by-util/test_od.rs
+++ b/tests/by-util/test_od.rs
@@ -3,116 +3,90 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore abcdefghijklmnopqrstuvwxyz
-
-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;
+// spell-checker:ignore abcdefghijklmnopqrstuvwxyz Anone
+
+#[cfg(unix)]
+use std::io::Read;
+
 use unindent::unindent;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
-// octal dump of 'abcdefghijklmnopqrstuvwxyz\n'     // spell-checker:disable-line
+// octal dump of 'abcdefghijklmnopqrstuvwxyz\n'
 static ALPHA_OUT: &str = "
         0000000 061141 062143 063145 064147 065151 066153 067155 070157
         0000020 071161 072163 073165 074167 075171 000012
         0000033
         ";
 
-// XXX We could do a better job of ensuring that we have a fresh temp dir to ourselves,
-// not a general one full of other process leftovers.
-
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 // Test that od can read one file and dump with default format
 #[test]
 fn test_file() {
-    // TODO: Can this be replaced by AtPath?
-    use std::env;
-    let temp = env::temp_dir();
-    let tmpdir = Path::new(&temp);
-    let file = tmpdir.join("test");
-
-    {
-        let mut f = File::create(&file).unwrap();
-        // spell-checker:disable-next-line
-        assert!(
-            f.write_all(b"abcdefghijklmnopqrstuvwxyz\n").is_ok(),
-            "Test setup failed - could not write file"
-        );
-    }
-
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.write("test", "abcdefghijklmnopqrstuvwxyz\n");
+    scene
+        .ucmd()
         .arg("--endian=little")
-        .arg(file.as_os_str())
+        .arg("test")
+        .succeeds()
+        .no_stderr()
+        .stdout_is(unindent(ALPHA_OUT));
+    scene
+        .ucmd()
+        .arg("--endian=littl") // spell-checker:disable-line
+        .arg("test")
+        .succeeds()
+        .no_stderr()
+        .stdout_is(unindent(ALPHA_OUT));
+    scene
+        .ucmd()
+        .arg("--endian=l")
+        .arg("test")
         .succeeds()
         .no_stderr()
         .stdout_is(unindent(ALPHA_OUT));
-
     // Ensure that default format matches `-t o2`, and that `-t` does not absorb file argument
-    new_ucmd!()
+    scene
+        .ucmd()
         .arg("--endian=little")
         .arg("-t")
         .arg("o2")
-        .arg(file.as_os_str())
-        .succeeds()
-        .no_stderr()
-        .stdout_is(unindent(ALPHA_OUT));
-
-    let _ = remove_file(file);
+        .arg("test");
 }
 
 // Test that od can read 2 files and concatenate the contents
 #[test]
 fn test_2files() {
-    let temp = env::temp_dir();
-    let tmpdir = Path::new(&temp);
-    let file1 = tmpdir.join("test1");
-    let file2 = tmpdir.join("test2");
-
-    for (n, a) in [(1, "a"), (2, "b")] {
-        println!("number: {n} letter:{a}");
-    }
-
-    // spell-checker:disable-next-line
-    for (path, data) in [(&file1, "abcdefghijklmnop"), (&file2, "qrstuvwxyz\n")] {
-        let mut f = File::create(path).unwrap();
-        assert!(
-            f.write_all(data.as_bytes()).is_ok(),
-            "Test setup failed - could not write file"
-        );
-    }
-
-    new_ucmd!()
-        .arg("--endian=little")
-        .arg(file1.as_os_str())
-        .arg(file2.as_os_str())
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("test1", "abcdefghijklmnop");
+    at.write("test2", "qrstuvwxyz\n"); // spell-checker:disable-line
+    ucmd.arg("--endian=little")
+        .arg("test1")
+        .arg("test2")
         .succeeds()
         .no_stderr()
         .stdout_is(unindent(ALPHA_OUT));
-    // TODO: Handle errors?
-    let _ = remove_file(file1);
-    let _ = remove_file(file2);
 }
 
 // Test that od gives non-0 exit val for filename that doesn't exist.
 #[test]
 fn test_no_file() {
-    let temp = env::temp_dir();
-    let tmpdir = Path::new(&temp);
-    let file = tmpdir.join("}surely'none'would'thus'a'file'name"); // spell-checker:disable-line
-
-    new_ucmd!().arg(file.as_os_str()).fails();
+    let (_at, mut ucmd) = at_and_ucmd!();
+    ucmd.arg("}surely'none'would'thus'a'file'name").fails();
 }
 
 // Test that od reads from stdin instead of a file
 #[test]
 fn test_from_stdin() {
-    let input = "abcdefghijklmnopqrstuvwxyz\n"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopqrstuvwxyz\n";
     new_ucmd!()
         .arg("--endian=little")
         .run_piped_stdin(input.as_bytes())
@@ -124,26 +98,16 @@ fn test_from_stdin() {
 // Test that od reads from stdin and also from files
 #[test]
 fn test_from_mixed() {
-    let temp = env::temp_dir();
-    let tmpdir = Path::new(&temp);
-    let file1 = tmpdir.join("test-1");
-    let file3 = tmpdir.join("test-3");
-
+    let (at, mut ucmd) = at_and_ucmd!();
     // spell-checker:disable-next-line
     let (data1, data2, data3) = ("abcdefg", "hijklmnop", "qrstuvwxyz\n");
-    for (path, data) in [(&file1, data1), (&file3, data3)] {
-        let mut f = File::create(path).unwrap();
-        assert!(
-            f.write_all(data.as_bytes()).is_ok(),
-            "Test setup failed - could not write file"
-        );
-    }
+    at.write("test-1", data1);
+    at.write("test-3", data3);
 
-    new_ucmd!()
-        .arg("--endian=little")
-        .arg(file1.as_os_str())
+    ucmd.arg("--endian=little")
+        .arg("test-1")
         .arg("-")
-        .arg(file3.as_os_str())
+        .arg("test-3")
         .run_piped_stdin(data2.as_bytes())
         .success()
         .no_stderr()
@@ -152,7 +116,7 @@ fn test_from_mixed() {
 
 #[test]
 fn test_multiple_formats() {
-    let input = "abcdefghijklmnopqrstuvwxyz\n"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopqrstuvwxyz\n";
     new_ucmd!()
         .arg("-c")
         .arg("-b")
@@ -463,6 +427,16 @@ fn test_big_endian() {
         .run_piped_stdin(&input[..])
         .no_stderr()
         .success()
+        .stdout_is(&expected_output);
+    new_ucmd!()
+        .arg("--endian=b")
+        .arg("-F")
+        .arg("-f")
+        .arg("-X")
+        .arg("-x")
+        .run_piped_stdin(&input[..])
+        .no_stderr()
+        .success()
         .stdout_is(expected_output);
 }
 
@@ -592,8 +566,8 @@ fn test_dec_offset() {
 
 #[test]
 fn test_no_offset() {
-    let input = [0u8; 31];
     const LINE: &str = " 00000000 00000000 00000000 00000000\n";
+    let input = [0u8; 31];
     let expected_output = [LINE, LINE, LINE, LINE].join("");
 
     new_ucmd!()
@@ -611,9 +585,30 @@ fn test_invalid_offset() {
     new_ucmd!().arg("-Ab").fails();
 }
 
+#[test]
+fn test_empty_offset() {
+    new_ucmd!()
+        .arg("-A")
+        .arg("")
+        .fails()
+        .stderr_only("od: Radix cannot be empty, and must be one of [o, d, x, n]\n");
+}
+
+#[test]
+fn test_offset_compatibility() {
+    let input = [0u8; 4];
+    let expected_output = " 000000 000000\n";
+
+    new_ucmd!()
+        .arg("-Anone")
+        .pipe_in(input)
+        .succeeds()
+        .stdout_only(expected_output);
+}
+
 #[test]
 fn test_skip_bytes() {
-    let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopq";
     new_ucmd!()
         .arg("-c")
         .arg("--skip-bytes=5")
@@ -630,7 +625,7 @@ fn test_skip_bytes() {
 
 #[test]
 fn test_skip_bytes_hex() {
-    let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopq";
     new_ucmd!()
         .arg("-c")
         .arg("--skip-bytes=0xB")
@@ -668,14 +663,40 @@ fn test_skip_bytes_error() {
 
 #[test]
 fn test_read_bytes() {
-    let input = "abcdefghijklmnopqrstuvwxyz\n12345678"; // spell-checker:disable-line
-    new_ucmd!()
+    let scene = TestScenario::new(util_name!());
+    let fixtures = &scene.fixtures;
+
+    let input = "abcdefghijklmnopqrstuvwxyz\n12345678";
+
+    fixtures.write("f1", input);
+    let file = fixtures.open("f1");
+    #[cfg(unix)]
+    let mut file_shadow = file.try_clone().unwrap();
+
+    scene
+        .ucmd()
         .arg("--endian=little")
         .arg("--read-bytes=27")
-        .run_piped_stdin(input.as_bytes())
-        .no_stderr()
-        .success()
-        .stdout_is(unindent(ALPHA_OUT));
+        .set_stdin(file)
+        .succeeds()
+        .stdout_only(unindent(ALPHA_OUT));
+
+    // On unix platforms, confirm that only 27 bytes and strictly no more were read from stdin.
+    // Leaving stdin in the correct state is required for GNU compatibility.
+    #[cfg(unix)]
+    {
+        // skip(27) to skip the 27 bytes that should have been consumed with the
+        // --read-bytes flag.
+        let expected_bytes_remaining_in_stdin: Vec<_> = input.bytes().skip(27).collect();
+        let mut bytes_remaining_in_stdin = vec![];
+        assert_eq!(
+            file_shadow
+                .read_to_end(&mut bytes_remaining_in_stdin)
+                .unwrap(),
+            expected_bytes_remaining_in_stdin.len()
+        );
+        assert_eq!(expected_bytes_remaining_in_stdin, bytes_remaining_in_stdin);
+    }
 }
 
 #[test]
@@ -727,7 +748,7 @@ fn test_filename_parsing() {
 
 #[test]
 fn test_stdin_offset() {
-    let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopq";
     new_ucmd!()
         .arg("-c")
         .arg("+5")
@@ -762,7 +783,7 @@ fn test_file_offset() {
 #[test]
 fn test_traditional() {
     // note gnu od does not align both lines
-    let input = "abcdefghijklmnopq"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopq";
     new_ucmd!()
         .arg("--traditional")
         .arg("-a")
@@ -785,7 +806,7 @@ fn test_traditional() {
 #[test]
 fn test_traditional_with_skip_bytes_override() {
     // --skip-bytes is ignored in this case
-    let input = "abcdefghijklmnop"; // spell-checker:disable-line
+    let input = "abcdefghijklmnop";
     new_ucmd!()
         .arg("--traditional")
         .arg("--skip-bytes=10")
@@ -805,7 +826,7 @@ fn test_traditional_with_skip_bytes_override() {
 #[test]
 fn test_traditional_with_skip_bytes_non_override() {
     // no offset specified in the traditional way, so --skip-bytes is used
-    let input = "abcdefghijklmnop"; // spell-checker:disable-line
+    let input = "abcdefghijklmnop";
     new_ucmd!()
         .arg("--traditional")
         .arg("--skip-bytes=10")
@@ -835,7 +856,7 @@ fn test_traditional_error() {
 
 #[test]
 fn test_traditional_only_label() {
-    let input = "abcdefghijklmnopqrstuvwxyz"; // spell-checker:disable-line
+    let input = "abcdefghijklmnopqrstuvwxyz";
     new_ucmd!()
         .arg("-An")
         .arg("--traditional")
@@ -879,25 +900,21 @@ fn test_od_invalid_bytes() {
         new_ucmd!()
             .arg(format!("{option}={INVALID_SIZE}"))
             .arg("file")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_only(format!("od: invalid {option} argument '{INVALID_SIZE}'\n"));
 
         new_ucmd!()
             .arg(format!("{option}={INVALID_SUFFIX}"))
             .arg("file")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_only(format!(
                 "od: invalid suffix in {option} argument '{INVALID_SUFFIX}'\n"
             ));
 
-        #[cfg(not(target_pointer_width = "128"))]
         new_ucmd!()
             .arg(format!("{option}={BIG_SIZE}"))
             .arg("file")
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_only(format!("od: {option} argument '{BIG_SIZE}' too large\n"));
     }
 }
diff --git a/tests/by-util/test_paste.rs b/tests/by-util/test_paste.rs
index 0fbdb75d268..c4c1097f8f9 100644
--- a/tests/by-util/test_paste.rs
+++ b/tests/by-util/test_paste.rs
@@ -2,7 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore bsdutils toybox
+
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 struct TestData<'b> {
     name: &'b str,
@@ -11,7 +17,7 @@ struct TestData<'b> {
     out: &'b str,
 }
 
-static EXAMPLE_DATA: &[TestData] = &[
+const EXAMPLE_DATA: &[TestData] = &[
     // Ensure that paste properly handles files lacking a final newline.
     TestData {
         name: "no-nl-1",
@@ -134,7 +140,7 @@ static EXAMPLE_DATA: &[TestData] = &[
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -143,7 +149,7 @@ fn test_combine_pairs_of_lines() {
         for d in ["-d", "--delimiters"] {
             new_ucmd!()
                 .args(&[s, d, "\t\n", "html_colors.txt"])
-                .run()
+                .succeeds()
                 .stdout_is_fixture("html_colors.expected");
         }
     }
@@ -167,12 +173,12 @@ 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);
+        for (i, one_in) in ["a\n", "b\n"].iter().enumerate() {
+            let file = format!("in{i}");
+            at.write(&file, one_in);
             ins.push(file);
         }
-        ucmd.args(&[d, "\\\\"])
+        ucmd.args(&[d, r"\\"])
             .args(&ins)
             .succeeds()
             .stdout_is("a\\b\n");
@@ -183,13 +189,174 @@ fn test_delimiter_list_ending_with_escaped_backslash() {
 fn test_delimiter_list_ending_with_unescaped_backslash() {
     for d in ["-d", "--delimiters"] {
         new_ucmd!()
-            .args(&[d, "\\"])
+            .args(&[d, r"\"])
             .fails()
-            .stderr_contains("delimiter list ends with an unescaped backslash: \\");
+            .stderr_contains(r"delimiter list ends with an unescaped backslash: \");
+
+        new_ucmd!()
+            .args(&[d, r"\\\"])
+            .fails()
+            .stderr_contains(r"delimiter list ends with an unescaped backslash: \\\");
+
         new_ucmd!()
-            .args(&[d, "_\\"])
+            .args(&[d, r"_\"])
             .fails()
-            .stderr_contains("delimiter list ends with an unescaped backslash: _\\");
+            .stderr_contains(r"delimiter list ends with an unescaped backslash: _\");
+    }
+}
+
+#[test]
+fn test_delimiter_list_empty() {
+    for option_style in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[option_style, "", "-s"])
+            .pipe_in(
+                "\
+A ALPHA 1 _
+B BRAVO 2 _
+C CHARLIE 3 _
+",
+            )
+            .succeeds()
+            .stdout_only(
+                "\
+A ALPHA 1 _B BRAVO 2 _C CHARLIE 3 _
+",
+            );
+    }
+}
+
+// Was panicking (usize subtraction that would have resulted in a negative number)
+// Not observable in release builds, since integer overflow checking is not enabled
+#[test]
+fn test_delimiter_truncation() {
+    for option_style in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[option_style, "!@#", "-s", "-", "-", "-"])
+            .pipe_in(
+                "\
+FIRST
+SECOND
+THIRD
+FOURTH
+ABCDEFG
+",
+            )
+            .succeeds()
+            .stdout_only(
+                "\
+FIRST!SECOND@THIRD#FOURTH!ABCDEFG
+
+
+",
+            );
+    }
+}
+
+#[test]
+fn test_non_utf8_input() {
+    // 0xC0 is not valid UTF-8
+    const INPUT: &[u8] = b"Non-UTF-8 test: \xC0\x00\xC0.\n";
+
+    new_ucmd!()
+        .pipe_in(INPUT)
+        .succeeds()
+        .stdout_only_bytes(INPUT);
+}
+
+#[test]
+fn test_three_trailing_backslashes_delimiter() {
+    const ONE_BACKSLASH_STR: &str = r"\";
+
+    let three_backslashes_string = ONE_BACKSLASH_STR.repeat(3);
+
+    for option_style in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[option_style, &three_backslashes_string])
+            .fails()
+            .no_stdout()
+            .stderr_str_check(|st| {
+                st.ends_with(&format!(
+                    ": delimiter list ends with an unescaped backslash: {three_backslashes_string}\n"
+                ))
+            });
+    }
+}
+
+// "If any other characters follow the <backslash>, the results are unspecified."
+// https://pubs.opengroup.org/onlinepubs/9799919799/utilities/paste.html
+// However, other implementations remove the backslash
+#[test]
+fn test_posix_unspecified_delimiter() {
+    for option_style in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[option_style, r"\z", "-s"])
+            .pipe_in(
+                "\
+1
+2
+3
+4
+",
+            )
+            .succeeds()
+            .stdout_only(
+                "\
+1z2z3z4
+",
+            );
+    }
+}
+
+// "Empty string (not a null character)"
+// https://pubs.opengroup.org/onlinepubs/9799919799/utilities/paste.html
+#[test]
+fn test_backslash_zero_delimiter() {
+    for option_style in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[option_style, r"\0z\0", "-s"])
+            .pipe_in(
+                "\
+1
+2
+3
+4
+5
+6
+",
+            )
+            .succeeds()
+            .stdout_only(
+                "\
+12z345z6
+",
+            );
+    }
+}
+
+// As of 2024-10-09, only bsdutils (https://github.com/dcantrell/bsdutils, derived from FreeBSD) and toybox handle
+// multibyte delimiter characters in the way a user would likely expect. BusyBox and GNU Core Utilities do not.
+#[test]
+fn test_multi_byte_delimiter() {
+    for option_style in ["-d", "--delimiters"] {
+        new_ucmd!()
+            .args(&[option_style, "!ß@", "-s"])
+            .pipe_in(
+                "\
+1
+2
+3
+4
+5
+6
+",
+            )
+            .succeeds()
+            .stdout_only(
+                "\
+1!2ß3@4!5ß6
+",
+            );
     }
 }
 
@@ -198,9 +365,9 @@ fn test_data() {
     for example in EXAMPLE_DATA {
         let (at, mut ucmd) = at_and_ucmd!();
         let mut ins = vec![];
-        for (i, _in) in example.ins.iter().enumerate() {
+        for (i, one_in) in example.ins.iter().enumerate() {
             let file = format!("in{i}");
-            at.write(&file, _in);
+            at.write(&file, one_in);
             ins.push(file);
         }
         println!("{}", example.name);
diff --git a/tests/by-util/test_pathchk.rs b/tests/by-util/test_pathchk.rs
index f497cfe898d..6e6b5dd85f3 100644
--- a/tests/by-util/test_pathchk.rs
+++ b/tests/by-util/test_pathchk.rs
@@ -2,25 +2,41 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+#[test]
+fn test_no_args() {
+    new_ucmd!()
+        .fails()
+        .no_stdout()
+        .stderr_contains("pathchk: missing operand");
+}
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_default_mode() {
-    // test the default mode
-
     // accept some reasonable default
     new_ucmd!().args(&["dir/file"]).succeeds().no_stdout();
 
     // accept non-portable chars
     new_ucmd!().args(&["dir#/$file"]).succeeds().no_stdout();
 
-    // accept empty path
-    new_ucmd!().args(&[""]).succeeds().no_stdout();
+    // fail on empty path
+    new_ucmd!()
+        .args(&[""])
+        .fails()
+        .stderr_only("pathchk: '': No such file or directory\n");
+
+    new_ucmd!().args(&["", ""]).fails().stderr_only(
+        "pathchk: '': No such file or directory\n\
+        pathchk: '': No such file or directory\n",
+    );
 
     // fail on long path
     new_ucmd!()
@@ -40,8 +56,6 @@ fn test_default_mode() {
 
 #[test]
 fn test_posix_mode() {
-    // test the posix mode
-
     // accept some reasonable default
     new_ucmd!().args(&["-p", "dir/file"]).succeeds().no_stdout();
 
@@ -66,8 +80,6 @@ fn test_posix_mode() {
 
 #[test]
 fn test_posix_special() {
-    // test the posix special mode
-
     // accept some reasonable default
     new_ucmd!().args(&["-P", "dir/file"]).succeeds().no_stdout();
 
@@ -107,8 +119,6 @@ fn test_posix_special() {
 
 #[test]
 fn test_posix_all() {
-    // test the posix special mode
-
     // accept some reasonable default
     new_ucmd!()
         .args(&["-p", "-P", "dir/file"])
@@ -156,10 +166,3 @@ fn test_posix_all() {
     // fail on empty path
     new_ucmd!().args(&["-p", "-P", ""]).fails().no_stdout();
 }
-
-#[test]
-fn test_args_parsing() {
-    // fail on no args
-    let empty_args: [String; 0] = [];
-    new_ucmd!().args(&empty_args).fails().no_stdout();
-}
diff --git a/tests/by-util/test_pinky.rs b/tests/by-util/test_pinky.rs
index 57413c4c95e..6418906ae55 100644
--- a/tests/by-util/test_pinky.rs
+++ b/tests/by-util/test_pinky.rs
@@ -3,13 +3,20 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::common::util::{expected_result, TestScenario};
 use pinky::Capitalize;
+#[cfg(not(target_os = "openbsd"))]
 use uucore::entries::{Locate, Passwd};
+use uutests::new_ucmd;
+use uutests::unwrap_or_return;
+#[cfg(target_os = "openbsd")]
+use uutests::util::TestScenario;
+#[cfg(not(target_os = "openbsd"))]
+use uutests::util::{TestScenario, expected_result};
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -21,6 +28,7 @@ fn test_capitalize() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_long_format() {
     let login = "root";
     let pw: Passwd = Passwd::locate(login).unwrap();
@@ -44,14 +52,12 @@ fn test_long_format() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_long_format_multiple_users() {
     // multiple instances of one account we know exists,
     // the account of the test runner,
     // and an account that (probably) doesn't exist
-    let runner = match std::env::var("USER") {
-        Ok(user) => user,
-        Err(_) => String::new(),
-    };
+    let runner = std::env::var("USER").unwrap_or_default();
     let args = ["-l", "root", "root", "root", &runner, "no_such_user"];
     let ts = TestScenario::new(util_name!());
     let expect = unwrap_or_return!(expected_result(&ts, &args));
@@ -71,6 +77,7 @@ fn test_long_format_wo_user() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_short_format_i() {
     // allow whitespace variation
     // * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
@@ -85,6 +92,7 @@ fn test_short_format_i() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_short_format_q() {
     // allow whitespace variation
     // * minor whitespace differences occur between platform built-in outputs; specifically, the number of trailing TABs may be variant
@@ -99,6 +107,7 @@ fn test_short_format_q() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_no_flag() {
     let ts = TestScenario::new(util_name!());
     let actual = ts.ucmd().succeeds().stdout_move_str();
diff --git a/tests/by-util/test_pr.rs b/tests/by-util/test_pr.rs
index 195d4056798..1dcb162c079 100644
--- a/tests/by-util/test_pr.rs
+++ b/tests/by-util/test_pr.rs
@@ -4,14 +4,13 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (ToDO) Sdivide
 
-use crate::common::util::{TestScenario, UCommand};
+use chrono::{DateTime, Duration, Utc};
 use std::fs::metadata;
-use time::macros::format_description;
-use time::Duration;
-use time::OffsetDateTime;
+use uutests::new_ucmd;
+use uutests::util::{TestScenario, UCommand};
+use uutests::util_name;
 
-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";
 
 fn file_last_modified_time(ucmd: &UCommand, path: &str) -> String {
     let tmp_dir_path = ucmd.get_full_fixture_path(path);
@@ -20,33 +19,40 @@ fn file_last_modified_time(ucmd: &UCommand, path: &str) -> String {
         .map(|i| {
             i.modified()
                 .map(|x| {
-                    let date_time: OffsetDateTime = x.into();
-                    date_time.format(&DATE_TIME_FORMAT).unwrap()
+                    let date_time: DateTime<Utc> = x.into();
+                    date_time.format(DATE_TIME_FORMAT).to_string()
                 })
                 .unwrap_or_default()
         })
         .unwrap_or_default()
 }
 
-fn all_minutes(from: OffsetDateTime, to: OffsetDateTime) -> Vec<String> {
-    let to = to + Duration::minutes(1);
-    // const FORMAT: &str = "%b %d %H:%M %Y";
+fn all_minutes(from: DateTime<Utc>, to: DateTime<Utc>) -> Vec<String> {
+    let to = to + Duration::try_minutes(1).unwrap();
     let mut vec = vec![];
     let mut current = from;
     while current < to {
-        vec.push(current.format(&DATE_TIME_FORMAT).unwrap());
-        current += Duration::minutes(1);
+        vec.push(current.format(DATE_TIME_FORMAT).to_string());
+        current += Duration::try_minutes(1).unwrap();
     }
     vec
 }
 
-fn valid_last_modified_template_vars(from: OffsetDateTime) -> Vec<Vec<(String, String)>> {
-    all_minutes(from, OffsetDateTime::now_utc())
+fn valid_last_modified_template_vars(from: DateTime<Utc>) -> Vec<Vec<(String, String)>> {
+    all_minutes(from, Utc::now())
         .into_iter()
         .map(|time| vec![("{last_modified_time}".to_string(), time)])
         .collect()
 }
 
+#[test]
+fn test_invalid_flag() {
+    new_ucmd!()
+        .arg("--invalid-argument")
+        .fails_with_code(1)
+        .no_stdout();
+}
+
 #[test]
 fn test_without_any_options() {
     let test_file_path = "test_one_page.log";
@@ -257,11 +263,11 @@ 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_utc();
+    let start = Utc::now();
     scenario
         .pipe_in_fixture("stdin.log")
         .args(&["--pages=1:2", "-n", "-"])
-        .run()
+        .succeeds()
         .stdout_is_templated_fixture_any(
             expected_file_path,
             &valid_last_modified_template_vars(start),
@@ -320,7 +326,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_utc();
+    let start = Utc::now();
     new_ucmd!()
         .args(&["--pages=1:2", "-m", "-n", test_file_path, test_file_path1])
         .succeeds()
@@ -329,7 +335,7 @@ fn test_with_mpr() {
             &valid_last_modified_template_vars(start),
         );
 
-    let start = OffsetDateTime::now_utc();
+    let start = Utc::now();
     new_ucmd!()
         .args(&["--pages=2:4", "-m", "-n", test_file_path, test_file_path1])
         .succeeds()
@@ -338,7 +344,7 @@ fn test_with_mpr() {
             &valid_last_modified_template_vars(start),
         );
 
-    let start = OffsetDateTime::now_utc();
+    let start = Utc::now();
     new_ucmd!()
         .args(&[
             "--pages=1:2",
@@ -413,7 +419,7 @@ fn test_with_pr_core_utils_tests() {
         let mut scenario = new_ucmd!();
         let input_file_path = input_file.first().unwrap();
         let test_file_path = expected_file.first().unwrap();
-        let value = file_last_modified_time(&scenario, test_file_path);
+        let value = file_last_modified_time(&scenario, input_file_path);
         let mut arguments: Vec<&str> = flags
             .split(' ')
             .filter(|i| i.trim() != "")
@@ -445,10 +451,10 @@ 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_utc();
+    let start = Utc::now();
     scenario
         .args(&["+1:2", "-J", "-m", test_file_1, test_file_2])
-        .run()
+        .succeeds()
         .stdout_is_templated_fixture_any(
             expected_file_path,
             &valid_last_modified_template_vars(start),
diff --git a/tests/by-util/test_printenv.rs b/tests/by-util/test_printenv.rs
index c9eb3c60eed..aa8910ba51e 100644
--- a/tests/by-util/test_printenv.rs
+++ b/tests/by-util/test_printenv.rs
@@ -2,7 +2,8 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_get_all() {
diff --git a/tests/by-util/test_printf.rs b/tests/by-util/test_printf.rs
index d7ba5679ecf..c0e9c41b3aa 100644
--- a/tests/by-util/test_printf.rs
+++ b/tests/by-util/test_printf.rs
@@ -2,7 +2,11 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore fffffffffffffffc
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn basic_literal() {
@@ -13,37 +17,34 @@ fn basic_literal() {
 }
 
 #[test]
-fn escaped_tab() {
+fn test_missing_escaped_hex_value() {
     new_ucmd!()
-        .args(&["hello\\t world"])
-        .succeeds()
-        .stdout_only("hello\t world");
+        .arg(r"\x")
+        .fails_with_code(1)
+        .stderr_only("printf: missing hexadecimal number in escape\n");
 }
 
 #[test]
-fn escaped_newline() {
+fn escaped_octal_and_newline() {
     new_ucmd!()
-        .args(&["hello\\n world"])
+        .args(&["\\101\\0377\\n"])
         .succeeds()
-        .stdout_only("hello\n world");
+        .stdout_only("A\x1F7\n");
 }
 
 #[test]
-fn escaped_slash() {
+fn variable_sized_octal() {
+    for x in ["|\\5|", "|\\05|", "|\\005|"] {
+        new_ucmd!()
+            .arg(x)
+            .succeeds()
+            .stdout_only_bytes([b'|', 5u8, b'|']);
+    }
+
     new_ucmd!()
-        .args(&["hello\\\\ world"])
+        .arg("|\\0005|")
         .succeeds()
-        .stdout_only("hello\\ world");
-}
-
-#[test]
-fn escaped_hex() {
-    new_ucmd!().args(&["\\x41"]).succeeds().stdout_only("A");
-}
-
-#[test]
-fn escaped_octal() {
-    new_ucmd!().args(&["\\101"]).succeeds().stdout_only("A");
+        .stdout_only_bytes([b'|', 0, b'5', b'|']);
 }
 
 #[test]
@@ -59,6 +60,39 @@ fn escaped_unicode_eight_digit() {
         .stdout_only("Ä¥");
 }
 
+#[test]
+fn escaped_unicode_null_byte() {
+    new_ucmd!()
+        .args(&["\\0001_"])
+        .succeeds()
+        .stdout_is_bytes([0u8, b'1', b'_']);
+
+    new_ucmd!()
+        .args(&["%b", "\\0001_"])
+        .succeeds()
+        .stdout_is_bytes([1u8, b'_']);
+}
+
+#[test]
+fn escaped_unicode_incomplete() {
+    for arg in ["\\u", "\\U", "\\uabc", "\\Uabcd"] {
+        new_ucmd!()
+            .arg(arg)
+            .fails_with_code(1)
+            .stderr_only("printf: missing hexadecimal number in escape\n");
+    }
+}
+
+#[test]
+fn escaped_unicode_invalid() {
+    for arg in ["\\ud9d0", "\\U0000D8F9"] {
+        new_ucmd!().arg(arg).fails_with_code(1).stderr_only(format!(
+            "printf: invalid universal character name {}\n",
+            arg
+        ));
+    }
+}
+
 #[test]
 fn escaped_percent_sign() {
     new_ucmd!()
@@ -73,51 +107,73 @@ fn escaped_unrecognized() {
 }
 
 #[test]
-fn sub_string() {
+fn sub_b_string_handle_escapes() {
     new_ucmd!()
-        .args(&["hello %s", "world"])
+        .args(&["hello %b", "\\tworld"])
         .succeeds()
-        .stdout_only("hello world");
+        .stdout_only("hello \tworld");
 }
 
 #[test]
-fn sub_multi_field() {
+fn sub_b_string_variable_size_unicode() {
+    for x in ["\\5|", "\\05|", "\\005|", "\\0005|"] {
+        new_ucmd!()
+            .args(&["|%b", x])
+            .succeeds()
+            .stdout_only_bytes([b'|', 5u8, b'|']);
+    }
+
     new_ucmd!()
-        .args(&["%s %s", "hello", "world"])
+        .args(&["|%b", "\\00005|"])
         .succeeds()
-        .stdout_only("hello world");
+        .stdout_only_bytes([b'|', 0, b'5', b'|']);
 }
 
 #[test]
-fn sub_repeat_format_str() {
+fn sub_b_string_validate_field_params() {
     new_ucmd!()
-        .args(&["%s.", "hello", "world"])
-        .succeeds()
-        .stdout_only("hello.world.");
+        .args(&["hello %7b", "world"])
+        .fails()
+        .stdout_is("hello ")
+        .stderr_is("printf: %7b: invalid conversion specification\n");
 }
 
 #[test]
-fn sub_string_ignore_escapes() {
+fn sub_b_string_ignore_subs() {
     new_ucmd!()
-        .args(&["hello %s", "\\tworld"])
+        .args(&["hello %b", "world %% %i"])
         .succeeds()
-        .stdout_only("hello \\tworld");
+        .stdout_only("hello world %% %i");
 }
 
 #[test]
-fn sub_b_string_handle_escapes() {
+fn sub_q_string_non_printable() {
     new_ucmd!()
-        .args(&["hello %b", "\\tworld"])
+        .args(&["non-printable: %q", "\"$test\""])
         .succeeds()
-        .stdout_only("hello \tworld");
+        .stdout_only("non-printable: '\"$test\"'");
 }
 
 #[test]
-fn sub_b_string_ignore_subs() {
+fn sub_q_string_validate_field_params() {
     new_ucmd!()
-        .args(&["hello %b", "world %% %i"])
+        .args(&["hello %7q", "world"])
+        .fails()
+        .stdout_is("hello ")
+        .stderr_is("printf: %7q: invalid conversion specification\n");
+}
+
+#[test]
+fn sub_q_string_special_non_printable() {
+    new_ucmd!()
+        .args(&["non-printable: %q", "test~"])
         .succeeds()
-        .stdout_only("hello world %% %i");
+        .stdout_only("non-printable: test~");
+}
+
+#[test]
+fn sub_q_string_empty() {
+    new_ucmd!().args(&["%q", ""]).succeeds().stdout_only("''");
 }
 
 #[test]
@@ -128,6 +184,14 @@ fn sub_char() {
         .stdout_only("the letter A");
 }
 
+#[test]
+fn sub_char_from_string() {
+    new_ucmd!()
+        .args(&["%c%c%c", "five", "%", "oval"])
+        .succeeds()
+        .stdout_only("f%o");
+}
+
 #[test]
 fn sub_num_int() {
     new_ucmd!()
@@ -190,6 +254,31 @@ fn sub_num_int_char_const_in() {
         .args(&["ninety seven is %i", "'a"])
         .succeeds()
         .stdout_only("ninety seven is 97");
+
+    new_ucmd!()
+        .args(&["emoji is %i", "'🙃"])
+        .succeeds()
+        .stdout_only("emoji is 128579");
+
+    new_ucmd!()
+        .args(&["ninety seven is %i", "\"a"])
+        .succeeds()
+        .stdout_only("ninety seven is 97");
+
+    new_ucmd!()
+        .args(&["emoji is %i", "\"🙃"])
+        .succeeds()
+        .stdout_only("emoji is 128579");
+}
+
+#[test]
+fn sub_num_thousands() {
+    // For "C" locale, the thousands separator is ignored but should
+    // not result in an error
+    new_ucmd!()
+        .args(&["%'i", "123456"])
+        .succeeds()
+        .stdout_only("123456");
 }
 
 #[test]
@@ -224,6 +313,13 @@ fn sub_num_hex_upper() {
         .stdout_only("thirty in hex is 1E");
 }
 
+#[test]
+fn sub_num_hex_non_numerical() {
+    new_ucmd!()
+        .args(&["parameters need to be numbers %X", "%194"])
+        .fails_with_code(1);
+}
+
 #[test]
 fn sub_num_float() {
     new_ucmd!()
@@ -249,7 +345,16 @@ fn sub_num_float_e_no_round() {
 }
 
 #[test]
-fn sub_num_float_round() {
+fn sub_num_float_round_to_one() {
+    new_ucmd!()
+        .args(&["one is %f", "0.9999995"])
+        .succeeds()
+        .stdout_only("one is 1.000000");
+}
+
+#[test]
+#[ignore = "Requires 'long double' precision floats to be used internally"]
+fn sub_num_float_round_to_two() {
     new_ucmd!()
         .args(&["two is %f", "1.9999995"])
         .succeeds()
@@ -296,7 +401,14 @@ fn sub_num_dec_trunc() {
         .stdout_only("pi is ~ 3.14159");
 }
 
-#[cfg_attr(not(feature = "test_unimplemented"), ignore)]
+#[test]
+fn sub_num_sci_negative() {
+    new_ucmd!()
+        .args(&["-1234 is %e", "-1234"])
+        .succeeds()
+        .stdout_only("-1234 is -1.234000e+03");
+}
+
 #[test]
 fn sub_num_hex_float_lower() {
     new_ucmd!()
@@ -305,7 +417,6 @@ fn sub_num_hex_float_lower() {
         .stdout_only("0xep-4");
 }
 
-#[cfg_attr(not(feature = "test_unimplemented"), ignore)]
 #[test]
 fn sub_num_hex_float_upper() {
     new_ucmd!()
@@ -427,35 +538,112 @@ fn sub_any_asterisk_hex_arg() {
 }
 
 #[test]
-fn sub_any_specifiers_no_params() {
+fn sub_any_asterisk_negative_first_param() {
     new_ucmd!()
-        .args(&["%ztlhLji", "3"]) //spell-checker:disable-line
+        .args(&["a(%*s)b", "-5", "xyz"])
         .succeeds()
-        .stdout_only("3");
+        .stdout_only("a(xyz  )b"); // Would be 'a(  xyz)b' if -5 was 5
+
+    // Negative octal
+    new_ucmd!()
+        .args(&["a(%*s)b", "-010", "xyz"])
+        .succeeds()
+        .stdout_only("a(xyz     )b");
+
+    // Negative hexadecimal
+    new_ucmd!()
+        .args(&["a(%*s)b", "-0x10", "xyz"])
+        .succeeds()
+        .stdout_only("a(xyz             )b");
+
+    // Should also work on %c
+    new_ucmd!()
+        .args(&["a(%*c)b", "-5", "x"])
+        .succeeds()
+        .stdout_only("a(x    )b"); // Would be 'a(    x)b' if -5 was 5
 }
 
 #[test]
-fn sub_any_specifiers_after_first_param() {
+fn sub_any_asterisk_first_param_with_integer() {
     new_ucmd!()
-        .args(&["%0ztlhLji", "3"]) //spell-checker:disable-line
+        .args(&["|%*d|", "3", "0"])
         .succeeds()
-        .stdout_only("3");
+        .stdout_only("|  0|");
+
+    new_ucmd!()
+        .args(&["|%*d|", "1", "0"])
+        .succeeds()
+        .stdout_only("|0|");
+
+    new_ucmd!()
+        .args(&["|%*d|", "0", "0"])
+        .succeeds()
+        .stdout_only("|0|");
+
+    new_ucmd!()
+        .args(&["|%*d|", "-1", "0"])
+        .succeeds()
+        .stdout_only("|0|");
+
+    // Negative widths are left-aligned
+    new_ucmd!()
+        .args(&["|%*d|", "-3", "0"])
+        .succeeds()
+        .stdout_only("|0  |");
 }
 
 #[test]
-fn sub_any_specifiers_after_period() {
+fn sub_any_asterisk_second_param_with_integer() {
     new_ucmd!()
-        .args(&["%0.ztlhLji", "3"]) //spell-checker:disable-line
+        .args(&["|%.*d|", "3", "10"])
         .succeeds()
-        .stdout_only("3");
+        .stdout_only("|010|");
+
+    new_ucmd!()
+        .args(&["|%*.d|", "1", "10"])
+        .succeeds()
+        .stdout_only("|10|");
+
+    new_ucmd!()
+        .args(&["|%.*d|", "0", "10"])
+        .succeeds()
+        .stdout_only("|10|");
+
+    new_ucmd!()
+        .args(&["|%.*d|", "-1", "10"])
+        .succeeds()
+        .stdout_only("|10|");
+
+    new_ucmd!()
+        .args(&["|%.*d|", "-2", "10"])
+        .succeeds()
+        .stdout_only("|10|");
+
+    new_ucmd!()
+        .args(&["|%.*d|", &i64::MIN.to_string(), "10"])
+        .succeeds()
+        .stdout_only("|10|");
+
+    new_ucmd!()
+        .args(&["|%.*d|", &format!("-{}", u128::MAX), "10"])
+        .fails_with_code(1)
+        .stdout_is("|10|")
+        .stderr_is(
+            "printf: '-340282366920938463463374607431768211455': Numerical result out of range\n",
+        );
+}
+
+#[test]
+fn sub_any_specifiers() {
+    // spell-checker:disable-next-line
+    for format in ["%ztlhLji", "%0ztlhLji", "%0.ztlhLji"] {
+        new_ucmd!().args(&[format, "3"]).succeeds().stdout_only("3");
+    }
 }
 
 #[test]
 fn unspecified_left_justify_is_1_width() {
-    new_ucmd!()
-        .args(&["%-o"]) //spell-checker:disable-line
-        .succeeds()
-        .stdout_only("0");
+    new_ucmd!().args(&["%-o"]).succeeds().stdout_only("0");
 }
 
 #[test]
@@ -469,7 +657,7 @@ fn sub_any_specifiers_after_second_param() {
 #[test]
 fn stop_after_additional_escape() {
     new_ucmd!()
-        .args(&["A%sC\\cD%sF", "B", "E"]) //spell-checker:disable-line
+        .args(&["A%sC\\cD%sF", "B", "E"])
         .succeeds()
         .stdout_only("ABC");
 }
@@ -534,3 +722,643 @@ fn sub_general_round_float_leading_zeroes() {
         .succeeds()
         .stdout_only("1.00001");
 }
+
+#[test]
+fn partial_float() {
+    new_ucmd!()
+        .args(&["%.2f is %s", "42.03x", "a lot"])
+        .fails_with_code(1)
+        .stdout_is("42.03 is a lot")
+        .stderr_is("printf: '42.03x': value not completely converted\n");
+}
+
+#[test]
+fn partial_integer() {
+    new_ucmd!()
+        .args(&["%d is %s", "42x23", "a lot"])
+        .fails_with_code(1)
+        .stdout_is("42 is a lot")
+        .stderr_is("printf: '42x23': value not completely converted\n");
+
+    new_ucmd!()
+        .args(&["%d is not %s", "0xwa", "a lot"])
+        .fails_with_code(1)
+        .stdout_is("0 is not a lot")
+        .stderr_is("printf: '0xwa': value not completely converted\n");
+}
+
+#[test]
+fn unsigned_hex_negative_wraparound() {
+    new_ucmd!()
+        .args(&["%x", "-0b100"])
+        .succeeds()
+        .stdout_only("fffffffffffffffc");
+
+    new_ucmd!()
+        .args(&["%x", "-0100"])
+        .succeeds()
+        .stdout_only("ffffffffffffffc0");
+
+    new_ucmd!()
+        .args(&["%x", "-100"])
+        .succeeds()
+        .stdout_only("ffffffffffffff9c");
+
+    new_ucmd!()
+        .args(&["%x", "-0x100"])
+        .succeeds()
+        .stdout_only("ffffffffffffff00");
+
+    new_ucmd!()
+        .args(&["%x", "-92233720368547758150"])
+        .fails_with_code(1)
+        .stdout_is("ffffffffffffffff")
+        .stderr_is("printf: '-92233720368547758150': Numerical result out of range\n");
+
+    new_ucmd!()
+        .args(&["%u", "-1002233720368547758150"])
+        .fails_with_code(1)
+        .stdout_is("18446744073709551615")
+        .stderr_is("printf: '-1002233720368547758150': Numerical result out of range\n");
+}
+
+#[test]
+fn test_overflow() {
+    new_ucmd!()
+        .args(&["%d", "36893488147419103232"])
+        .fails_with_code(1)
+        .stdout_is("9223372036854775807")
+        .stderr_is("printf: '36893488147419103232': Numerical result out of range\n");
+
+    new_ucmd!()
+        .args(&["%d", "-36893488147419103232"])
+        .fails_with_code(1)
+        .stdout_is("-9223372036854775808")
+        .stderr_is("printf: '-36893488147419103232': Numerical result out of range\n");
+
+    new_ucmd!()
+        .args(&["%u", "36893488147419103232"])
+        .fails_with_code(1)
+        .stdout_is("18446744073709551615")
+        .stderr_is("printf: '36893488147419103232': Numerical result out of range\n");
+}
+
+#[test]
+fn partial_char() {
+    new_ucmd!()
+        .args(&["%d", "'abc"])
+        .fails_with_code(1)
+        .stdout_is("97")
+        .stderr_is(
+            "printf: warning: bc: character(s) following character constant have been ignored\n",
+        );
+}
+
+#[test]
+fn sub_alternative_lower_hex_0() {
+    new_ucmd!().args(&["%#x", "0"]).succeeds().stdout_only("0");
+}
+
+#[test]
+fn sub_alternative_lower_hex() {
+    new_ucmd!()
+        .args(&["%#x", "42"])
+        .succeeds()
+        .stdout_only("0x2a");
+}
+
+#[test]
+fn sub_alternative_upper_hex_0() {
+    new_ucmd!().args(&["%#X", "0"]).succeeds().stdout_only("0");
+}
+
+#[test]
+fn sub_alternative_upper_hex() {
+    new_ucmd!()
+        .args(&["%#X", "42"])
+        .succeeds()
+        .stdout_only("0X2A");
+}
+
+#[test]
+fn char_as_byte() {
+    new_ucmd!()
+        .args(&["%c", "🙃"])
+        .succeeds()
+        .no_stderr()
+        .stdout_is_bytes(b"\xf0");
+}
+
+#[test]
+fn no_infinite_loop() {
+    new_ucmd!()
+        .args(&["a", "b"])
+        .succeeds()
+        .stdout_is("a")
+        .stderr_contains("warning: ignoring excess arguments, starting with 'b'");
+}
+
+#[test]
+fn pad_octal_with_prefix() {
+    new_ucmd!()
+        .args(&[">%#15.6o<", "0"])
+        .succeeds()
+        .stdout_only(">         000000<");
+
+    new_ucmd!()
+        .args(&[">%#15.6o<", "01"])
+        .succeeds()
+        .stdout_only(">         000001<");
+
+    new_ucmd!()
+        .args(&[">%#15.6o<", "01234"])
+        .succeeds()
+        .stdout_only(">         001234<");
+
+    new_ucmd!()
+        .args(&[">%#15.6o<", "012345"])
+        .succeeds()
+        .stdout_only(">         012345<");
+
+    new_ucmd!()
+        .args(&[">%#15.6o<", "0123456"])
+        .succeeds()
+        .stdout_only(">        0123456<");
+}
+
+#[test]
+fn pad_unsigned_zeroes() {
+    for format in ["%.3u", "%.3x", "%.3X", "%.3o"] {
+        new_ucmd!()
+            .args(&[format, "0"])
+            .succeeds()
+            .stdout_only("000");
+    }
+}
+
+#[test]
+fn pad_unsigned_three() {
+    for (format, expected) in [
+        ("%.3u", "003"),
+        ("%.3x", "003"),
+        ("%.3X", "003"),
+        ("%.3o", "003"),
+        ("%#.3x", "0x003"),
+        ("%#.3X", "0X003"),
+        ("%#.3o", "003"),
+    ] {
+        new_ucmd!()
+            .args(&[format, "3"])
+            .succeeds()
+            .stdout_only(expected);
+    }
+}
+
+#[test]
+fn pad_char() {
+    for (format, expected) in [("%3c", "  X"), ("%1c", "X"), ("%-1c", "X"), ("%-3c", "X  ")] {
+        new_ucmd!()
+            .args(&[format, "X"])
+            .succeeds()
+            .stdout_only(expected);
+    }
+}
+
+#[test]
+fn pad_string() {
+    for (format, expected) in [
+        ("%8s", "  bottle"),
+        ("%-8s", "bottle  "),
+        ("%6s", "bottle"),
+        ("%-6s", "bottle"),
+    ] {
+        new_ucmd!()
+            .args(&[format, "bottle"])
+            .succeeds()
+            .stdout_only(expected);
+    }
+}
+
+#[test]
+fn format_spec_zero_fails() {
+    // It is invalid to have the format spec
+    for format in ["%0c", "%0s"] {
+        new_ucmd!().args(&[format, "3"]).fails_with_code(1);
+    }
+}
+
+#[test]
+fn invalid_precision_tests() {
+    // It is invalid to have length of output string greater than i32::MAX
+    for format in ["%.*d", "%.*f"] {
+        let expected_error = "printf: invalid precision: '2147483648'\n";
+        new_ucmd!()
+            .args(&[format, "2147483648", "0"])
+            .fails()
+            .stderr_is(expected_error);
+    }
+}
+
+// The following padding-tests test for the cases in which flags in ['0', ' '] are given.
+// For integer, only try to pad when no precision is given, while
+// for float, always try to pad
+#[test]
+fn space_padding_with_space_test() {
+    //  Check if printf gives an extra space in the beginning
+    new_ucmd!()
+        .args(&["% 3d", "1"])
+        .succeeds()
+        .stdout_only("  1");
+}
+
+#[test]
+fn zero_padding_with_space_test() {
+    new_ucmd!()
+        .args(&["% 03d", "1"])
+        .succeeds()
+        .stdout_only(" 01");
+}
+
+#[test]
+fn zero_padding_with_plus_test() {
+    new_ucmd!()
+        .args(&["%+04d", "1"])
+        .succeeds()
+        .stdout_only("+001");
+}
+
+#[test]
+fn negative_zero_padding_test() {
+    new_ucmd!()
+        .args(&["%03d", "-1"])
+        .succeeds()
+        .stdout_only("-01");
+}
+
+#[test]
+fn negative_zero_padding_with_space_test() {
+    new_ucmd!()
+        .args(&["% 03d", "-1"])
+        .succeeds()
+        .stdout_only("-01");
+}
+
+#[test]
+fn spaces_before_numbers_are_ignored() {
+    new_ucmd!()
+        .args(&["%*.*d", "   5", "  3", " 6"])
+        .succeeds()
+        .stdout_only("  006");
+}
+
+#[test]
+fn float_with_zero_precision_should_pad() {
+    new_ucmd!()
+        .args(&["%03.0f", "-1"])
+        .succeeds()
+        .stdout_only("-01");
+}
+
+#[test]
+fn float_non_finite() {
+    new_ucmd!()
+        .args(&[
+            "%f %f %F %f %f %F",
+            "nan",
+            "-nan",
+            "nan",
+            "inf",
+            "-inf",
+            "inf",
+        ])
+        .succeeds()
+        .stdout_only("nan -nan NAN inf -inf INF");
+}
+
+#[test]
+fn float_zero_neg_zero() {
+    new_ucmd!()
+        .args(&["%f %f", "0.0", "-0.0"])
+        .succeeds()
+        .stdout_only("0.000000 -0.000000");
+}
+
+#[test]
+fn precision_check() {
+    new_ucmd!()
+        .args(&["%.3d", "1"])
+        .succeeds()
+        .stdout_only("001");
+}
+
+#[test]
+fn space_padding_with_precision() {
+    new_ucmd!()
+        .args(&["%4.3d", "1"])
+        .succeeds()
+        .stdout_only(" 001");
+}
+
+#[test]
+fn float_zero_padding_with_precision() {
+    new_ucmd!()
+        .args(&["%04.1f", "1"])
+        .succeeds()
+        .stdout_only("01.0");
+}
+
+#[test]
+fn float_space_padding_with_precision() {
+    new_ucmd!()
+        .args(&["%4.1f", "1"])
+        .succeeds()
+        .stdout_only(" 1.0");
+}
+
+#[test]
+fn negative_float_zero_padding_with_precision() {
+    new_ucmd!()
+        .args(&["%05.1f", "-1"])
+        .succeeds()
+        .stdout_only("-01.0");
+}
+
+#[test]
+fn float_default_precision_space_padding() {
+    new_ucmd!()
+        .args(&["%10f", "1"])
+        .succeeds()
+        .stdout_only("  1.000000");
+}
+
+#[test]
+fn float_default_precision_zero_padding() {
+    new_ucmd!()
+        .args(&["%010f", "1"])
+        .succeeds()
+        .stdout_only("001.000000");
+}
+
+#[test]
+fn flag_position_space_padding() {
+    new_ucmd!()
+        .args(&["% +3.1d", "1"])
+        .succeeds()
+        .stdout_only(" +1");
+}
+
+#[test]
+fn float_flag_position_space_padding() {
+    new_ucmd!()
+        .args(&["% +5.1f", "1"])
+        .succeeds()
+        .stdout_only(" +1.0");
+}
+
+#[test]
+fn float_large_precision() {
+    // Note: This does not match GNU coreutils output (0.100000000000000000001355252716 on x86),
+    // as we parse and format using ExtendedBigDecimal, which provides arbitrary precision.
+    new_ucmd!()
+        .args(&["%.30f", "0.1"])
+        .succeeds()
+        .stdout_only("0.100000000000000000000000000000");
+}
+
+#[test]
+fn float_non_finite_space_padding() {
+    new_ucmd!()
+        .args(&["% 5.2f|% 5.2f|% 5.2f|% 5.2f", "inf", "-inf", "nan", "-nan"])
+        .succeeds()
+        .stdout_only("  inf| -inf|  nan| -nan");
+}
+
+#[test]
+fn float_non_finite_zero_padding() {
+    // Zero-padding pads non-finite numbers with spaces.
+    new_ucmd!()
+        .args(&["%05.2f|%05.2f|%05.2f|%05.2f", "inf", "-inf", "nan", "-nan"])
+        .succeeds()
+        .stdout_only("  inf| -inf|  nan| -nan");
+}
+
+#[test]
+fn float_abs_value_less_than_one() {
+    new_ucmd!()
+        .args(&["%g", "0.1171875"])
+        .succeeds()
+        .stdout_only("0.117188");
+
+    // The original value from #7031 issue
+    new_ucmd!()
+        .args(&["%g", "-0.1171875"])
+        .succeeds()
+        .stdout_only("-0.117188");
+
+    new_ucmd!()
+        .args(&["%g", "0.01171875"])
+        .succeeds()
+        .stdout_only("0.0117188");
+
+    new_ucmd!()
+        .args(&["%g", "-0.01171875"])
+        .succeeds()
+        .stdout_only("-0.0117188");
+
+    new_ucmd!()
+        .args(&["%g", "0.001171875001"])
+        .succeeds()
+        .stdout_only("0.00117188");
+
+    new_ucmd!()
+        .args(&["%g", "-0.001171875001"])
+        .succeeds()
+        .stdout_only("-0.00117188");
+}
+
+#[test]
+fn float_switch_switch_decimal_scientific() {
+    new_ucmd!()
+        .args(&["%g", "0.0001"])
+        .succeeds()
+        .stdout_only("0.0001");
+
+    new_ucmd!()
+        .args(&["%g", "0.00001"])
+        .succeeds()
+        .stdout_only("1e-05");
+}
+
+#[test]
+fn float_arg_zero() {
+    new_ucmd!()
+        .args(&["%f", "0."])
+        .succeeds()
+        .stdout_only("0.000000");
+
+    new_ucmd!()
+        .args(&["%f", ".0"])
+        .succeeds()
+        .stdout_only("0.000000");
+
+    new_ucmd!()
+        .args(&["%f", ".0e100000"])
+        .succeeds()
+        .stdout_only("0.000000");
+}
+
+#[test]
+fn float_arg_invalid() {
+    // Just a dot fails.
+    new_ucmd!()
+        .args(&["%f", "."])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("expected a numeric value");
+
+    new_ucmd!()
+        .args(&["%f", "-."])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("expected a numeric value");
+
+    // Just an exponent indicator fails.
+    new_ucmd!()
+        .args(&["%f", "e"])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("expected a numeric value");
+
+    // No digit but only exponent fails
+    new_ucmd!()
+        .args(&["%f", ".e12"])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("expected a numeric value");
+
+    // No exponent partially fails
+    new_ucmd!()
+        .args(&["%f", "123e"])
+        .fails()
+        .stdout_is("123.000000")
+        .stderr_contains("value not completely converted");
+
+    // Nothing past `0x` parses as zero
+    new_ucmd!()
+        .args(&["%f", "0x"])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("value not completely converted");
+
+    new_ucmd!()
+        .args(&["%f", "0x."])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("value not completely converted");
+
+    new_ucmd!()
+        .args(&["%f", "0xp12"])
+        .fails()
+        .stdout_is("0.000000")
+        .stderr_contains("value not completely converted");
+}
+
+#[test]
+fn float_arg_with_whitespace() {
+    new_ucmd!()
+        .args(&["%f", " \u{0020}\u{000d}\t\n0.000001"])
+        .succeeds()
+        .stdout_only("0.000001");
+
+    new_ucmd!()
+        .args(&["%f", "0.1 "])
+        .fails()
+        .stderr_contains("value not completely converted");
+
+    // Unicode whitespace should not be allowed in a number
+    new_ucmd!()
+        .args(&["%f", "\u{2029}0.1"])
+        .fails()
+        .stderr_contains("expected a numeric value");
+
+    // An input string with a whitespace special character that has
+    // not already been expanded should fail.
+    new_ucmd!()
+        .args(&["%f", "\\t0.1"])
+        .fails()
+        .stderr_contains("expected a numeric value");
+}
+
+#[test]
+fn mb_input() {
+    for format in ["\"á", "\'á", "'\u{e1}"] {
+        new_ucmd!()
+            .args(&["%04x\n", format])
+            .succeeds()
+            .stdout_only("00e1\n");
+    }
+
+    let cases = vec![
+        ("\"á=", "="),
+        ("\'á-", "-"),
+        ("\'á=-==", "=-=="),
+        ("'\u{e1}++", "++"),
+    ];
+
+    for (format, expected) in cases {
+        new_ucmd!()
+            .args(&["%04x\n", format])
+            .succeeds()
+            .stdout_is("00e1\n")
+            .stderr_is(format!("printf: warning: {expected}: character(s) following character constant have been ignored\n"));
+    }
+}
+
+#[test]
+fn positional_format_specifiers() {
+    new_ucmd!()
+        .args(&["%1$d%d-", "5", "10", "6", "20"])
+        .succeeds()
+        .stdout_only("55-1010-66-2020-");
+
+    new_ucmd!()
+        .args(&["%2$d%d-", "5", "10", "6", "20"])
+        .succeeds()
+        .stdout_only("105-206-");
+
+    new_ucmd!()
+        .args(&["%3$d%d-", "5", "10", "6", "20"])
+        .succeeds()
+        .stdout_only("65-020-");
+
+    new_ucmd!()
+        .args(&["%4$d%d-", "5", "10", "6", "20"])
+        .succeeds()
+        .stdout_only("205-");
+
+    new_ucmd!()
+        .args(&["%5$d%d-", "5", "10", "6", "20"])
+        .succeeds()
+        .stdout_only("05-");
+
+    new_ucmd!()
+        .args(&["%0$d%d-", "5", "10", "6", "20"])
+        .fails_with_code(1)
+        .stderr_only("printf: %0$: invalid conversion specification\n");
+
+    new_ucmd!()
+        .args(&[
+            "Octal: %6$o, Int: %1$d, Float: %4$f, String: %2$s, Hex: %7$x, Scientific: %5$e, Char: %9$c, Unsigned: %3$u, Integer: %8$i",
+            "42",          // 1$d - Int
+            "hello",       // 2$s - String
+            "100",         // 3$u - Unsigned
+            "3.14159",     // 4$f - Float
+            "0.00001",     // 5$e - Scientific
+            "77",          // 6$o - Octal
+            "255",         // 7$x - Hex
+            "123",         // 8$i - Integer
+            "A",           // 9$c - Char
+        ])
+        .succeeds()
+        .stdout_only("Octal: 115, Int: 42, Float: 3.141590, String: hello, Hex: ff, Scientific: 1.000000e-05, Char: A, Unsigned: 100, Integer: 123");
+}
diff --git a/tests/by-util/test_ptx.rs b/tests/by-util/test_ptx.rs
index a106972ac29..4be44fbc7db 100644
--- a/tests/by-util/test_ptx.rs
+++ b/tests/by-util/test_ptx.rs
@@ -2,11 +2,15 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+// spell-checker:ignore roff
+
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -112,3 +116,75 @@ fn gnu_ext_disabled_empty_word_regexp_ignores_break_file() {
         .succeeds()
         .stdout_only_fixture("gnu_ext_disabled_rightward_no_ref.expected");
 }
+
+#[test]
+fn test_reject_too_many_operands() {
+    new_ucmd!().args(&["-G", "-", "-", "-"]).fails_with_code(1);
+}
+
+#[test]
+fn test_break_file_regex_escaping() {
+    new_ucmd!()
+        .pipe_in("\\.+*?()|[]{}^$#&-~")
+        .args(&["-G", "-b", "-", "input"])
+        .succeeds()
+        .stdout_only_fixture("break_file_regex_escaping.expected");
+}
+
+#[test]
+fn test_ignore_case() {
+    new_ucmd!()
+        .args(&["-G", "-f"])
+        .pipe_in("a _")
+        .succeeds()
+        .stdout_only(".xx \"\" \"\" \"a _\" \"\"\n.xx \"\" \"a\" \"_\" \"\"\n");
+}
+
+#[test]
+fn test_format() {
+    new_ucmd!()
+        .args(&["-G", "-O"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_only(".xx \"\" \"\" \"a\" \"\"\n");
+    new_ucmd!()
+        .args(&["-G", "-T"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_only("\\xx {}{}{a}{}{}\n");
+    new_ucmd!()
+        .args(&["-G", "--format=roff"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_only(".xx \"\" \"\" \"a\" \"\"\n");
+    new_ucmd!()
+        .args(&["-G", "--format=tex"])
+        .pipe_in("a")
+        .succeeds()
+        .stdout_only("\\xx {}{}{a}{}{}\n");
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .arg("-G")
+        .pipe_in("hello")
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("ptx: write failed: No space left on device\n");
+}
+
+#[test]
+fn test_utf8() {
+    new_ucmd!()
+        .args(&["-G"])
+        .pipe_in("it’s disabled\n")
+        .succeeds()
+        .stdout_only(".xx \"\" \"it’s\" \"disabled\" \"\"\n.xx \"\" \"\" \"it’s disabled\" \"\"\n");
+    new_ucmd!()
+        .args(&["-G", "-T"])
+        .pipe_in("it’s disabled\n")
+        .succeeds()
+        .stdout_only("\\xx {}{it’s}{disabled}{}{}\n\\xx {}{}{it’s}{ disabled}{}\n");
+}
diff --git a/tests/by-util/test_pwd.rs b/tests/by-util/test_pwd.rs
index 89341c0c33d..77826b8788a 100644
--- a/tests/by-util/test_pwd.rs
+++ b/tests/by-util/test_pwd.rs
@@ -6,11 +6,14 @@
 
 use std::path::PathBuf;
 
-use crate::common::util::{TestScenario, UCommand};
+use uutests::new_ucmd;
+use uutests::util::{TestScenario, UCommand};
+//use uutests::at_and_ucmd;
+use uutests::{at_and_ucmd, util_name};
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -31,7 +34,7 @@ fn test_deleted_dir() {
     use std::process::Command;
 
     let ts = TestScenario::new(util_name!());
-    let at = ts.fixtures;
+    let at = &ts.fixtures;
     let output = Command::new("sh")
         .arg("-c")
         .arg(format!(
diff --git a/tests/by-util/test_readlink.rs b/tests/by-util/test_readlink.rs
index 973e30a3597..33840c9a183 100644
--- a/tests/by-util/test_readlink.rs
+++ b/tests/by-util/test_readlink.rs
@@ -3,7 +3,10 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore regfile
-use crate::common::util::{get_root_path, TestScenario};
+use uutests::new_ucmd;
+use uutests::path_concat;
+use uutests::util::{TestScenario, get_root_path};
+use uutests::{at_and_ucmd, util_name};
 
 static GIBBERISH: &str = "supercalifragilisticexpialidocious";
 
@@ -14,7 +17,7 @@ static NOT_A_DIRECTORY: &str = "The directory name is invalid.";
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -31,7 +34,7 @@ fn test_resolve() {
 #[test]
 fn test_canonicalize() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let actual = ucmd.arg("-f").arg(".").run().stdout_move_str();
+    let actual = ucmd.arg("-f").arg(".").succeeds().stdout_move_str();
     let expect = at.root_dir_resolved() + "\n";
     println!("actual: {actual:?}");
     println!("expect: {expect:?}");
@@ -41,7 +44,7 @@ fn test_canonicalize() {
 #[test]
 fn test_canonicalize_existing() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let actual = ucmd.arg("-e").arg(".").run().stdout_move_str();
+    let actual = ucmd.arg("-e").arg(".").succeeds().stdout_move_str();
     let expect = at.root_dir_resolved() + "\n";
     println!("actual: {actual:?}");
     println!("expect: {expect:?}");
@@ -51,7 +54,7 @@ fn test_canonicalize_existing() {
 #[test]
 fn test_canonicalize_missing() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let actual = ucmd.arg("-m").arg(GIBBERISH).run().stdout_move_str();
+    let actual = ucmd.arg("-m").arg(GIBBERISH).succeeds().stdout_move_str();
     let expect = path_concat!(at.root_dir_resolved(), GIBBERISH) + "\n";
     println!("actual: {actual:?}");
     println!("expect: {expect:?}");
@@ -63,7 +66,12 @@ fn test_long_redirection_to_current_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
     // Create a 256-character path to current directory
     let dir = path_concat!(".", ..128);
-    let actual = ucmd.arg("-n").arg("-m").arg(dir).run().stdout_move_str();
+    let actual = ucmd
+        .arg("-n")
+        .arg("-m")
+        .arg(dir)
+        .succeeds()
+        .stdout_move_str();
     let expect = at.root_dir_resolved();
     println!("actual: {actual:?}");
     println!("expect: {expect:?}");
@@ -78,7 +86,7 @@ fn test_long_redirection_to_root() {
         .arg("-n")
         .arg("-m")
         .arg(dir)
-        .run()
+        .succeeds()
         .stdout_move_str();
     let expect = get_root_path();
     println!("actual: {actual:?}");
@@ -91,8 +99,7 @@ fn test_symlink_to_itself_verbose() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.relative_symlink_file("a", "a");
     ucmd.args(&["-ev", "a"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("Too many levels of symbolic links");
 }
 
@@ -104,8 +111,7 @@ fn test_trailing_slash_regular_file() {
     scene
         .ucmd()
         .args(&["-ev", "./regfile/"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains(NOT_A_DIRECTORY)
         .no_stdout();
     scene
@@ -124,8 +130,7 @@ fn test_trailing_slash_symlink_to_regular_file() {
     scene
         .ucmd()
         .args(&["-ev", "./link/"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains(NOT_A_DIRECTORY)
         .no_stdout();
     scene
@@ -136,8 +141,7 @@ fn test_trailing_slash_symlink_to_regular_file() {
     scene
         .ucmd()
         .args(&["-e", "./link/more"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .no_stdout();
 }
 
@@ -171,8 +175,7 @@ fn test_trailing_slash_symlink_to_directory() {
     scene
         .ucmd()
         .args(&["-ev", "./link/more"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("No such file or directory")
         .no_stdout();
 }
@@ -197,8 +200,7 @@ fn test_trailing_slash_symlink_to_missing() {
         scene
             .ucmd()
             .args(&["-ev", query])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains("No such file or directory")
             .no_stdout();
     }
@@ -219,22 +221,19 @@ fn test_canonicalize_trailing_slash_regfile() {
         scene
             .ucmd()
             .args(&["-fv", &format!("./{name}/")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(NOT_A_DIRECTORY)
             .no_stdout();
         scene
             .ucmd()
             .args(&["-fv", &format!("{name}/more")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(NOT_A_DIRECTORY)
             .no_stdout();
         scene
             .ucmd()
             .args(&["-fv", &format!("./{name}/more/")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .stderr_contains(NOT_A_DIRECTORY)
             .no_stdout();
     }
@@ -270,14 +269,12 @@ fn test_canonicalize_trailing_slash_subdir() {
         scene
             .ucmd()
             .args(&["-f", &format!("{name}/more/more2")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .no_stdout();
         scene
             .ucmd()
             .args(&["-f", &format!("./{name}/more/more2/")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .no_stdout();
     }
 }
@@ -301,14 +298,12 @@ fn test_canonicalize_trailing_slash_missing() {
         scene
             .ucmd()
             .args(&["-f", &format!("{name}/more")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .no_stdout();
         scene
             .ucmd()
             .args(&["-f", &format!("./{name}/more/")])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .no_stdout();
     }
 }
@@ -330,8 +325,7 @@ fn test_canonicalize_trailing_slash_subdir_missing() {
         scene
             .ucmd()
             .args(&["-f", query])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .no_stdout();
     }
 }
@@ -345,8 +339,7 @@ fn test_canonicalize_trailing_slash_symlink_loop() {
         scene
             .ucmd()
             .args(&["-f", query])
-            .fails()
-            .code_is(1)
+            .fails_with_code(1)
             .no_stdout();
     }
 }
diff --git a/tests/by-util/test_realpath.rs b/tests/by-util/test_realpath.rs
index c3a15fba40e..ee156f5d031 100644
--- a/tests/by-util/test_realpath.rs
+++ b/tests/by-util/test_realpath.rs
@@ -2,11 +2,15 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::{get_root_path, TestScenario};
+// spell-checker:ignore nusr
+use uutests::new_ucmd;
+use uutests::path_concat;
+use uutests::util::{TestScenario, get_root_path};
+use uutests::{at_and_ucmd, util_name};
 
 #[cfg(windows)]
 use regex::Regex;
-use std::path::{Path, MAIN_SEPARATOR};
+use std::path::{MAIN_SEPARATOR, Path};
 
 static GIBBERISH: &str = "supercalifragilisticexpialidocious";
 
@@ -231,7 +235,7 @@ fn test_realpath_when_symlink_is_absolute_and_enoent() {
     ucmd.arg("dir1/foo1")
         .arg("dir1/foo2")
         .arg("dir1/foo3")
-        .run()
+        .fails()
         .stdout_contains("/dir2/bar\n")
         .stdout_contains("/dir2/baz\n")
         .stderr_is("realpath: dir1/foo2: No such file or directory\n");
@@ -240,7 +244,7 @@ fn test_realpath_when_symlink_is_absolute_and_enoent() {
     ucmd.arg("dir1/foo1")
         .arg("dir1/foo2")
         .arg("dir1/foo3")
-        .run()
+        .fails()
         .stdout_contains("\\dir2\\bar\n")
         .stdout_contains("\\dir2\\baz\n")
         .stderr_is("realpath: dir1/foo2: No such file or directory\n");
@@ -263,7 +267,7 @@ fn test_realpath_when_symlink_part_is_missing() {
     let expect2 = format!("dir2{MAIN_SEPARATOR}baz");
 
     ucmd.args(&["dir1/foo1", "dir1/foo2", "dir1/foo3", "dir1/foo4"])
-        .run()
+        .fails()
         .stdout_contains(expect1 + "\n")
         .stdout_contains(expect2 + "\n")
         .stderr_contains("realpath: dir1/foo2: No such file or directory\n")
@@ -276,8 +280,7 @@ fn test_relative_existing_require_directories() {
     at.mkdir("dir1");
     at.touch("dir1/f");
     ucmd.args(&["-e", "--relative-base=.", "--relative-to=dir1/f", "."])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("directory");
 }
 
@@ -353,7 +356,7 @@ fn test_relative() {
     new_ucmd!()
         .args(&["-sm", "--relative-base=/", "--relative-to=/", "/", "/usr"])
         .succeeds()
-        .stdout_is(".\nusr\n"); // spell-checker:disable-line
+        .stdout_is(".\nusr\n");
 
     let result = new_ucmd!()
         .args(&["-sm", "--relative-base=/usr", "/tmp", "/usr"])
@@ -366,7 +369,7 @@ fn test_relative() {
     new_ucmd!()
         .args(&["-sm", "--relative-base=/", "/", "/usr"])
         .succeeds()
-        .stdout_is(".\nusr\n"); // spell-checker:disable-line
+        .stdout_is(".\nusr\n");
 }
 
 #[test]
@@ -382,83 +385,82 @@ fn test_realpath_trailing_slash() {
         .ucmd()
         .arg("link_file")
         .succeeds()
-        .stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR));
-    scene.ucmd().arg("link_file/").fails().code_is(1);
+        .stdout_contains(format!("{MAIN_SEPARATOR}file\n"));
+    scene.ucmd().arg("link_file/").fails_with_code(1);
     scene
         .ucmd()
         .arg("link_dir")
         .succeeds()
-        .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}dir\n"));
     scene
         .ucmd()
         .arg("link_dir/")
         .succeeds()
-        .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}dir\n"));
     scene
         .ucmd()
         .arg("link_no_dir")
         .succeeds()
-        .stdout_contains(format!("{}no_dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}no_dir\n"));
     scene
         .ucmd()
         .arg("link_no_dir/")
         .succeeds()
-        .stdout_contains(format!("{}no_dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}no_dir\n"));
     scene
         .ucmd()
         .args(&["-e", "link_file"])
         .succeeds()
-        .stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR));
-    scene.ucmd().args(&["-e", "link_file/"]).fails().code_is(1);
+        .stdout_contains(format!("{MAIN_SEPARATOR}file\n"));
+    scene.ucmd().args(&["-e", "link_file/"]).fails_with_code(1);
     scene
         .ucmd()
         .args(&["-e", "link_dir"])
         .succeeds()
-        .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}dir\n"));
     scene
         .ucmd()
         .args(&["-e", "link_dir/"])
         .succeeds()
-        .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
-    scene.ucmd().args(&["-e", "link_no_dir"]).fails().code_is(1);
+        .stdout_contains(format!("{MAIN_SEPARATOR}dir\n"));
+    scene.ucmd().args(&["-e", "link_no_dir"]).fails_with_code(1);
     scene
         .ucmd()
         .args(&["-e", "link_no_dir/"])
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
     scene
         .ucmd()
         .args(&["-m", "link_file"])
         .succeeds()
-        .stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}file\n"));
     scene
         .ucmd()
         .args(&["-m", "link_file/"])
         .succeeds()
-        .stdout_contains(format!("{}file\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}file\n"));
     scene
         .ucmd()
         .args(&["-m", "link_dir"])
         .succeeds()
-        .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}dir\n"));
     scene
         .ucmd()
         .args(&["-m", "link_dir/"])
         .succeeds()
-        .stdout_contains(format!("{}dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}dir\n"));
     scene
         .ucmd()
         .args(&["-m", "link_no_dir"])
         .succeeds()
-        .stdout_contains(format!("{}no_dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}no_dir\n"));
     scene
         .ucmd()
         .args(&["-m", "link_no_dir/"])
         .succeeds()
-        .stdout_contains(format!("{}no_dir\n", std::path::MAIN_SEPARATOR));
+        .stdout_contains(format!("{MAIN_SEPARATOR}no_dir\n"));
 }
 
 #[test]
 fn test_realpath_empty() {
-    new_ucmd!().fails().code_is(1);
+    new_ucmd!().fails_with_code(1);
 }
diff --git a/tests/by-util/test_relpath.rs b/tests/by-util/test_relpath.rs
deleted file mode 100644
index 8a3c91802e1..00000000000
--- a/tests/by-util/test_relpath.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-// 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.
-use crate::common::util::TestScenario;
-use std::borrow::Cow;
-use std::path::Path;
-
-struct TestCase<'a> {
-    from: &'a str,
-    to: &'a str,
-    expected: &'a str,
-}
-
-const TESTS: [TestCase; 10] = [
-    TestCase {
-        from: "A/B/C",
-        to: "A",
-        expected: "../..",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/B",
-        expected: "..",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/B/C",
-        expected: "",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/B/C/D",
-        expected: "D",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/B/C/D/E",
-        expected: "D/E",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/B/D",
-        expected: "../D",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/B/D/E",
-        expected: "../D/E",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/D",
-        expected: "../../D",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "D/E/F",
-        expected: "../../../D/E/F",
-    },
-    TestCase {
-        from: "A/B/C",
-        to: "A/D/E",
-        expected: "../../D/E",
-    },
-];
-
-#[allow(clippy::needless_lifetimes)]
-fn convert_path<'a>(path: &'a str) -> Cow<'a, str> {
-    #[cfg(windows)]
-    return path.replace('/', "\\").into();
-    #[cfg(not(windows))]
-    return path.into();
-}
-
-#[test]
-fn test_relpath_with_from_no_d() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
-
-    for test in &TESTS {
-        let from: &str = &convert_path(test.from);
-        let to: &str = &convert_path(test.to);
-        let expected: &str = &convert_path(test.expected);
-
-        at.mkdir_all(to);
-        at.mkdir_all(from);
-
-        scene
-            .ucmd()
-            .arg(to)
-            .arg(from)
-            .succeeds()
-            .stdout_only(&format!("{expected}\n"));
-    }
-}
-
-#[test]
-fn test_relpath_with_from_with_d() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
-
-    for test in &TESTS {
-        let from: &str = &convert_path(test.from);
-        let to: &str = &convert_path(test.to);
-        let pwd = at.as_string();
-        at.mkdir_all(to);
-        at.mkdir_all(from);
-
-        // d is part of subpath -> expect relative path
-        let mut _result_stdout = scene
-            .ucmd()
-            .arg(to)
-            .arg(from)
-            .arg(&format!("-d{pwd}"))
-            .succeeds()
-            .stdout_move_str();
-        // relax rules for windows test environment
-        #[cfg(not(windows))]
-        assert!(Path::new(&_result_stdout).is_relative());
-
-        // d is not part of subpath -> expect absolute path
-        _result_stdout = scene
-            .ucmd()
-            .arg(to)
-            .arg(from)
-            .arg("-dnon_existing") // spell-checker:disable-line
-            .succeeds()
-            .stdout_move_str();
-        assert!(Path::new(&_result_stdout).is_absolute());
-    }
-}
-
-#[test]
-fn test_relpath_no_from_no_d() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
-
-    for test in &TESTS {
-        let to: &str = &convert_path(test.to);
-        at.mkdir_all(to);
-
-        let _result_stdout = scene.ucmd().arg(to).succeeds().stdout_move_str();
-        #[cfg(not(windows))]
-        assert_eq!(_result_stdout, format!("{to}\n"));
-        // relax rules for windows test environment
-        #[cfg(windows)]
-        assert!(_result_stdout.ends_with(&format!("{to}\n")));
-    }
-}
-
-#[test]
-fn test_relpath_no_from_with_d() {
-    let scene = TestScenario::new(util_name!());
-    let at = &scene.fixtures;
-
-    for test in &TESTS {
-        let to: &str = &convert_path(test.to);
-        let pwd = at.as_string();
-        at.mkdir_all(to);
-
-        // d is part of subpath -> expect relative path
-        let _result_stdout = scene
-            .ucmd()
-            .arg(to)
-            .arg(&format!("-d{pwd}"))
-            .succeeds()
-            .stdout_move_str();
-        // relax rules for windows test environment
-        #[cfg(not(windows))]
-        assert!(Path::new(&_result_stdout).is_relative());
-
-        // d is not part of subpath -> expect absolute path
-        let result_stdout = scene
-            .ucmd()
-            .arg(to)
-            .arg("-dnon_existing") // spell-checker:disable-line
-            .succeeds()
-            .stdout_move_str();
-        assert!(Path::new(&result_stdout).is_absolute());
-    }
-}
diff --git a/tests/by-util/test_rm.rs b/tests/by-util/test_rm.rs
index 73f99566c40..5ce3a610751 100644
--- a/tests/by-util/test_rm.rs
+++ b/tests/by-util/test_rm.rs
@@ -2,13 +2,18 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+#![allow(clippy::stable_sort_primitive)]
+
 use std::process::Stdio;
 
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -28,9 +33,9 @@ fn test_rm_failed() {
     let (_at, mut ucmd) = at_and_ucmd!();
     let file = "test_rm_one_file"; // Doesn't exist
 
-    ucmd.arg(file).fails().stderr_contains(&format!(
-        "cannot remove '{file}': No such file or directory"
-    ));
+    ucmd.arg(file)
+        .fails()
+        .stderr_contains(format!("cannot remove '{file}': No such file or directory"));
 }
 
 #[test]
@@ -165,10 +170,11 @@ fn test_rm_non_empty_directory() {
     at.mkdir(dir);
     at.touch(file_a);
 
-    ucmd.arg("-d")
-        .arg(dir)
-        .fails()
-        .stderr_contains(&format!("cannot remove '{dir}': Directory not empty"));
+    #[cfg(windows)]
+    let expected = "rm: cannot remove 'test_rm_non_empty_dir': The directory is not empty.\n";
+    #[cfg(not(windows))]
+    let expected = "rm: cannot remove 'test_rm_non_empty_dir': Directory not empty\n";
+    ucmd.arg("-d").arg(dir).fails().stderr_only(expected);
     assert!(at.file_exists(file_a));
     assert!(at.dir_exists(dir));
 }
@@ -223,7 +229,20 @@ fn test_rm_directory_without_flag() {
 
     ucmd.arg(dir)
         .fails()
-        .stderr_contains(&format!("cannot remove '{dir}': Is a directory"));
+        .stderr_contains(format!("cannot remove '{dir}': Is a directory"));
+}
+
+#[test]
+#[cfg(windows)]
+// https://github.com/uutils/coreutils/issues/3200
+fn test_rm_directory_with_trailing_backslash() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir = "dir";
+
+    at.mkdir(dir);
+
+    ucmd.arg(".\\dir\\").arg("-rf").succeeds();
+    assert!(!at.dir_exists(dir));
 }
 
 #[test]
@@ -274,7 +293,7 @@ fn test_rm_symlink_dir() {
         .ucmd()
         .arg(link)
         .fails()
-        .stderr_contains(&format!("cannot remove '{link}': Is a directory"));
+        .stderr_contains(format!("cannot remove '{link}': Is a directory"));
 
     assert!(at.dir_exists(link));
 
@@ -314,15 +333,14 @@ fn test_rm_verbose_slash() {
     at.touch(file_a);
 
     let file_a_normalized = &format!(
-        "{}{}test_rm_verbose_slash_file_a",
-        dir,
+        "{dir}{}test_rm_verbose_slash_file_a",
         std::path::MAIN_SEPARATOR
     );
 
     ucmd.arg("-r")
         .arg("-f")
         .arg("-v")
-        .arg(&format!("{dir}///"))
+        .arg(format!("{dir}///"))
         .succeeds()
         .stdout_only(format!(
             "removed '{file_a_normalized}'\nremoved directory '{dir}'\n"
@@ -561,6 +579,50 @@ fn test_rm_prompts() {
     assert!(!at.dir_exists("a"));
 }
 
+#[cfg(feature = "chmod")]
+#[test]
+fn test_rm_prompts_no_tty() {
+    // This test ensures InteractiveMode.PromptProtected proceeds silently with non-interactive stdin
+
+    use std::io::Write;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    at.mkdir("a/");
+
+    let file_1 = "a/empty";
+    let file_2 = "a/empty-no-write";
+    let file_3 = "a/f-no-write";
+
+    at.touch(file_1);
+    at.touch(file_2);
+    at.make_file(file_3)
+        .write_all(b"not-empty")
+        .expect("Couldn't write to a/f-no-write");
+
+    at.symlink_dir("a/empty-f", "a/slink");
+    at.symlink_dir(".", "a/slink-dot");
+
+    let dir_1 = "a/b/";
+    let dir_2 = "a/b-no-write/";
+
+    at.mkdir(dir_1);
+    at.mkdir(dir_2);
+
+    scene
+        .ccmd("chmod")
+        .arg("u-w")
+        .arg(file_3)
+        .arg(dir_2)
+        .arg(file_2)
+        .succeeds();
+
+    scene.ucmd().arg("-r").arg("a").succeeds().no_output();
+
+    assert!(!at.dir_exists("a"));
+}
+
 #[test]
 fn test_rm_force_prompts_order() {
     // Needed for talking with stdin on platforms where CRLF or LF matters
@@ -628,7 +690,13 @@ fn test_prompt_write_protected_yes() {
 
     scene.ccmd("chmod").arg("0").arg(file_1).succeeds();
 
-    scene.ucmd().arg(file_1).pipe_in("y").succeeds();
+    scene
+        .ucmd()
+        .arg("---presume-input-tty")
+        .arg(file_1)
+        .pipe_in("y")
+        .succeeds()
+        .stderr_contains("rm: remove write-protected regular empty file");
     assert!(!at.file_exists(file_1));
 }
 
@@ -643,10 +711,93 @@ fn test_prompt_write_protected_no() {
 
     scene.ccmd("chmod").arg("0").arg(file_2).succeeds();
 
-    scene.ucmd().arg(file_2).pipe_in("n").succeeds();
+    scene
+        .ucmd()
+        .arg("---presume-input-tty")
+        .arg(file_2)
+        .pipe_in("n")
+        .succeeds()
+        .stderr_contains("rm: remove write-protected regular empty file");
     assert!(at.file_exists(file_2));
 }
 
+#[cfg(feature = "chmod")]
+#[test]
+fn test_remove_inaccessible_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dir_1 = "test_rm_protected";
+
+    at.mkdir(dir_1);
+
+    scene.ccmd("chmod").arg("0").arg(dir_1).succeeds();
+
+    scene.ucmd().arg("-rf").arg(dir_1).succeeds();
+    assert!(!at.dir_exists(dir_1));
+}
+
+#[test]
+#[cfg(not(windows))]
+fn test_rm_current_or_parent_dir_rm4() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("d");
+
+    let answers = [
+        "rm: refusing to remove '.' or '..' directory: skipping 'd/.'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd/./'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd/./'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd/..'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd/../'",
+    ];
+    let std_err_str = ts
+        .ucmd()
+        .arg("-rf")
+        .arg("d/.")
+        .arg("d/./")
+        .arg("d/.////")
+        .arg("d/..")
+        .arg("d/../")
+        .fails()
+        .stderr_move_str();
+
+    for (idx, line) in std_err_str.lines().enumerate() {
+        assert_eq!(line, answers[idx]);
+    }
+}
+
+#[test]
+#[cfg(windows)]
+fn test_rm_current_or_parent_dir_rm4_windows() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+
+    at.mkdir("d");
+
+    let answers = [
+        "rm: refusing to remove '.' or '..' directory: skipping 'd\\.'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd\\.\\'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd\\.\\'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd\\..'",
+        "rm: refusing to remove '.' or '..' directory: skipping 'd\\..\\'",
+    ];
+    let std_err_str = ts
+        .ucmd()
+        .arg("-rf")
+        .arg("d\\.")
+        .arg("d\\.\\")
+        .arg("d\\.\\\\\\\\")
+        .arg("d\\..")
+        .arg("d\\..\\")
+        .fails()
+        .stderr_move_str();
+
+    for (idx, line) in std_err_str.lines().enumerate() {
+        assert_eq!(line, answers[idx]);
+    }
+}
+
 #[test]
 #[cfg(not(windows))]
 fn test_fifo_removal() {
@@ -683,3 +834,183 @@ fn test_non_utf8() {
     ucmd.arg(file).succeeds();
     assert!(!at.file_exists(file));
 }
+
+#[test]
+fn test_uchild_when_run_no_wait_with_a_blocking_command() {
+    let ts = TestScenario::new("rm");
+    let at = &ts.fixtures;
+
+    at.mkdir("a");
+    at.touch("a/empty");
+
+    #[cfg(target_vendor = "apple")]
+    let delay: u64 = 2000;
+    #[cfg(not(target_vendor = "apple"))]
+    let delay: u64 = 1000;
+
+    let yes = if cfg!(windows) { "y\r\n" } else { "y\n" };
+
+    let mut child = ts
+        .ucmd()
+        .set_stdin(Stdio::piped())
+        .stderr_to_stdout()
+        .args(&["-riv", "a"])
+        .run_no_wait();
+    child
+        .make_assertion_with_delay(delay)
+        .is_alive()
+        .with_current_output()
+        .stdout_is("rm: descend into directory 'a'? ");
+
+    #[cfg(windows)]
+    let expected = "rm: descend into directory 'a'? \
+                    rm: remove regular empty file 'a\\empty'? ";
+    #[cfg(unix)]
+    let expected = "rm: descend into directory 'a'? \
+                    rm: remove regular empty file 'a/empty'? ";
+    child.write_in(yes);
+    child
+        .make_assertion_with_delay(delay)
+        .is_alive()
+        .with_all_output()
+        .stdout_is(expected);
+
+    #[cfg(windows)]
+    let expected = "removed 'a\\empty'\nrm: remove directory 'a'? ";
+    #[cfg(unix)]
+    let expected = "removed 'a/empty'\nrm: remove directory 'a'? ";
+
+    child
+        .write_in(yes)
+        .make_assertion_with_delay(delay)
+        .is_alive()
+        .with_exact_output(44, 0)
+        .stdout_only(expected);
+
+    let expected = "removed directory 'a'\n";
+
+    child.write_in(yes);
+    child.wait().unwrap().stdout_only(expected).success();
+}
+
+#[test]
+fn test_recursive_interactive() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a");
+    at.mkdir("a/b");
+    #[cfg(windows)]
+    let expected =
+        "rm: descend into directory 'a'? rm: remove directory 'a\\b'? rm: remove directory 'a'? ";
+    #[cfg(not(windows))]
+    let expected =
+        "rm: descend into directory 'a'? rm: remove directory 'a/b'? rm: remove directory 'a'? ";
+    ucmd.args(&["-i", "-r", "a"])
+        .pipe_in("y\ny\ny\n")
+        .succeeds()
+        .stderr_only(expected);
+    assert!(!at.dir_exists("a/b"));
+    assert!(!at.dir_exists("a"));
+}
+
+// Avoid an infinite recursion due to a symbolic link to the current directory.
+#[test]
+fn test_recursive_symlink_loop() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("d");
+    at.relative_symlink_file(".", "d/link");
+    #[cfg(windows)]
+    let expected = "rm: descend into directory 'd'? rm: remove symbolic link 'd\\link'? rm: remove directory 'd'? ";
+    #[cfg(not(windows))]
+    let expected = "rm: descend into directory 'd'? rm: remove symbolic link 'd/link'? rm: remove directory 'd'? ";
+    ucmd.args(&["-i", "-r", "d"])
+        .pipe_in("y\ny\ny\n")
+        .succeeds()
+        .stderr_only(expected);
+    assert!(!at.symlink_exists("d/link"));
+    assert!(!at.dir_exists("d"));
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_only_first_error_recursive() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a");
+    at.mkdir("a/b");
+    at.touch("a/b/file");
+    // Make the inner directory not writable.
+    at.set_mode("a/b", 0o0555);
+
+    // To match the behavior of GNU `rm`, print an error message for
+    // the file in the non-writable directory, but don't print the
+    // error messages that would have appeared when trying to remove
+    // the directories containing the file.
+    ucmd.args(&["-r", "-f", "a"])
+        .fails()
+        .stderr_only("rm: cannot remove 'a/b/file': Permission denied\n");
+    assert!(at.file_exists("a/b/file"));
+    assert!(at.dir_exists("a/b"));
+    assert!(at.dir_exists("a"));
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_unreadable_and_nonempty_dir() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir_all("a/b");
+    at.set_mode("a", 0o0333);
+
+    ucmd.args(&["-r", "-f", "a"])
+        .fails()
+        .stderr_only("rm: cannot remove 'a': Permission denied\n");
+    assert!(at.dir_exists("a/b"));
+    assert!(at.dir_exists("a"));
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_inaccessible_dir() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("dir");
+    at.set_mode("dir", 0o0333);
+    ucmd.args(&["-d", "dir"]).succeeds().no_output();
+    assert!(!at.dir_exists("dir"));
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_inaccessible_dir_nonempty() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("dir");
+    at.touch("dir/f");
+    at.set_mode("dir", 0o0333);
+    ucmd.args(&["-d", "dir"])
+        .fails()
+        .stderr_only("rm: cannot remove 'dir': Directory not empty\n");
+    assert!(at.file_exists("dir/f"));
+    assert!(at.dir_exists("dir"));
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_inaccessible_dir_interactive() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("dir");
+    at.set_mode("dir", 0);
+    ucmd.args(&["-i", "-d", "dir"])
+        .pipe_in("y\n")
+        .succeeds()
+        .stderr_only("rm: attempt removal of inaccessible directory 'dir'? ");
+    assert!(!at.dir_exists("dir"));
+}
+
+#[cfg(not(windows))]
+#[test]
+fn test_inaccessible_dir_recursive() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("a");
+    at.mkdir("a/unreadable");
+    at.set_mode("a/unreadable", 0o0333);
+    ucmd.args(&["-r", "-f", "a"]).succeeds().no_output();
+    assert!(!at.dir_exists("a/unreadable"));
+    assert!(!at.dir_exists("a"));
+}
diff --git a/tests/by-util/test_rmdir.rs b/tests/by-util/test_rmdir.rs
index 086d43748ab..09a711eafbf 100644
--- a/tests/by-util/test_rmdir.rs
+++ b/tests/by-util/test_rmdir.rs
@@ -2,7 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 const DIR: &str = "dir";
 const DIR_FILE: &str = "dir/file";
@@ -26,7 +29,14 @@ const NOT_A_DIRECTORY: &str = "Not a directory";
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_no_arg() {
+    new_ucmd!()
+        .fails_with_code(1)
+        .stderr_contains("error: the following required arguments were not provided:");
 }
 
 #[test]
diff --git a/tests/by-util/test_runcon.rs b/tests/by-util/test_runcon.rs
index 8e8b9b6b562..c024f571d0b 100644
--- a/tests/by-util/test_runcon.rs
+++ b/tests/by-util/test_runcon.rs
@@ -6,7 +6,9 @@
 
 #![cfg(feature = "feat_selinux")]
 
-use crate::common::util::*;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 // TODO: Check the implementation of `--compute` somehow.
 
@@ -22,6 +24,11 @@ fn help() {
     new_ucmd!().arg("-h").succeeds();
 }
 
+#[test]
+fn invalid_input() {
+    new_ucmd!().arg("-/").fails_with_code(125);
+}
+
 #[test]
 fn print() {
     new_ucmd!().succeeds();
@@ -40,42 +47,43 @@ fn print() {
 
 #[test]
 fn invalid() {
-    new_ucmd!().arg("invalid").fails().code_is(1);
+    new_ucmd!().arg("invalid").fails_with_code(1);
 
     let args = &[
         "unconfined_u:unconfined_r:unconfined_t:s0",
         "inexistent-file",
     ];
-    new_ucmd!().args(args).fails().code_is(127);
+    new_ucmd!().args(args).fails_with_code(127);
 
     let args = &["invalid", "/bin/true"];
-    new_ucmd!().args(args).fails().code_is(1);
+    new_ucmd!().args(args).fails_with_code(1);
 
     let args = &["--compute", "inexistent-file"];
-    new_ucmd!().args(args).fails().code_is(1);
+    new_ucmd!().args(args).fails_with_code(1);
 
     let args = &["--compute", "--compute"];
-    new_ucmd!().args(args).fails().code_is(1);
+    new_ucmd!().args(args).fails_with_code(125);
 
     // clap has an issue that makes this test fail: https://github.com/clap-rs/clap/issues/1543
     // TODO: Enable this code once the issue is fixed in the clap version we're using.
-    //new_ucmd!().arg("--compute=example").fails().code_is(1);
+    //new_ucmd!().arg("--compute=example").fails_with_code(1);
 
     for flag in [
         "-t", "--type", "-u", "--user", "-r", "--role", "-l", "--range",
     ] {
-        new_ucmd!().arg(flag).fails().code_is(1);
+        new_ucmd!().arg(flag).fails_with_code(125);
 
         let args = &[flag, "example", flag, "example"];
-        new_ucmd!().args(args).fails().code_is(1);
+        new_ucmd!().args(args).fails_with_code(125);
     }
 }
 
 #[test]
+#[cfg(feature = "feat_selinux")]
 fn plain_context() {
     let ctx = "unconfined_u:unconfined_r:unconfined_t:s0-s0";
     new_ucmd!().args(&[ctx, "/bin/true"]).succeeds();
-    new_ucmd!().args(&[ctx, "/bin/false"]).fails().code_is(1);
+    new_ucmd!().args(&[ctx, "/bin/false"]).fails_with_code(1);
 
     let output = new_ucmd!().args(&[ctx, "sestatus", "-v"]).succeeds();
     let r = get_sestatus_context(output.stdout());
@@ -90,6 +98,7 @@ fn plain_context() {
 }
 
 #[test]
+#[cfg(feature = "feat_selinux")]
 fn custom_context() {
     let t_ud = "unconfined_t";
     let u_ud = "unconfined_u";
@@ -98,7 +107,7 @@ fn custom_context() {
     new_ucmd!().args(&["--compute", "/bin/true"]).succeeds();
 
     let args = &["--compute", "/bin/false"];
-    new_ucmd!().args(args).fails().code_is(1);
+    new_ucmd!().args(args).fails_with_code(1);
 
     let args = &["--type", t_ud, "/bin/true"];
     new_ucmd!().args(args).succeeds();
diff --git a/tests/by-util/test_seq.rs b/tests/by-util/test_seq.rs
index 8f879263b2c..e44bf32487d 100644
--- a/tests/by-util/test_seq.rs
+++ b/tests/by-util/test_seq.rs
@@ -3,22 +3,30 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore lmnop xlmnop
-use crate::common::util::TestScenario;
-use std::process::Stdio;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_no_args() {
     new_ucmd!()
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("missing operand");
 }
 
+#[test]
+fn test_format_and_equal_width() {
+    new_ucmd!()
+        .args(&["-w", "-f", "%f", "1"])
+        .fails_with_code(1)
+        .stderr_contains("format string may not be specified");
+}
+
 #[test]
 fn test_hex_rejects_sign_after_identifier() {
     new_ucmd!()
@@ -48,12 +56,12 @@ fn test_hex_rejects_sign_after_identifier() {
         .args(&["-0x-123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains("unexpected argument '-0' found");
+        .usage_error("invalid floating point argument: '-0x-123ABC'");
     new_ucmd!()
         .args(&["-0x+123ABC"])
         .fails()
         .no_stdout()
-        .stderr_contains("unexpected argument '-0' found");
+        .usage_error("invalid floating point argument: '-0x+123ABC'");
 }
 
 #[test]
@@ -182,7 +190,7 @@ fn test_width_invalid_float() {
 fn test_count_up() {
     new_ucmd!()
         .args(&["10"])
-        .run()
+        .succeeds()
         .stdout_is("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n");
 }
 
@@ -190,11 +198,11 @@ fn test_count_up() {
 fn test_count_down() {
     new_ucmd!()
         .args(&["--", "5", "-1", "1"])
-        .run()
+        .succeeds()
         .stdout_is("5\n4\n3\n2\n1\n");
     new_ucmd!()
         .args(&["5", "-1", "1"])
-        .run()
+        .succeeds()
         .stdout_is("5\n4\n3\n2\n1\n");
 }
 
@@ -202,19 +210,23 @@ fn test_count_down() {
 fn test_separator_and_terminator() {
     new_ucmd!()
         .args(&["-s", ",", "-t", "!", "2", "6"])
-        .run()
+        .succeeds()
         .stdout_is("2,3,4,5,6!");
     new_ucmd!()
         .args(&["-s", ",", "2", "6"])
-        .run()
+        .succeeds()
         .stdout_is("2,3,4,5,6\n");
+    new_ucmd!()
+        .args(&["-s", "", "2", "6"])
+        .succeeds()
+        .stdout_is("23456\n");
     new_ucmd!()
         .args(&["-s", "\n", "2", "6"])
-        .run()
+        .succeeds()
         .stdout_is("2\n3\n4\n5\n6\n");
     new_ucmd!()
         .args(&["-s", "\\n", "2", "6"])
-        .run()
+        .succeeds()
         .stdout_is("2\\n3\\n4\\n5\\n6\n");
 }
 
@@ -224,7 +236,7 @@ fn test_equalize_widths() {
     for arg in args {
         new_ucmd!()
             .args(&[arg, "5", "10"])
-            .run()
+            .succeeds()
             .stdout_is("05\n06\n07\n08\n09\n10\n");
     }
 }
@@ -256,7 +268,7 @@ fn test_big_numbers() {
 fn test_count_up_floats() {
     new_ucmd!()
         .args(&["10.0"])
-        .run()
+        .succeeds()
         .stdout_is("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n");
 }
 
@@ -264,11 +276,11 @@ fn test_count_up_floats() {
 fn test_count_down_floats() {
     new_ucmd!()
         .args(&["--", "5", "-1.0", "1"])
-        .run()
+        .succeeds()
         .stdout_is("5.0\n4.0\n3.0\n2.0\n1.0\n");
     new_ucmd!()
         .args(&["5", "-1", "1.0"])
-        .run()
+        .succeeds()
         .stdout_is("5\n4\n3\n2\n1\n");
 }
 
@@ -276,15 +288,19 @@ fn test_count_down_floats() {
 fn test_separator_and_terminator_floats() {
     new_ucmd!()
         .args(&["-s", ",", "-t", "!", "2.0", "6"])
-        .run()
+        .succeeds()
         .stdout_is("2.0,3.0,4.0,5.0,6.0!");
+    new_ucmd!()
+        .args(&["-s", "", "-t", "!", "2.0", "6"])
+        .succeeds()
+        .stdout_is("2.03.04.05.06.0!");
 }
 
 #[test]
 fn test_equalize_widths_floats() {
     new_ucmd!()
         .args(&["-w", "5", "10.0"])
-        .run()
+        .succeeds()
         .stdout_is("05\n06\n07\n08\n09\n10\n");
 }
 
@@ -303,18 +319,15 @@ fn test_preserve_negative_zero_start() {
     new_ucmd!()
         .args(&["-0", "1"])
         .succeeds()
-        .stdout_is("-0\n1\n")
-        .no_stderr();
+        .stdout_only("-0\n1\n");
     new_ucmd!()
         .args(&["-0", "1", "2"])
         .succeeds()
-        .stdout_is("-0\n1\n2\n")
-        .no_stderr();
+        .stdout_only("-0\n1\n2\n");
     new_ucmd!()
         .args(&["-0", "1", "2.0"])
         .succeeds()
-        .stdout_is("-0\n1\n2\n")
-        .no_stderr();
+        .stdout_only("-0\n1\n2\n");
 }
 
 #[test]
@@ -322,8 +335,7 @@ fn test_drop_negative_zero_end() {
     new_ucmd!()
         .args(&["1", "-1", "-0"])
         .succeeds()
-        .stdout_is("1\n0\n")
-        .no_stderr();
+        .stdout_only("1\n0\n");
 }
 
 #[test]
@@ -331,8 +343,11 @@ fn test_width_scientific_notation() {
     new_ucmd!()
         .args(&["-w", "999", "1e3"])
         .succeeds()
-        .stdout_is("0999\n1000\n")
-        .no_stderr();
+        .stdout_only("0999\n1000\n");
+    new_ucmd!()
+        .args(&["-w", "999", "1E3"])
+        .succeeds()
+        .stdout_only("0999\n1000\n");
 }
 
 #[test]
@@ -340,18 +355,15 @@ fn test_width_negative_zero() {
     new_ucmd!()
         .args(&["-w", "-0", "1"])
         .succeeds()
-        .stdout_is("-0\n01\n")
-        .no_stderr();
+        .stdout_only("-0\n01\n");
     new_ucmd!()
         .args(&["-w", "-0", "1", "2"])
         .succeeds()
-        .stdout_is("-0\n01\n02\n")
-        .no_stderr();
+        .stdout_only("-0\n01\n02\n");
     new_ucmd!()
         .args(&["-w", "-0", "1", "2.0"])
         .succeeds()
-        .stdout_is("-0\n01\n02\n")
-        .no_stderr();
+        .stdout_only("-0\n01\n02\n");
 }
 
 #[test]
@@ -359,33 +371,27 @@ fn test_width_negative_zero_decimal_notation() {
     new_ucmd!()
         .args(&["-w", "-0.0", "1"])
         .succeeds()
-        .stdout_is("-0.0\n01.0\n")
-        .no_stderr();
+        .stdout_only("-0.0\n01.0\n");
     new_ucmd!()
         .args(&["-w", "-0.0", "1.0"])
         .succeeds()
-        .stdout_is("-0.0\n01.0\n")
-        .no_stderr();
+        .stdout_only("-0.0\n01.0\n");
     new_ucmd!()
         .args(&["-w", "-0.0", "1", "2"])
         .succeeds()
-        .stdout_is("-0.0\n01.0\n02.0\n")
-        .no_stderr();
+        .stdout_only("-0.0\n01.0\n02.0\n");
     new_ucmd!()
         .args(&["-w", "-0.0", "1", "2.0"])
         .succeeds()
-        .stdout_is("-0.0\n01.0\n02.0\n")
-        .no_stderr();
+        .stdout_only("-0.0\n01.0\n02.0\n");
     new_ucmd!()
         .args(&["-w", "-0.0", "1.0", "2"])
         .succeeds()
-        .stdout_is("-0.0\n01.0\n02.0\n")
-        .no_stderr();
+        .stdout_only("-0.0\n01.0\n02.0\n");
     new_ucmd!()
         .args(&["-w", "-0.0", "1.0", "2.0"])
         .succeeds()
-        .stdout_is("-0.0\n01.0\n02.0\n")
-        .no_stderr();
+        .stdout_only("-0.0\n01.0\n02.0\n");
 }
 
 #[test]
@@ -393,98 +399,80 @@ fn test_width_negative_zero_scientific_notation() {
     new_ucmd!()
         .args(&["-w", "-0e0", "1"])
         .succeeds()
-        .stdout_is("-0\n01\n")
-        .no_stderr();
+        .stdout_only("-0\n01\n");
     new_ucmd!()
         .args(&["-w", "-0e0", "1", "2"])
         .succeeds()
-        .stdout_is("-0\n01\n02\n")
-        .no_stderr();
+        .stdout_only("-0\n01\n02\n");
     new_ucmd!()
         .args(&["-w", "-0e0", "1", "2.0"])
         .succeeds()
-        .stdout_is("-0\n01\n02\n")
-        .no_stderr();
+        .stdout_only("-0\n01\n02\n");
 
     new_ucmd!()
         .args(&["-w", "-0e+1", "1"])
         .succeeds()
-        .stdout_is("-00\n001\n")
-        .no_stderr();
+        .stdout_only("-00\n001\n");
     new_ucmd!()
         .args(&["-w", "-0e+1", "1", "2"])
         .succeeds()
-        .stdout_is("-00\n001\n002\n")
-        .no_stderr();
+        .stdout_only("-00\n001\n002\n");
     new_ucmd!()
         .args(&["-w", "-0e+1", "1", "2.0"])
         .succeeds()
-        .stdout_is("-00\n001\n002\n")
-        .no_stderr();
+        .stdout_only("-00\n001\n002\n");
 
     new_ucmd!()
         .args(&["-w", "-0.000e0", "1"])
         .succeeds()
-        .stdout_is("-0.000\n01.000\n")
-        .no_stderr();
+        .stdout_only("-0.000\n01.000\n");
     new_ucmd!()
         .args(&["-w", "-0.000e0", "1", "2"])
         .succeeds()
-        .stdout_is("-0.000\n01.000\n02.000\n")
-        .no_stderr();
+        .stdout_only("-0.000\n01.000\n02.000\n");
     new_ucmd!()
         .args(&["-w", "-0.000e0", "1", "2.0"])
         .succeeds()
-        .stdout_is("-0.000\n01.000\n02.000\n")
-        .no_stderr();
+        .stdout_only("-0.000\n01.000\n02.000\n");
 
     new_ucmd!()
         .args(&["-w", "-0.000e-2", "1"])
         .succeeds()
-        .stdout_is("-0.00000\n01.00000\n")
-        .no_stderr();
+        .stdout_only("-0.00000\n01.00000\n");
     new_ucmd!()
         .args(&["-w", "-0.000e-2", "1", "2"])
         .succeeds()
-        .stdout_is("-0.00000\n01.00000\n02.00000\n")
-        .no_stderr();
+        .stdout_only("-0.00000\n01.00000\n02.00000\n");
     new_ucmd!()
         .args(&["-w", "-0.000e-2", "1", "2.0"])
         .succeeds()
-        .stdout_is("-0.00000\n01.00000\n02.00000\n")
-        .no_stderr();
+        .stdout_only("-0.00000\n01.00000\n02.00000\n");
 
     new_ucmd!()
         .args(&["-w", "-0.000e5", "1"])
         .succeeds()
-        .stdout_is("-000000\n0000001\n")
-        .no_stderr();
+        .stdout_only("-000000\n0000001\n");
     new_ucmd!()
         .args(&["-w", "-0.000e5", "1", "2"])
         .succeeds()
-        .stdout_is("-000000\n0000001\n0000002\n")
-        .no_stderr();
+        .stdout_only("-000000\n0000001\n0000002\n");
     new_ucmd!()
         .args(&["-w", "-0.000e5", "1", "2.0"])
         .succeeds()
-        .stdout_is("-000000\n0000001\n0000002\n")
-        .no_stderr();
+        .stdout_only("-000000\n0000001\n0000002\n");
 
     new_ucmd!()
         .args(&["-w", "-0.000e5", "1"])
         .succeeds()
-        .stdout_is("-000000\n0000001\n")
-        .no_stderr();
+        .stdout_only("-000000\n0000001\n");
     new_ucmd!()
         .args(&["-w", "-0.000e5", "1", "2"])
         .succeeds()
-        .stdout_is("-000000\n0000001\n0000002\n")
-        .no_stderr();
+        .stdout_only("-000000\n0000001\n0000002\n");
     new_ucmd!()
         .args(&["-w", "-0.000e5", "1", "2.0"])
         .succeeds()
-        .stdout_is("-000000\n0000001\n0000002\n")
-        .no_stderr();
+        .stdout_only("-000000\n0000001\n0000002\n");
 }
 
 #[test]
@@ -492,14 +480,12 @@ fn test_width_decimal_scientific_notation_increment() {
     new_ucmd!()
         .args(&["-w", ".1", "1e-2", ".11"])
         .succeeds()
-        .stdout_is("0.10\n0.11\n")
-        .no_stderr();
+        .stdout_only("0.10\n0.11\n");
 
     new_ucmd!()
         .args(&["-w", ".0", "1.500e-1", ".2"])
         .succeeds()
-        .stdout_is("0.0000\n0.1500\n")
-        .no_stderr();
+        .stdout_only("0.0000\n0.1500\n");
 }
 
 /// Test that trailing zeros in the start argument contribute to precision.
@@ -508,8 +494,7 @@ fn test_width_decimal_scientific_notation_trailing_zeros_start() {
     new_ucmd!()
         .args(&["-w", ".1000", "1e-2", ".11"])
         .succeeds()
-        .stdout_is("0.1000\n0.1100\n")
-        .no_stderr();
+        .stdout_only("0.1000\n0.1100\n");
 }
 
 /// Test that trailing zeros in the increment argument contribute to precision.
@@ -518,8 +503,7 @@ fn test_width_decimal_scientific_notation_trailing_zeros_increment() {
     new_ucmd!()
         .args(&["-w", "1e-1", "0.0100", ".11"])
         .succeeds()
-        .stdout_is("0.1000\n0.1100\n")
-        .no_stderr();
+        .stdout_only("0.1000\n0.1100\n");
 }
 
 #[test]
@@ -527,8 +511,7 @@ fn test_width_negative_decimal_notation() {
     new_ucmd!()
         .args(&["-w", "-.1", ".1", ".11"])
         .succeeds()
-        .stdout_is("-0.1\n00.0\n00.1\n")
-        .no_stderr();
+        .stdout_only("-0.1\n00.0\n00.1\n");
 }
 
 #[test]
@@ -536,22 +519,19 @@ fn test_width_negative_scientific_notation() {
     new_ucmd!()
         .args(&["-w", "-1e-3", "1"])
         .succeeds()
-        .stdout_is("-0.001\n00.999\n")
-        .no_stderr();
+        .stdout_only("-0.001\n00.999\n");
     new_ucmd!()
         .args(&["-w", "-1.e-3", "1"])
         .succeeds()
-        .stdout_is("-0.001\n00.999\n")
-        .no_stderr();
+        .stdout_only("-0.001\n00.999\n");
     new_ucmd!()
         .args(&["-w", "-1.0e-4", "1"])
         .succeeds()
-        .stdout_is("-0.00010\n00.99990\n")
-        .no_stderr();
+        .stdout_only("-0.00010\n00.99990\n");
     new_ucmd!()
         .args(&["-w", "-.1e2", "10", "100"])
         .succeeds()
-        .stdout_is(
+        .stdout_only(
             "-010
 0000
 0010
@@ -565,12 +545,11 @@ fn test_width_negative_scientific_notation() {
 0090
 0100
 ",
-        )
-        .no_stderr();
+        );
     new_ucmd!()
         .args(&["-w", "-0.1e2", "10", "100"])
         .succeeds()
-        .stdout_is(
+        .stdout_only(
             "-010
 0000
 0010
@@ -584,8 +563,7 @@ fn test_width_negative_scientific_notation() {
 0090
 0100
 ",
-        )
-        .no_stderr();
+        );
 }
 
 /// Test that trailing zeros in the end argument do not contribute to width.
@@ -594,8 +572,7 @@ fn test_width_decimal_scientific_notation_trailing_zeros_end() {
     new_ucmd!()
         .args(&["-w", "1e-1", "1e-2", ".1100"])
         .succeeds()
-        .stdout_is("0.10\n0.11\n")
-        .no_stderr();
+        .stdout_only("0.10\n0.11\n");
 }
 
 #[test]
@@ -603,54 +580,60 @@ fn test_width_floats() {
     new_ucmd!()
         .args(&["-w", "9.0", "10.0"])
         .succeeds()
-        .stdout_is("09.0\n10.0\n")
-        .no_stderr();
+        .stdout_only("09.0\n10.0\n");
 }
 
-// TODO This is duplicated from `test_yes.rs`; refactor them.
-/// Run `seq`, capture some of the output, close the pipe, and verify it.
-fn run(args: &[&str], 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();
-    child.wait().unwrap().success();
-    assert_eq!(buf.as_slice(), expected);
+#[test]
+fn test_neg_inf() {
+    new_ucmd!()
+        .args(&["--", "-inf", "0"])
+        .run_stdout_starts_with(b"-inf\n-inf\n-inf\n")
+        .success();
 }
 
 #[test]
-fn test_neg_inf() {
-    run(&["--", "-inf", "0"], b"-inf\n-inf\n-inf\n");
+fn test_neg_infinity() {
+    new_ucmd!()
+        .args(&["--", "-infinity", "0"])
+        .run_stdout_starts_with(b"-inf\n-inf\n-inf\n")
+        .success();
 }
 
 #[test]
 fn test_inf() {
-    run(&["inf"], b"1\n2\n3\n");
+    new_ucmd!()
+        .args(&["inf"])
+        .run_stdout_starts_with(b"1\n2\n3\n")
+        .success();
+}
+
+#[test]
+fn test_infinity() {
+    new_ucmd!()
+        .args(&["infinity"])
+        .run_stdout_starts_with(b"1\n2\n3\n")
+        .success();
 }
 
 #[test]
 fn test_inf_width() {
-    run(
-        &["-w", "1.000", "inf", "inf"],
-        b"1.000\n  inf\n  inf\n  inf\n",
-    );
+    new_ucmd!()
+        .args(&["-w", "1.000", "inf", "inf"])
+        .run_stdout_starts_with(b"1.000\n  inf\n  inf\n  inf\n")
+        .success();
 }
 
 #[test]
 fn test_neg_inf_width() {
-    run(
-        &["-w", "1.000", "-inf", "-inf"],
-        b"1.000\n -inf\n -inf\n -inf\n",
-    );
+    new_ucmd!()
+        .args(&["-w", "1.000", "-inf", "-inf"])
+        .run_stdout_starts_with(b"1.000\n -inf\n -inf\n -inf\n")
+        .success();
 }
 
 #[test]
 fn test_ignore_leading_whitespace() {
-    new_ucmd!()
-        .arg("   1")
-        .succeeds()
-        .stdout_is("1\n")
-        .no_stderr();
+    new_ucmd!().arg("   1").succeeds().stdout_only("1\n");
 }
 
 #[test]
@@ -669,8 +652,7 @@ fn test_negative_zero_int_start_float_increment() {
     new_ucmd!()
         .args(&["-0", "0.1", "0.1"])
         .succeeds()
-        .stdout_is("-0.0\n0.1\n")
-        .no_stderr();
+        .stdout_only("-0.0\n0.1\n");
 }
 
 #[test]
@@ -678,7 +660,7 @@ fn test_float_precision_increment() {
     new_ucmd!()
         .args(&["999", "0.1", "1000.1"])
         .succeeds()
-        .stdout_is(
+        .stdout_only(
             "999.0
 999.1
 999.2
@@ -692,8 +674,7 @@ fn test_float_precision_increment() {
 1000.0
 1000.1
 ",
-        )
-        .no_stderr();
+        );
 }
 
 /// Test for floating point precision issues.
@@ -702,8 +683,7 @@ fn test_negative_increment_decimal() {
     new_ucmd!()
         .args(&["0.1", "-0.1", "-0.2"])
         .succeeds()
-        .stdout_is("0.1\n0.0\n-0.1\n-0.2\n")
-        .no_stderr();
+        .stdout_only("0.1\n0.0\n-0.1\n-0.2\n");
 }
 
 #[test]
@@ -711,8 +691,7 @@ fn test_zero_not_first() {
     new_ucmd!()
         .args(&["-w", "-0.1", "0.1", "0.1"])
         .succeeds()
-        .stdout_is("-0.1\n00.0\n00.1\n")
-        .no_stderr();
+        .stdout_only("-0.1\n00.0\n00.1\n");
 }
 
 #[test]
@@ -720,8 +699,7 @@ fn test_rounding_end() {
     new_ucmd!()
         .args(&["1", "-1", "0.1"])
         .succeeds()
-        .stdout_is("1\n")
-        .no_stderr();
+        .stdout_only("1\n");
 }
 
 #[test]
@@ -737,7 +715,7 @@ fn test_parse_error_hex() {
     new_ucmd!()
         .arg("0xlmnop")
         .fails()
-        .usage_error("invalid hexadecimal argument: '0xlmnop'");
+        .usage_error("invalid floating point argument: '0xlmnop'");
 }
 
 #[test]
@@ -748,6 +726,67 @@ fn test_format_option() {
         .stdout_only("0.00\n0.10\n0.20\n0.30\n0.40\n0.50\n");
 }
 
+#[test]
+fn test_format_option_default_precision() {
+    new_ucmd!()
+        .args(&["-f", "%f", "0", "0.7", "2"])
+        .succeeds()
+        .stdout_only("0.000000\n0.700000\n1.400000\n");
+}
+
+#[test]
+fn test_format_option_default_precision_short() {
+    new_ucmd!()
+        .args(&["-f", "%g", "0", "0.987654321", "2"])
+        .succeeds()
+        .stdout_only("0\n0.987654\n1.97531\n");
+}
+
+#[test]
+fn test_format_option_default_precision_scientific() {
+    new_ucmd!()
+        .args(&["-f", "%E", "0", "0.7", "2"])
+        .succeeds()
+        .stdout_only("0.000000E+00\n7.000000E-01\n1.400000E+00\n");
+}
+
+#[test]
+fn test_auto_precision() {
+    new_ucmd!()
+        .args(&["1", "0x1p-1", "2"])
+        .succeeds()
+        .stdout_only("1\n1.5\n2\n");
+}
+
+#[test]
+fn test_undefined() {
+    new_ucmd!()
+        .args(&["1e-9223372036854775808"])
+        .succeeds()
+        .no_output();
+}
+
+#[test]
+fn test_invalid_float_point_fail_properly() {
+    // Note that we support arguments that are much bigger than what GNU coreutils supports.
+    // Tests below use exponents larger than we support (i64)
+    new_ucmd!()
+        .args(&["66000e0000000000000000000000000000000000000000000000000000092233720368547758070"])
+        .fails()
+        .no_stdout()
+        .usage_error("invalid floating point argument: '66000e0000000000000000000000000000000000000000000000000000092233720368547758070'");
+    new_ucmd!()
+        .args(&["-1.1e92233720368547758070"])
+        .fails()
+        .no_stdout()
+        .usage_error("invalid floating point argument: '-1.1e92233720368547758070'");
+    new_ucmd!()
+        .args(&["-.1e92233720368547758070"])
+        .fails()
+        .no_stdout()
+        .usage_error("invalid floating point argument: '-.1e92233720368547758070'");
+}
+
 #[test]
 fn test_invalid_zero_increment_value() {
     new_ucmd!()
@@ -756,3 +795,286 @@ fn test_invalid_zero_increment_value() {
         .no_stdout()
         .usage_error("invalid Zero increment value: '0'");
 }
+
+#[test]
+fn test_power_of_ten_display() {
+    new_ucmd!()
+        .args(&["-f", "%.2g", "10", "10"])
+        .succeeds()
+        .stdout_only("10\n");
+}
+
+#[test]
+fn test_default_g_precision() {
+    new_ucmd!()
+        .args(&["-f", "%010g", "1e5", "1e5"])
+        .succeeds()
+        .stdout_only("0000100000\n");
+    new_ucmd!()
+        .args(&["-f", "%010g", "1e6", "1e6"])
+        .succeeds()
+        .stdout_only("000001e+06\n");
+}
+
+#[test]
+fn test_invalid_format() {
+    new_ucmd!()
+        .args(&["-f", "%%g", "1"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("format '%%g' has no % directive");
+    new_ucmd!()
+        .args(&["-f", "%g%g", "1"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("format '%g%g' has too many % directives");
+    new_ucmd!()
+        .args(&["-f", "%g%", "1"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("format '%g%' has too many % directives");
+    new_ucmd!()
+        .args(&["-f", "%", "1"])
+        .fails()
+        .no_stdout()
+        .stderr_contains("format '%' ends in %");
+}
+
+#[test]
+fn test_parse_scientific_zero() {
+    new_ucmd!()
+        .args(&["0e15", "1"])
+        .succeeds()
+        .stdout_only("0\n1\n");
+    new_ucmd!()
+        .args(&["0.0e15", "1"])
+        .succeeds()
+        .stdout_only("0\n1\n");
+    new_ucmd!()
+        .args(&["0", "1"])
+        .succeeds()
+        .stdout_only("0\n1\n");
+    new_ucmd!()
+        .args(&["-w", "0e15", "1"])
+        .succeeds()
+        .stdout_only("0000000000000000\n0000000000000001\n");
+    new_ucmd!()
+        .args(&["-w", "0.0e15", "1"])
+        .succeeds()
+        .stdout_only("0000000000000000\n0000000000000001\n");
+    new_ucmd!()
+        .args(&["-w", "0", "1"])
+        .succeeds()
+        .stdout_only("0\n1\n");
+}
+
+#[test]
+fn test_parse_valid_hexadecimal_float_two_args() {
+    let test_cases = [
+        (["0x1p-1", "2"], "0.5\n1.5\n"),
+        (["0x.8p16", "32768"], "32768\n"),
+        (["0xffff.4p-4", "4096"], "4095.95\n"),
+        (["0xA.A9p-1", "6"], "5.33008\n"),
+        (["0xa.a9p-1", "6"], "5.33008\n"),
+        (["0xffffffffffp-30", "1024"], "1024\n"), // spell-checker:disable-line
+        (["  0XA.A9P-1", "6"], "5.33008\n"),
+        (["  0xee.", "  0xef."], "238\n239\n"),
+    ];
+
+    for (input_arguments, expected_output) in &test_cases {
+        new_ucmd!()
+            .args(input_arguments)
+            .succeeds()
+            .stdout_only(expected_output);
+    }
+}
+
+#[test]
+fn test_parse_valid_hexadecimal_float_three_args() {
+    let test_cases = [
+        (["0x3.4p-1", "0x4p-1", "4"], "1.625\n3.625\n"),
+        (
+            ["-0x.ep-3", "-0x.1p-3", "-0x.fp-3"],
+            "-0.109375\n-0.117188\n",
+        ),
+    ];
+
+    for (input_arguments, expected_output) in &test_cases {
+        new_ucmd!()
+            .args(input_arguments)
+            .succeeds()
+            .stdout_only(expected_output);
+    }
+}
+
+#[test]
+fn test_parse_float_gnu_coreutils() {
+    // some values from GNU coreutils tests
+    new_ucmd!()
+        .args(&[".89999", "1e-7", ".8999901"])
+        .succeeds()
+        .stdout_only("0.8999900\n0.8999901\n");
+
+    new_ucmd!()
+        .args(&["0", "0.000001", "0.000003"])
+        .succeeds()
+        .stdout_only("0.000000\n0.000001\n0.000002\n0.000003\n");
+}
+
+#[test]
+fn test_parse_out_of_bounds_exponents() {
+    // The value 1e-9223372036854775808 is used in GNU Coreutils and BigDecimal tests to verify
+    // overflows and undefined behavior. Let's test the value too.
+    new_ucmd!()
+        .args(&["1e-9223372036854775808"])
+        .succeeds()
+        .stdout_only("");
+
+    // GNU seq supports arbitrarily small exponents (and treats the value as 0).
+    new_ucmd!()
+        .args(&["1e-922337203685477580800000000", "1"])
+        .succeeds()
+        .stdout_only("0\n1\n");
+
+    // Check we can also underflow to -0.0.
+    new_ucmd!()
+        .args(&["-1e-922337203685477580800000000", "1"])
+        .succeeds()
+        .stdout_only("-0\n1\n");
+}
+
+#[ignore]
+#[test]
+fn test_parse_valid_hexadecimal_float_format_issues() {
+    // These tests detect differences in the representation of floating-point values with GNU seq.
+    // There are two key areas to investigate:
+    //
+    // 1. GNU seq uses long double (80-bit) types for values, while the current implementation
+    // relies on f64 (64-bit). This can lead to differences due to varying precision. However, it's
+    // likely not the primary cause, as even double (64-bit) values can differ when compared to
+    // f64.
+    //
+    // 2. GNU seq uses the %Lg format specifier for printing (see the "get_default_format" function
+    // ). It appears that Rust lacks a direct equivalent for this format. Additionally, %Lg
+    // can use %f (floating) or %e (scientific) depending on the precision. There also seem to be
+    // some differences in the behavior of C and Rust when displaying floating-point or scientific
+    // notation, at least without additional configuration.
+    //
+    // It makes sense to begin by experimenting with formats and attempting to replicate
+    // the printf("%Lg",...) behavior. Another area worth investigating is glibc, as reviewing its
+    // code may help uncover additional corner cases or test data that could reveal more issues.
+
+    //Test output: 0.00000000992804416455328464508056640625
+    new_ucmd!()
+        .args(&["0xa.a9p-30", "1"])
+        .succeeds()
+        .stdout_only("9.92804e-09\n1\n");
+}
+
+// GNU `seq` manual states that, when the parameters "all use a fixed point
+// decimal representation", the format should be `%.pf`, where the precision
+// is inferred from parameters. Else, `%g` is used.
+//
+// This is understandable, as translating hexadecimal precision to decimal precision
+// is not straightforward or intuitive to the user. There are some exceptions though,
+// if a mix of hexadecimal _integers_ and decimal floats are provided.
+//
+// The way precision is inferred is said to be able to "represent the output numbers
+// exactly". In practice, this means that trailing zeros in first/increment number are
+// considered, but not in the last number. This makes sense if we take that last number
+// as a "bound", and not really part of input/output.
+#[test]
+fn test_precision_corner_cases() {
+    // Mixed input with integer hex still uses precision in decimal float
+    new_ucmd!()
+        .args(&["0x1", "0.90", "3"])
+        .succeeds()
+        .stdout_is("1.00\n1.90\n2.80\n");
+
+    // Mixed input with hex float reverts to %g
+    new_ucmd!()
+        .args(&["0x1.00", "0.90", "3"])
+        .succeeds()
+        .stdout_is("1\n1.9\n2.8\n");
+
+    // Even if it's the last number.
+    new_ucmd!()
+        .args(&["1", "1.20", "0x3.000000"])
+        .succeeds()
+        .stdout_is("1\n2.2\n");
+
+    // Otherwise, precision in last number is ignored.
+    new_ucmd!()
+        .args(&["1", "1.20", "3.000000"])
+        .succeeds()
+        .stdout_is("1.00\n2.20\n");
+
+    // Infinity is ignored
+    new_ucmd!()
+        .args(&["1", "1.2", "inf"])
+        .run_stdout_starts_with(b"1.0\n2.2\n3.4\n")
+        .success();
+}
+
+// GNU `seq` manual only makes guarantees about `-w` working if the
+// provided numbers "all use a fixed point decimal representation",
+// and guides the user to use `-f` for other cases.
+#[test]
+fn test_equalize_widths_corner_cases() {
+    // Mixed input with hexadecimal does behave as expected
+    new_ucmd!()
+        .args(&["-w", "0x1", "5.2", "9"])
+        .succeeds()
+        .stdout_is("1.0\n6.2\n");
+
+    // Confusingly, the number of integral digits in the last number is
+    // used to pad the output numbers, while it is ignored for precision
+    // computation.
+    //
+    // This problem has been reported on list here:
+    // "bug#77179: seq incorrectly(?) pads output when last parameter magnitude"
+    // https://lists.gnu.org/archive/html/bug-coreutils/2025-03/msg00028.html
+    //
+    // TODO: This case could be handled correctly, consider fixing this in
+    // `uutils` implementation. Output should probably be "1.0\n6.2\n".
+    new_ucmd!()
+        .args(&["-w", "0x1", "5.2", "10.0000"])
+        .succeeds()
+        .stdout_is("01.0\n06.2\n");
+
+    // But if we fixed the case above, we need to make sure we still pad
+    // if the last number in the output requires an extra digit.
+    new_ucmd!()
+        .args(&["-w", "0x1", "5.2", "15.0000"])
+        .succeeds()
+        .stdout_is("01.0\n06.2\n11.4\n");
+
+    // GNU `seq` bails out if any hex float is in the output.
+    // Unlike the precision corner cases above, it is harder to justify
+    // this behavior for hexadecimal float inputs, as it is always be
+    // possible to output numbers with a fixed width.
+    //
+    // This problem has been reported on list here:
+    // "bug#76070: Subject: seq, hexadecimal args and equal width"
+    // https://lists.gnu.org/archive/html/bug-coreutils/2025-02/msg00007.html
+    //
+    // TODO: These cases could be handled correctly, consider fixing this in
+    // `uutils` implementation.
+    // If we ignore hexadecimal precision, the output should be "1.0\n6.2\n".
+    new_ucmd!()
+        .args(&["-w", "0x1.0000", "5.2", "10"])
+        .succeeds()
+        .stdout_is("1\n6.2\n");
+    // The equivalent `seq -w 1.0625 1.00002 3` correctly pads the first number: "1.06250\n2.06252\n"
+    new_ucmd!()
+        .args(&["-w", "0x1.1", "1.00002", "3"])
+        .succeeds()
+        .stdout_is("1.0625\n2.06252\n");
+
+    // We can't really pad with infinite number of zeros, so `-w` is ignored.
+    // (there is another test with infinity as an increment above)
+    new_ucmd!()
+        .args(&["-w", "1", "1.2", "inf"])
+        .run_stdout_starts_with(b"1.0\n2.2\n3.4\n")
+        .success();
+}
diff --git a/tests/by-util/test_shred.rs b/tests/by-util/test_shred.rs
index 83d2890ed0b..9c810ae64bb 100644
--- a/tests/by-util/test_shred.rs
+++ b/tests/by-util/test_shred.rs
@@ -2,15 +2,106 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore wipesync
+
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+const PATTERNS: [&str; 22] = [
+    "000000", "ffffff", "555555", "aaaaaa", "249249", "492492", "6db6db", "924924", "b6db6d",
+    "db6db6", "111111", "222222", "333333", "444444", "666666", "777777", "888888", "999999",
+    "bbbbbb", "cccccc", "dddddd", "eeeeee",
+];
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_invalid_remove_arg() {
+    new_ucmd!().arg("--remove=unknown").fails_with_code(1);
+}
+
+#[test]
+fn test_ambiguous_remove_arg() {
+    new_ucmd!().arg("--remove=wip").fails_with_code(1);
+}
+
+#[test]
+fn test_shred() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred";
+    let file_original_content = "test_shred file content";
+
+    at.write(file, file_original_content);
+
+    ucmd.arg(file).succeeds();
+
+    // File exists
+    assert!(at.file_exists(file));
+    // File is obfuscated
+    assert_ne!(at.read_bytes(file), file_original_content.as_bytes());
 }
 
 #[test]
 fn test_shred_remove() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred_remove";
+    at.touch(file);
+
+    ucmd.arg("--remove").arg(file).succeeds();
+
+    // File was deleted
+    assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_unlink() {
+    // spell-checker:disable-next-line
+    for argument in ["--remove=unlink", "--remove=unlin", "--remove=u"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let file = "test_shred_remove_unlink";
+        at.touch(file);
+        ucmd.arg(argument).arg(file).succeeds();
+        // File was deleted
+        assert!(!at.file_exists(file));
+    }
+}
+
+#[test]
+fn test_shred_remove_wipe() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    let file = "test_shred_remove_wipe";
+    at.touch(file);
+
+    ucmd.arg("--remove=wipe").arg(file).succeeds();
+
+    // File was deleted
+    assert!(!at.file_exists(file));
+}
+
+#[test]
+fn test_shred_remove_wipesync() {
+    // spell-checker:disable-next-line
+    for argument in ["--remove=wipesync", "--remove=wipesyn", "--remove=wipes"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let file = "test_shred_remove_wipesync";
+        at.touch(file);
+        ucmd.arg(argument).arg(file).succeeds();
+        // File was deleted
+        assert!(!at.file_exists(file));
+    }
+}
+
+#[test]
+fn test_shred_u() {
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
 
@@ -44,13 +135,13 @@ fn test_shred_force() {
     at.set_readonly(file);
 
     // Try shred -u.
-    scene.ucmd().arg("-u").arg(file).run();
+    scene.ucmd().arg("-u").arg(file).fails();
 
     // file_a was not deleted because it is readonly.
     assert!(at.file_exists(file));
 
     // Try shred -u -f.
-    scene.ucmd().arg("-u").arg("-f").arg(file).run();
+    scene.ucmd().arg("-u").arg("-f").arg(file).succeeds();
 
     // file_a was deleted.
     assert!(!at.file_exists(file));
@@ -66,3 +157,138 @@ fn test_hex() {
 
     ucmd.arg("--size=0x10").arg(file).succeeds();
 }
+
+#[test]
+fn test_shred_empty() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file_a = "test_shred_remove_a";
+
+    at.touch(file_a);
+
+    // Shred file_a and verify that, as it is empty, it doesn't have "pass 1/3 (random)"
+    scene
+        .ucmd()
+        .arg("-uv")
+        .arg(file_a)
+        .succeeds()
+        .stderr_does_not_contain("1/3 (random)");
+
+    assert!(!at.file_exists(file_a));
+
+    // if the file isn't empty, we should have random
+    at.touch(file_a);
+    at.write(file_a, "1");
+    scene
+        .ucmd()
+        .arg("-uv")
+        .arg(file_a)
+        .succeeds()
+        .stderr_contains("1/3 (random)");
+
+    assert!(!at.file_exists(file_a));
+}
+
+#[test]
+#[cfg(all(unix, feature = "chmod"))]
+fn test_shred_fail_no_perm() {
+    use std::path::Path;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let dir = "dir";
+
+    let file = "test_shred_remove_a";
+
+    let binding = Path::new("dir").join(file);
+    let path = binding.to_str().unwrap();
+    at.mkdir(dir);
+    at.touch(path);
+    scene.ccmd("chmod").arg("a-w").arg(dir).succeeds();
+
+    scene
+        .ucmd()
+        .arg("-uv")
+        .arg(path)
+        .fails()
+        .stderr_contains("Couldn't rename to");
+}
+
+#[test]
+fn test_shred_verbose_no_padding_1() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "foo";
+    at.write(file, "non-empty");
+    ucmd.arg("-vn1")
+        .arg(file)
+        .succeeds()
+        .stderr_only("shred: foo: pass 1/1 (random)...\n");
+}
+
+#[test]
+fn test_shred_verbose_no_padding_10() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "foo";
+    at.write(file, "non-empty");
+    ucmd.arg("-vn10")
+        .arg(file)
+        .succeeds()
+        .stderr_contains("shred: foo: pass 1/10 (random)...\n");
+}
+
+#[test]
+fn test_all_patterns_present() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let file = "foo.txt";
+    at.write(file, "bar");
+
+    let result = scene.ucmd().arg("-vn25").arg(file).succeeds();
+
+    for pat in PATTERNS {
+        result.stderr_contains(pat);
+    }
+}
+
+#[test]
+fn test_random_source_regular_file() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    // Currently, our block size is 4096. If it changes, this test has to be adapted.
+    let mut many_bytes = Vec::with_capacity(4096 * 4);
+    for i in 0..4096u32 {
+        many_bytes.extend(i.to_le_bytes());
+    }
+    assert_eq!(many_bytes.len(), 4096 * 4);
+    at.write_bytes("source_long", &many_bytes);
+    let file = "foo.txt";
+    at.write(file, "a");
+    scene
+        .ucmd()
+        .arg("-vn3")
+        .arg("--random-source=source_long")
+        .arg(file)
+        .succeeds()
+        .stderr_only("shred: foo.txt: pass 1/3 (random)...\nshred: foo.txt: pass 2/3 (random)...\nshred: foo.txt: pass 3/3 (random)...\n");
+    // Should rewrite the file exactly three times
+    assert_eq!(at.read_bytes(file), many_bytes[(4096 * 2)..(4096 * 3)]);
+}
+
+#[test]
+#[ignore = "known issue #7947"]
+fn test_random_source_dir() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.mkdir("source");
+    let file = "foo.txt";
+    at.write(file, "a");
+    scene
+        .ucmd()
+        .arg("-v")
+        .arg("--random-source=source")
+        .arg(file)
+        .fails()
+        .stderr_only("shred: foo.txt: pass 1/3 (random)...\nshred: foo.txt: File write pass failed: Is a directory\n");
+}
diff --git a/tests/by-util/test_shuf.rs b/tests/by-util/test_shuf.rs
index 13df0fa483f..ad64c52ca51 100644
--- a/tests/by-util/test_shuf.rs
+++ b/tests/by-util/test_shuf.rs
@@ -2,11 +2,16 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+
+// spell-checker:ignore (ToDO) unwritable
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -32,6 +37,28 @@ fn test_output_is_random_permutation() {
     assert_eq!(result_seq, input_seq, "Output is not a permutation");
 }
 
+#[test]
+fn test_explicit_stdin_file() {
+    let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let input = input_seq
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    let result = new_ucmd!().arg("-").pipe_in(input.as_bytes()).succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<i32> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    result_seq.sort_unstable();
+    assert_eq!(result_seq, input_seq, "Output is not a permutation");
+}
+
 #[test]
 fn test_zero_termination() {
     let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
@@ -48,6 +75,221 @@ fn test_zero_termination() {
     assert_eq!(result_seq, input_seq, "Output is not a permutation");
 }
 
+#[test]
+fn test_zero_termination_multi() {
+    let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let result = new_ucmd!().arg("-z").arg("-z").arg("-i1-10").succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<i32> = result
+        .stdout_str()
+        .split('\0')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    result_seq.sort_unstable();
+    assert_eq!(result_seq, input_seq, "Output is not a permutation");
+}
+
+#[test]
+fn test_very_large_range() {
+    let num_samples = 10;
+    let result = new_ucmd!()
+        .arg("-n")
+        .arg(num_samples.to_string())
+        .arg("-i0-1234567890")
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<isize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
+    assert!(
+        result_seq.iter().all(|x| (0..=1_234_567_890).contains(x)),
+        "Output includes element not from range: {}",
+        result.stdout_str()
+    );
+}
+
+#[test]
+fn test_very_large_range_offset() {
+    let num_samples = 10;
+    let result = new_ucmd!()
+        .arg("-n")
+        .arg(num_samples.to_string())
+        .arg("-i1234567890-2147483647")
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<isize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
+    assert!(
+        result_seq
+            .iter()
+            .all(|x| (1_234_567_890..=2_147_483_647).contains(x)),
+        "Output includes element not from range: {}",
+        result.stdout_str()
+    );
+}
+
+#[test]
+fn test_range_repeat_no_overflow_1_max() {
+    let upper_bound = usize::MAX;
+    let result = new_ucmd!()
+        .arg("-rn1")
+        .arg(format!("-i1-{upper_bound}"))
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<usize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_repeat_no_overflow_0_max_minus_1() {
+    let upper_bound = usize::MAX - 1;
+    let result = new_ucmd!()
+        .arg("-rn1")
+        .arg(format!("-i0-{upper_bound}"))
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<usize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_permute_no_overflow_1_max() {
+    let upper_bound = usize::MAX;
+    let result = new_ucmd!()
+        .arg("-n1")
+        .arg(format!("-i1-{upper_bound}"))
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<usize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_permute_no_overflow_0_max_minus_1() {
+    let upper_bound = usize::MAX - 1;
+    let result = new_ucmd!()
+        .arg("-n1")
+        .arg(format!("-i0-{upper_bound}"))
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<usize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_range_permute_no_overflow_0_max() {
+    // NOTE: This is different from GNU shuf!
+    // GNU shuf accepts -i0-MAX-1 and -i1-MAX, but not -i0-MAX.
+    // This feels like a bug in GNU shuf.
+    let upper_bound = usize::MAX;
+    let result = new_ucmd!()
+        .arg("-n1")
+        .arg(format!("-i0-{upper_bound}"))
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<usize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), 1, "Miscounted output length!");
+}
+
+#[test]
+fn test_very_high_range_full() {
+    let input_seq = vec![
+        2_147_483_641,
+        2_147_483_642,
+        2_147_483_643,
+        2_147_483_644,
+        2_147_483_645,
+        2_147_483_646,
+        2_147_483_647,
+    ];
+    let result = new_ucmd!().arg("-i2147483641-2147483647").succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<isize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    result_seq.sort_unstable();
+    assert_eq!(result_seq, input_seq, "Output is not a permutation");
+}
+
+#[test]
+fn test_range_repeat() {
+    let num_samples = 500;
+    let result = new_ucmd!()
+        .arg("-r")
+        .arg("-n")
+        .arg(num_samples.to_string())
+        .arg("-i12-34")
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<isize> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), num_samples, "Miscounted output length!");
+    assert!(
+        result_seq.iter().all(|x| (12..=34).contains(x)),
+        "Output includes element not from range: {}",
+        result.stdout_str()
+    );
+}
+
+#[test]
+fn test_empty_input() {
+    let result = new_ucmd!().pipe_in(vec![]).succeeds();
+    result.no_stderr();
+    result.no_stdout();
+}
+
 #[test]
 fn test_echo() {
     let input_seq = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
@@ -72,6 +314,102 @@ fn test_echo() {
     assert_eq!(result_seq, input_seq, "Output is not a permutation");
 }
 
+#[test]
+fn test_echo_multi() {
+    let result = new_ucmd!()
+        .arg("-e")
+        .arg("a")
+        .arg("b")
+        .arg("-e")
+        .arg("c")
+        .succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<String> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(std::convert::Into::into)
+        .collect();
+    result_seq.sort_unstable();
+    assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
+}
+
+#[test]
+fn test_echo_postfix() {
+    let result = new_ucmd!().arg("a").arg("b").arg("c").arg("-e").succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<String> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(std::convert::Into::into)
+        .collect();
+    result_seq.sort_unstable();
+    assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
+}
+
+#[test]
+fn test_echo_short_collapsed_zero() {
+    let result = new_ucmd!().arg("-ez").arg("a").arg("b").arg("c").succeeds();
+    result.no_stderr();
+
+    let mut result_seq: Vec<String> = result
+        .stdout_str()
+        .split('\0')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    result_seq.sort_unstable();
+    assert_eq!(result_seq, ["a", "b", "c"], "Output is not a permutation");
+}
+
+#[test]
+fn test_echo_separators_in_arguments() {
+    // We used to split arguments themselves on newlines, but this was wrong.
+    // shuf should behave as though it's shuffling two arguments and therefore
+    // output all of them.
+    // (Note that arguments can't contain null bytes so we don't need to test that.)
+    let result = new_ucmd!()
+        .arg("-e")
+        .arg("-n2")
+        .arg("a\nb")
+        .arg("c\nd")
+        .succeeds();
+    result.no_stderr();
+    assert_eq!(result.stdout_str().len(), 8, "Incorrect output length");
+}
+
+#[cfg(unix)]
+#[test]
+fn test_echo_invalid_unicode_in_arguments() {
+    use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
+
+    let result = new_ucmd!()
+        .arg("-e")
+        .arg(OsStr::from_bytes(b"a\xFFb"))
+        .arg("ok")
+        .succeeds();
+    result.no_stderr();
+    assert!(result.stdout().contains(&b'\xFF'));
+}
+
+#[cfg(any(unix, target_os = "wasi"))]
+#[cfg(not(target_os = "macos"))]
+#[test]
+fn test_invalid_unicode_in_filename() {
+    use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let filename = OsStr::from_bytes(b"a\xFFb");
+    at.append(filename, "foo\n");
+
+    let result = ucmd.arg(filename).succeeds();
+    result.no_stderr();
+    assert_eq!(result.stdout(), b"foo\n");
+}
+
 #[test]
 fn test_head_count() {
     let repeat_limit = 5;
@@ -103,6 +441,145 @@ fn test_head_count() {
     );
 }
 
+#[test]
+fn test_zero_head_count_pipe() {
+    let result = new_ucmd!().arg("-n0").pipe_in(vec![]).succeeds();
+    // Output must be completely empty, not even a newline!
+    result.no_output();
+}
+
+#[test]
+fn test_zero_head_count_pipe_explicit() {
+    let result = new_ucmd!().arg("-n0").arg("-").pipe_in(vec![]).succeeds();
+    result.no_output();
+}
+
+#[test]
+fn test_zero_head_count_file_unreadable() {
+    new_ucmd!()
+        .arg("-n0")
+        .arg("/invalid/unreadable")
+        .pipe_in(vec![])
+        .succeeds()
+        .no_output();
+}
+
+#[test]
+fn test_zero_head_count_file_touch_output_negative() {
+    new_ucmd!()
+        .arg("-n0")
+        .arg("-o")
+        .arg("/invalid/unwritable")
+        .pipe_in(vec![])
+        .fails()
+        .stderr_contains("failed to open '/invalid/unwritable' for writing:");
+}
+
+#[test]
+fn test_zero_head_count_file_touch_output_positive_new() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n0", "-o", "file"]).succeeds().no_output();
+    assert_eq!(
+        at.read_bytes("file"),
+        Vec::new(),
+        "Output file must exist and be completely empty"
+    );
+}
+
+#[test]
+fn test_zero_head_count_file_touch_output_positive_existing() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.touch("file");
+    ucmd.args(&["-n0", "-o", "file"]).succeeds().no_output();
+    assert_eq!(
+        at.read_bytes("file"),
+        Vec::new(),
+        "Output file must exist and be completely empty"
+    );
+}
+
+#[test]
+fn test_zero_head_count_echo() {
+    new_ucmd!()
+        .arg("-n0")
+        .arg("-e")
+        .arg("hello")
+        .pipe_in(vec![])
+        .succeeds()
+        .no_output();
+}
+
+#[test]
+fn test_zero_head_count_range() {
+    new_ucmd!().arg("-n0").arg("-i4-8").succeeds().no_output();
+}
+
+#[test]
+fn test_head_count_multi_big_then_small() {
+    let repeat_limit = 5;
+    let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let input = input_seq
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    let result = new_ucmd!()
+        .arg("-n")
+        .arg((repeat_limit + 1).to_string())
+        .arg("-n")
+        .arg(repeat_limit.to_string())
+        .pipe_in(input.as_bytes())
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<i32> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
+    assert!(
+        result_seq.iter().all(|x| input_seq.contains(x)),
+        "Output includes element not from input: {}",
+        result.stdout_str()
+    );
+}
+
+#[test]
+fn test_head_count_multi_small_then_big() {
+    let repeat_limit = 5;
+    let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let input = input_seq
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    let result = new_ucmd!()
+        .arg("-n")
+        .arg(repeat_limit.to_string())
+        .arg("-n")
+        .arg((repeat_limit + 1).to_string())
+        .pipe_in(input.as_bytes())
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<i32> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(result_seq.len(), repeat_limit, "Output is not limited");
+    assert!(
+        result_seq.iter().all(|x| input_seq.contains(x)),
+        "Output includes element not from input: {}",
+        result.stdout_str()
+    );
+}
+
 #[test]
 fn test_repeat() {
     let repeat_limit = 15000;
@@ -141,6 +618,45 @@ fn test_repeat() {
     );
 }
 
+#[test]
+fn test_repeat_multi() {
+    let repeat_limit = 15000;
+    let input_seq = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let input = input_seq
+        .iter()
+        .map(ToString::to_string)
+        .collect::<Vec<String>>()
+        .join("\n");
+
+    let result = new_ucmd!()
+        .arg("-r")
+        .arg("-r") // The only difference to test_repeat()
+        .args(&["-n", &repeat_limit.to_string()])
+        .pipe_in(input.as_bytes())
+        .succeeds();
+    result.no_stderr();
+
+    let result_seq: Vec<i32> = result
+        .stdout_str()
+        .split('\n')
+        .filter(|x| !x.is_empty())
+        .map(|x| x.parse().unwrap())
+        .collect();
+    assert_eq!(
+        result_seq.len(),
+        repeat_limit,
+        "Output is not repeating forever"
+    );
+    assert!(
+        result_seq.iter().all(|x| input_seq.contains(x)),
+        "Output includes element not from input: {:?}",
+        result_seq
+            .iter()
+            .filter(|x| !input_seq.contains(x))
+            .collect::<Vec<&i32>>()
+    );
+}
+
 #[test]
 fn test_file_input() {
     let expected_seq = vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
@@ -179,31 +695,62 @@ fn test_shuf_invalid_input_range_one() {
     new_ucmd!()
         .args(&["-i", "0"])
         .fails()
-        .stderr_contains("invalid input range");
+        .stderr_contains("invalid value '0' for '--input-range <LO-HI>': missing '-'");
 }
 
 #[test]
 fn test_shuf_invalid_input_range_two() {
+    new_ucmd!().args(&["-i", "a-9"]).fails().stderr_contains(
+        "invalid value 'a-9' for '--input-range <LO-HI>': invalid digit found in string",
+    );
+}
+
+#[test]
+fn test_shuf_invalid_input_range_three() {
+    new_ucmd!().args(&["-i", "0-b"]).fails().stderr_contains(
+        "invalid value '0-b' for '--input-range <LO-HI>': invalid digit found in string",
+    );
+}
+
+#[test]
+fn test_shuf_multiple_input_ranges() {
     new_ucmd!()
-        .args(&["-i", "a-9"])
+        .args(&["-i", "2-9", "-i", "2-9"])
         .fails()
-        .stderr_contains("invalid input range: 'a'");
+        .stderr_contains("--input-range")
+        .stderr_contains("cannot be used multiple times");
 }
 
 #[test]
-fn test_shuf_invalid_input_range_three() {
+fn test_shuf_multiple_outputs() {
     new_ucmd!()
-        .args(&["-i", "0-b"])
+        .args(&["-o", "file_a", "-o", "file_b"])
         .fails()
-        .stderr_contains("invalid input range: 'b'");
+        .stderr_contains("--output")
+        .stderr_contains("cannot be used multiple times");
 }
 
 #[test]
-fn test_shuf_invalid_input_line_count() {
+fn test_shuf_two_input_files() {
     new_ucmd!()
-        .args(&["-n", "a"])
+        .args(&["file_a", "file_b"])
         .fails()
-        .stderr_contains("invalid line count: 'a'");
+        .stderr_contains("unexpected argument 'file_b' found");
+}
+
+#[test]
+fn test_shuf_three_input_files() {
+    new_ucmd!()
+        .args(&["file_a", "file_b", "file_c"])
+        .fails()
+        .stderr_contains("unexpected argument 'file_b' found");
+}
+
+#[test]
+fn test_shuf_invalid_input_line_count() {
+    new_ucmd!().args(&["-n", "a"]).fails().stderr_contains(
+        "invalid value 'a' for '--head-count <COUNT>': invalid digit found in string",
+    );
 }
 
 #[test]
@@ -221,3 +768,84 @@ fn test_shuf_multiple_input_line_count() {
         .count();
     assert_eq!(result_count, 5, "Output should have 5 items");
 }
+
+#[test]
+fn test_shuf_repeat_empty_range() {
+    new_ucmd!()
+        .arg("-ri4-3")
+        .fails()
+        .no_stdout()
+        .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_shuf_repeat_empty_echo() {
+    new_ucmd!()
+        .arg("-re")
+        .fails()
+        .no_stdout()
+        .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_shuf_repeat_empty_input() {
+    new_ucmd!()
+        .arg("-r")
+        .pipe_in("")
+        .fails()
+        .no_stdout()
+        .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_range_one_elem() {
+    new_ucmd!()
+        .arg("-i5-5")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("5\n");
+}
+
+#[test]
+fn test_range_empty() {
+    new_ucmd!().arg("-i5-4").succeeds().no_output();
+}
+
+#[test]
+fn test_range_empty_minus_one() {
+    new_ucmd!()
+        .arg("-i5-3")
+        .fails()
+        .no_stdout()
+        .stderr_contains("invalid value '5-3' for '--input-range <LO-HI>': start exceeds end\n");
+}
+
+#[test]
+fn test_range_repeat_one_elem() {
+    new_ucmd!()
+        .arg("-n1")
+        .arg("-ri5-5")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("5\n");
+}
+
+#[test]
+fn test_range_repeat_empty() {
+    new_ucmd!()
+        .arg("-n1")
+        .arg("-ri5-4")
+        .fails()
+        .no_stdout()
+        .stderr_only("shuf: no lines to repeat\n");
+}
+
+#[test]
+fn test_range_repeat_empty_minus_one() {
+    new_ucmd!()
+        .arg("-n1")
+        .arg("-ri5-3")
+        .fails()
+        .no_stdout()
+        .stderr_contains("invalid value '5-3' for '--input-range <LO-HI>': start exceeds end\n");
+}
diff --git a/tests/by-util/test_sleep.rs b/tests/by-util/test_sleep.rs
index dd99c74060b..26a799e6705 100644
--- a/tests/by-util/test_sleep.rs
+++ b/tests/by-util/test_sleep.rs
@@ -4,9 +4,15 @@
 // file that was distributed with this source code.
 use rstest::rstest;
 
-// spell-checker:ignore dont
-use crate::common::util::TestScenario;
-
+use uucore::display::Quotable;
+// spell-checker:ignore dont SIGBUS SIGSEGV sigsegv sigbus infd
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+#[cfg(unix)]
+use nix::sys::signal::Signal::{SIGBUS, SIGSEGV};
+use std::io::ErrorKind;
 use std::time::{Duration, Instant};
 
 #[test]
@@ -14,11 +20,11 @@ fn test_invalid_time_interval() {
     new_ucmd!()
         .arg("xyz")
         .fails()
-        .usage_error("invalid time interval 'xyz': Invalid input: xyz");
+        .usage_error("invalid time interval 'xyz'");
     new_ucmd!()
         .args(&["--", "-1"])
         .fails()
-        .usage_error("invalid time interval '-1': Number was negative");
+        .usage_error("invalid time interval '-1'");
 }
 
 #[test]
@@ -135,10 +141,44 @@ fn test_sleep_wrong_time() {
     new_ucmd!().args(&["0.1s", "abc"]).fails();
 }
 
+#[test]
+#[cfg(unix)]
+fn test_sleep_stops_after_sigsegv() {
+    let mut child = new_ucmd!()
+        .arg("100")
+        .timeout(Duration::from_secs(10))
+        .run_no_wait();
+
+    child
+        .delay(100)
+        .kill_with_custom_signal(SIGSEGV)
+        .make_assertion()
+        .with_current_output()
+        .signal_is(SIGSEGV as i32) // make sure it was us who terminated the process
+        .no_output();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_sleep_stops_after_sigbus() {
+    let mut child = new_ucmd!()
+        .arg("100")
+        .timeout(Duration::from_secs(10))
+        .run_no_wait();
+
+    child
+        .delay(100)
+        .kill_with_custom_signal(SIGBUS)
+        .make_assertion()
+        .with_current_output()
+        .signal_is(SIGBUS as i32) // make sure it was us who terminated the process
+        .no_output();
+}
+
 #[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))
+        .arg(format!("{}", u128::from(u64::MAX) + 1))
         .timeout(Duration::from_secs(10))
         .run_no_wait();
 
@@ -189,9 +229,7 @@ fn test_sleep_when_multiple_inputs_exceed_max_duration_then_no_error() {
 #[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) {
+fn test_sleep_when_input_has_leading_whitespace_then_no_error(#[case] input: &str) {
     new_ucmd!()
         .arg(input)
         .timeout(Duration::from_secs(10))
@@ -199,6 +237,17 @@ fn test_sleep_when_input_has_whitespace_then_no_error(#[case] input: &str) {
         .no_output();
 }
 
+#[rstest]
+#[case::whitespace_suffix("0.1s ")]
+#[case::mixed_newlines_spaces_tabs("\n\t0.1s \n ")]
+fn test_sleep_when_input_has_trailing_whitespace_then_error(#[case] input: &str) {
+    new_ucmd!()
+        .arg(input)
+        .timeout(Duration::from_secs(10))
+        .fails()
+        .usage_error(format!("invalid time interval {}", input.quote()));
+}
+
 #[rstest]
 #[case::only_space(" ")]
 #[case::only_tab("\t")]
@@ -208,16 +257,14 @@ fn test_sleep_when_input_has_only_whitespace_then_error(#[case] input: &str) {
         .arg(input)
         .timeout(Duration::from_secs(10))
         .fails()
-        .usage_error(format!(
-            "invalid time interval '{input}': Found only whitespace in input"
-        ));
+        .usage_error(format!("invalid time interval {}", input.quote()));
 }
 
 #[test]
 fn test_sleep_when_multiple_input_some_with_error_then_shows_all_errors() {
-    let expected = "invalid time interval 'abc': Invalid input: abc\n\
-        sleep: invalid time interval '1years': Invalid time unit: 'years' at position 2\n\
-        sleep: invalid time interval ' ': Found only whitespace in input";
+    let expected = "invalid time interval 'abc'\n\
+                    sleep: invalid time interval '1years'\n\
+                    sleep: invalid time interval ' '";
 
     // 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
@@ -234,5 +281,172 @@ fn test_negative_interval() {
     new_ucmd!()
         .args(&["--", "-1"])
         .fails()
-        .usage_error("invalid time interval '-1': Number was negative");
+        .usage_error("invalid time interval '-1'");
+}
+
+#[rstest]
+#[case::int("0x0")]
+#[case::negative_zero("-0x0")]
+#[case::int_suffix("0x0s")]
+#[case::int_suffix("0x0h")]
+#[case::frac("0x0.1")]
+#[case::frac_suffix("0x0.1s")]
+#[case::frac_suffix("0x0.001h")]
+#[case::scientific("0x1.0p-3")]
+#[case::scientific_suffix("0x1.0p-4s")]
+fn test_valid_hex_duration(#[case] input: &str) {
+    new_ucmd!().args(&["--", input]).succeeds().no_output();
+}
+
+#[rstest]
+#[case::negative("-0x1")]
+#[case::negative_suffix("-0x1s")]
+#[case::negative_frac_suffix("-0x0.1s")]
+#[case::wrong_capitalization("infD")]
+#[case::wrong_capitalization("INFD")]
+#[case::wrong_capitalization("iNfD")]
+#[case::single_quote("'1")]
+fn test_invalid_duration(#[case] input: &str) {
+    new_ucmd!()
+        .args(&["--", input])
+        .fails()
+        .usage_error(format!("invalid time interval {}", input.quote()));
+}
+
+#[cfg(unix)]
+#[test]
+#[should_panic = "Program must be run first or has not finished"]
+fn test_cmd_result_signal_when_still_running_then_panic() {
+    let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+
+    child
+        .make_assertion()
+        .is_alive()
+        .with_current_output()
+        .signal();
+}
+
+#[cfg(unix)]
+#[test]
+fn test_cmd_result_signal_when_kill_then_signal() {
+    let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+
+    child.kill();
+    child
+        .make_assertion()
+        .is_not_alive()
+        .with_current_output()
+        .signal_is(9)
+        .signal_name_is("SIGKILL")
+        .signal_name_is("KILL")
+        .signal_name_is("9")
+        .signal()
+        .expect("Signal was none");
+
+    let result = child.wait().unwrap();
+    result
+        .signal_is(9)
+        .signal_name_is("SIGKILL")
+        .signal_name_is("KILL")
+        .signal_name_is("9")
+        .signal()
+        .expect("Signal was none");
+}
+
+#[cfg(unix)]
+#[rstest]
+#[case::signal_only_part_of_name("IGKILL")] // spell-checker: disable-line
+#[case::signal_just_sig("SIG")]
+#[case::signal_value_too_high("100")]
+#[case::signal_value_negative("-1")]
+#[should_panic = "Invalid signal name or value"]
+fn test_cmd_result_signal_when_invalid_signal_name_then_panic(#[case] signal_name: &str) {
+    let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+    child.kill();
+    let result = child.wait().unwrap();
+    result.signal_name_is(signal_name);
+}
+
+#[test]
+#[cfg(unix)]
+fn test_cmd_result_signal_name_is_accepts_lowercase() {
+    let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
+    child.kill();
+    let result = child.wait().unwrap();
+    result.signal_name_is("sigkill");
+    result.signal_name_is("kill");
+}
+
+#[test]
+fn test_uchild_when_wait_and_timeout_is_reached_then_timeout_error() {
+    let ts = TestScenario::new("sleep");
+    let child = ts
+        .ucmd()
+        .timeout(Duration::from_secs(1))
+        .arg("10.0")
+        .run_no_wait();
+
+    match child.wait() {
+        Err(error) if error.kind() == ErrorKind::Other => {
+            std::assert_eq!(error.to_string(), "wait: Timeout of '1s' reached");
+        }
+        Err(error) => panic!("Assertion failed: Expected error with timeout but was: {error}"),
+        Ok(_) => panic!("Assertion failed: Expected timeout of `wait`."),
+    }
+}
+
+#[rstest]
+#[timeout(Duration::from_secs(5))]
+fn test_uchild_when_kill_and_timeout_higher_than_kill_time_then_no_panic() {
+    let ts = TestScenario::new("sleep");
+    let mut child = ts
+        .ucmd()
+        .timeout(Duration::from_secs(60))
+        .arg("20.0")
+        .run_no_wait();
+
+    child.kill().make_assertion().is_not_alive();
+}
+
+#[test]
+fn test_uchild_when_try_kill_and_timeout_is_reached_then_error() {
+    let ts = TestScenario::new("sleep");
+    let mut child = ts.ucmd().timeout(Duration::ZERO).arg("10.0").run_no_wait();
+
+    match child.try_kill() {
+        Err(error) if error.kind() == ErrorKind::Other => {
+            std::assert_eq!(error.to_string(), "kill: Timeout of '0s' reached");
+        }
+        Err(error) => panic!("Assertion failed: Expected error with timeout but was: {error}"),
+        Ok(()) => panic!("Assertion failed: Expected timeout of `try_kill`."),
+    }
+}
+
+#[test]
+#[should_panic = "kill: Timeout of '0s' reached"]
+fn test_uchild_when_kill_with_timeout_and_timeout_is_reached_then_panic() {
+    let ts = TestScenario::new("sleep");
+    let mut child = ts.ucmd().timeout(Duration::ZERO).arg("10.0").run_no_wait();
+
+    child.kill();
+    panic!("Assertion failed: Expected timeout of `kill`.");
+}
+
+#[test]
+#[should_panic(expected = "wait: Timeout of '1.1s' reached")]
+fn test_ucommand_when_run_with_timeout_and_timeout_is_reached_then_panic() {
+    let ts = TestScenario::new("sleep");
+    ts.ucmd()
+        .timeout(Duration::from_millis(1100))
+        .arg("10.0")
+        .run();
+
+    panic!("Assertion failed: Expected timeout of `run`.")
+}
+
+#[rstest]
+#[timeout(Duration::from_secs(10))]
+fn test_ucommand_when_run_with_timeout_higher_then_execution_time_then_no_panic() {
+    let ts = TestScenario::new("sleep");
+    ts.ucmd().timeout(Duration::from_secs(60)).arg("1.0").run();
 }
diff --git a/tests/by-util/test_sort.rs b/tests/by-util/test_sort.rs
index 690623c1c96..988360ca696 100644
--- a/tests/by-util/test_sort.rs
+++ b/tests/by-util/test_sort.rs
@@ -3,11 +3,15 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-// spell-checker:ignore (words) ints
+// spell-checker:ignore (words) ints (linux) NOFILE
+#![allow(clippy::cast_possible_wrap)]
 
 use std::time::Duration;
 
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 fn test_helper(file_name: &str, possible_args: &[&str]) {
     for args in possible_args {
@@ -28,6 +32,10 @@ fn test_helper(file_name: &str, possible_args: &[&str]) {
 
 #[test]
 fn test_buffer_sizes() {
+    #[cfg(target_os = "linux")]
+    let buffer_sizes = ["0", "50K", "50k", "1M", "100M", "0%", "10%"];
+    // TODO Percentage sizes are not yet supported beyond Linux.
+    #[cfg(not(target_os = "linux"))]
     let buffer_sizes = ["0", "50K", "50k", "1M", "100M"];
     for buffer_size in &buffer_sizes {
         TestScenario::new(util_name!())
@@ -38,20 +46,20 @@ fn test_buffer_sizes() {
             .arg("ext_sort.txt")
             .succeeds()
             .stdout_is_fixture("ext_sort.expected");
+    }
 
-        #[cfg(not(target_pointer_width = "32"))]
-        {
-            let buffer_sizes = ["1000G", "10T"];
-            for buffer_size in &buffer_sizes {
-                TestScenario::new(util_name!())
-                    .ucmd()
-                    .arg("-n")
-                    .arg("-S")
-                    .arg(buffer_size)
-                    .arg("ext_sort.txt")
-                    .succeeds()
-                    .stdout_is_fixture("ext_sort.expected");
-            }
+    #[cfg(not(target_pointer_width = "32"))]
+    {
+        let buffer_sizes = ["1000G", "10T"];
+        for buffer_size in &buffer_sizes {
+            TestScenario::new(util_name!())
+                .ucmd()
+                .arg("-n")
+                .arg("-S")
+                .arg(buffer_size)
+                .arg("ext_sort.txt")
+                .succeeds()
+                .stdout_is_fixture("ext_sort.expected");
         }
     }
 }
@@ -61,25 +69,29 @@ fn test_invalid_buffer_size() {
     new_ucmd!()
         .arg("-S")
         .arg("asd")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only("sort: invalid --buffer-size argument 'asd'\n");
 
     new_ucmd!()
         .arg("-S")
         .arg("100f")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only("sort: invalid suffix in --buffer-size argument '100f'\n");
 
-    #[cfg(not(target_pointer_width = "128"))]
+    // TODO Percentage sizes are not yet supported beyond Linux.
+    #[cfg(target_os = "linux")]
+    new_ucmd!()
+        .arg("-S")
+        .arg("0x123%")
+        .fails_with_code(2)
+        .stderr_only("sort: invalid --buffer-size argument '0x123%'\n");
+
     new_ucmd!()
         .arg("-n")
         .arg("-S")
         .arg("1Y")
         .arg("ext_sort.txt")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only("sort: --buffer-size argument '1Y' too large\n");
 
     #[cfg(target_pointer_width = "32")]
@@ -91,11 +103,9 @@ fn test_invalid_buffer_size() {
                 .arg("-S")
                 .arg(buffer_size)
                 .arg("ext_sort.txt")
-                .fails()
-                .code_is(2)
+                .fails_with_code(2)
                 .stderr_only(format!(
-                    "sort: --buffer-size argument '{}' too large\n",
-                    buffer_size
+                    "sort: --buffer-size argument '{buffer_size}' too large\n"
                 ));
         }
     }
@@ -126,7 +136,16 @@ fn test_ext_sort_zero_terminated() {
 
 #[test]
 fn test_months_whitespace() {
-    test_helper("months-whitespace", &["-M", "--month-sort", "--sort=month"]);
+    test_helper(
+        "months-whitespace",
+        &[
+            "-M",
+            "--month-sort",
+            "--sort=month",
+            "--sort=mont",
+            "--sort=m",
+        ],
+    );
 }
 
 #[test]
@@ -141,6 +160,16 @@ fn test_version_sort_unstable() {
         .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
         .succeeds()
         .stdout_is("0.1\n0.002\n0.02\n0.2\n0.3\n");
+    new_ucmd!()
+        .arg("--sort=versio") // spell-checker:disable-line
+        .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
+        .succeeds()
+        .stdout_is("0.1\n0.002\n0.02\n0.2\n0.3\n");
+    new_ucmd!()
+        .arg("--sort=v")
+        .pipe_in("0.1\n0.02\n0.2\n0.002\n0.3\n")
+        .succeeds()
+        .stdout_is("0.1\n0.002\n0.02\n0.2\n0.3\n");
 }
 
 #[test]
@@ -157,7 +186,14 @@ fn test_version_sort_stable() {
 fn test_human_numeric_whitespace() {
     test_helper(
         "human-numeric-whitespace",
-        &["-h", "--human-numeric-sort", "--sort=human-numeric"],
+        &[
+            "-h",
+            "--human-numeric-sort",
+            "--sort=human-numeric",
+            "--sort=human-numeri", // spell-checker:disable-line
+            "--sort=human",
+            "--sort=h",
+        ],
     );
 }
 
@@ -177,7 +213,14 @@ fn test_ext_sort_as64_bailout() {
 fn test_multiple_decimals_general() {
     test_helper(
         "multiple_decimals_general",
-        &["-g", "--general-numeric-sort", "--sort=general-numeric"],
+        &[
+            "-g",
+            "--general-numeric-sort",
+            "--sort=general-numeric",
+            "--sort=general-numeri", // spell-checker:disable-line
+            "--sort=general",
+            "--sort=g",
+        ],
     );
 }
 
@@ -185,7 +228,7 @@ fn test_multiple_decimals_general() {
 fn test_multiple_decimals_numeric() {
     test_helper(
         "multiple_decimals_numeric",
-        &["-n", "--numeric-sort", "--sort=numeric"],
+        &["-n", "--numeric-sort", "--sort=numeric", "--sort=n"],
     );
 }
 
@@ -221,7 +264,7 @@ fn test_random_shuffle_len() {
     // check whether output is the same length as the input
     const FILE: &str = "default_unsorted_ints.expected";
     let (at, _ucmd) = at_and_ucmd!();
-    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
+    let result = new_ucmd!().arg("-R").arg(FILE).succeeds().stdout_move_str();
     let expected = at.read(FILE);
 
     assert_ne!(result, expected);
@@ -233,9 +276,12 @@ fn test_random_shuffle_contains_all_lines() {
     // check whether lines of input are all in output
     const FILE: &str = "default_unsorted_ints.expected";
     let (at, _ucmd) = at_and_ucmd!();
-    let result = new_ucmd!().arg("-R").arg(FILE).run().stdout_move_str();
+    let result = new_ucmd!().arg("-R").arg(FILE).succeeds().stdout_move_str();
     let expected = at.read(FILE);
-    let result_sorted = new_ucmd!().pipe_in(result.clone()).run().stdout_move_str();
+    let result_sorted = new_ucmd!()
+        .pipe_in(result.clone())
+        .succeeds()
+        .stdout_move_str();
 
     assert_ne!(result, expected);
     assert_eq!(result_sorted, expected);
@@ -249,9 +295,9 @@ fn test_random_shuffle_two_runs_not_the_same() {
         // as the starting order, or if both random sorts end up having the same order.
         const FILE: &str = "default_unsorted_ints.expected";
         let (at, _ucmd) = at_and_ucmd!();
-        let result = new_ucmd!().arg(arg).arg(FILE).run().stdout_move_str();
+        let result = new_ucmd!().arg(arg).arg(FILE).succeeds().stdout_move_str();
         let expected = at.read(FILE);
-        let unexpected = new_ucmd!().arg(arg).arg(FILE).run().stdout_move_str();
+        let unexpected = new_ucmd!().arg(arg).arg(FILE).succeeds().stdout_move_str();
 
         assert_ne!(result, expected);
         assert_ne!(result, unexpected);
@@ -784,7 +830,13 @@ fn test_pipe() {
 
 #[test]
 fn test_check() {
-    for diagnose_arg in ["-c", "--check", "--check=diagnose-first"] {
+    for diagnose_arg in [
+        "-c",
+        "--check",
+        "--check=diagnose-first",
+        "--check=diagnose",
+        "--check=d",
+    ] {
         new_ucmd!()
             .arg(diagnose_arg)
             .arg("check_fail.txt")
@@ -802,24 +854,43 @@ fn test_check() {
 
 #[test]
 fn test_check_silent() {
-    for silent_arg in ["-C", "--check=silent", "--check=quiet"] {
+    for silent_arg in [
+        "-C",
+        "--check=silent",
+        "--check=quiet",
+        "--check=silen", // spell-checker:disable-line
+        "--check=quie",  // spell-checker:disable-line
+        "--check=s",
+        "--check=q",
+    ] {
         new_ucmd!()
             .arg(silent_arg)
             .arg("check_fail.txt")
             .fails()
             .stdout_is("");
+        new_ucmd!()
+            .arg(silent_arg)
+            .arg("empty.txt")
+            .succeeds()
+            .no_output();
     }
 }
 
 #[test]
 fn test_check_unique() {
-    // Due to a clap bug the combination "-cu" does not work. "-c -u" works.
-    // See https://github.com/clap-rs/clap/issues/2624
     new_ucmd!()
         .args(&["-c", "-u"])
         .pipe_in("A\nA\n")
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
+        .stderr_only("sort: -:2: disorder: A\n");
+}
+
+#[test]
+fn test_check_unique_combined() {
+    new_ucmd!()
+        .args(&["-cu"])
+        .pipe_in("A\nA\n")
+        .fails_with_code(1)
         .stderr_only("sort: -:2: disorder: A\n");
 }
 
@@ -829,7 +900,7 @@ fn test_dictionary_and_nonprinting_conflicts() {
     for restricted_arg in ["d", "i"] {
         for conflicting_arg in &conflicting_args {
             new_ucmd!()
-                .arg(&format!("-{restricted_arg}{conflicting_arg}"))
+                .arg(format!("-{restricted_arg}{conflicting_arg}"))
                 .fails();
         }
         for conflicting_arg in &conflicting_args {
@@ -837,7 +908,7 @@ fn test_dictionary_and_nonprinting_conflicts() {
                 .args(&[
                     format!("-{restricted_arg}").as_str(),
                     "-k",
-                    &format!("1,1{conflicting_arg}"),
+                    format!("1,1{conflicting_arg}").as_str(),
                 ])
                 .succeeds();
         }
@@ -862,8 +933,7 @@ fn test_trailing_separator() {
 fn test_nonexistent_file() {
     new_ucmd!()
         .arg("nonexistent.txt")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_only(
             #[cfg(not(windows))]
             "sort: cannot read: nonexistent.txt: No such file or directory\n",
@@ -976,6 +1046,34 @@ fn test_merge_batches() {
         .stdout_only_fixture("ext_sort.expected");
 }
 
+#[test]
+fn test_batch_size_invalid() {
+    TestScenario::new(util_name!())
+        .ucmd()
+        .arg("--batch-size=0")
+        .fails_with_code(2)
+        .stderr_contains("sort: invalid --batch-size argument '0'")
+        .stderr_contains("sort: minimum --batch-size argument is '2'");
+}
+
+#[test]
+fn test_batch_size_too_large() {
+    let large_batch_size = "18446744073709551616";
+    TestScenario::new(util_name!())
+        .ucmd()
+        .arg(format!("--batch-size={large_batch_size}"))
+        .fails_with_code(2)
+        .stderr_contains(format!(
+            "--batch-size argument '{large_batch_size}' too large"
+        ));
+    #[cfg(target_os = "linux")]
+    TestScenario::new(util_name!())
+        .ucmd()
+        .arg(format!("--batch-size={large_batch_size}"))
+        .fails_with_code(2)
+        .stderr_contains("maximum --batch-size argument with current rlimit is");
+}
+
 #[test]
 fn test_merge_batch_size() {
     TestScenario::new(util_name!())
@@ -993,6 +1091,33 @@ fn test_merge_batch_size() {
         .stdout_only_fixture("merge_ints_interleaved.expected");
 }
 
+#[test]
+// TODO(#7542): Re-enable on Android once we figure out why setting limit is broken.
+// #[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(target_os = "linux")]
+fn test_merge_batch_size_with_limit() {
+    use rlimit::Resource;
+    // Currently need...
+    // 3 descriptors for stdin, stdout, stderr
+    // 2 descriptors for CTRL+C handling logic (to be reworked at some point)
+    // 2 descriptors for the input files (i.e. batch-size of 2).
+    let limit_fd = 3 + 2 + 2;
+    TestScenario::new(util_name!())
+        .ucmd()
+        .limit(Resource::NOFILE, limit_fd, limit_fd)
+        .arg("--batch-size=2")
+        .arg("-m")
+        .arg("--unique")
+        .arg("merge_ints_interleaved_1.txt")
+        .arg("merge_ints_interleaved_2.txt")
+        .arg("merge_ints_interleaved_3.txt")
+        .arg("merge_ints_interleaved_3.txt")
+        .arg("merge_ints_interleaved_2.txt")
+        .arg("merge_ints_interleaved_1.txt")
+        .succeeds()
+        .stdout_only_fixture("merge_ints_interleaved.expected");
+}
+
 #[test]
 fn test_sigpipe_panic() {
     let mut cmd = new_ucmd!();
@@ -1034,8 +1159,7 @@ fn test_verifies_out_file() {
             .args(&["-o", "nonexistent_dir/nonexistent_file"])
             .pipe_in(input)
             .ignore_stdin_write_error()
-            .fails()
-            .code_is(2)
+            .fails_with_code(2)
             .stderr_only(
                 #[cfg(not(windows))]
                 "sort: open failed: nonexistent_dir/nonexistent_file: No such file or directory\n",
@@ -1055,8 +1179,7 @@ fn test_verifies_files_after_keys() {
             "0",
             "nonexistent_dir/input_file",
         ])
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_contains("failed to parse key");
 }
 
@@ -1065,8 +1188,7 @@ fn test_verifies_files_after_keys() {
 fn test_verifies_input_files() {
     new_ucmd!()
         .args(&["/dev/random", "nonexistent_file"])
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("sort: cannot read: nonexistent_file: No such file or directory\n");
 }
 
@@ -1123,8 +1245,7 @@ fn test_no_error_for_version() {
 fn test_wrong_args_exit_code() {
     new_ucmd!()
         .arg("--misspelled")
-        .fails()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_contains("--misspelled");
 }
 
@@ -1134,6 +1255,7 @@ fn test_tmp_files_deleted_on_sigint() {
     use std::{fs::read_dir, time::Duration};
 
     use nix::{sys::signal, unistd::Pid};
+    use rand::rngs::SmallRng;
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("tmp_dir");
@@ -1144,8 +1266,8 @@ fn test_tmp_files_deleted_on_sigint() {
         let mut file = at.make_file(file_name);
         // approximately 20 MB
         for _ in 0..40 {
-            let lines = rand_pcg::Pcg32::seed_from_u64(123)
-                .sample_iter(rand::distributions::uniform::Uniform::new(0, 10000))
+            let lines = SmallRng::seed_from_u64(123)
+                .sample_iter(rand::distr::uniform::Uniform::new(0, 10000).unwrap())
                 .take(100_000)
                 .map(|x| x.to_string() + "\n")
                 .collect::<String>();
@@ -1181,3 +1303,54 @@ fn test_tmp_files_deleted_on_sigint() {
 fn test_same_sort_mode_twice() {
     new_ucmd!().args(&["-k", "2n,2n", "empty.txt"]).succeeds();
 }
+
+#[test]
+fn test_args_override() {
+    new_ucmd!().args(&["-f", "-f"]).pipe_in("foo").succeeds();
+}
+
+#[test]
+fn test_k_overflow() {
+    let input = "2\n1\n";
+    let output = "1\n2\n";
+    new_ucmd!()
+        .args(&["-k", "18446744073709551616"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_is(output);
+}
+
+#[test]
+fn test_human_blocks_r_and_q() {
+    let input = "1Q\n1R\n";
+    let output = "1R\n1Q\n";
+    new_ucmd!()
+        .args(&["-h"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_is(output);
+}
+
+#[test]
+fn test_args_check_conflict() {
+    new_ucmd!().arg("-c").arg("-C").fails();
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .pipe_in("hello")
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("sort: write failed: 'standard output': No space left on device\n");
+}
+
+#[test]
+// Test for GNU tests/sort/sort.pl "o2"
+fn test_multiple_output_files() {
+    new_ucmd!()
+        .args(&["-o", "foo", "-o", "bar"])
+        .fails_with_code(2)
+        .stderr_is("sort: multiple output files specified\n");
+}
diff --git a/tests/by-util/test_split.rs b/tests/by-util/test_split.rs
index f3317d4c7a4..84e718abd5d 100644
--- a/tests/by-util/test_split.rs
+++ b/tests/by-util/test_split.rs
@@ -2,22 +2,26 @@
 //
 // 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 dxen
+// spell-checker:ignore xzaaa sixhundredfiftyonebytes ninetyonebytes threebytes asciilowercase ghijkl mnopq rstuv wxyz fivelines twohundredfortyonebytes onehundredlines nbbbb dxen ncccc rlimit NOFILE
 
-use crate::common::util::{AtPath, TestScenario};
-use rand::{thread_rng, Rng, SeedableRng};
+use rand::{Rng, SeedableRng, rng};
 use regex::Regex;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use rlimit::Resource;
 #[cfg(not(windows))]
 use std::env;
 use std::path::Path;
 use std::{
-    fs::{read_dir, File},
+    fs::{File, read_dir},
     io::{BufWriter, Read, Write},
 };
+use uutests::util::{AtPath, TestScenario};
+
+use uutests::{at_and_ucmd, new_ucmd, util_name};
 
 fn random_chars(n: usize) -> String {
-    thread_rng()
-        .sample_iter(&rand::distributions::Alphanumeric)
+    rng()
+        .sample_iter(&rand::distr::Alphanumeric)
         .map(char::from)
         .take(n)
         .collect::<String>()
@@ -108,9 +112,14 @@ impl RandomFile {
 
     /// Add n lines each of size `RandomFile::LINESIZE`
     fn add_lines(&mut self, lines: usize) {
+        self.add_lines_with_line_size(lines, Self::LINESIZE);
+    }
+
+    /// Add n lines each of the given size.
+    fn add_lines_with_line_size(&mut self, lines: usize, line_size: usize) {
         let mut n = lines;
         while n > 0 {
-            writeln!(self.inner, "{}", random_chars(Self::LINESIZE)).unwrap();
+            writeln!(self.inner, "{}", random_chars(line_size)).unwrap();
             n -= 1;
         }
     }
@@ -118,7 +127,15 @@ impl RandomFile {
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_split_non_existing_file() {
+    new_ucmd!()
+        .arg("non-existing")
+        .fails_with_code(1)
+        .stderr_is("split: cannot open 'non-existing' for reading: No such file or directory\n");
 }
 
 #[test]
@@ -170,6 +187,22 @@ fn test_split_str_prefixed_chunks_by_bytes() {
     assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
+/// Test short bytes option concatenated with value
+#[test]
+fn test_split_by_bytes_short_concatenated_with_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "split_by_bytes_short_concatenated_with_value";
+    RandomFile::new(&at, name).add_bytes(10000);
+    ucmd.args(&["-b1000", name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 10);
+    for filename in glob.collect() {
+        assert_eq!(glob.directory.metadata(&filename).len(), 1000);
+    }
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
 // This is designed to test what happens when the desired part size is not a
 // multiple of the buffer size and we hopefully don't overshoot the desired part
 // size.
@@ -231,11 +264,30 @@ fn test_split_additional_suffix() {
 }
 
 #[test]
-fn test_additional_suffix_no_slash() {
+fn test_additional_suffix_dir_separator() {
+    #[cfg(unix)]
     new_ucmd!()
         .args(&["--additional-suffix", "a/b"])
         .fails()
         .usage_error("invalid suffix 'a/b', contains directory separator");
+
+    #[cfg(windows)]
+    new_ucmd!()
+        .args(&["--additional-suffix", "a\\b"])
+        .fails()
+        .usage_error("invalid suffix 'a\\b', contains directory separator");
+}
+
+#[test]
+fn test_split_additional_suffix_hyphen_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "split_additional_suffix";
+    RandomFile::new(&at, name).add_lines(2000);
+    ucmd.args(&["--additional-suffix", "-300", name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]-300$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 // note: the test_filter* tests below are unix-only
@@ -279,13 +331,18 @@ fn test_filter_with_env_var_set() {
     RandomFile::new(&at, name).add_lines(n_lines);
 
     let env_var_value = "some-value";
-    env::set_var("FILE", env_var_value);
+    unsafe {
+        env::set_var("FILE", env_var_value);
+    }
     ucmd.args(&[format!("--filter={}", "cat > $FILE").as_str(), name])
         .succeeds();
 
     let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
     assert_eq!(glob.collate(), at.read_bytes(name));
-    assert!(env::var("FILE").unwrap_or_else(|_| "var was unset".to_owned()) == env_var_value);
+    assert_eq!(
+        env::var("FILE").unwrap_or_else(|_| "var was unset".to_owned()),
+        env_var_value
+    );
 }
 
 #[test]
@@ -299,6 +356,48 @@ fn test_filter_command_fails() {
         .fails();
 }
 
+#[test]
+#[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
+fn test_filter_broken_pipe() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "filter-big-input";
+
+    RandomFile::new(&at, name).add_lines(1024 * 10);
+    ucmd.args(&["--filter=head -c1 > /dev/null", "-n", "r/1", name])
+        .succeeds();
+}
+
+#[test]
+#[cfg(unix)]
+fn test_filter_with_kth_chunk() {
+    let scene = TestScenario::new(util_name!());
+    scene
+        .ucmd()
+        .args(&["--filter='some'", "--number=1/2"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .no_stdout()
+        .stderr_contains("--filter does not process a chunk extracted to stdout");
+    scene
+        .ucmd()
+        .args(&["--filter='some'", "--number=l/1/2"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .no_stdout()
+        .stderr_contains("--filter does not process a chunk extracted to stdout");
+    scene
+        .ucmd()
+        .args(&["--filter='some'", "--number=r/1/2"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .no_stdout()
+        .stderr_contains("--filter does not process a chunk extracted to stdout");
+}
+
 #[test]
 fn test_split_lines_number() {
     // Test if stdout/stderr for '--lines' option is correct
@@ -312,29 +411,303 @@ fn test_split_lines_number() {
         .succeeds()
         .no_stderr()
         .no_stdout();
+    scene
+        .ucmd()
+        .args(&["--lines", "0", "file"])
+        .fails_with_code(1)
+        .stderr_only("split: invalid number of lines: 0\n");
+    scene
+        .ucmd()
+        .args(&["-0", "file"])
+        .fails_with_code(1)
+        .stderr_only("split: invalid number of lines: 0\n");
     scene
         .ucmd()
         .args(&["--lines", "2fb", "file"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_only("split: invalid number of lines: '2fb'\n");
+    scene
+        .ucmd()
+        .args(&["--lines", "file"])
+        .fails_with_code(1)
+        .stderr_only("split: invalid number of lines: 'file'\n");
+}
+
+/// Test interference between split line size and IO buffer capacity.
+/// See issue #7869.
+#[test]
+fn test_split_lines_interfere_with_io_buf_capacity() {
+    let buf_capacity = BufWriter::new(Vec::new()).capacity();
+    // We intentionally set the line size to be less than the IO write buffer
+    // capacity. This is to trigger the condition where after the first split
+    // file is written, there are still bytes left in the buffer. We then
+    // test that those bytes are written to the next split file.
+    let line_size = buf_capacity - 2;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "split_lines_interfere_with_io_buf_capacity";
+    RandomFile::new(&at, name).add_lines_with_line_size(2, line_size);
+    ucmd.args(&["-l", "1", name]).succeeds();
+
+    // Note that `lines_size` doesn't take the trailing newline into account,
+    // we add 1 for adjustment.
+    assert_eq!(at.read("xaa").len(), line_size + 1);
+    assert_eq!(at.read("xab").len(), line_size + 1);
+}
+
+/// Test short lines option with value concatenated
+#[test]
+fn test_split_lines_short_concatenated_with_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "split_num_prefixed_chunks_by_lines";
+    RandomFile::new(&at, name).add_lines(10000);
+    ucmd.args(&["-l1000", name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 10);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for obsolete lines option standalone
+#[test]
+fn test_split_obs_lines_standalone() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "obs-lines-standalone";
+    RandomFile::new(&at, name).add_lines(4);
+    ucmd.args(&["-2", name]).succeeds().no_stderr().no_stdout();
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for obsolete lines option standalone overflow
+#[test]
+fn test_split_obs_lines_standalone_overflow() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "obs-lines-standalone";
+    RandomFile::new(&at, name).add_lines(4);
+    ucmd.args(&["-99999999999999999991", name])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 1);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for obsolete lines option as part of invalid combined short options
+#[test]
+fn test_split_obs_lines_within_invalid_combined_shorts() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+
+    scene
+        .ucmd()
+        .args(&["-2fb", "file"])
+        .fails_with_code(1)
+        .stderr_contains("error: unexpected argument '-f' found\n");
+}
+
+/// Test for obsolete lines option as part of combined short options
+#[test]
+fn test_split_obs_lines_within_combined_shorts() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let name = "obs-lines-within-shorts";
+    RandomFile::new(at, name).add_lines(400);
+
+    scene
+        .ucmd()
+        .args(&["-x200de", name])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    let glob = Glob::new(at, ".", r"x\d\d$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for obsolete lines option as part of combined short options with tailing suffix length with value
+#[test]
+fn test_split_obs_lines_within_combined_shorts_tailing_suffix_length() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "obs-lines-combined-shorts-tailing-suffix-length";
+    RandomFile::new(&at, name).add_lines(1000);
+    ucmd.args(&["-d200a4", name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x\d\d\d\d$");
+    assert_eq!(glob.count(), 5);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for obsolete lines option starts as part of combined short options
+#[test]
+fn test_split_obs_lines_starts_combined_shorts() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let name = "obs-lines-starts-shorts";
+    RandomFile::new(at, name).add_lines(400);
+
+    scene
+        .ucmd()
+        .args(&["-200xd", name])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    let glob = Glob::new(at, ".", r"x\d\d$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for using both obsolete lines (standalone) option and short/long lines option simultaneously
+#[test]
+fn test_split_both_lines_and_obs_lines_standalone() {
+    // This test will ensure that:
+    // if both lines option '-l' or '--lines' (with value) and obsolete lines option '-100' are used - it fails
+    // if standalone lines option is used incorrectly and treated as a hyphen prefixed value of other option - it fails
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+
+    scene
+        .ucmd()
+        .args(&["-l", "2", "-2", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: cannot split in more than one way\n");
+    scene
+        .ucmd()
+        .args(&["--lines", "2", "-2", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: cannot split in more than one way\n");
+}
+
+/// Test for using obsolete lines option incorrectly, so it is treated as a hyphen prefixed value of other option
+#[test]
+fn test_split_obs_lines_as_other_option_value() {
+    // This test will ensure that:
+    // if obsolete lines option is used incorrectly and treated as a hyphen prefixed value of other option - it fails
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+
+    scene
+        .ucmd()
+        .args(&["--lines", "-200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of lines: '-200'\n");
+    scene
+        .ucmd()
+        .args(&["-l", "-200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of lines: '-200'\n");
+    scene
+        .ucmd()
+        .args(&["-a", "-200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid suffix length: '-200'\n");
+    scene
+        .ucmd()
+        .args(&["--suffix-length", "-d200e", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid suffix length: '-d200e'\n");
+    scene
+        .ucmd()
+        .args(&["-C", "-200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of bytes: '-200'\n");
+    scene
+        .ucmd()
+        .args(&["--line-bytes", "-x200a4", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of bytes: '-x200a4'\n");
+    scene
+        .ucmd()
+        .args(&["-b", "-200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of bytes: '-200'\n");
+    scene
+        .ucmd()
+        .args(&["--bytes", "-200xd", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of bytes: '-200xd'\n");
+    scene
+        .ucmd()
+        .args(&["-n", "-200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of chunks: '-200'\n");
+    scene
+        .ucmd()
+        .args(&["--number", "-e200", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: invalid number of chunks: '-e200'\n");
+}
+
+/// Test for using more than one obsolete lines option (standalone)
+/// last one wins
+#[test]
+fn test_split_multiple_obs_lines_standalone() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let name = "multiple-obs-lines";
+    RandomFile::new(at, name).add_lines(400);
+
+    scene
+        .ucmd()
+        .args(&["-3000", "-200", name])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    let glob = Glob::new(at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for using more than one obsolete lines option within combined shorts
+/// last one wins
+#[test]
+fn test_split_multiple_obs_lines_within_combined() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let name = "multiple-obs-lines";
+    RandomFile::new(at, name).add_lines(400);
+
+    scene
+        .ucmd()
+        .args(&["-d5000x", "-e200d", name])
+        .succeeds()
+        .no_stderr()
+        .no_stdout();
+    let glob = Glob::new(at, ".", r"x\d\d$");
+    assert_eq!(glob.count(), 2);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
+/// Test for using both obsolete lines option within combined shorts with conflicting -n option simultaneously
+#[test]
+fn test_split_obs_lines_within_combined_with_number() {
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    at.touch("file");
+
+    scene
+        .ucmd()
+        .args(&["-3dxen", "4", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: cannot split in more than one way\n");
+    scene
+        .ucmd()
+        .args(&["-dxe30n", "4", "file"])
+        .fails_with_code(1)
+        .stderr_contains("split: cannot split in more than one way\n");
 }
 
 #[test]
 fn test_split_invalid_bytes_size() {
     new_ucmd!()
-        .args(&["-b", "1024R"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: invalid number of bytes: '1024R'\n");
-    #[cfg(not(target_pointer_width = "128"))]
-    new_ucmd!()
-        .args(&["-b", "1Y"])
-        .fails()
-        .code_is(1)
-        .stderr_only(
-            "split: invalid number of bytes: '1Y': Value too large for defined data type\n",
-        );
+        .args(&["-b", "1024W"])
+        .fails_with_code(1)
+        .stderr_only("split: invalid number of bytes: '1024W'\n");
     #[cfg(target_pointer_width = "32")]
     {
         let sizes = ["1000G", "10T"];
@@ -345,34 +718,51 @@ fn test_split_invalid_bytes_size() {
 }
 
 #[test]
-fn test_split_chunks_num_chunks_oversized_32() {
-    #[cfg(target_pointer_width = "32")]
-    {
-        let scene = TestScenario::new(util_name!());
-        let at = &scene.fixtures;
-        at.touch("file");
-        scene
-            .ucmd()
-            .args(&["--number", "5000000000", "file"])
-            .fails()
-            .code_is(1)
-            .stderr_only("split: Number of chunks too big\n");
-    }
+fn test_split_overflow_bytes_size() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "test_split_overflow_bytes_size";
+    RandomFile::new(&at, name).add_bytes(1000);
+    ucmd.args(&["-b", "1Y", name]).succeeds();
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 1);
+    assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
 #[test]
 fn test_split_stdin_num_chunks() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=1"]).pipe_in("").succeeds();
+    assert_eq!(at.read("xaa"), "");
+    assert!(!at.plus("xab").exists());
+}
+
+#[test]
+fn test_split_stdin_num_kth_chunk() {
     new_ucmd!()
-        .args(&["--number=1"])
-        .fails()
-        .code_is(1)
-        .stderr_only("split: -: cannot determine file size\n");
+        .args(&["--number=1/2"])
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds()
+        .stdout_only("1\n2\n3");
 }
 
-fn file_read(at: &AtPath, filename: &str) -> String {
-    let mut s = String::new();
-    at.open(filename).read_to_string(&mut s).unwrap();
-    s
+#[test]
+fn test_split_stdin_num_line_chunks() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=l/2"])
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds();
+    assert_eq!(at.read("xaa"), "1\n2\n3\n");
+    assert_eq!(at.read("xab"), "4\n5\n");
+    assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_split_stdin_num_kth_line_chunk() {
+    new_ucmd!()
+        .args(&["--number=l/2/5"])
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds()
+        .stdout_only("2\n");
 }
 
 /// Test for the default suffix length behavior: dynamically increasing size.
@@ -394,11 +784,11 @@ fn test_alphabetic_dynamic_suffix_length() {
     for i in b'a'..=b'y' {
         for j in b'a'..=b'z' {
             let filename = format!("x{}{}", i as char, j as char);
-            let contents = file_read(&at, &filename);
+            let contents = at.read(&filename);
             assert_eq!(contents, "a");
         }
     }
-    assert_eq!(file_read(&at, "xzaaa"), "a");
+    assert_eq!(at.read("xzaaa"), "a");
 }
 
 /// Test for the default suffix length behavior: dynamically increasing size.
@@ -418,10 +808,10 @@ fn test_numeric_dynamic_suffix_length() {
         .succeeds();
     for i in 0..90 {
         let filename = format!("x{i:02}");
-        let contents = file_read(&at, &filename);
+        let contents = at.read(&filename);
         assert_eq!(contents, "a");
     }
-    assert_eq!(file_read(&at, "x9000"), "a");
+    assert_eq!(at.read("x9000"), "a");
 }
 
 #[test]
@@ -440,10 +830,83 @@ fn test_hex_dynamic_suffix_length() {
         .succeeds();
     for i in 0..240 {
         let filename = format!("x{i:02x}");
-        let contents = file_read(&at, &filename);
+        let contents = at.read(&filename);
         assert_eq!(contents, "a");
     }
-    assert_eq!(file_read(&at, "xf000"), "a");
+    assert_eq!(at.read("xf000"), "a");
+}
+
+/// Test for dynamic suffix length (auto-widening) disabled when suffix start number is specified
+#[test]
+fn test_dynamic_suffix_length_off_with_suffix_start() {
+    new_ucmd!()
+        .args(&["-b", "1", "--numeric-suffixes=89", "ninetyonebytes.txt"])
+        .fails()
+        .stderr_only("split: output file suffixes exhausted\n");
+}
+
+/// Test for dynamic suffix length (auto-widening) enabled when suffix start number is NOT specified
+#[test]
+fn test_dynamic_suffix_length_on_with_suffix_start_no_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-b", "1", "--numeric-suffixes", "ninetyonebytes.txt"])
+        .succeeds();
+    assert_eq!(at.read("x9000"), "a");
+}
+
+/// Test for suffix auto-width with --number strategy and suffix start number
+#[test]
+fn test_suffix_auto_width_with_number() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--numeric-suffixes=1", "--number=r/100", "fivelines.txt"])
+        .succeeds();
+    let glob = Glob::new(&at, ".", r"x\d\d\d$");
+    assert_eq!(glob.count(), 100);
+    assert_eq!(glob.collate(), at.read_bytes("fivelines.txt"));
+    assert_eq!(at.read("x001"), "1\n");
+    assert_eq!(at.read("x100"), "");
+
+    new_ucmd!()
+        .args(&["--numeric-suffixes=100", "--number=r/100", "fivelines.txt"])
+        .fails();
+}
+
+/// Test for edge case of specifying 0 for suffix length
+#[test]
+fn test_suffix_length_zero() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&[
+        "--numeric-suffixes=1",
+        "--number=r/100",
+        "-a",
+        "0",
+        "fivelines.txt",
+    ])
+    .succeeds();
+    let glob = Glob::new(&at, ".", r"x\d\d\d$");
+    assert_eq!(glob.count(), 100);
+
+    new_ucmd!()
+        .args(&[
+            "--numeric-suffixes=100",
+            "--number=r/100",
+            "-a",
+            "0",
+            "fivelines.txt",
+        ])
+        .fails();
+
+    new_ucmd!()
+        .args(&[
+            "-b",
+            "1",
+            "--numeric-suffixes=89",
+            "-a",
+            "0",
+            "ninetyonebytes.txt",
+        ])
+        .fails()
+        .stderr_only("split: output file suffixes exhausted\n");
 }
 
 #[test]
@@ -454,6 +917,14 @@ fn test_suffixes_exhausted() {
         .stderr_only("split: output file suffixes exhausted\n");
 }
 
+#[test]
+fn test_suffix_length_req() {
+    new_ucmd!()
+        .args(&["-n", "100", "-a", "1", "asciilowercase.txt"])
+        .fails()
+        .stderr_only("split: the suffix length needs to be at least 2\n");
+}
+
 #[test]
 fn test_verbose() {
     new_ucmd!()
@@ -471,36 +942,118 @@ creating file 'xaf'
 }
 
 #[test]
-fn test_number() {
+fn test_number_n() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
     ucmd.args(&["-n", "5", "asciilowercase.txt"]).succeeds();
-    assert_eq!(file_read("xaa"), "abcde");
-    assert_eq!(file_read("xab"), "fghij");
-    assert_eq!(file_read("xac"), "klmno");
-    assert_eq!(file_read("xad"), "pqrst");
-    assert_eq!(file_read("xae"), "uvwxyz\n");
+    assert_eq!(at.read("xaa"), "abcdef");
+    assert_eq!(at.read("xab"), "ghijkl");
+    assert_eq!(at.read("xac"), "mnopq");
+    assert_eq!(at.read("xad"), "rstuv");
+    assert_eq!(at.read("xae"), "wxyz\n");
+    #[cfg(unix)]
+    new_ucmd!()
+        .args(&["--number=100", "/dev/null"])
+        .succeeds()
+        .stdout_only("");
+}
+
+#[test]
+fn test_number_kth_of_n() {
+    new_ucmd!()
+        .args(&["--number=3/5", "asciilowercase.txt"])
+        .succeeds()
+        .stdout_only("mnopq");
+    new_ucmd!()
+        .args(&["--number=5/5", "asciilowercase.txt"])
+        .succeeds()
+        .stdout_only("wxyz\n");
+    new_ucmd!()
+        .args(&["-e", "--number=99/100", "asciilowercase.txt"])
+        .succeeds()
+        .stdout_only("");
+    #[cfg(unix)]
+    new_ucmd!()
+        .args(&["--number=3/10", "/dev/null"])
+        .succeeds()
+        .stdout_only("");
+    #[cfg(target_pointer_width = "64")]
+    new_ucmd!()
+        .args(&[
+            "--number=r/9223372036854775807/18446744073709551615",
+            "asciilowercase.txt",
+        ])
+        .succeeds()
+        .stdout_only("");
+    new_ucmd!()
+        .args(&["--number=0/5", "asciilowercase.txt"])
+        .fails()
+        .stderr_contains("split: invalid chunk number: '0'");
+    new_ucmd!()
+        .args(&["--number=10/5", "asciilowercase.txt"])
+        .fails()
+        .stderr_contains("split: invalid chunk number: '10'");
+    #[cfg(target_pointer_width = "64")]
+    new_ucmd!()
+        .args(&[
+            "--number=9223372036854775807/18446744073709551616",
+            "asciilowercase.txt",
+        ])
+        .fails()
+        .stderr_contains("split: invalid number of chunks: '18446744073709551616'");
+}
+
+#[test]
+fn test_number_kth_of_n_round_robin() {
+    new_ucmd!()
+        .args(&["--number", "r/2/3", "fivelines.txt"])
+        .succeeds()
+        .stdout_only("2\n5\n");
+    new_ucmd!()
+        .args(&["--number", "r/1/4", "fivelines.txt"])
+        .succeeds()
+        .stdout_only("1\n5\n");
+    new_ucmd!()
+        .args(&["-e", "--number", "r/7/7", "fivelines.txt"])
+        .succeeds()
+        .stdout_only("");
+    #[cfg(target_pointer_width = "64")]
+    new_ucmd!()
+        .args(&[
+            "--number",
+            "r/9223372036854775807/18446744073709551615",
+            "fivelines.txt",
+        ])
+        .succeeds()
+        .stdout_only("");
+    #[cfg(target_pointer_width = "64")]
+    new_ucmd!()
+        .args(&[
+            "--number",
+            "r/9223372036854775807/18446744073709551616",
+            "fivelines.txt",
+        ])
+        .fails()
+        .stderr_contains("split: invalid number of chunks: '18446744073709551616'");
+    new_ucmd!()
+        .args(&["--number", "r/0/3", "fivelines.txt"])
+        .fails()
+        .stderr_contains("split: invalid chunk number: '0'");
+    new_ucmd!()
+        .args(&["--number", "r/10/3", "fivelines.txt"])
+        .fails()
+        .stderr_contains("split: invalid chunk number: '10'");
 }
 
 #[test]
 fn test_split_number_with_io_blksize() {
     let (at, mut ucmd) = at_and_ucmd!();
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
     ucmd.args(&["-n", "5", "asciilowercase.txt", "---io-blksize", "1024"])
         .succeeds();
-    assert_eq!(file_read("xaa"), "abcde");
-    assert_eq!(file_read("xab"), "fghij");
-    assert_eq!(file_read("xac"), "klmno");
-    assert_eq!(file_read("xad"), "pqrst");
-    assert_eq!(file_read("xae"), "uvwxyz\n");
+    assert_eq!(at.read("xaa"), "abcdef");
+    assert_eq!(at.read("xab"), "ghijkl");
+    assert_eq!(at.read("xac"), "mnopq");
+    assert_eq!(at.read("xad"), "rstuv");
+    assert_eq!(at.read("xae"), "wxyz\n");
 }
 
 #[test]
@@ -515,6 +1068,33 @@ fn test_split_default_with_io_blksize() {
     assert_eq!(glob.collate(), at.read_bytes(name));
 }
 
+#[test]
+fn test_split_invalid_io_blksize() {
+    new_ucmd!()
+        .args(&["---io-blksize=XYZ", "threebytes.txt"])
+        .fails()
+        .stderr_only("split: invalid IO block size: 'XYZ'\n");
+    new_ucmd!()
+        .args(&["---io-blksize=5000000000", "threebytes.txt"])
+        .fails()
+        .stderr_only("split: invalid IO block size: '5000000000'\n");
+    #[cfg(target_pointer_width = "32")]
+    new_ucmd!()
+        .args(&["---io-blksize=2146435072", "threebytes.txt"])
+        .fails()
+        .stderr_only("split: invalid IO block size: '2146435072'\n");
+}
+
+#[test]
+fn test_split_number_oversized_stdin() {
+    new_ucmd!()
+        .args(&["--number=3", "---io-blksize=600"])
+        .pipe_in_fixture("sixhundredfiftyonebytes.txt")
+        .ignore_stdin_write_error()
+        .fails()
+        .stderr_only("split: -: cannot determine input size\n");
+}
+
 #[test]
 fn test_invalid_suffix_length() {
     new_ucmd!()
@@ -524,6 +1104,19 @@ fn test_invalid_suffix_length() {
         .stderr_contains("invalid suffix length: 'xyz'");
 }
 
+/// Test short suffix length option with value concatenated
+#[test]
+fn test_split_suffix_length_short_concatenated_with_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "split_num_prefixed_chunks_by_lines";
+    RandomFile::new(&at, name).add_lines(10000);
+    ucmd.args(&["-a4", name]).succeeds();
+
+    let glob = Glob::new(&at, ".", r"x[[:alpha:]][[:alpha:]][[:alpha:]][[:alpha:]]$");
+    assert_eq!(glob.count(), 10);
+    assert_eq!(glob.collate(), at.read_bytes(name));
+}
+
 #[test]
 fn test_include_newlines() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -542,6 +1135,19 @@ fn test_include_newlines() {
     assert_eq!(s, "5\n");
 }
 
+/// Test short number of chunks option concatenated with value
+#[test]
+fn test_split_number_chunks_short_concatenated_with_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n3", "threebytes.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "a");
+    assert_eq!(at.read("xab"), "b");
+    assert_eq!(at.read("xac"), "c");
+}
+
 #[test]
 fn test_allow_empty_files() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -556,7 +1162,7 @@ fn test_allow_empty_files() {
 }
 
 #[test]
-fn test_elide_empty_files() {
+fn test_elide_empty_files_n_chunks() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-e", "-n", "4", "threebytes.txt"])
         .succeeds()
@@ -570,7 +1176,7 @@ fn test_elide_empty_files() {
 
 #[test]
 #[cfg(unix)]
-fn test_elide_dev_null() {
+fn test_elide_dev_null_n_chunks() {
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-e", "-n", "3", "/dev/null"])
         .succeeds()
@@ -582,30 +1188,108 @@ fn test_elide_dev_null() {
 }
 
 #[test]
-fn test_lines() {
+#[cfg(unix)]
+fn test_dev_zero() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "3", "/dev/zero"])
+        .fails()
+        .stderr_only("split: /dev/zero: cannot determine file size\n");
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
+
+#[test]
+fn test_elide_empty_files_l_chunks() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-e", "-n", "l/7", "fivelines.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("xaa"), "1\n");
+    assert_eq!(at.read("xab"), "2\n");
+    assert_eq!(at.read("xac"), "3\n");
+    assert_eq!(at.read("xad"), "4\n");
+    assert_eq!(at.read("xae"), "5\n");
+    assert!(!at.plus("xaf").exists());
+    assert!(!at.plus("xag").exists());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_elide_dev_null_l_chunks() {
     let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-e", "-n", "l/3", "/dev/null"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
 
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
+#[test]
+#[cfg(unix)]
+fn test_number_by_bytes_dev_zero() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "3", "/dev/zero"])
+        .fails()
+        .stderr_only("split: /dev/zero: cannot determine file size\n");
+    assert!(!at.plus("xaa").exists());
+    assert!(!at.plus("xab").exists());
+    assert!(!at.plus("xac").exists());
+}
 
+#[test]
+fn test_number_by_lines() {
+    let (at, mut ucmd) = at_and_ucmd!();
     // Split into two files without splitting up lines.
     ucmd.args(&["-n", "l/2", "fivelines.txt"]).succeeds();
 
-    assert_eq!(file_read("xaa"), "1\n2\n3\n");
-    assert_eq!(file_read("xab"), "4\n5\n");
+    assert_eq!(at.read("xaa"), "1\n2\n3\n");
+    assert_eq!(at.read("xab"), "4\n5\n");
 }
 
 #[test]
-fn test_lines_kth() {
+fn test_number_by_lines_kth() {
     new_ucmd!()
         .args(&["-n", "l/3/10", "onehundredlines.txt"])
         .succeeds()
         .stdout_only("20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n");
 }
 
+#[test]
+#[cfg(unix)]
+fn test_number_by_lines_kth_dev_null() {
+    new_ucmd!()
+        .args(&["-n", "l/3/10", "/dev/null"])
+        .succeeds()
+        .stdout_only("");
+}
+
+#[test]
+fn test_number_by_lines_kth_no_end_sep() {
+    new_ucmd!()
+        .args(&["-n", "l/3/10"])
+        .pipe_in("1\n2222\n3\n4")
+        .succeeds()
+        .stdout_only("2222\n");
+    new_ucmd!()
+        .args(&["-e", "-n", "l/2/2"])
+        .pipe_in("1\n2222\n3\n4")
+        .succeeds()
+        .stdout_only("3\n4");
+}
+
+#[test]
+fn test_number_by_lines_rr_kth_no_end_sep() {
+    new_ucmd!()
+        .args(&["-n", "r/2/3"])
+        .pipe_in("1\n2\n3\n4\n5")
+        .succeeds()
+        .stdout_only("2\n5");
+}
+
 #[test]
 fn test_line_bytes() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -616,6 +1300,25 @@ fn test_line_bytes() {
     assert_eq!(at.read("xad"), "ee\n");
 }
 
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_line_bytes_overflow() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-C", "18446744073709551616", "letters.txt"])
+        .succeeds();
+    assert_eq!(at.read("xaa"), "aaaaaaaaa\nbbbb\ncccc\ndd\nee\n");
+}
+
+#[test]
+fn test_line_bytes_concatenated_with_value() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-C8", "letters.txt"]).succeeds();
+    assert_eq!(at.read("xaa"), "aaaaaaaa");
+    assert_eq!(at.read("xab"), "a\nbbbb\n");
+    assert_eq!(at.read("xac"), "cccc\ndd\n");
+    assert_eq!(at.read("xad"), "ee\n");
+}
+
 #[test]
 fn test_line_bytes_no_final_newline() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -725,6 +1428,19 @@ fn test_numeric_suffix() {
     assert_eq!(at.read("x12"), "");
 }
 
+#[test]
+fn test_numeric_suffix_inferred() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "4", "--numeric=9", "threebytes.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("x09"), "a");
+    assert_eq!(at.read("x10"), "b");
+    assert_eq!(at.read("x11"), "c");
+    assert_eq!(at.read("x12"), "");
+}
+
 #[test]
 fn test_hex_suffix() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -738,6 +1454,19 @@ fn test_hex_suffix() {
     assert_eq!(at.read("x0c"), "");
 }
 
+#[test]
+fn test_hex_suffix_alias() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["-n", "4", "--hex=9", "threebytes.txt"])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert_eq!(at.read("x09"), "a");
+    assert_eq!(at.read("x0a"), "b");
+    assert_eq!(at.read("x0b"), "c");
+    assert_eq!(at.read("x0c"), "");
+}
+
 #[test]
 fn test_numeric_suffix_no_equal() {
     new_ucmd!()
@@ -871,7 +1600,7 @@ fn test_short_combination() {
     assert_eq!(at.read("x00"), "a");
     assert_eq!(at.read("x01"), "b");
     assert_eq!(at.read("x02"), "c");
-    assert_eq!(at.file_exists("x03"), false);
+    assert!(!at.file_exists("x03"));
 }
 
 /// Test for the last effective suffix, ignoring all others - numeric long last
@@ -925,17 +1654,21 @@ fn test_effective_suffix_hex_last() {
 #[test]
 fn test_round_robin() {
     let (at, mut ucmd) = at_and_ucmd!();
-
-    let file_read = |f| {
-        let mut s = String::new();
-        at.open(f).read_to_string(&mut s).unwrap();
-        s
-    };
-
     ucmd.args(&["-n", "r/2", "fivelines.txt"]).succeeds();
 
-    assert_eq!(file_read("xaa"), "1\n3\n5\n");
-    assert_eq!(file_read("xab"), "2\n4\n");
+    assert_eq!(at.read("xaa"), "1\n3\n5\n");
+    assert_eq!(at.read("xab"), "2\n4\n");
+}
+
+#[test]
+// TODO(#7542): Re-enable on Android once we figure out why rlimit is broken.
+// #[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(target_os = "linux")]
+fn test_round_robin_limited_file_descriptors() {
+    new_ucmd!()
+        .args(&["-n", "r/40", "onehundredlines.txt"])
+        .limit(Resource::NOFILE, 9, 9)
+        .succeeds();
 }
 
 #[test]
@@ -968,5 +1701,307 @@ fn test_split_invalid_input() {
         .args(&["-n", "0", "file"])
         .fails()
         .no_stdout()
-        .stderr_contains("split: invalid number of chunks: 0");
+        .stderr_contains("split: invalid number of chunks: '0'");
+}
+
+/// Test if there are invalid (non UTF-8) in the arguments - unix
+/// clap is expected to fail/panic
+#[test]
+#[cfg(unix)]
+fn test_split_non_utf8_argument_unix() {
+    use std::ffi::OsStr;
+    use std::os::unix::ffi::OsStrExt;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "test_split_non_utf8_argument";
+    let opt = OsStr::from_bytes("--additional-suffix".as_bytes());
+    RandomFile::new(&at, name).add_lines(2000);
+    // Here, the values 0x66 and 0x6f correspond to 'f' and 'o'
+    // respectively. The value 0x80 is a lone continuation byte, invalid
+    // in a UTF-8 sequence.
+    let opt_value = [0x66, 0x6f, 0x80, 0x6f];
+    let opt_value = OsStr::from_bytes(&opt_value[..]);
+    let name = OsStr::from_bytes(name.as_bytes());
+    ucmd.args(&[opt, opt_value, name])
+        .fails()
+        .stderr_contains("error: invalid UTF-8 was detected in one or more arguments");
+}
+
+/// Test if there are invalid (non UTF-8) in the arguments - windows
+/// clap is expected to fail/panic
+#[test]
+#[cfg(windows)]
+fn test_split_non_utf8_argument_windows() {
+    use std::ffi::OsString;
+    use std::os::windows::ffi::OsStringExt;
+
+    let (at, mut ucmd) = at_and_ucmd!();
+    let name = "test_split_non_utf8_argument";
+    let opt = OsString::from("--additional-suffix");
+    RandomFile::new(&at, name).add_lines(2000);
+    // Here the values 0x0066 and 0x006f correspond to 'f' and 'o'
+    // respectively. The value 0xD800 is a lone surrogate half, invalid
+    // in a UTF-16 sequence.
+    let opt_value = [0x0066, 0x006f, 0xD800, 0x006f];
+    let opt_value = OsString::from_wide(&opt_value[..]);
+    let name = OsString::from(name);
+    ucmd.args(&[opt, opt_value, name])
+        .fails()
+        .stderr_contains("error: invalid UTF-8 was detected in one or more arguments");
+}
+
+// Test '--separator' / '-t' option following GNU tests example
+// test separators: '\n' , '\0' , ';'
+// test with '--lines=2' , '--line-bytes=4' , '--number=l/3' , '--number=r/3' , '--number=l/1/3' , '--number=r/1/3'
+#[test]
+fn test_split_separator_nl_lines() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--lines=2", "-t", "\n"])
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\n2\n");
+    assert_eq!(at.read("xab"), "3\n4\n");
+    assert_eq!(at.read("xac"), "5\n");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nl_line_bytes() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--line-bytes=4", "-t", "\n"])
+        .pipe_in("1\n2\n3\n4\n5\n")
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\n2\n");
+    assert_eq!(at.read("xab"), "3\n4\n");
+    assert_eq!(at.read("xac"), "5\n");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nl_number_l() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=l/3", "--separator=\n", "fivelines.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\n2\n");
+    assert_eq!(at.read("xab"), "3\n4\n");
+    assert_eq!(at.read("xac"), "5\n");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nl_number_r() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=r/3", "--separator", "\n", "fivelines.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\n4\n");
+    assert_eq!(at.read("xab"), "2\n5\n");
+    assert_eq!(at.read("xac"), "3\n");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nul_lines() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--lines=2", "-t", "\\0", "separator_nul.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\x002\0");
+    assert_eq!(at.read("xab"), "3\x004\0");
+    assert_eq!(at.read("xac"), "5\0");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nul_line_bytes() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--line-bytes=4", "-t", "\\0", "separator_nul.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\x002\0");
+    assert_eq!(at.read("xab"), "3\x004\0");
+    assert_eq!(at.read("xac"), "5\0");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nul_number_l() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=l/3", "--separator=\\0", "separator_nul.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\x002\0");
+    assert_eq!(at.read("xab"), "3\x004\0");
+    assert_eq!(at.read("xac"), "5\0");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_nul_number_r() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=r/3", "--separator=\\0", "separator_nul.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1\x004\0");
+    assert_eq!(at.read("xab"), "2\x005\0");
+    assert_eq!(at.read("xac"), "3\0");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_lines() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--lines=2", "-t", ";", "separator_semicolon.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1;2;");
+    assert_eq!(at.read("xab"), "3;4;");
+    assert_eq!(at.read("xac"), "5;");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_line_bytes() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--line-bytes=4", "-t", ";", "separator_semicolon.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1;2;");
+    assert_eq!(at.read("xab"), "3;4;");
+    assert_eq!(at.read("xac"), "5;");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_number_l() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=l/3", "--separator=;", "separator_semicolon.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1;2;");
+    assert_eq!(at.read("xab"), "3;4;");
+    assert_eq!(at.read("xac"), "5;");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_number_r() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.args(&["--number=r/3", "--separator=;", "separator_semicolon.txt"])
+        .succeeds();
+
+    assert_eq!(at.read("xaa"), "1;4;");
+    assert_eq!(at.read("xab"), "2;5;");
+    assert_eq!(at.read("xac"), "3;");
+    assert!(!at.plus("xad").exists());
+}
+
+#[test]
+fn test_split_separator_semicolon_number_kth_l() {
+    new_ucmd!()
+        .args(&[
+            "--number=l/1/3",
+            "--separator",
+            ";",
+            "separator_semicolon.txt",
+        ])
+        .succeeds()
+        .stdout_only("1;2;");
+}
+
+#[test]
+fn test_split_separator_semicolon_number_kth_r() {
+    new_ucmd!()
+        .args(&[
+            "--number=r/1/3",
+            "--separator",
+            ";",
+            "separator_semicolon.txt",
+        ])
+        .succeeds()
+        .stdout_only("1;4;");
+}
+
+// Test error edge cases for separator option
+#[test]
+fn test_split_separator_no_value() {
+    new_ucmd!()
+        .args(&["-t"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .stderr_contains(
+            "error: a value is required for '--separator <SEP>' but none was supplied",
+        );
+}
+
+#[test]
+fn test_split_separator_invalid_usage() {
+    let scene = TestScenario::new(util_name!());
+    scene
+        .ucmd()
+        .args(&["--separator=xx"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .no_stdout()
+        .stderr_contains("split: multi-character separator 'xx'");
+    scene
+        .ucmd()
+        .args(&["-ta", "-tb"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .no_stdout()
+        .stderr_contains("split: multiple separator characters specified");
+    scene
+        .ucmd()
+        .args(&["-t'\n'", "-tb"])
+        .ignore_stdin_write_error()
+        .pipe_in("a\n")
+        .fails()
+        .no_stdout()
+        .stderr_contains("split: multiple separator characters specified");
+}
+
+// Test using same separator multiple times
+#[test]
+fn test_split_separator_same_multiple() {
+    let scene = TestScenario::new(util_name!());
+    scene
+        .ucmd()
+        .args(&["--separator=:", "--separator=:", "fivelines.txt"])
+        .succeeds();
+    scene
+        .ucmd()
+        .args(&["-t:", "--separator=:", "fivelines.txt"])
+        .succeeds();
+    scene
+        .ucmd()
+        .args(&["-t", ":", "-t", ":", "fivelines.txt"])
+        .succeeds();
+    scene
+        .ucmd()
+        .args(&["-t:", "-t:", "-t,", "fivelines.txt"])
+        .fails();
+}
+
+#[test]
+fn test_long_lines() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let line1 = [" ".repeat(131_070), String::from("\n")].concat();
+    let line2 = [" ", "\n"].concat();
+    let line3 = [" ".repeat(131_071), String::from("\n")].concat();
+    let infile = [line1, line2, line3].concat();
+    ucmd.args(&["-C", "131072"])
+        .pipe_in(infile)
+        .succeeds()
+        .no_output();
+    assert_eq!(at.read("xaa").len(), 131_071);
+    assert_eq!(at.read("xab").len(), 2);
+    assert_eq!(at.read("xac").len(), 131_072);
+    assert!(!at.plus("xad").exists());
 }
diff --git a/tests/by-util/test_stat.rs b/tests/by-util/test_stat.rs
index e918d54e9c7..6c4258189bd 100644
--- a/tests/by-util/test_stat.rs
+++ b/tests/by-util/test_stat.rs
@@ -3,11 +3,15 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
-use crate::common::util::{expected_result, TestScenario};
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::unwrap_or_return;
+use uutests::util::{TestScenario, expected_result};
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -30,7 +34,7 @@ fn test_terse_fs_format() {
     let args = ["-f", "-t", "/proc"];
     let ts = TestScenario::new(util_name!());
     let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
-    ts.ucmd().args(&args).run().stdout_is(expected_stdout);
+    ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
 }
 
 #[test]
@@ -39,7 +43,7 @@ fn test_fs_format() {
     let args = ["-f", "-c", FS_FORMAT_STR, "/dev/shm"];
     let ts = TestScenario::new(util_name!());
     let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
-    ts.ucmd().args(&args).run().stdout_is(expected_stdout);
+    ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
 }
 
 #[cfg(unix)]
@@ -134,6 +138,7 @@ fn test_normal_format() {
 }
 
 #[cfg(unix)]
+#[cfg(not(target_os = "openbsd"))]
 #[test]
 fn test_symlinks() {
     let ts = TestScenario::new(util_name!());
@@ -160,9 +165,7 @@ fn test_symlinks() {
             ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
         }
     }
-    if !tested {
-        panic!("No symlink found to test in this environment");
-    }
+    assert!(tested, "No symlink found to test in this environment");
 }
 
 #[cfg(any(target_os = "linux", target_os = "android", target_vendor = "apple"))]
@@ -185,9 +188,71 @@ fn test_char() {
     ];
     let ts = TestScenario::new(util_name!());
     let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
+    eprintln!("{expected_stdout}");
+    ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_printf_mtime_precision() {
+    // TODO Higher precision numbers (`%.3Y`, `%.4Y`, etc.) are
+    // formatted correctly, but we are not precise enough when we do
+    // some `mtime` computations, so we get `.7640` instead of
+    // `.7639`. This can be fixed by being more careful when
+    // transforming the number from `Metadata::mtime_nsec()` to the form
+    // used in rendering.
+    let args = ["-c", "%.0Y %.1Y %.2Y", "/dev/pts/ptmx"];
+    let ts = TestScenario::new(util_name!());
+    let expected_stdout = unwrap_or_return!(expected_result(&ts, &args)).stdout_move_str();
+    eprintln!("{expected_stdout}");
     ts.ucmd().args(&args).succeeds().stdout_is(expected_stdout);
 }
 
+#[cfg(feature = "touch")]
+#[test]
+fn test_timestamp_format() {
+    let ts = TestScenario::new(util_name!());
+
+    // Create a file with a specific timestamp for testing
+    ts.ccmd("touch")
+        .args(&["-d", "1970-01-01 18:43:33.023456789", "k"])
+        .succeeds()
+        .no_stderr();
+
+    let test_cases = vec![
+        // Basic timestamp formats
+        ("%Y", "67413"),
+        ("%.Y", "67413.023456789"),
+        ("%.1Y", "67413.0"),
+        ("%.3Y", "67413.023"),
+        ("%.6Y", "67413.023456"),
+        ("%.9Y", "67413.023456789"),
+        // Width and padding tests
+        ("%13.6Y", " 67413.023456"),
+        ("%013.6Y", "067413.023456"),
+        ("%-13.6Y", "67413.023456 "),
+        // Longer width/precision combinations
+        ("%18.10Y", "  67413.0234567890"),
+        ("%I18.10Y", "  67413.0234567890"),
+        ("%018.10Y", "0067413.0234567890"),
+        ("%-18.10Y", "67413.0234567890  "),
+    ];
+
+    for (format_str, expected) in test_cases {
+        let result = ts
+            .ucmd()
+            .args(&["-c", format_str, "k"])
+            .succeeds()
+            .stdout_move_str();
+
+        assert_eq!(
+            result,
+            format!("{expected}\n"),
+            "Format '{format_str}' failed.\nExpected: '{expected}'\nGot: '{result}'",
+        );
+    }
+}
+
 #[cfg(any(target_os = "linux", target_os = "android", target_vendor = "apple"))]
 #[test]
 fn test_date() {
@@ -243,7 +308,7 @@ fn test_multi_files() {
 #[test]
 fn test_printf() {
     let args = [
-        "--printf=123%-# 15q\\r\\\"\\\\\\a\\b\\e\\f\\v%+020.23m\\x12\\167\\132\\112\\n",
+        "--printf=123%-# 15q\\r\\\"\\\\\\a\\b\\x1B\\f\\x0B%+020.23m\\x12\\167\\132\\112\\n",
         "/",
     ];
     let ts = TestScenario::new(util_name!());
@@ -257,15 +322,23 @@ fn test_pipe_fifo() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkfifo("FIFO");
     ucmd.arg("FIFO")
-        .run()
+        .succeeds()
         .no_stderr()
         .stdout_contains("fifo")
-        .stdout_contains("File: FIFO")
-        .succeeded();
+        .stdout_contains("File: FIFO");
 }
 
+// TODO(#7583): Re-enable on Mac OS X (and possibly other Unix platforms)
 #[test]
-#[cfg(all(unix, not(any(target_os = "android", target_os = "freebsd"))))]
+#[cfg(all(
+    unix,
+    not(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "macos"
+    ))
+))]
 fn test_stdin_pipe_fifo1() {
     // $ echo | stat -
     // File: -
@@ -273,23 +346,22 @@ fn test_stdin_pipe_fifo1() {
     new_ucmd!()
         .arg("-")
         .set_stdin(std::process::Stdio::piped())
-        .run()
+        .succeeds()
         .no_stderr()
         .stdout_contains("fifo")
-        .stdout_contains("File: -")
-        .succeeded();
+        .stdout_contains("File: -");
     new_ucmd!()
         .args(&["-L", "-"])
         .set_stdin(std::process::Stdio::piped())
-        .run()
+        .succeeds()
         .no_stderr()
         .stdout_contains("fifo")
-        .stdout_contains("File: -")
-        .succeeded();
+        .stdout_contains("File: -");
 }
 
+// TODO(#7583): Re-enable on Mac OS X (and maybe Android)
 #[test]
-#[cfg(all(unix, not(target_os = "android")))]
+#[cfg(all(unix, not(any(target_os = "android", target_os = "macos"))))]
 fn test_stdin_pipe_fifo2() {
     // $ stat -
     // File: -
@@ -297,11 +369,10 @@ fn test_stdin_pipe_fifo2() {
     new_ucmd!()
         .arg("-")
         .set_stdin(std::process::Stdio::null())
-        .run()
+        .succeeds()
         .no_stderr()
         .stdout_contains("character special file")
-        .stdout_contains("File: -")
-        .succeeded();
+        .stdout_contains("File: -");
 }
 
 #[test]
@@ -312,15 +383,19 @@ fn test_stdin_with_fs_option() {
         .arg("-f")
         .arg("-")
         .set_stdin(std::process::Stdio::null())
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("using '-' to denote standard input does not work in file system mode");
 }
 
 #[test]
 #[cfg(all(
     unix,
-    not(any(target_os = "android", target_os = "macos", target_os = "freebsd"))
+    not(any(
+        target_os = "android",
+        target_os = "macos",
+        target_os = "freebsd",
+        target_os = "openbsd"
+    ))
 ))]
 fn test_stdin_redirect() {
     // $ touch f && stat - < f
@@ -332,9 +407,110 @@ fn test_stdin_redirect() {
     ts.ucmd()
         .arg("-")
         .set_stdin(std::fs::File::open(at.plus("f")).unwrap())
-        .run()
+        .succeeds()
         .no_stderr()
         .stdout_contains("regular empty file")
-        .stdout_contains("File: -")
-        .succeeded();
+        .stdout_contains("File: -");
+}
+
+#[test]
+fn test_without_argument() {
+    new_ucmd!()
+        .fails()
+        .stderr_contains("missing operand\nTry 'stat --help' for more information.");
+}
+
+#[test]
+fn test_quoting_style_locale() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("'");
+    ts.ucmd()
+        .env("QUOTING_STYLE", "locale")
+        .args(&["-c", "%N", "'"])
+        .succeeds()
+        .stdout_only("'\\''\n");
+
+    ts.ucmd()
+        .args(&["-c", "%N", "'"])
+        .succeeds()
+        .stdout_only("\"'\"\n");
+}
+
+#[test]
+fn test_printf_octal_1() {
+    let ts = TestScenario::new(util_name!());
+    let expected_stdout = vec![0x0A, 0xFF]; // Newline + byte 255
+    ts.ucmd()
+        .args(&["--printf=\\012\\377", "."])
+        .succeeds()
+        .stdout_is_bytes(expected_stdout);
+}
+
+#[test]
+fn test_printf_octal_2() {
+    let ts = TestScenario::new(util_name!());
+    let expected_stdout = vec![b'.', 0x0A, b'a', 0xFF, b'b'];
+    ts.ucmd()
+        .args(&["--printf=.\\012a\\377b", "."])
+        .succeeds()
+        .stdout_is_bytes(expected_stdout);
+}
+
+#[test]
+fn test_printf_incomplete_hex() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .args(&["--printf=\\x", "."])
+        .succeeds()
+        .stderr_contains("warning: incomplete hex escape");
+}
+
+#[test]
+fn test_printf_bel_etc() {
+    let ts = TestScenario::new(util_name!());
+    let expected_stdout = vec![0x07, 0x08, 0x0C, 0x0A, 0x0D, 0x09]; // BEL, BS, FF, LF, CR, TAB
+    ts.ucmd()
+        .args(&["--printf=\\a\\b\\f\\n\\r\\t", "."])
+        .succeeds()
+        .stdout_is_bytes(expected_stdout);
+}
+
+#[test]
+fn test_printf_invalid_directive() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .args(&["--printf=%9", "."])
+        .fails_with_code(1)
+        .stderr_contains("'%9': invalid directive");
+
+    ts.ucmd()
+        .args(&["--printf=%9%", "."])
+        .fails_with_code(1)
+        .stderr_contains("'%9%': invalid directive");
+}
+
+#[test]
+#[cfg(feature = "feat_selinux")]
+fn test_stat_selinux() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.touch("f");
+    ts.ucmd()
+        .arg("--printf='%C'")
+        .arg("f")
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("unconfined_u");
+    ts.ucmd()
+        .arg("--printf='%C'")
+        .arg("/bin/")
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("system_u");
+    // Count that we have 4 fields
+    let result = ts.ucmd().arg("--printf='%C'").arg("/bin/").succeeds();
+    let s: Vec<_> = result.stdout_str().split(':').collect();
+    assert!(s.len() == 4);
 }
diff --git a/tests/by-util/test_stdbuf.rs b/tests/by-util/test_stdbuf.rs
index e31c532e22a..c4294c6af41 100644
--- a/tests/by-util/test_stdbuf.rs
+++ b/tests/by-util/test_stdbuf.rs
@@ -2,27 +2,52 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+use uutests::new_ucmd;
 #[cfg(not(target_os = "windows"))]
-use crate::common::util::TestScenario;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+#[test]
+fn invalid_input() {
+    new_ucmd!().arg("-/").fails_with_code(125);
+}
+
+#[test]
+fn test_permission() {
+    new_ucmd!()
+        .arg("-o1")
+        .arg(".")
+        .fails_with_code(126)
+        .stderr_contains("Permission denied");
+}
 
-#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_no_such() {
+    new_ucmd!()
+        .arg("-o1")
+        .arg("no_such")
+        .fails_with_code(127)
+        .stderr_contains("No such file or directory");
+}
+
+#[cfg(all(not(target_os = "windows"), not(target_os = "openbsd")))]
 #[test]
 fn test_stdbuf_unbuffered_stdout() {
     // This is a basic smoke test
     new_ucmd!()
         .args(&["-o0", "head"])
         .pipe_in("The quick brown fox jumps over the lazy dog.")
-        .run()
+        .succeeds()
         .stdout_is("The quick brown fox jumps over the lazy dog.");
 }
 
-#[cfg(not(target_os = "windows"))]
+#[cfg(all(not(target_os = "windows"), not(target_os = "openbsd")))]
 #[test]
 fn test_stdbuf_line_buffered_stdout() {
     new_ucmd!()
         .args(&["-oL", "head"])
         .pipe_in("The quick brown fox jumps over the lazy dog.")
-        .run()
+        .succeeds()
         .stdout_is("The quick brown fox jumps over the lazy dog.");
 }
 
@@ -37,13 +62,13 @@ fn test_stdbuf_no_buffer_option_fails() {
         .stderr_contains("the following required arguments were not provided:");
 }
 
-#[cfg(not(target_os = "windows"))]
+#[cfg(all(not(target_os = "windows"), not(target_os = "openbsd")))]
 #[test]
 fn test_stdbuf_trailing_var_arg() {
     new_ucmd!()
         .args(&["-i", "1024", "tail", "-1"])
         .pipe_in("The quick brown fox\njumps over the lazy dog.")
-        .run()
+        .succeeds()
         .stdout_is("jumps over the lazy dog.");
 }
 
@@ -63,21 +88,17 @@ fn test_stdbuf_invalid_mode_fails() {
     for option in &options {
         new_ucmd!()
             .args(&[*option, "1024R", "head"])
-            .fails()
-            .code_is(125)
-            .stderr_only("stdbuf: invalid mode '1024R'\n");
-        #[cfg(not(target_pointer_width = "128"))]
+            .fails_with_code(125)
+            .usage_error("invalid mode '1024R': Value too large for defined data type");
         new_ucmd!()
             .args(&[*option, "1Y", "head"])
-            .fails()
-            .code_is(125)
+            .fails_with_code(125)
             .stderr_contains("stdbuf: invalid mode '1Y': Value too large for defined data type");
         #[cfg(target_pointer_width = "32")]
         {
             new_ucmd!()
                 .args(&[*option, "5GB", "head"])
-                .fails()
-                .code_is(125)
+                .fails_with_code(125)
                 .stderr_contains(
                     "stdbuf: invalid mode '5GB': Value too large for defined data type",
                 );
diff --git a/tests/by-util/test_stty.rs b/tests/by-util/test_stty.rs
index a9a9209b034..7ccc56e5dee 100644
--- a/tests/by-util/test_stty.rs
+++ b/tests/by-util/test_stty.rs
@@ -4,11 +4,13 @@
 // file that was distributed with this source code.
 // spell-checker:ignore parenb parmrk ixany iuclc onlcr ofdel icanon noflsh
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_sum.rs b/tests/by-util/test_sum.rs
index 13f453ba113..a87084cb460 100644
--- a/tests/by-util/test_sum.rs
+++ b/tests/by-util/test_sum.rs
@@ -2,11 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_sync.rs b/tests/by-util/test_sync.rs
index 9a824cd4861..757dc65c12c 100644
--- a/tests/by-util/test_sync.rs
+++ b/tests/by-util/test_sync.rs
@@ -2,13 +2,15 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
 use std::fs;
 use tempfile::tempdir;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_tac.rs b/tests/by-util/test_tac.rs
index fa5f67f133f..42e7b76d6c7 100644
--- a/tests/by-util/test_tac.rs
+++ b/tests/by-util/test_tac.rs
@@ -3,11 +3,13 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 // spell-checker:ignore axxbxx bxxaxx axxx axxxx xxaxx xxax xxxxa axyz zyax zyxa
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -16,7 +18,7 @@ fn test_invalid_arg() {
 fn test_stdin_default() {
     new_ucmd!()
         .pipe_in("100\n200\n300\n400\n500")
-        .run()
+        .succeeds()
         .stdout_is("500400\n300\n200\n100\n");
 }
 
@@ -27,7 +29,7 @@ fn test_stdin_non_newline_separator() {
     new_ucmd!()
         .args(&["-s", ":"])
         .pipe_in("100:200:300:400:500")
-        .run()
+        .succeeds()
         .stdout_is("500400:300:200:100:");
 }
 
@@ -38,7 +40,7 @@ fn test_stdin_non_newline_separator_before() {
     new_ucmd!()
         .args(&["-b", "-s", ":"])
         .pipe_in("100:200:300:400:500")
-        .run()
+        .succeeds()
         .stdout_is(":500:400:300:200100");
 }
 
@@ -46,7 +48,7 @@ fn test_stdin_non_newline_separator_before() {
 fn test_single_default() {
     new_ucmd!()
         .arg("prime_per_line.txt")
-        .run()
+        .succeeds()
         .stdout_is_fixture("prime_per_line.expected");
 }
 
@@ -54,7 +56,7 @@ fn test_single_default() {
 fn test_single_non_newline_separator() {
     new_ucmd!()
         .args(&["-s", ":", "delimited_primes.txt"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("delimited_primes.expected");
 }
 
@@ -62,7 +64,7 @@ fn test_single_non_newline_separator() {
 fn test_single_non_newline_separator_before() {
     new_ucmd!()
         .args(&["-b", "-s", ":", "delimited_primes.txt"])
-        .run()
+        .succeeds()
         .stdout_is_fixture("delimited_primes_before.expected");
 }
 
@@ -307,3 +309,13 @@ fn test_regex_before() {
         //          |--------||----||---|
         .stdout_is("+---+c+d-e+--++b+-+a+");
 }
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .pipe_in("hello")
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("tac: failed to write to stdout: No space left on device (os error 28)\n");
+}
diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs
index bc89f56a03c..736182bfee8 100644
--- a/tests/by-util/test_tail.rs
+++ b/tests/by-util/test_tail.rs
@@ -6,15 +6,15 @@
 // spell-checker:ignore (ToDO) abcdefghijklmnopqrstuvwxyz efghijklmnopqrstuvwxyz vwxyz emptyfile file siette ocho nueve diez MULT
 // spell-checker:ignore (libs) kqueue
 // spell-checker:ignore (jargon) tailable untailable datasame runneradmin tmpi
+// spell-checker:ignore (cmd) taskkill
+#![allow(
+    clippy::unicode_not_nfc,
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation
+)]
 
-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 rand::distr::Alphanumeric;
 use rstest::rstest;
 use std::char::from_digit;
 use std::fs::File;
@@ -23,18 +23,34 @@ use std::io::Write;
 use std::io::{Seek, SeekFrom};
 #[cfg(all(
     not(target_vendor = "apple"),
+    not(target_os = "android"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))]
 use std::path::Path;
 use std::process::Stdio;
 use tail::chunks::BUFFER_SIZE as CHUNK_BUFFER_SIZE;
 #[cfg(all(
     not(target_vendor = "apple"),
+    not(target_os = "android"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))]
 use tail::text;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::random::{AlphanumericNewline, RandomizedString};
+#[cfg(unix)]
+use uutests::unwrap_or_return;
+use uutests::util::TestScenario;
+#[cfg(unix)]
+use uutests::util::expected_result;
+#[cfg(unix)]
+#[cfg(not(windows))]
+use uutests::util::is_ci;
+use uutests::util_name;
 
 const FOOBAR_TXT: &str = "foobar.txt";
 const FOOBAR_2_TXT: &str = "foobar2.txt";
@@ -46,7 +62,6 @@ const FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected";
 #[allow(dead_code)]
 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
@@ -58,14 +73,14 @@ const INVALID_UTF16: u16 = 0xD800;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 fn test_stdin_default() {
     new_ucmd!()
         .pipe_in_fixture(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_stdin_default.expected")
         .no_stderr();
 }
@@ -75,14 +90,12 @@ fn test_stdin_explicit() {
     new_ucmd!()
         .pipe_in_fixture(FOOBAR_TXT)
         .arg("-")
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_stdin_default.expected")
         .no_stderr();
 }
 
 #[test]
-// FIXME: the -f test fails with: Assertion failed. Expected 'tail' to be running but exited with status=exit status: 0
-#[cfg(disable_until_fixed)]
 #[cfg(not(target_vendor = "apple"))] // FIXME: for currently not working platforms
 fn test_stdin_redirect_file() {
     // $ echo foo > f
@@ -90,7 +103,7 @@ fn test_stdin_redirect_file() {
     // $ tail < f
     // foo
 
-    // $ tail -f < f
+    // $ tail -v < f
     // foo
     //
 
@@ -100,16 +113,29 @@ fn test_stdin_redirect_file() {
 
     ts.ucmd()
         .set_stdin(File::open(at.plus("f")).unwrap())
-        .run()
-        .stdout_is("foo")
-        .succeeded();
+        .succeeds()
+        .stdout_is("foo");
     ts.ucmd()
         .set_stdin(File::open(at.plus("f")).unwrap())
         .arg("-v")
-        .run()
-        .no_stderr()
-        .stdout_is("==> standard input <==\nfoo")
-        .succeeded();
+        .succeeds()
+        .stdout_only("==> standard input <==\nfoo");
+}
+
+#[test]
+// FIXME: the -f test fails with: Assertion failed. Expected 'tail' to be running but exited with status=exit status: 0
+#[ignore = "disabled until fixed"]
+#[cfg(not(target_vendor = "apple"))] // FIXME: for currently not working platforms
+fn test_stdin_redirect_file_follow() {
+    // $ echo foo > f
+
+    // $ tail -f < f
+    // foo
+    //
+
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.write("f", "foo");
 
     let mut p = ts
         .ucmd()
@@ -136,12 +162,7 @@ fn test_stdin_redirect_offset() {
     let mut fh = File::open(at.plus("k")).unwrap();
     fh.seek(SeekFrom::Start(2)).unwrap();
 
-    ts.ucmd()
-        .set_stdin(fh)
-        .run()
-        .no_stderr()
-        .stdout_is("2\n")
-        .succeeded();
+    ts.ucmd().set_stdin(fh).succeeds().stdout_only("2\n");
 }
 
 #[test]
@@ -161,12 +182,10 @@ fn test_stdin_redirect_offset2() {
     ts.ucmd()
         .set_stdin(fh)
         .args(&["k", "-", "l", "m"])
-        .run()
-        .no_stderr()
-        .stdout_is(
+        .succeeds()
+        .stdout_only(
             "==> k <==\n1\n2\n\n==> standard input <==\n2\n\n==> l <==\n3\n4\n\n==> m <==\n5\n6\n",
-        )
-        .succeeded();
+        );
 }
 
 #[test]
@@ -174,88 +193,74 @@ fn test_nc_0_wo_follow() {
     // verify that -[nc]0 without -f, exit without reading
 
     let ts = TestScenario::new(util_name!());
-    ts.ucmd()
-        .args(&["-n0", "missing"])
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .succeeded();
-    ts.ucmd()
-        .args(&["-c0", "missing"])
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .succeeded();
+    ts.ucmd().args(&["-n0", "missing"]).succeeds().no_output();
+    ts.ucmd().args(&["-c0", "missing"]).succeeds().no_output();
 }
 
 #[test]
 #[cfg(all(unix, not(target_os = "freebsd")))]
 fn test_nc_0_wo_follow2() {
+    use std::os::unix::fs::PermissionsExt;
     // verify that -[nc]0 without -f, exit without reading
 
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
 
-    use std::os::unix::fs::PermissionsExt;
     at.make_file("unreadable")
         .set_permissions(PermissionsExt::from_mode(0o000))
         .unwrap();
 
     ts.ucmd()
         .args(&["-n0", "unreadable"])
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .succeeded();
+        .succeeds()
+        .no_output();
     ts.ucmd()
         .args(&["-c0", "unreadable"])
-        .run()
-        .no_stderr()
-        .no_stdout()
-        .succeeded();
+        .succeeds()
+        .no_output();
 }
 
 // TODO: Add similar test for windows
 #[test]
 #[cfg(unix)]
 fn test_permission_denied() {
+    use std::os::unix::fs::PermissionsExt;
+
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
 
-    use std::os::unix::fs::PermissionsExt;
     at.make_file("unreadable")
         .set_permissions(PermissionsExt::from_mode(0o000))
         .unwrap();
 
     ts.ucmd()
         .arg("unreadable")
-        .fails()
+        .fails_with_code(1)
         .stderr_is("tail: cannot open 'unreadable' for reading: Permission denied\n")
-        .no_stdout()
-        .code_is(1);
+        .no_stdout();
 }
 
 // TODO: Add similar test for windows
 #[test]
 #[cfg(unix)]
 fn test_permission_denied_multiple() {
+    use std::os::unix::fs::PermissionsExt;
+
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
 
     at.touch("file1");
     at.touch("file2");
 
-    use std::os::unix::fs::PermissionsExt;
     at.make_file("unreadable")
         .set_permissions(PermissionsExt::from_mode(0o000))
         .unwrap();
 
     ts.ucmd()
         .args(&["file1", "unreadable", "file2"])
-        .fails()
+        .fails_with_code(1)
         .stderr_is("tail: cannot open 'unreadable' for reading: Permission denied\n")
-        .stdout_is("==> file1 <==\n\n==> file2 <==\n")
-        .code_is(1);
+        .stdout_is("==> file1 <==\n\n==> file2 <==\n");
 }
 
 #[test]
@@ -273,10 +278,9 @@ fn test_follow_redirect_stdin_name_retry() {
         ts.ucmd()
             .set_stdin(File::open(at.plus("f")).unwrap())
             .args(&args)
-            .fails()
+            .fails_with_code(1)
             .no_stdout()
-            .stderr_is("tail: cannot follow '-' by name\n")
-            .code_is(1);
+            .stderr_is("tail: cannot follow '-' by name\n");
         args.pop();
     }
 }
@@ -286,7 +290,8 @@ fn test_follow_redirect_stdin_name_retry() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_stdin_redirect_dir() {
     // $ mkdir dir
@@ -299,17 +304,15 @@ fn test_stdin_redirect_dir() {
 
     ts.ucmd()
         .set_stdin(File::open(at.plus("dir")).unwrap())
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: error reading 'standard input': Is a directory\n")
-        .code_is(1);
+        .stderr_is("tail: error reading 'standard input': Is a directory\n");
     ts.ucmd()
         .set_stdin(File::open(at.plus("dir")).unwrap())
         .arg("-")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: error reading 'standard input': Is a directory\n")
-        .code_is(1);
+        .stderr_is("tail: error reading 'standard input': Is a directory\n");
 }
 
 // On macOS path.is_dir() can be false for directories if it was a redirect,
@@ -332,17 +335,64 @@ fn test_stdin_redirect_dir_when_target_os_is_macos() {
 
     ts.ucmd()
         .set_stdin(File::open(at.plus("dir")).unwrap())
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n")
-        .code_is(1);
+        .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n");
     ts.ucmd()
         .set_stdin(File::open(at.plus("dir")).unwrap())
         .arg("-")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n")
-        .code_is(1);
+        .stderr_is("tail: cannot open 'standard input' for reading: No such file or directory\n");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_stdin_via_script_redirection_and_pipe() {
+    // $ touch file.txt
+    // $ echo line1 > file.txt
+    // $ echo line2 >> file.txt
+    // $ chmod +x test.sh
+    // $ ./test.sh < file.txt
+    // line1
+    // line2
+    // $ cat file.txt | ./test.sh
+    // line1
+    // line2
+    use std::os::unix::fs::PermissionsExt;
+
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+    let data = "line1\nline2\n";
+
+    at.write("file.txt", data);
+
+    let mut script = at.make_file("test.sh");
+    writeln!(script, "#!/usr/bin/env sh").unwrap();
+    writeln!(script, "tail").unwrap();
+    script
+        .set_permissions(PermissionsExt::from_mode(0o755))
+        .unwrap();
+
+    drop(script); // close the file handle to ensure file is not busy
+
+    // test with redirection
+    scene
+        .cmd("sh")
+        .current_dir(at.plus(""))
+        .arg("-c")
+        .arg("./test.sh < file.txt")
+        .succeeds()
+        .stdout_only(data);
+
+    // test with pipe
+    scene
+        .cmd("sh")
+        .current_dir(at.plus(""))
+        .arg("-c")
+        .arg("cat file.txt | ./test.sh")
+        .succeeds()
+        .stdout_only(data);
 }
 
 #[test]
@@ -375,10 +425,9 @@ fn test_follow_stdin_name_retry() {
     for _ in 0..2 {
         new_ucmd!()
             .args(&args)
-            .run()
+            .fails_with_code(1)
             .no_stdout()
-            .stderr_is("tail: cannot follow '-' by name\n")
-            .code_is(1);
+            .stderr_is("tail: cannot follow '-' by name\n");
         args.pop();
     }
 }
@@ -406,7 +455,7 @@ fn test_follow_bad_fd() {
 fn test_single_default() {
     new_ucmd!()
         .arg(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_single_default.expected");
 }
 
@@ -416,7 +465,7 @@ fn test_n_greater_than_number_of_lines() {
         .arg("-n")
         .arg("99999999")
         .arg(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture(FOOBAR_TXT);
 }
 
@@ -425,7 +474,7 @@ fn test_null_default() {
     new_ucmd!()
         .arg("-z")
         .arg(FOOBAR_WITH_NULL_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_with_null_default.expected");
 }
 
@@ -531,37 +580,40 @@ fn test_follow_multiple() {
 #[test]
 #[cfg(not(target_os = "windows"))] // FIXME: test times out
 fn test_follow_name_multiple() {
-    let (at, mut ucmd) = at_and_ucmd!();
-    let mut child = ucmd
-        .arg("--follow=name")
-        .arg(FOOBAR_TXT)
-        .arg(FOOBAR_2_TXT)
-        .run_no_wait();
+    // spell-checker:disable-next-line
+    for argument in ["--follow=name", "--follo=nam", "--f=n"] {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let mut child = ucmd
+            .arg(argument)
+            .arg(FOOBAR_TXT)
+            .arg(FOOBAR_2_TXT)
+            .run_no_wait();
 
-    child
-        .make_assertion_with_delay(500)
-        .is_alive()
-        .with_current_output()
-        .stdout_only_fixture("foobar_follow_multiple.expected");
+        child
+            .make_assertion_with_delay(500)
+            .is_alive()
+            .with_current_output()
+            .stdout_only_fixture("foobar_follow_multiple.expected");
 
-    let first_append = "trois\n";
-    at.append(FOOBAR_2_TXT, first_append);
+        let first_append = "trois\n";
+        at.append(FOOBAR_2_TXT, first_append);
 
-    child
-        .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
-        .with_current_output()
-        .stdout_only(first_append);
+        child
+            .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
+            .with_current_output()
+            .stdout_only(first_append);
 
-    let second_append = "twenty\nthirty\n";
-    at.append(FOOBAR_TXT, second_append);
+        let second_append = "twenty\nthirty\n";
+        at.append(FOOBAR_TXT, second_append);
 
-    child
-        .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
-        .with_current_output()
-        .stdout_only_fixture("foobar_follow_multiple_appended.expected");
+        child
+            .make_assertion_with_delay(DEFAULT_SLEEP_INTERVAL_MILLIS)
+            .with_current_output()
+            .stdout_only_fixture("foobar_follow_multiple_appended.expected");
 
-    child.make_assertion().is_alive();
-    child.kill();
+        child.make_assertion().is_alive();
+        child.kill();
+    }
 }
 
 #[test]
@@ -589,10 +641,9 @@ fn test_follow_multiple_untailable() {
     ucmd.arg("-f")
         .arg("DIR1")
         .arg("DIR2")
-        .fails()
+        .fails_with_code(1)
         .stderr_is(expected_stderr)
-        .stdout_is(expected_stdout)
-        .code_is(1);
+        .stdout_is(expected_stdout);
 }
 
 #[test]
@@ -600,7 +651,7 @@ fn test_follow_stdin_pipe() {
     new_ucmd!()
         .arg("-f")
         .pipe_in_fixture(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("follow_stdin.expected")
         .no_stderr();
 }
@@ -610,7 +661,7 @@ fn test_follow_stdin_pipe() {
 fn test_follow_invalid_pid() {
     new_ucmd!()
         .args(&["-f", "--pid=-1234"])
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
         .stderr_is("tail: invalid PID: '-1234'\n");
     new_ucmd!()
@@ -721,7 +772,7 @@ fn test_single_big_args() {
     }
     big_expected.flush().expect("Could not flush EXPECTED_FILE");
 
-    ucmd.arg(FILE).arg("-n").arg(format!("{N_ARG}")).run();
+    ucmd.arg(FILE).arg("-n").arg(format!("{N_ARG}")).succeeds();
     // .stdout_is(at.read(EXPECTED_FILE));
 }
 
@@ -731,7 +782,7 @@ fn test_bytes_single() {
         .arg("-c")
         .arg("10")
         .arg(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_bytes_single.expected");
 }
 
@@ -741,7 +792,7 @@ fn test_bytes_stdin() {
         .pipe_in_fixture(FOOBAR_TXT)
         .arg("-c")
         .arg("13")
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_bytes_stdin.expected")
         .no_stderr();
 }
@@ -807,7 +858,7 @@ fn test_lines_with_size_suffix() {
     ucmd.arg(FILE)
         .arg("-n")
         .arg("2K")
-        .run()
+        .succeeds()
         .stdout_is_fixture(EXPECTED_FILE);
 }
 
@@ -816,7 +867,7 @@ fn test_multiple_input_files() {
     new_ucmd!()
         .arg(FOOBAR_TXT)
         .arg(FOOBAR_2_TXT)
-        .run()
+        .succeeds()
         .no_stderr()
         .stdout_is_fixture("foobar_follow_multiple.expected");
 }
@@ -828,13 +879,12 @@ fn test_multiple_input_files_missing() {
         .arg("missing1")
         .arg(FOOBAR_2_TXT)
         .arg("missing2")
-        .run()
+        .fails()
         .stdout_is_fixture("foobar_follow_multiple.expected")
         .stderr_is(
             "tail: cannot open 'missing1' for reading: No such file or directory\n\
                 tail: cannot open 'missing2' for reading: No such file or directory\n",
-        )
-        .code_is(1);
+        );
 }
 
 #[test]
@@ -842,17 +892,16 @@ fn test_follow_missing() {
     // Ensure that --follow=name does not imply --retry.
     // Ensure that --follow={descriptor,name} (without --retry) does *not wait* for the
     // file to appear.
-    for follow_mode in &["--follow=descriptor", "--follow=name"] {
+    for follow_mode in &["--follow=descriptor", "--follow=name", "--fo=d", "--fo=n"] {
         new_ucmd!()
             .arg(follow_mode)
             .arg("missing")
-            .run()
+            .fails_with_code(1)
             .no_stdout()
             .stderr_is(
                 "tail: cannot open 'missing' for reading: No such file or directory\n\
                     tail: no files remaining\n",
-            )
-            .code_is(1);
+            );
     }
 }
 
@@ -865,17 +914,15 @@ fn test_follow_name_stdin() {
     ts.ucmd()
         .arg("--follow=name")
         .arg("-")
-        .run()
-        .stderr_is("tail: cannot follow '-' by name\n")
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_is("tail: cannot follow '-' by name\n");
     ts.ucmd()
         .arg("--follow=name")
         .arg("FILE1")
         .arg("-")
         .arg("FILE2")
-        .run()
-        .stderr_is("tail: cannot follow '-' by name\n")
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_is("tail: cannot follow '-' by name\n");
 }
 
 #[test]
@@ -884,7 +931,7 @@ fn test_multiple_input_files_with_suppressed_headers() {
         .arg(FOOBAR_TXT)
         .arg(FOOBAR_2_TXT)
         .arg("-q")
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_multiple_quiet.expected");
 }
 
@@ -895,7 +942,7 @@ fn test_multiple_input_quiet_flag_overrides_verbose_flag_for_suppressing_headers
         .arg(FOOBAR_2_TXT)
         .arg("-v")
         .arg("-q")
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_multiple_quiet.expected");
 }
 
@@ -904,9 +951,8 @@ fn test_dir() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.mkdir("DIR");
     ucmd.arg("DIR")
-        .run()
-        .stderr_is("tail: error reading 'DIR': Is a directory\n")
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_is("tail: error reading 'DIR': Is a directory\n");
 }
 
 #[test]
@@ -918,14 +964,13 @@ fn test_dir_follow() {
         ts.ucmd()
             .arg(mode)
             .arg("DIR")
-            .run()
+            .fails_with_code(1)
             .no_stdout()
             .stderr_is(
                 "tail: error reading 'DIR': Is a directory\n\
                     tail: DIR: cannot follow end of this type of file; giving up on this name\n\
                     tail: no files remaining\n",
-            )
-            .code_is(1);
+            );
     }
 }
 
@@ -938,25 +983,24 @@ fn test_dir_follow_retry() {
         .arg("--follow=descriptor")
         .arg("--retry")
         .arg("DIR")
-        .run()
+        .fails_with_code(1)
         .stderr_is(
             "tail: warning: --retry only effective for the initial open\n\
                 tail: error reading 'DIR': Is a directory\n\
                 tail: DIR: cannot follow end of this type of file\n\
                 tail: no files remaining\n",
-        )
-        .code_is(1);
+        );
 }
 
 #[test]
 fn test_negative_indexing() {
-    let positive_lines_index = new_ucmd!().arg("-n").arg("5").arg(FOOBAR_TXT).run();
+    let positive_lines_index = new_ucmd!().arg("-n").arg("5").arg(FOOBAR_TXT).succeeds();
 
-    let negative_lines_index = new_ucmd!().arg("-n").arg("-5").arg(FOOBAR_TXT).run();
+    let negative_lines_index = new_ucmd!().arg("-n").arg("-5").arg(FOOBAR_TXT).succeeds();
 
-    let positive_bytes_index = new_ucmd!().arg("-c").arg("20").arg(FOOBAR_TXT).run();
+    let positive_bytes_index = new_ucmd!().arg("-c").arg("20").arg(FOOBAR_TXT).succeeds();
 
-    let negative_bytes_index = new_ucmd!().arg("-c").arg("-20").arg(FOOBAR_TXT).run();
+    let negative_bytes_index = new_ucmd!().arg("-c").arg("-20").arg(FOOBAR_TXT).succeeds();
 
     assert_eq!(positive_lines_index.stdout(), negative_lines_index.stdout());
     assert_eq!(positive_bytes_index.stdout(), negative_bytes_index.stdout());
@@ -972,9 +1016,8 @@ fn test_sleep_interval() {
         .arg("-s")
         .arg("1..1")
         .arg(FOOBAR_TXT)
-        .fails()
-        .stderr_contains("invalid number of seconds: '1..1'")
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_contains("invalid number of seconds: '1..1'");
 }
 
 /// Test for reading all but the first NUM bytes: `tail -c +3`.
@@ -1106,13 +1149,11 @@ fn test_invalid_num() {
         .fails()
         .stderr_str()
         .starts_with("tail: invalid number of lines: '1024R'");
-    #[cfg(not(target_pointer_width = "128"))]
     new_ucmd!()
         .args(&["-c", "1Y", "emptyfile.txt"])
         .fails()
         .stderr_str()
         .starts_with("tail: invalid number of bytes: '1Y': Value too large for defined data type");
-    #[cfg(not(target_pointer_width = "128"))]
     new_ucmd!()
         .args(&["-n", "1Y", "emptyfile.txt"])
         .fails()
@@ -1158,12 +1199,11 @@ fn test_bytes_for_funny_unix_files() {
             continue;
         }
         let args = ["--bytes", "1", file];
-        let result = ts.ucmd().args(&args).run();
         let exp_result = unwrap_or_return!(expected_result(&ts, &args));
+        let result = ts.ucmd().args(&args).succeeds();
         result
             .stdout_is(exp_result.stdout_str())
-            .stderr_is(exp_result.stderr_str())
-            .code_is(exp_result.code());
+            .stderr_is(exp_result.stderr_str());
     }
 }
 
@@ -1177,8 +1217,10 @@ fn test_retry1() {
     let file_name = "FILE";
     at.touch(file_name);
 
-    let result = ts.ucmd().arg(file_name).arg("--retry").run();
-    result
+    ts.ucmd()
+        .arg(file_name)
+        .arg("--retry")
+        .succeeds()
         .stderr_is("tail: warning: --retry ignored; --retry is useful only when following\n")
         .code_is(0);
 }
@@ -1191,13 +1233,14 @@ fn test_retry2() {
     let ts = TestScenario::new(util_name!());
     let missing = "missing";
 
-    let result = ts.ucmd().arg(missing).arg("--retry").run();
-    result
+    ts.ucmd()
+        .arg(missing)
+        .arg("--retry")
+        .fails_with_code(1)
         .stderr_is(
             "tail: warning: --retry ignored; --retry is useful only when following\n\
                 tail: cannot open 'missing' for reading: No such file or directory\n",
-        )
-        .code_is(1);
+        );
 }
 
 #[test]
@@ -1205,7 +1248,8 @@ fn test_retry2() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_retry3() {
     // inspired by: gnu/tests/tail-2/retry.sh
@@ -1249,7 +1293,8 @@ fn test_retry3() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_retry4() {
     // inspired by: gnu/tests/tail-2/retry.sh
@@ -1306,7 +1351,8 @@ fn test_retry4() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_retry5() {
     // inspired by: gnu/tests/tail-2/retry.sh
@@ -1392,7 +1438,8 @@ fn test_retry6() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_retry7() {
     // inspired by: gnu/tests/tail-2/retry.sh
@@ -1466,7 +1513,8 @@ fn test_retry7() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_retry8() {
     // Ensure that inotify will switch to polling mode if directory
@@ -1534,7 +1582,8 @@ fn test_retry8() {
     not(target_vendor = "apple"),
     not(target_os = "android"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_retry9() {
     // inspired by: gnu/tests/tail-2/inotify-dir-recreate.sh
@@ -1615,7 +1664,8 @@ fn test_retry9() {
     not(target_vendor = "apple"),
     not(target_os = "android"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_descriptor_vs_rename1() {
     // inspired by: gnu/tests/tail-2/descriptor-vs-rename.sh
@@ -1678,7 +1728,8 @@ fn test_follow_descriptor_vs_rename1() {
     not(target_vendor = "apple"),
     not(target_os = "android"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_descriptor_vs_rename2() {
     // Ensure the headers are correct for --verbose.
@@ -1730,7 +1781,8 @@ fn test_follow_descriptor_vs_rename2() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_retry_headers() {
     // inspired by: "gnu/tests/tail-2/F-headers.sh"
@@ -1812,12 +1864,12 @@ fn test_follow_name_remove() {
     let expected_stdout = at.read(FOLLOW_NAME_SHORT_EXP);
     let expected_stderr = [
         format!(
-            "{}: {}: No such file or directory\n{0}: no files remaining\n",
-            ts.util_name, source_copy
+            "{}: {source_copy}: No such file or directory\n{0}: no files remaining\n",
+            ts.util_name,
         ),
         format!(
-            "{}: {}: No such file or directory\n",
-            ts.util_name, source_copy
+            "{}: {source_copy}: No such file or directory\n",
+            ts.util_name,
         ),
     ];
 
@@ -1873,7 +1925,7 @@ fn test_follow_name_truncate1() {
     let backup = "backup";
 
     let expected_stdout = at.read(FOLLOW_NAME_EXP);
-    let expected_stderr = format!("{}: {}: file truncated\n", ts.util_name, source);
+    let expected_stderr = format!("{}: {source}: file truncated\n", ts.util_name);
 
     let args = ["--follow=name", source];
     let mut p = ts.ucmd().args(&args).run_no_wait();
@@ -1915,7 +1967,7 @@ fn test_follow_name_truncate2() {
     at.touch(source);
 
     let expected_stdout = "x\nx\nx\nx\n";
-    let expected_stderr = format!("{}: {}: file truncated\n", ts.util_name, source);
+    let expected_stderr = format!("{}: {source}: file truncated\n", ts.util_name);
 
     let args = ["--follow=name", source];
     let mut p = ts.ucmd().args(&args).run_no_wait();
@@ -1977,7 +2029,11 @@ fn test_follow_name_truncate3() {
 }
 
 #[test]
-#[cfg(all(not(target_vendor = "apple"), not(target_os = "windows")))] // FIXME: for currently not working platforms
+#[cfg(all(
+    not(target_vendor = "apple"),
+    not(target_os = "windows"),
+    not(feature = "feat_selinux") // flaky
+))] // FIXME: for currently not working platforms
 fn test_follow_name_truncate4() {
     // Truncating a file with the same content it already has should not trigger a truncate event
 
@@ -2064,7 +2120,8 @@ fn test_follow_truncate_fast() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_move_create1() {
     // This test triggers a move/create event while `tail --follow=name file` is running.
@@ -2081,8 +2138,8 @@ fn test_follow_name_move_create1() {
 
     #[cfg(target_os = "linux")]
     let expected_stderr = format!(
-        "{}: {}: No such file or directory\n{0}: '{1}' has appeared;  following new file\n",
-        ts.util_name, source
+        "{}: {source}: No such file or directory\n{0}: '{source}' has appeared;  following new file\n",
+        ts.util_name,
     );
 
     // NOTE: We are less strict if not on Linux (inotify backend).
@@ -2091,7 +2148,7 @@ fn test_follow_name_move_create1() {
     let expected_stdout = at.read(FOLLOW_NAME_SHORT_EXP);
 
     #[cfg(not(target_os = "linux"))]
-    let expected_stderr = format!("{}: {}: No such file or directory\n", ts.util_name, source);
+    let expected_stderr = format!("{}: {source}: No such file or directory\n", ts.util_name);
 
     let delay = 500;
     let args = ["--follow=name", source];
@@ -2119,7 +2176,8 @@ fn test_follow_name_move_create1() {
     not(target_vendor = "apple"),
     not(target_os = "android"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_move_create2() {
     // inspired by: "gnu/tests/tail-2/inotify-hash-abuse.sh"
@@ -2198,7 +2256,8 @@ fn test_follow_name_move_create2() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_move1() {
     // This test triggers a move event while `tail --follow=name file` is running.
@@ -2213,10 +2272,10 @@ fn test_follow_name_move1() {
 
     let expected_stdout = at.read(FOLLOW_NAME_SHORT_EXP);
     let expected_stderr = [
-        format!("{}: {}: No such file or directory\n", ts.util_name, source),
+        format!("{}: {source}: No such file or directory\n", ts.util_name),
         format!(
-            "{}: {}: No such file or directory\n{0}: no files remaining\n",
-            ts.util_name, source
+            "{}: {source}: No such file or directory\n{0}: no files remaining\n",
+            ts.util_name,
         ),
     ];
 
@@ -2259,7 +2318,8 @@ fn test_follow_name_move1() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_move2() {
     // Like test_follow_name_move1, but move to a name that's already monitored.
@@ -2346,7 +2406,8 @@ fn test_follow_name_move2() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_move_retry1() {
     // Similar to test_follow_name_move1 but with `--retry` (`-F`)
@@ -2405,7 +2466,8 @@ fn test_follow_name_move_retry1() {
     not(target_vendor = "apple"),
     not(target_os = "windows"),
     not(target_os = "android"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd")
 ))] // FIXME: for currently not working platforms
 fn test_follow_name_move_retry2() {
     // inspired by: "gnu/tests/tail-2/F-vs-rename.sh"
@@ -2528,10 +2590,9 @@ fn test_follow_inotify_only_regular() {
 fn test_no_such_file() {
     new_ucmd!()
         .arg("missing")
-        .fails()
+        .fails_with_code(1)
         .stderr_is("tail: cannot open 'missing' for reading: No such file or directory\n")
-        .no_stdout()
-        .code_is(1);
+        .no_stdout();
 }
 
 #[test]
@@ -2558,7 +2619,7 @@ fn test_presume_input_pipe_default() {
     new_ucmd!()
         .arg("---presume-input-pipe")
         .pipe_in_fixture(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("foobar_stdin_default.expected")
         .no_stderr();
 }
@@ -2591,7 +2652,7 @@ fn test_fifo() {
 
 #[test]
 #[cfg(unix)]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_illegal_seek() {
     // This is here for reference only.
     // We don't call seek on fifos, so we don't hit this error case.
@@ -2802,7 +2863,7 @@ fn test_pipe_when_lines_option_given_multibyte_utf8_characters() {
 #[test]
 fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size_no_newline_at_eof() {
     let total_lines = 1;
-    let random_string = RandomString::generate_with_delimiter(
+    let random_string = RandomizedString::generate_with_delimiter(
         Alphanumeric,
         b'\n',
         total_lines,
@@ -2832,7 +2893,7 @@ fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size_no_newli
 #[test]
 fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() {
     let total_lines = 100;
-    let random_string = RandomString::generate_with_delimiter(
+    let random_string = RandomizedString::generate_with_delimiter(
         Alphanumeric,
         b'\n',
         total_lines,
@@ -2892,7 +2953,7 @@ fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() {
 #[test]
 fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_size() {
     let total_lines = 100;
-    let random_string = RandomString::generate_with_delimiter(
+    let random_string = RandomizedString::generate_with_delimiter(
         Alphanumeric,
         b'\n',
         total_lines,
@@ -2940,7 +3001,7 @@ fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_
 #[cfg(not(target_os = "windows"))]
 fn test_pipe_when_lines_option_given_input_size_has_multiple_size_of_buffer_size() {
     let total_lines = 100;
-    let random_string = RandomString::generate_with_delimiter(
+    let random_string = RandomizedString::generate_with_delimiter(
         Alphanumeric,
         b'\n',
         total_lines,
@@ -3132,7 +3193,7 @@ fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() {
 
 #[test]
 fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() {
-    let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE);
+    let random_string = RandomizedString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE);
     let random_string = random_string.as_str();
 
     new_ucmd!()
@@ -3191,7 +3252,7 @@ fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() {
 
 #[test]
 fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_size() {
-    let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE + 1);
+    let random_string = RandomizedString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE + 1);
     let random_string = random_string.as_str();
 
     new_ucmd!()
@@ -3246,7 +3307,7 @@ fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_
 #[test]
 #[cfg(not(target_os = "windows"))]
 fn test_pipe_when_bytes_option_given_input_size_has_multiple_size_of_buffer_size() {
-    let random_string = RandomString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE * 3);
+    let random_string = RandomizedString::generate(AlphanumericNewline, CHUNK_BUFFER_SIZE * 3);
     let random_string = random_string.as_str();
 
     new_ucmd!()
@@ -3342,7 +3403,7 @@ fn test_seek_bytes_backward_outside_file() {
         .arg("-c")
         .arg("100")
         .arg(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is_fixture(FOOBAR_TXT);
 }
 
@@ -3352,7 +3413,7 @@ fn test_seek_bytes_forward_outside_file() {
         .arg("-c")
         .arg("+100")
         .arg(FOOBAR_TXT)
-        .run()
+        .succeeds()
         .stdout_is("");
 }
 
@@ -3362,7 +3423,7 @@ fn test_seek_bytes_forward_outside_file() {
 #[cfg(all(not(target_os = "android"), not(target_os = "windows")))] // FIXME:
 #[test]
 fn test_args_when_presume_input_pipe_given_input_is_pipe() {
-    let random_string = RandomString::generate(AlphanumericNewline, 1000);
+    let random_string = RandomizedString::generate(AlphanumericNewline, 1000);
     let random_string = random_string.as_str();
 
     new_ucmd!()
@@ -3398,7 +3459,7 @@ fn test_args_when_presume_input_pipe_given_input_is_pipe() {
 
 #[test]
 fn test_args_when_presume_input_pipe_given_input_is_file() {
-    let random_string = RandomString::generate(AlphanumericNewline, 1000);
+    let random_string = RandomizedString::generate(AlphanumericNewline, 1000);
     let random_string = random_string.as_str();
 
     let ts = TestScenario::new(util_name!());
@@ -3429,7 +3490,7 @@ fn test_args_when_presume_input_pipe_given_input_is_file() {
 }
 
 #[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
 // FIXME: currently missing in the error message is the last line >>tail: no files remaining<<
 fn test_when_follow_retry_given_redirected_stdin_from_directory_then_correct_error_message() {
     let ts = TestScenario::new(util_name!());
@@ -3443,9 +3504,8 @@ fn test_when_follow_retry_given_redirected_stdin_from_directory_then_correct_err
     ts.ucmd()
         .set_stdin(File::open(at.plus("dir")).unwrap())
         .args(&["-f", "--retry"])
-        .fails()
-        .stderr_only(expected)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(expected);
 }
 
 #[test]
@@ -3457,9 +3517,8 @@ fn test_when_argument_file_is_a_directory() {
     let expected = "tail: error reading 'dir': Is a directory\n";
     ts.ucmd()
         .arg("dir")
-        .fails()
-        .stderr_only(expected)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(expected);
 }
 
 // TODO: make this work on windows
@@ -3479,7 +3538,7 @@ fn test_when_argument_file_is_a_symlink() {
         .no_stdout()
         .no_stderr();
 
-    let random_string = RandomString::generate(AlphanumericNewline, 100);
+    let random_string = RandomizedString::generate(AlphanumericNewline, 100);
     let result = file.write_all(random_string.as_bytes());
     assert!(result.is_ok());
 
@@ -3495,9 +3554,8 @@ fn test_when_argument_file_is_a_symlink() {
     let expected = "tail: error reading 'dir_link': Is a directory\n";
     ts.ucmd()
         .arg("dir_link")
-        .fails()
-        .stderr_only(expected)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(expected);
 }
 
 // TODO: make this work on windows
@@ -3513,15 +3571,14 @@ fn test_when_argument_file_is_a_symlink_to_directory_then_error() {
     let expected = "tail: error reading 'dir_link': Is a directory\n";
     ts.ucmd()
         .arg("dir_link")
-        .fails()
-        .stderr_only(expected)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(expected);
 }
 
 // TODO: make this work on windows
 #[test]
 #[cfg(unix)]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_when_argument_file_is_a_faulty_symlink_then_error() {
     let ts = TestScenario::new(util_name!());
     let at = &ts.fixtures;
@@ -3537,23 +3594,21 @@ fn test_when_argument_file_is_a_faulty_symlink_then_error() {
 
     ts.ucmd()
         .arg("self")
-        .fails()
-        .stderr_only(expected)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(expected);
 
     at.symlink_file("missing", "broken");
 
     let expected = "tail: cannot open 'broken' for reading: No such file or directory";
     ts.ucmd()
         .arg("broken")
-        .fails()
-        .stderr_only(expected)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(expected);
 }
 
 #[test]
 #[cfg(unix)]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
     use std::os::unix::net;
 
@@ -3567,38 +3622,31 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
     assert!(result.is_ok());
 
     #[cfg(all(not(target_os = "freebsd"), not(target_os = "macos")))]
-    let expected_stderr = format!(
-        "tail: cannot open '{}' for reading: No such device or address\n",
-        socket
-    );
+    let expected_stderr =
+        format!("tail: cannot open '{socket}' for reading: No such device or address\n");
     #[cfg(target_os = "freebsd")]
-    let expected_stderr = format!(
-        "tail: cannot open '{}' for reading: Operation not supported\n",
-        socket
-    );
+    let expected_stderr =
+        format!("tail: cannot open '{socket}' for reading: Operation not supported\n",);
     #[cfg(target_os = "macos")]
-    let expected_stderr = format!(
-        "tail: cannot open '{}' for reading: Operation not supported on socket\n",
-        socket
-    );
+    let expected_stderr =
+        format!("tail: cannot open '{socket}' for reading: Operation not supported on socket\n",);
 
     ts.ucmd()
         .arg(socket)
-        .fails()
-        .stderr_only(&expected_stderr)
-        .code_is(1);
+        .fails_with_code(1)
+        .stderr_only(&expected_stderr);
 
     let path = "file";
     let mut file = at.make_file(path);
 
-    let random_string = RandomString::generate(AlphanumericNewline, 100);
+    let random_string = RandomizedString::generate(AlphanumericNewline, 100);
     let result = file.write_all(random_string.as_bytes());
     assert!(result.is_ok());
 
-    let expected_stdout = vec![format!("==> {} <==", path), random_string].join("\n");
+    let expected_stdout = [format!("==> {path} <=="), random_string].join("\n");
     ts.ucmd()
         .args(&["-c", "+0", path, socket])
-        .fails()
+        .fails_with_code(1)
         .stdout_is(&expected_stdout)
         .stderr_is(&expected_stderr);
 
@@ -3612,14 +3660,14 @@ fn test_when_argument_file_is_non_existent_unix_socket_address_then_error() {
 }
 
 #[test]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
-    fixtures.write("empty", "");
-    fixtures.write("data", "file data");
-    fixtures.write("fifo", "fifo data");
+    at.touch("empty");
+    at.write("data", "file data");
+    at.write("fifo", "fifo data");
 
     let expected = "==> standard input <==\n\
                 fifo data\n\
@@ -3627,9 +3675,8 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
     scene
         .ucmd()
         .args(&["-c", "+0", "-", "empty"])
-        .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
-        .run()
-        .success()
+        .set_stdin(File::open(at.plus("fifo")).unwrap())
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
@@ -3639,8 +3686,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
         .ucmd()
         .args(&["-c", "+0", "-", "empty"])
         .pipe_in("")
-        .run()
-        .success()
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> empty <==\n\
@@ -3650,8 +3696,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
         .ucmd()
         .args(&["-c", "+0", "empty", "-"])
         .pipe_in("")
-        .run()
-        .success()
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> empty <==\n\
@@ -3661,9 +3706,8 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
     scene
         .ucmd()
         .args(&["-c", "+0", "empty", "-"])
-        .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
-        .run()
-        .success()
+        .set_stdin(File::open(at.plus("fifo")).unwrap())
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
@@ -3674,8 +3718,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
         .ucmd()
         .args(&["-c", "+0", "-", "data"])
         .pipe_in("pipe data")
-        .run()
-        .success()
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> data <==\n\
@@ -3686,8 +3729,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
         .ucmd()
         .args(&["-c", "+0", "data", "-"])
         .pipe_in("pipe data")
-        .run()
-        .success()
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
@@ -3697,8 +3739,7 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
         .ucmd()
         .args(&["-c", "+0", "-", "-"])
         .pipe_in("pipe data")
-        .run()
-        .success()
+        .succeeds()
         .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
@@ -3707,21 +3748,20 @@ fn test_when_argument_files_are_simple_combinations_of_stdin_and_regular_file()
     scene
         .ucmd()
         .args(&["-c", "+0", "-", "-"])
-        .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
-        .run()
-        .success()
+        .set_stdin(File::open(at.plus("fifo")).unwrap())
+        .succeeds()
         .stdout_only(expected);
 }
 
 #[test]
-#[cfg(disabled_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_file() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
-    fixtures.write("empty", "");
-    fixtures.write("data", "file data");
-    fixtures.write("fifo", "fifo data");
+    at.touch("empty");
+    at.write("data", "file data");
+    at.write("fifo", "fifo data");
 
     let expected = "==> standard input <==\n\
                 \n\
@@ -3732,10 +3772,9 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
     scene
         .ucmd()
         .args(&["-c", "+0", "-", "empty", "-"])
-        .set_stdin(File::open(fixtures.plus("empty")).unwrap())
-        .run()
-        .stdout_only(expected)
-        .success();
+        .set_stdin(File::open(at.plus("empty")).unwrap())
+        .succeeds()
+        .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
                 \n\
@@ -3747,9 +3786,8 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
         .args(&["-c", "+0", "-", "empty", "-"])
         .pipe_in("")
         .stderr_to_stdout()
-        .run()
-        .stdout_only(expected)
-        .success();
+        .succeeds()
+        .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
                 pipe data\n\
@@ -3760,9 +3798,8 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
         .ucmd()
         .args(&["-c", "+0", "-", "data", "-"])
         .pipe_in("pipe data")
-        .run()
-        .stdout_only(expected)
-        .success();
+        .succeeds()
+        .stdout_only(expected);
 
     // Correct behavior in a sh shell is to remember the file pointer for the fifo, so we don't
     // print the fifo twice. This matches the behavior, if only the pipe is present without fifo
@@ -3800,9 +3837,8 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
             "echo pipe data | {} tail -c +0  - data - < fifo",
             scene.bin_path.display(),
         ))
-        .run()
-        .stdout_only(expected)
-        .success();
+        .succeeds()
+        .stdout_only(expected);
 
     let expected = "==> standard input <==\n\
                 fifo data\n\
@@ -3812,10 +3848,9 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
     scene
         .ucmd()
         .args(&["-c", "+0", "-", "data", "-"])
-        .set_stdin(File::open(fixtures.plus("fifo")).unwrap())
-        .run()
-        .stdout_only(expected)
-        .success();
+        .set_stdin(File::open(at.plus("fifo")).unwrap())
+        .succeeds()
+        .stdout_only(expected);
 }
 
 // Bug description: The content of a file is not printed to stdout if the output data does not
@@ -3825,13 +3860,13 @@ fn test_when_argument_files_are_triple_combinations_of_fifo_pipe_and_regular_fil
 // test system. However, this behavior shows up on the command line and, at the time of writing this
 // description, with this test on macos and windows.
 #[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_when_follow_retry_then_initial_print_of_file_is_written_to_stdout() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let expected_stdout = "file data";
-    fixtures.write("data", expected_stdout);
+    at.write("data", expected_stdout);
 
     let mut child = scene
         .ucmd()
@@ -3850,10 +3885,10 @@ fn test_when_follow_retry_then_initial_print_of_file_is_written_to_stdout() {
 #[test]
 fn test_args_when_settings_check_warnings_then_shows_warnings() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let file_data = "file data\n";
-    fixtures.write("data", file_data);
+    at.write("data", file_data);
 
     let expected_stdout = format!(
         "tail: warning: --retry ignored; --retry is useful only when following\n\
@@ -3863,9 +3898,8 @@ fn test_args_when_settings_check_warnings_then_shows_warnings() {
         .ucmd()
         .args(&["--retry", "data"])
         .stderr_to_stdout()
-        .run()
-        .stdout_only(expected_stdout)
-        .success();
+        .succeeds()
+        .stdout_only(expected_stdout);
 
     let expected_stdout = format!(
         "tail: warning: --retry only effective for the initial open\n\
@@ -3892,9 +3926,8 @@ fn test_args_when_settings_check_warnings_then_shows_warnings() {
         .ucmd()
         .args(&["--pid=1000", "data"])
         .stderr_to_stdout()
-        .run()
-        .stdout_only(expected_stdout)
-        .success();
+        .succeeds()
+        .stdout_only(expected_stdout);
 
     let expected_stdout = format!(
         "tail: warning: --retry ignored; --retry is useful only when following\n\
@@ -3905,9 +3938,14 @@ fn test_args_when_settings_check_warnings_then_shows_warnings() {
         .ucmd()
         .args(&["--pid=1000", "--retry", "data"])
         .stderr_to_stdout()
-        .run()
-        .stdout_only(expected_stdout)
-        .success();
+        .succeeds()
+        .stdout_only(&expected_stdout);
+    scene
+        .ucmd()
+        .args(&["--pid=1000", "--pid=1000", "--retry", "data"])
+        .stderr_to_stdout()
+        .succeeds()
+        .stdout_only(expected_stdout);
 }
 
 /// TODO: Write similar tests for windows
@@ -4039,7 +4077,7 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_warning() {
 #[cfg(unix)]
 fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     #[cfg(target_vendor = "apple")]
     let delay = 1000;
@@ -4050,8 +4088,8 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
     let fifo_data = "fifo data\n";
     let fifo_name = "fifo";
     let file_name = "data";
-    fixtures.write(file_name, file_data);
-    fixtures.write(fifo_name, fifo_data);
+    at.write(file_name, file_data);
+    at.write(fifo_name, fifo_data);
 
     let pipe_data = "pipe data";
     let expected_stdout = format!(
@@ -4094,7 +4132,7 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
         let mut child = scene
             .ucmd()
             .args(&["--follow=descriptor", "-", file_name])
-            .set_stdin(File::open(fixtures.plus(fifo_name)).unwrap())
+            .set_stdin(File::open(at.plus(fifo_name)).unwrap())
             .stderr_to_stdout()
             .run_no_wait();
 
@@ -4114,7 +4152,7 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
         let mut child = scene
             .ucmd()
             .args(&["--follow=descriptor", "--pid=0", "-", file_name])
-            .set_stdin(File::open(fixtures.plus(fifo_name)).unwrap())
+            .set_stdin(File::open(at.plus(fifo_name)).unwrap())
             .stderr_to_stdout()
             .run_no_wait();
 
@@ -4129,16 +4167,16 @@ fn test_args_when_settings_check_warnings_follow_indefinitely_then_no_warning()
 
 /// The expected test outputs come from gnu's tail.
 #[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appended() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let file_data = "file data";
     let relative_path_name = "data";
 
-    fixtures.write(relative_path_name, file_data);
-    let absolute_path = fixtures.plus("data").canonicalize().unwrap();
+    at.write(relative_path_name, file_data);
+    let absolute_path = at.plus("data").canonicalize().unwrap();
 
     // run with relative path first and then the absolute path
     let mut child = scene
@@ -4153,7 +4191,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
     let more_data = "more data";
     child.delay(500);
 
-    fixtures.append(relative_path_name, more_data);
+    at.append(relative_path_name, more_data);
 
     let expected_stdout = format!(
         "==> {0} <==\n\
@@ -4178,7 +4216,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
         .stderr_only(expected_stdout);
 
     // run with absolute path first and then the relative path
-    fixtures.write(relative_path_name, file_data);
+    at.write(relative_path_name, file_data);
     let mut child = scene
         .ucmd()
         .args(&[
@@ -4190,7 +4228,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
 
     child.delay(500);
     let more_data = "more data";
-    fixtures.append(relative_path_name, more_data);
+    at.append(relative_path_name, more_data);
 
     let expected_stdout = format!(
         "==> {0} <==\n\
@@ -4217,16 +4255,16 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_data_is_appende
 
 /// The expected test outputs come from gnu's tail.
 #[test]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_is_truncated() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let file_data = "file data";
     let relative_path_name = "data";
 
-    fixtures.write(relative_path_name, file_data);
-    let absolute_path = fixtures.plus("data").canonicalize().unwrap();
+    at.write(relative_path_name, file_data);
+    let absolute_path = at.plus("data").canonicalize().unwrap();
 
     let mut child = scene
         .ucmd()
@@ -4242,7 +4280,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_is_truncat
 
     child.delay(500);
     let less_data = "less";
-    fixtures.write(relative_path_name, "less");
+    at.write(relative_path_name, "less");
 
     let expected_stdout = format!(
         "==> {0} <==\n\
@@ -4270,17 +4308,17 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_is_truncat
 /// The expected test outputs come from gnu's tail.
 #[test]
 #[cfg(unix)]
-#[cfg(disable_until_fixed)]
+#[ignore = "disabled until fixed"]
 fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let file_data = "file data";
     let path_name = "data";
     let link_name = "link";
 
-    fixtures.write(path_name, file_data);
-    fixtures.symlink_file(path_name, link_name);
+    at.write(path_name, file_data);
+    at.symlink_file(path_name, link_name);
 
     let mut child = scene
         .ucmd()
@@ -4295,21 +4333,17 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
 
     child.delay(500);
     let more_data = "more data";
-    fixtures.append(path_name, more_data);
+    at.append(path_name, more_data);
 
     let expected_stdout = format!(
-        "==> {0} <==\n\
-        {1}\n\
-        ==> {2} <==\n\
-        {1}\n\
-        ==> {0} <==\n\
-        {3}\n\
-        ==> {2} <==\n\
-        {3}",
-        path_name, // 0
-        file_data, // 1
-        link_name, // 2
-        more_data, // 3
+        "==> {path_name} <==\n\
+        {file_data}\n\
+        ==> {link_name} <==\n\
+        {file_data}\n\
+        ==> {path_name} <==\n\
+        {more_data}\n\
+        ==> {link_name} <==\n\
+        {more_data}"
     );
 
     child.make_assertion_with_delay(500).is_alive();
@@ -4319,7 +4353,7 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
         .with_current_output()
         .stdout_only(expected_stdout);
 
-    fixtures.write(path_name, file_data);
+    at.write(path_name, file_data);
     let mut child = scene
         .ucmd()
         .args(&[
@@ -4333,21 +4367,17 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
 
     child.delay(500);
     let more_data = "more data";
-    fixtures.append(path_name, more_data);
+    at.append(path_name, more_data);
 
     let expected_stdout = format!(
-        "==> {0} <==\n\
-        {1}\n\
-        ==> {2} <==\n\
-        {1}\n\
-        ==> {0} <==\n\
-        {3}\n\
-        ==> {2} <==\n\
-        {3}",
-        link_name, // 0
-        file_data, // 1
-        path_name, // 2
-        more_data, // 3
+        "==> {link_name} <==\n\
+        {file_data}\n\
+        ==> {path_name} <==\n\
+        {file_data}\n\
+        ==> {link_name} <==\n\
+        {more_data}\n\
+        ==> {path_name} <==\n\
+        {more_data}"
     );
 
     child.make_assertion_with_delay(500).is_alive();
@@ -4361,14 +4391,13 @@ fn test_follow_when_file_and_symlink_are_pointing_to_same_file_and_append_data()
 #[test]
 fn test_args_when_directory_given_shorthand_big_f_together_with_retry() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let dirname = "dir";
-    fixtures.mkdir(dirname);
+    at.mkdir(dirname);
     let expected_stderr = format!(
-        "tail: error reading '{0}': Is a directory\n\
-         tail: {0}: cannot follow end of this type of file\n",
-        dirname
+        "tail: error reading '{dirname}': Is a directory\n\
+         tail: {dirname}: cannot follow end of this type of file\n"
     );
     let mut child = scene.ucmd().args(&["-F", "--retry", "dir"]).run_no_wait();
 
@@ -4416,16 +4445,18 @@ fn test_args_when_directory_given_shorthand_big_f_together_with_retry() {
 #[cfg(all(
     not(target_vendor = "apple"),
     not(target_os = "windows"),
-    not(target_os = "freebsd")
+    not(target_os = "freebsd"),
+    not(target_os = "openbsd"),
+    not(feature = "feat_selinux") // flaky
 ))]
 fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same_size() {
     let scene = TestScenario::new(util_name!());
-    let fixtures = &scene.fixtures;
+    let at = &scene.fixtures;
 
     let file_data = "file data";
     let relative_path_name = "data";
 
-    fixtures.write(relative_path_name, file_data);
+    at.write(relative_path_name, file_data);
     let absolute_path = scene.fixtures.plus("data").canonicalize().unwrap();
 
     let mut child = scene
@@ -4441,7 +4472,7 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same
 
     child.delay(500);
     let same_data = "same data"; // equal size to file_data
-    fixtures.write(relative_path_name, same_data);
+    at.write(relative_path_name, same_data);
 
     let expected_stdout = format!(
         "==> {0} <==\n\
@@ -4462,7 +4493,6 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same
 }
 
 #[rstest]
-#[case::exponent_exceed_float_max("1.0e100000")]
 #[case::underscore_delimiter("1_000")]
 #[case::only_point(".")]
 #[case::space_in_primes("' '")]
@@ -4478,9 +4508,8 @@ fn test_follow_when_files_are_pointing_to_same_relative_file_and_file_stays_same
 fn test_args_sleep_interval_when_illegal_argument_then_usage_error(#[case] sleep_interval: &str) {
     new_ucmd!()
         .args(&["--sleep-interval", sleep_interval])
-        .run()
-        .usage_error(format!("invalid number of seconds: '{sleep_interval}'"))
-        .code_is(1);
+        .fails_with_code(1)
+        .usage_error(format!("invalid number of seconds: '{sleep_interval}'"));
 }
 
 #[test]
@@ -4534,7 +4563,7 @@ fn test_gnu_args_c() {
         .arg("-12c")
         .pipe_in(format!("x{}z", "y".repeat(12)))
         .succeeds()
-        .stdout_only(&format!("{}z", "y".repeat(11)));
+        .stdout_only(format!("{}z", "y".repeat(11)));
 }
 
 #[test]
@@ -4568,7 +4597,7 @@ fn test_gnu_args_l() {
         .arg("-l")
         .pipe_in(format!("x{}z", "y\n".repeat(10)))
         .succeeds()
-        .stdout_only(&format!("{}z", "y\n".repeat(9)));
+        .stdout_only(format!("{}z", "y\n".repeat(9)));
 }
 
 #[test]
@@ -4655,7 +4684,7 @@ fn test_gnu_args_b() {
         .arg("-b")
         .pipe_in("x\n".repeat(512 * 10 / 2 + 1))
         .succeeds()
-        .stdout_only(&"x\n".repeat(512 * 10 / 2));
+        .stdout_only("x\n".repeat(512 * 10 / 2));
 }
 
 #[test]
@@ -4666,73 +4695,64 @@ fn test_gnu_args_err() {
     scene
         .ucmd()
         .arg("+cl")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: cannot open '+cl' for reading: No such file or directory\n")
-        .code_is(1);
+        .stderr_is("tail: cannot open '+cl' for reading: No such file or directory\n");
     // err-2
     scene
         .ucmd()
         .arg("-cl")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: invalid number of bytes: 'l'\n")
-        .code_is(1);
+        .stderr_is("tail: invalid number of bytes: 'l'\n");
     // err-3
     scene
         .ucmd()
         .arg("+2cz")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: cannot open '+2cz' for reading: No such file or directory\n")
-        .code_is(1);
+        .stderr_is("tail: cannot open '+2cz' for reading: No such file or directory\n");
     // err-4
     scene
         .ucmd()
         .arg("-2cX")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: option used in invalid context -- 2\n")
-        .code_is(1);
+        .stderr_is("tail: option used in invalid context -- 2\n");
     // err-5
     scene
         .ucmd()
         .arg("-c99999999999999999999")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: invalid number of bytes: '99999999999999999999'\n")
-        .code_is(1);
+        .stderr_is("tail: invalid number of bytes: '99999999999999999999'\n");
     // err-6
     scene
         .ucmd()
         .arg("-c --")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: invalid number of bytes: '-'\n")
-        .code_is(1);
+        .stderr_is("tail: invalid number of bytes: '-'\n");
     scene
         .ucmd()
         .arg("-5cz")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: option used in invalid context -- 5\n")
-        .code_is(1);
+        .stderr_is("tail: option used in invalid context -- 5\n");
     scene
         .ucmd()
         .arg("-9999999999999999999b")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: invalid number: '-9999999999999999999b'\n")
-        .code_is(1);
+        .stderr_is("tail: invalid number: '-9999999999999999999b'\n");
     scene
         .ucmd()
         .arg("-999999999999999999999b")
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
         .stderr_is(
             "tail: invalid number: '-999999999999999999999b': Numerical result out of range\n",
-        )
-        .code_is(1);
+        );
 }
 
 #[test]
@@ -4775,10 +4795,9 @@ fn test_obsolete_encoding_unix() {
     scene
         .ucmd()
         .arg(invalid_utf8_arg)
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: bad argument encoding: '-�b'\n")
-        .code_is(1);
+        .stderr_is("tail: bad argument encoding: '-�b'\n");
 }
 
 #[test]
@@ -4793,8 +4812,111 @@ fn test_obsolete_encoding_windows() {
     scene
         .ucmd()
         .arg(&invalid_utf16_arg)
-        .fails()
+        .fails_with_code(1)
         .no_stdout()
-        .stderr_is("tail: bad argument encoding: '-�b'\n")
-        .code_is(1);
+        .stderr_is("tail: bad argument encoding: '-�b'\n");
+}
+
+#[test]
+#[cfg(not(target_vendor = "apple"))] // FIXME: for currently not working platforms
+fn test_following_with_pid() {
+    use std::process::Command;
+
+    let ts = TestScenario::new(util_name!());
+
+    #[cfg(not(windows))]
+    let mut sleep_command = Command::new("sleep")
+        .arg("999d")
+        .spawn()
+        .expect("failed to start sleep command");
+    #[cfg(windows)]
+    let mut sleep_command = Command::new("powershell")
+        .arg("-Command")
+        .arg("Start-Sleep -Seconds 999")
+        .spawn()
+        .expect("failed to start sleep command");
+
+    let sleep_pid = sleep_command.id();
+
+    let at = &ts.fixtures;
+    at.touch("f");
+    // when -f is specified, tail should die after
+    // the pid from --pid also dies
+    let mut child = ts
+        .ucmd()
+        .args(&[
+            "--pid",
+            &sleep_pid.to_string(),
+            "-f",
+            at.plus("f").to_str().unwrap(),
+        ])
+        .stderr_to_stdout()
+        .run_no_wait();
+    child.make_assertion_with_delay(2000).is_alive();
+
+    #[cfg(not(windows))]
+    Command::new("kill")
+        .arg("-9")
+        .arg(sleep_pid.to_string())
+        .output()
+        .expect("failed to kill sleep command");
+    #[cfg(windows)]
+    Command::new("taskkill")
+        .arg("/PID")
+        .arg(sleep_pid.to_string())
+        .arg("/F")
+        .output()
+        .expect("failed to kill sleep command");
+
+    let _ = sleep_command.wait();
+
+    child.make_assertion_with_delay(2000).is_not_alive();
+
+    child.kill();
+}
+
+// This error was first detected when running tail so tail is used here but
+// should fail with any command that takes piped input.
+// See also https://github.com/uutils/coreutils/issues/3895
+#[test]
+#[cfg_attr(not(feature = "expensive_tests"), ignore)]
+fn test_when_piped_input_then_no_broken_pipe() {
+    let ts = TestScenario::new("tail");
+    for i in 0..10000 {
+        dbg!(i);
+        let test_string = "a\nb\n";
+        ts.ucmd()
+            .args(&["-n", "0"])
+            .pipe_in(test_string)
+            .succeeds()
+            .no_stdout()
+            .no_stderr();
+    }
+}
+
+#[test]
+fn test_child_when_run_with_stderr_to_stdout() {
+    let ts = TestScenario::new("tail");
+    let at = &ts.fixtures;
+
+    at.write("data", "file data\n");
+
+    let expected_stdout = "==> data <==\n\
+                                file data\n\
+                                tail: cannot open 'missing' for reading: No such file or directory\n";
+    ts.ucmd()
+        .args(&["data", "missing"])
+        .stderr_to_stdout()
+        .fails()
+        .stdout_only(expected_stdout);
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .pipe_in("hello")
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("tail: No space left on device\n");
 }
diff --git a/tests/by-util/test_tee.rs b/tests/by-util/test_tee.rs
index 6f04edfc37a..e20a22326f5 100644
--- a/tests/by-util/test_tee.rs
+++ b/tests/by-util/test_tee.rs
@@ -2,7 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+#![allow(clippy::borrow_as_ptr)]
+
+use uutests::util::TestScenario;
+use uutests::{at_and_ucmd, new_ucmd, util_name};
+
+use regex::Regex;
+#[cfg(target_os = "linux")]
+use std::fmt::Write;
 
 // tests for basic tee functionality.
 // inspired by:
@@ -12,7 +19,23 @@ use crate::common::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_short_help_is_long_help() {
+    // I can't believe that this test is necessary.
+    let help_short = new_ucmd!()
+        .arg("-h")
+        .succeeds()
+        .no_stderr()
+        .stdout_str()
+        .to_owned();
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .no_stderr()
+        .stdout_is(help_short);
 }
 
 #[test]
@@ -74,7 +97,10 @@ fn test_tee_append() {
 fn test_tee_no_more_writeable_1() {
     // equals to 'tee /dev/full out2 <multi_read' call
     let (at, mut ucmd) = at_and_ucmd!();
-    let content = (1..=10).map(|x| format!("{x}\n")).collect::<String>();
+    let content = (1..=10).fold(String::new(), |mut output, x| {
+        writeln!(output, "{x}").unwrap();
+        output
+    });
     let file_out = "tee_file_out";
 
     ucmd.arg("/dev/full")
@@ -87,6 +113,27 @@ fn test_tee_no_more_writeable_1() {
     assert_eq!(at.read(file_out), content);
 }
 
+#[test]
+fn test_readonly() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let content_tee = "hello";
+    let content_file = "world";
+    let file_out = "tee_file_out";
+    let writable_file = "tee_file_out2";
+    at.write(file_out, content_file);
+    at.set_readonly(file_out);
+    ucmd.arg(file_out)
+        .arg(writable_file)
+        .pipe_in(content_tee)
+        .ignore_stdin_write_error()
+        .fails()
+        .stdout_is(content_tee)
+        // Windows says "Access is denied" for some reason.
+        .stderr_matches(&Regex::new("(Permission|Access is) denied").unwrap());
+    assert_eq!(at.read(file_out), content_file);
+    assert_eq!(at.read(writable_file), content_tee);
+}
+
 #[test]
 #[cfg(target_os = "linux")]
 fn test_tee_no_more_writeable_2() {
@@ -94,7 +141,10 @@ fn test_tee_no_more_writeable_2() {
     // but currently there is no way to redirect stdout to /dev/full
     // so this test is disabled
     let (_at, mut ucmd) = at_and_ucmd!();
-    let _content = (1..=10).map(|x| format!("{x}\n")).collect::<String>();
+    let _content = (1..=10).fold(String::new(), |mut output, x| {
+        let _ = writeln!(output, "{x}");
+        output
+    });
     let file_out_a = "tee_file_out_a";
     let file_out_b = "tee_file_out_b";
 
@@ -112,10 +162,15 @@ fn test_tee_no_more_writeable_2() {
 
 #[cfg(target_os = "linux")]
 mod linux_only {
-    use crate::common::util::{AtPath, TestScenario, UCommand};
+    use uutests::util::{AtPath, CmdResult, TestScenario, UCommand};
 
+    use std::fmt::Write;
     use std::fs::File;
-    use std::process::{Output, Stdio};
+    use std::process::Stdio;
+    use std::time::Duration;
+    use uutests::at_and_ucmd;
+    use uutests::new_ucmd;
+    use uutests::util_name;
 
     fn make_broken_pipe() -> File {
         use libc::c_int;
@@ -123,7 +178,7 @@ mod linux_only {
 
         let mut fds: [c_int; 2] = [0, 0];
         assert!(
-            (unsafe { libc::pipe(&mut fds as *mut c_int) } == 0),
+            (unsafe { libc::pipe(std::ptr::from_mut::<c_int>(&mut fds[0])) } == 0),
             "Failed to create pipe"
         );
 
@@ -134,61 +189,76 @@ mod linux_only {
         unsafe { File::from_raw_fd(fds[1]) }
     }
 
-    fn run_tee(proc: &mut UCommand) -> (String, Output) {
-        let content = (1..=100_000).map(|x| format!("{x}\n")).collect::<String>();
+    fn make_hanging_read() -> File {
+        use libc::c_int;
+        use std::os::unix::io::FromRawFd;
 
-        #[allow(deprecated)]
-        let output = proc
+        let mut fds: [c_int; 2] = [0, 0];
+        assert!(
+            (unsafe { libc::pipe(std::ptr::from_mut::<c_int>(&mut fds[0])) } == 0),
+            "Failed to create pipe"
+        );
+
+        // PURPOSELY leak the write end of the pipe, so the read end hangs.
+
+        // Return the read end of the pipe
+        unsafe { File::from_raw_fd(fds[0]) }
+    }
+
+    fn run_tee(proc: &mut UCommand) -> (String, CmdResult) {
+        let content = (1..=100_000).fold(String::new(), |mut output, x| {
+            let _ = writeln!(output, "{x}");
+            output
+        });
+
+        let result = proc
             .ignore_stdin_write_error()
             .set_stdin(Stdio::piped())
             .run_no_wait()
-            .pipe_in_and_wait_with_output(content.as_bytes());
+            .pipe_in_and_wait(content.as_bytes());
 
-        (content, output)
+        (content, result)
     }
 
-    fn expect_success(output: &Output) {
+    fn expect_success(result: &CmdResult) {
         assert!(
-            output.status.success(),
+            result.succeeded(),
             "Command was expected to succeed.\nstdout = {}\n stderr = {}",
-            std::str::from_utf8(&output.stdout).unwrap(),
-            std::str::from_utf8(&output.stderr).unwrap(),
+            std::str::from_utf8(result.stdout()).unwrap(),
+            std::str::from_utf8(result.stderr()).unwrap(),
         );
         assert!(
-            output.stderr.is_empty(),
+            result.stderr_str().is_empty(),
             "Unexpected data on stderr.\n stderr = {}",
-            std::str::from_utf8(&output.stderr).unwrap(),
+            std::str::from_utf8(result.stderr()).unwrap(),
         );
     }
 
-    fn expect_failure(output: &Output, message: &str) {
+    fn expect_failure(result: &CmdResult, message: &str) {
         assert!(
-            !output.status.success(),
+            !result.succeeded(),
             "Command was expected to fail.\nstdout = {}\n stderr = {}",
-            std::str::from_utf8(&output.stdout).unwrap(),
-            std::str::from_utf8(&output.stderr).unwrap(),
+            std::str::from_utf8(result.stdout()).unwrap(),
+            std::str::from_utf8(result.stderr()).unwrap(),
         );
         assert!(
-            std::str::from_utf8(&output.stderr)
-                .unwrap()
-                .contains(message),
-            "Expected to see error message fragment {} in stderr, but did not.\n stderr = {}",
-            message,
-            std::str::from_utf8(&output.stderr).unwrap(),
+            result.stderr_str().contains(message),
+            "Expected to see error message fragment {message} in stderr, but did not.\n stderr = {}",
+            std::str::from_utf8(result.stderr()).unwrap(),
         );
     }
 
-    fn expect_silent_failure(output: &Output) {
+    fn expect_silent_failure(result: &CmdResult) {
         assert!(
-            !output.status.success(),
+            !result.succeeded(),
             "Command was expected to fail.\nstdout = {}\n stderr = {}",
-            std::str::from_utf8(&output.stdout).unwrap(),
-            std::str::from_utf8(&output.stderr).unwrap(),
+            std::str::from_utf8(result.stdout()).unwrap(),
+            std::str::from_utf8(result.stderr()).unwrap(),
         );
         assert!(
-            output.stderr.is_empty(),
+            result.stderr_str().is_empty(),
             "Unexpected data on stderr.\n stderr = {}",
-            std::str::from_utf8(&output.stderr).unwrap(),
+            std::str::from_utf8(result.stderr()).unwrap(),
         );
     }
 
@@ -203,13 +273,14 @@ mod linux_only {
         let compare = at.read(name);
         assert!(
             compare.len() < contents.len(),
-            "Too many bytes ({}) written to {} (should be a short count from {})",
+            "Too many bytes ({}) written to {name} (should be a short count from {})",
             compare.len(),
-            name,
             contents.len()
         );
-        assert!(contents.starts_with(&compare),
-                "Expected truncated output to be a prefix of the correct output, but it isn't.\n Correct: {contents}\n Compare: {compare}");
+        assert!(
+            contents.starts_with(&compare),
+            "Expected truncated output to be a prefix of the correct output, but it isn't.\n Correct: {contents}\n Compare: {compare}"
+        );
     }
 
     #[test]
@@ -277,6 +348,23 @@ mod linux_only {
         expect_correct(file_out_a, &at, content.as_str());
     }
 
+    #[test]
+    fn test_pipe_error_warn_nopipe_3_shortcut() {
+        let (at, mut ucmd) = at_and_ucmd!();
+
+        let file_out_a = "tee_file_out_a";
+
+        let proc = ucmd
+            .arg("--output-error=warn-")
+            .arg(file_out_a)
+            .set_stdout(make_broken_pipe());
+
+        let (content, output) = run_tee(proc);
+
+        expect_success(&output);
+        expect_correct(file_out_a, &at, content.as_str());
+    }
+
     #[test]
     fn test_pipe_error_warn() {
         let (at, mut ucmd) = at_and_ucmd!();
@@ -328,6 +416,23 @@ mod linux_only {
         expect_correct(file_out_a, &at, content.as_str());
     }
 
+    #[test]
+    fn test_pipe_error_exit_nopipe_shortcut() {
+        let (at, mut ucmd) = at_and_ucmd!();
+
+        let file_out_a = "tee_file_out_a";
+
+        let proc = ucmd
+            .arg("--output-error=exit-nop")
+            .arg(file_out_a)
+            .set_stdout(make_broken_pipe());
+
+        let (content, output) = run_tee(proc);
+
+        expect_success(&output);
+        expect_correct(file_out_a, &at, content.as_str());
+    }
+
     #[test]
     fn test_space_error_default() {
         let (at, mut ucmd) = at_and_ucmd!();
@@ -449,4 +554,31 @@ mod linux_only {
         expect_failure(&output, "No space left");
         expect_short(file_out_a, &at, content.as_str());
     }
+
+    #[test]
+    fn test_pipe_mode_broken_pipe_only() {
+        new_ucmd!()
+            .timeout(Duration::from_secs(1))
+            .arg("-p")
+            .set_stdin(make_hanging_read())
+            .set_stdout(make_broken_pipe())
+            .succeeds();
+    }
+
+    #[test]
+    fn test_pipe_mode_broken_pipe_file() {
+        let (at, mut ucmd) = at_and_ucmd!();
+
+        let file_out_a = "tee_file_out_a";
+
+        let proc = ucmd
+            .arg("-p")
+            .arg(file_out_a)
+            .set_stdout(make_broken_pipe());
+
+        let (content, output) = run_tee(proc);
+
+        expect_success(&output);
+        expect_correct(file_out_a, &at, content.as_str());
+    }
 }
diff --git a/tests/by-util/test_test.rs b/tests/by-util/test_test.rs
index 2f36a805c36..1dba782f540 100644
--- a/tests/by-util/test_test.rs
+++ b/tests/by-util/test_test.rs
@@ -5,17 +5,19 @@
 
 // spell-checker:ignore (words) egid euid pseudofloat
 
-use crate::common::util::TestScenario;
-use std::thread::sleep;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_empty_test_equivalent_to_false() {
-    new_ucmd!().run().code_is(1);
+    new_ucmd!().fails_with_code(1);
 }
 
 #[test]
 fn test_empty_string_is_false() {
-    new_ucmd!().arg("").run().code_is(1);
+    new_ucmd!().arg("").fails_with_code(1);
 }
 
 #[test]
@@ -56,24 +58,24 @@ fn test_some_literals() {
 
     // run the inverse of all these tests
     for test in &tests {
-        scenario.ucmd().arg("!").arg(test).run().code_is(1);
+        scenario.ucmd().arg("!").arg(test).fails_with_code(1);
     }
 }
 
 #[test]
 fn test_double_not_is_false() {
-    new_ucmd!().args(&["!", "!"]).run().code_is(1);
+    new_ucmd!().args(&["!", "!"]).fails_with_code(1);
 }
 
 #[test]
 fn test_and_not_is_false() {
-    new_ucmd!().args(&["-a", "!"]).run().code_is(1);
+    new_ucmd!().args(&["-a", "!"]).fails_with_code(2);
 }
 
 #[test]
 fn test_not_and_is_false() {
     // `-a` is a literal here & has nonzero length
-    new_ucmd!().args(&["!", "-a"]).run().code_is(1);
+    new_ucmd!().args(&["!", "-a"]).fails_with_code(1);
 }
 
 #[test]
@@ -86,17 +88,27 @@ fn test_simple_or() {
     new_ucmd!().args(&["foo", "-o", ""]).succeeds();
 }
 
+#[test]
+fn test_errors_miss_and_or() {
+    new_ucmd!()
+        .args(&["-o", "arg"])
+        .fails_with_code(2)
+        .stderr_contains("'-o': unary operator expected");
+    new_ucmd!()
+        .args(&["-a", "arg"])
+        .fails()
+        .stderr_contains("'-a': unary operator expected");
+}
+
 #[test]
 fn test_negated_or() {
     new_ucmd!()
         .args(&["!", "foo", "-o", "bar"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
     new_ucmd!().args(&["foo", "-o", "!", "bar"]).succeeds();
     new_ucmd!()
         .args(&["!", "foo", "-o", "!", "bar"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -107,10 +119,10 @@ fn test_string_length_of_nothing() {
 
 #[test]
 fn test_string_length_of_empty() {
-    new_ucmd!().args(&["-n", ""]).run().code_is(1);
+    new_ucmd!().args(&["-n", ""]).fails_with_code(1);
 
     // STRING equivalent to -n STRING
-    new_ucmd!().arg("").run().code_is(1);
+    new_ucmd!().arg("").fails_with_code(1);
 }
 
 #[test]
@@ -131,14 +143,14 @@ fn test_zero_len_equals_zero_len() {
 
 #[test]
 fn test_zero_len_not_equals_zero_len_is_false() {
-    new_ucmd!().args(&["", "!=", ""]).run().code_is(1);
+    new_ucmd!().args(&["", "!=", ""]).fails_with_code(1);
 }
 
 #[test]
 fn test_double_equal_is_string_comparison_op() {
     // undocumented but part of the GNU test suite
     new_ucmd!().args(&["t", "==", "t"]).succeeds();
-    new_ucmd!().args(&["t", "==", "f"]).run().code_is(1);
+    new_ucmd!().args(&["t", "==", "f"]).fails_with_code(1);
 }
 
 #[test]
@@ -160,7 +172,7 @@ fn test_string_comparison() {
 
     // run the inverse of all these tests
     for test in &tests {
-        scenario.ucmd().arg("!").args(&test[..]).run().code_is(1);
+        scenario.ucmd().arg("!").args(&test[..]).fails_with_code(1);
     }
 }
 
@@ -169,8 +181,7 @@ fn test_string_comparison() {
 fn test_dangling_string_comparison_is_error() {
     new_ucmd!()
         .args(&["missing_something", "="])
-        .run()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("test: missing argument after '='");
 }
 
@@ -192,7 +203,7 @@ fn test_string_operator_is_literal_after_bang() {
     ];
 
     for test in &tests {
-        scenario.ucmd().args(&test[..]).run().code_is(1);
+        scenario.ucmd().args(&test[..]).fails_with_code(1);
     }
 }
 
@@ -241,7 +252,7 @@ fn test_some_int_compares() {
 
     // run the inverse of all these tests
     for test in &tests {
-        scenario.ucmd().arg("!").args(&test[..]).run().code_is(1);
+        scenario.ucmd().arg("!").args(&test[..]).fails_with_code(1);
     }
 }
 
@@ -273,7 +284,7 @@ fn test_negative_int_compare() {
 
     // run the inverse of all these tests
     for test in &tests {
-        scenario.ucmd().arg("!").args(&test[..]).run().code_is(1);
+        scenario.ucmd().arg("!").args(&test[..]).fails_with_code(1);
     }
 }
 
@@ -281,8 +292,7 @@ fn test_negative_int_compare() {
 fn test_float_inequality_is_error() {
     new_ucmd!()
         .args(&["123.45", "-ge", "6"])
-        .run()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("test: invalid integer '123.45'\n");
 }
 
@@ -297,14 +307,12 @@ fn test_invalid_utf8_integer_compare() {
 
     new_ucmd!()
         .args(&[OsStr::new("123"), OsStr::new("-ne"), arg])
-        .run()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("test: invalid integer $'fo\\x80o'\n");
 
     new_ucmd!()
         .args(&[arg, OsStr::new("-eq"), OsStr::new("456")])
-        .run()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("test: invalid integer $'fo\\x80o'\n");
 }
 
@@ -317,17 +325,15 @@ fn test_file_is_itself() {
 }
 
 #[test]
-#[cfg(not(any(target_env = "musl", target_os = "android")))]
+#[cfg(not(target_os = "android"))]
 fn test_file_is_newer_than_and_older_than_itself() {
     // odd but matches GNU
     new_ucmd!()
         .args(&["regular_file", "-nt", "regular_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
     new_ucmd!()
         .args(&["regular_file", "-ot", "regular_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -337,7 +343,7 @@ fn test_non_existing_files() {
     let result = scenario
         .ucmd()
         .args(&["newer_file", "-nt", "regular_file"])
-        .fails();
+        .fails_with_code(1);
     assert!(result.stderr().is_empty());
 }
 
@@ -364,23 +370,33 @@ fn test_same_device_inode() {
 }
 
 #[test]
-#[cfg(not(any(target_env = "musl", target_os = "android")))]
-// musl: creation time is not available on this platform currently
+#[cfg(not(target_os = "android"))]
 fn test_newer_file() {
     let scenario = TestScenario::new(util_name!());
 
-    scenario.fixtures.touch("regular_file");
-    sleep(std::time::Duration::from_millis(1000));
+    let older_file = scenario.fixtures.make_file("older_file");
+    older_file.set_modified(std::time::UNIX_EPOCH).unwrap();
     scenario.fixtures.touch("newer_file");
 
     scenario
         .ucmd()
-        .args(&["newer_file", "-nt", "regular_file"])
+        .args(&["newer_file", "-nt", "older_file"])
         .succeeds();
+
+    scenario
+        .ucmd()
+        .args(&["older_file", "-nt", "newer_file"])
+        .fails();
+
     scenario
         .ucmd()
-        .args(&["newer_file", "-ot", "regular_file"])
+        .args(&["older_file", "-ot", "newer_file"])
         .succeeds();
+
+    scenario
+        .ucmd()
+        .args(&["newer_file", "-ot", "older_file"])
+        .fails();
 }
 
 #[test]
@@ -392,16 +408,14 @@ fn test_file_exists() {
 fn test_nonexistent_file_does_not_exist() {
     new_ucmd!()
         .args(&["-e", "nonexistent_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
 fn test_nonexistent_file_is_not_regular() {
     new_ucmd!()
         .args(&["-f", "nonexistent_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -492,8 +506,7 @@ fn test_is_not_empty() {
 fn test_nonexistent_file_size_test_is_false() {
     new_ucmd!()
         .args(&["-s", "nonexistent_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -543,9 +556,9 @@ fn test_nonexistent_file_is_not_symlink() {
 }
 
 #[test]
-// FixME: freebsd fails with 'chmod: sticky_file: Inappropriate file type or format'
+// Only the superuser is allowed to set the sticky bit on files on FreeBSD/OpenBSD.
 // Windows has no concept of sticky bit
-#[cfg(not(any(windows, target_os = "freebsd")))]
+#[cfg(not(any(windows, target_os = "freebsd", target_os = "openbsd")))]
 fn test_file_is_sticky() {
     let scenario = TestScenario::new(util_name!());
     let mut ucmd = scenario.ucmd();
@@ -559,12 +572,12 @@ fn test_file_is_sticky() {
 
 #[test]
 fn test_file_is_not_sticky() {
-    new_ucmd!().args(&["-k", "regular_file"]).run().code_is(1);
+    new_ucmd!().args(&["-k", "regular_file"]).fails_with_code(1);
 }
 
 #[test]
 fn test_solo_empty_parenthetical_is_error() {
-    new_ucmd!().args(&["(", ")"]).run().code_is(2);
+    new_ucmd!().args(&["(", ")"]).fails_with_code(2);
 }
 
 #[test]
@@ -602,8 +615,7 @@ fn test_parenthesized_literal() {
             .arg("(")
             .arg(test)
             .arg(")")
-            .run()
-            .code_is(1);
+            .fails_with_code(1);
     }
 }
 
@@ -611,7 +623,7 @@ fn test_parenthesized_literal() {
 fn test_parenthesized_op_compares_literal_parenthesis() {
     // ensure we aren’t treating this case as “string length of literal equal
     // sign�
-    new_ucmd!().args(&["(", "=", ")"]).run().code_is(1);
+    new_ucmd!().args(&["(", "=", ")"]).fails_with_code(1);
 }
 
 #[test]
@@ -632,13 +644,13 @@ fn test_parenthesized_string_comparison() {
 
     // run the inverse of all these tests
     for test in &tests {
-        scenario.ucmd().arg("!").args(&test[..]).run().code_is(1);
+        scenario.ucmd().arg("!").args(&test[..]).fails_with_code(1);
     }
 }
 
 #[test]
 fn test_parenthesized_right_parenthesis_as_literal() {
-    new_ucmd!().args(&["(", "-f", ")", ")"]).run().code_is(1);
+    new_ucmd!().args(&["(", "-f", ")", ")"]).fails_with_code(1);
 }
 
 #[test]
@@ -652,12 +664,11 @@ fn test_file_owned_by_euid() {
 fn test_nonexistent_file_not_owned_by_euid() {
     new_ucmd!()
         .args(&["-O", "nonexistent_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_file_not_owned_by_euid() {
     new_ucmd!()
         .args(&["-f", "/bin/sh", "-a", "!", "-O", "/bin/sh"])
@@ -665,9 +676,31 @@ fn test_file_not_owned_by_euid() {
 }
 
 #[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_file_owned_by_egid() {
-    new_ucmd!().args(&["-G", "regular_file"]).succeeds();
+    // On some platforms (mostly the BSDs) the test fixture files copied to the
+    // /tmp directory will have a different gid than the current egid (due to
+    // the sticky bit set on the /tmp directory). Fix this before running the
+    // test command.
+    use std::ffi::CString;
+    use std::os::unix::ffi::OsStrExt;
+    use std::os::unix::fs::MetadataExt;
+    use uucore::process::getegid;
+    let scene = TestScenario::new(util_name!());
+    let at = &scene.fixtures;
+
+    let metadata = at.metadata("regular_file");
+    let file_gid = metadata.gid();
+    let user_gid = getegid();
+
+    if user_gid != file_gid {
+        let file_metadata_uid = metadata.uid();
+        let path = CString::new(at.plus("regular_file").as_os_str().as_bytes()).expect("bad path");
+        let r = unsafe { libc::chown(path.as_ptr(), file_metadata_uid, user_gid) };
+        assert_ne!(r, -1);
+    }
+
+    scene.ucmd().args(&["-G", "regular_file"]).succeeds();
 }
 
 #[test]
@@ -675,15 +708,23 @@ fn test_file_owned_by_egid() {
 fn test_nonexistent_file_not_owned_by_egid() {
     new_ucmd!()
         .args(&["-G", "nonexistent_file"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
-#[cfg(all(not(windows), not(target_os = "freebsd")))]
+#[cfg(not(windows))]
 fn test_file_not_owned_by_egid() {
+    let target_file = if cfg!(target_os = "freebsd") {
+        // The coreutils test runner user has a primary group id of "wheel",
+        // which matches the gid of /bin/sh, so use /sbin/shutdown which has gid
+        // of "operator".
+        "/sbin/shutdown"
+    } else {
+        "/bin/sh"
+    };
+
     new_ucmd!()
-        .args(&["-f", "/bin/sh", "-a", "!", "-G", "/bin/sh"])
+        .args(&["-f", target_file, "-a", "!", "-G", target_file])
         .succeeds();
 }
 
@@ -696,8 +737,7 @@ fn test_op_precedence_and_or_1() {
 fn test_op_precedence_and_or_1_overridden_by_parentheses() {
     new_ucmd!()
         .args(&["(", " ", "-o", "", ")", "-a", ""])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -711,8 +751,7 @@ fn test_op_precedence_and_or_2() {
 fn test_op_precedence_and_or_2_overridden_by_parentheses() {
     new_ucmd!()
         .args(&["", "-a", "(", "", "-o", " ", ")", "-a", " "])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -737,7 +776,7 @@ fn test_negated_boolean_precedence() {
     ];
 
     for test in &negative_tests {
-        scenario.ucmd().args(&test[..]).run().code_is(1);
+        scenario.ucmd().args(&test[..]).fails_with_code(1);
     }
 }
 
@@ -749,26 +788,22 @@ fn test_bang_bool_op_precedence() {
 
     new_ucmd!()
         .args(&["!", "a value", "-o", "another value"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 
     // Introducing a UOP — even one that is equivalent to a bare string — causes
     // bang to invert only the first term
     new_ucmd!()
         .args(&["!", "-n", "", "-a", ""])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
     new_ucmd!()
         .args(&["!", "", "-a", "-n", ""])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 
     // for compound Boolean expressions, bang inverts the _next_ expression
     // only, not the entire compound expression
     new_ucmd!()
         .args(&["!", "", "-a", "", "-a", ""])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 
     // parentheses can override this
     new_ucmd!()
@@ -781,8 +816,7 @@ fn test_inverted_parenthetical_bool_op_precedence() {
     // For a Boolean combination of two literals, bang inverts the entire expression
     new_ucmd!()
         .args(&["!", "a value", "-o", "another value"])
-        .run()
-        .code_is(1);
+        .fails_with_code(1);
 
     // only the parenthetical is inverted, not the entire expression
     new_ucmd!()
@@ -795,8 +829,7 @@ fn test_inverted_parenthetical_bool_op_precedence() {
 fn test_dangling_parenthesis() {
     new_ucmd!()
         .args(&["(", "(", "a", "!=", "b", ")", "-o", "-n", "c"])
-        .run()
-        .code_is(2);
+        .fails_with_code(2);
     new_ucmd!()
         .args(&["(", "(", "a", "!=", "b", ")", "-o", "-n", "c", ")"])
         .succeeds();
@@ -816,29 +849,27 @@ fn test_complicated_parenthesized_expression() {
 fn test_erroneous_parenthesized_expression() {
     new_ucmd!()
         .args(&["a", "!=", "(", "b", "-a", "b", ")", "!=", "c"])
-        .run()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("test: extra argument 'b'\n");
 }
 
 #[test]
 fn test_or_as_filename() {
-    new_ucmd!().args(&["x", "-a", "-z", "-o"]).run().code_is(1);
+    new_ucmd!()
+        .args(&["x", "-a", "-z", "-o"])
+        .fails_with_code(1);
 }
 
 #[test]
 #[ignore = "TODO: Busybox has this working"]
 fn test_filename_or_with_equal() {
-    new_ucmd!()
-        .args(&["-f", "=", "a", "-o", "b"])
-        .run()
-        .code_is(0);
+    new_ucmd!().args(&["-f", "=", "a", "-o", "b"]).succeeds();
 }
 
 #[test]
 #[ignore = "GNU considers this an error"]
 fn test_string_length_and_nothing() {
-    new_ucmd!().args(&["-n", "a", "-a"]).run().code_is(2);
+    new_ucmd!().args(&["-n", "a", "-a"]).fails_with_code(2);
 }
 
 #[test]
@@ -854,7 +885,7 @@ fn test_bracket_syntax_failure() {
     let scenario = TestScenario::new("[");
     let mut ucmd = scenario.ucmd();
 
-    ucmd.args(&["1", "-eq", "2", "]"]).run().code_is(1);
+    ucmd.args(&["1", "-eq", "2", "]"]).fails_with_code(1);
 }
 
 #[test]
@@ -864,8 +895,7 @@ fn test_bracket_syntax_missing_right_bracket() {
 
     // Missing closing bracket takes precedence over other possible errors.
     ucmd.args(&["1", "-eq"])
-        .run()
-        .code_is(2)
+        .fails_with_code(2)
         .stderr_is("[: missing ']'\n");
 }
 
@@ -884,21 +914,39 @@ fn test_bracket_syntax_version() {
 
     ucmd.arg("--version")
         .succeeds()
-        .stdout_matches(&r"\[ \d+\.\d+\.\d+".parse().unwrap());
+        .stdout_matches(&r"\[ \(uutils coreutils\) \d+\.\d+\.\d+".parse().unwrap());
 }
 
 #[test]
 #[allow(non_snake_case)]
 #[cfg(unix)]
 fn test_file_N() {
+    use std::{fs::FileTimes, time::Duration};
+
     let scene = TestScenario::new(util_name!());
     let at = &scene.fixtures;
-    scene.ucmd().args(&["-N", "regular_file"]).fails();
-    // The file will have different create/modified data
-    // so, test -N will return 0
-    sleep(std::time::Duration::from_millis(1000));
-    at.touch("regular_file");
-    scene.ucmd().args(&["-N", "regular_file"]).succeeds();
+
+    let f = at.make_file("file");
+
+    // Set the times so that the file is accessed _after_ being modified
+    // => test -N return false.
+    let times = FileTimes::new()
+        .set_accessed(std::time::UNIX_EPOCH + Duration::from_secs(123))
+        .set_modified(std::time::UNIX_EPOCH);
+    f.set_times(times).unwrap();
+    // TODO: stat call for debugging #7570, remove?
+    println!("{}", scene.cmd_shell("stat file").succeeds().stdout_str());
+    scene.ucmd().args(&["-N", "file"]).fails();
+
+    // Set the times so that the file is modified _after_ being accessed
+    // => test -N return true.
+    let times = FileTimes::new()
+        .set_accessed(std::time::UNIX_EPOCH)
+        .set_modified(std::time::UNIX_EPOCH + Duration::from_secs(123));
+    f.set_times(times).unwrap();
+    // TODO: stat call for debugging #7570, remove?
+    println!("{}", scene.cmd_shell("stat file").succeeds().stdout_str());
+    scene.ucmd().args(&["-N", "file"]).succeeds();
 }
 
 #[test]
@@ -936,3 +984,36 @@ fn test_missing_argument_after() {
         "test: missing argument after 'foo'"
     );
 }
+
+#[test]
+fn test_string_lt_gt_operator() {
+    let items = [
+        ("a", "b"),
+        ("a", "aa"),
+        ("a", "a "),
+        ("a", "a b"),
+        ("", "b"),
+        ("a", "ä"),
+    ];
+    for (left, right) in items {
+        new_ucmd!().args(&[left, "<", right]).succeeds().no_output();
+        new_ucmd!()
+            .args(&[right, "<", left])
+            .fails_with_code(1)
+            .no_output();
+
+        new_ucmd!().args(&[right, ">", left]).succeeds().no_output();
+        new_ucmd!()
+            .args(&[left, ">", right])
+            .fails_with_code(1)
+            .no_output();
+    }
+    new_ucmd!()
+        .args(&["", "<", ""])
+        .fails_with_code(1)
+        .no_output();
+    new_ucmd!()
+        .args(&["", ">", ""])
+        .fails_with_code(1)
+        .no_output();
+}
diff --git a/tests/by-util/test_timeout.rs b/tests/by-util/test_timeout.rs
index 6c4a00eb552..ee8e9d18f94 100644
--- a/tests/by-util/test_timeout.rs
+++ b/tests/by-util/test_timeout.rs
@@ -1,13 +1,20 @@
+use std::time::Duration;
+
 // 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.
 // spell-checker:ignore dont
-use crate::common::util::TestScenario;
+use rstest::rstest;
+
+use uucore::display::Quotable;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(125);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(125);
 }
 
 // FIXME: this depends on the system having true and false in PATH
@@ -17,24 +24,24 @@ fn test_invalid_arg() {
 fn test_subcommand_return_code() {
     new_ucmd!().arg("1").arg("true").succeeds();
 
-    new_ucmd!().arg("1").arg("false").run().code_is(1);
+    new_ucmd!().arg("1").arg("false").fails_with_code(1);
 }
 
-#[test]
-fn test_invalid_time_interval() {
+#[rstest]
+#[case::alphabetic("xyz")]
+#[case::single_quote("'1")]
+fn test_invalid_time_interval(#[case] input: &str) {
     new_ucmd!()
-        .args(&["xyz", "sleep", "0"])
-        .fails()
-        .code_is(125)
-        .usage_error("invalid time interval 'xyz'");
+        .args(&[input, "sleep", "0"])
+        .fails_with_code(125)
+        .usage_error(format!("invalid time interval {}", input.quote()));
 }
 
 #[test]
 fn test_invalid_kill_after() {
     new_ucmd!()
         .args(&["-k", "xyz", "1", "sleep", "0"])
-        .fails()
-        .code_is(125)
+        .fails_with_code(125)
         .usage_error("invalid time interval 'xyz'");
 }
 
@@ -65,13 +72,11 @@ fn test_zero_timeout() {
     new_ucmd!()
         .args(&["-v", "0", "sleep", ".1"])
         .succeeds()
-        .no_stderr()
-        .no_stdout();
+        .no_output();
     new_ucmd!()
         .args(&["-v", "0", "-s0", "-k0", "sleep", ".1"])
         .succeeds()
-        .no_stderr()
-        .no_stdout();
+        .no_output();
 }
 
 #[test]
@@ -79,18 +84,40 @@ fn test_command_empty_args() {
     new_ucmd!()
         .args(&["", ""])
         .fails()
-        .stderr_contains("timeout: empty string");
+        .stderr_contains("timeout: invalid time interval ''");
+}
+
+#[test]
+fn test_foreground() {
+    for arg in ["-f", "--foreground"] {
+        new_ucmd!()
+            .args(&[arg, ".1", "sleep", "10"])
+            .fails_with_code(124)
+            .no_output();
+    }
 }
 
 #[test]
 fn test_preserve_status() {
-    new_ucmd!()
-        .args(&["--preserve-status", ".1", "sleep", "10"])
-        .fails()
-        // 128 + SIGTERM = 128 + 15
-        .code_is(128 + 15)
-        .no_stderr()
-        .no_stdout();
+    for arg in ["-p", "--preserve-status"] {
+        new_ucmd!()
+            .args(&[arg, ".1", "sleep", "10"])
+            // 128 + SIGTERM = 128 + 15
+            .fails_with_code(128 + 15)
+            .no_output();
+    }
+}
+
+#[test]
+fn test_preserve_status_even_when_send_signal() {
+    // When sending CONT signal, process doesn't get killed or stopped.
+    // So, expected result is success and code 0.
+    for cont_spelling in ["CONT", "cOnT", "SIGcont"] {
+        new_ucmd!()
+            .args(&["-s", cont_spelling, "--preserve-status", ".1", "sleep", "2"])
+            .succeeds()
+            .no_output();
+    }
 }
 
 #[test]
@@ -98,15 +125,29 @@ fn test_dont_overflow() {
     new_ucmd!()
         .args(&["9223372036854775808d", "sleep", "0"])
         .succeeds()
-        .code_is(0)
-        .no_stderr()
-        .no_stdout();
+        .no_output();
     new_ucmd!()
         .args(&["-k", "9223372036854775808d", "10", "sleep", "0"])
         .succeeds()
-        .code_is(0)
-        .no_stderr()
-        .no_stdout();
+        .no_output();
+}
+
+#[test]
+fn test_dont_underflow() {
+    new_ucmd!()
+        .args(&[".0000000001", "sleep", "1"])
+        .fails_with_code(124)
+        .no_output();
+    new_ucmd!()
+        .args(&["1e-100", "sleep", "1"])
+        .fails_with_code(124)
+        .no_output();
+    // Unlike GNU coreutils, we underflow to 1ns for very short timeouts.
+    // https://debbugs.gnu.org/cgi/bugreport.cgi?bug=77535
+    new_ucmd!()
+        .args(&["1e-18172487393827593258", "sleep", "1"])
+        .fails_with_code(124)
+        .no_output();
 }
 
 #[test]
@@ -139,8 +180,7 @@ fn test_kill_after_long() {
     new_ucmd!()
         .args(&["--kill-after=1", "1", "sleep", "0"])
         .succeeds()
-        .no_stdout()
-        .no_stderr();
+        .no_output();
 }
 
 #[test]
@@ -151,10 +191,18 @@ fn test_kill_subprocess() {
             "10",
             "sh",
             "-c",
-            "sh -c \"trap 'echo xyz' TERM; sleep 30\"",
+            "trap 'echo inside_trap' TERM; sleep 30",
         ])
-        .fails()
-        .code_is(124)
-        .stdout_contains("xyz")
+        .fails_with_code(124)
+        .stdout_contains("inside_trap")
         .stderr_contains("Terminated");
 }
+
+#[test]
+fn test_hex_timeout_ending_with_d() {
+    new_ucmd!()
+        .args(&["0x0.1d", "sleep", "10"])
+        .timeout(Duration::from_secs(1))
+        .fails_with_code(124)
+        .no_output();
+}
diff --git a/tests/by-util/test_touch.rs b/tests/by-util/test_touch.rs
index 942446a3383..746d2170412 100644
--- a/tests/by-util/test_touch.rs
+++ b/tests/by-util/test_touch.rs
@@ -4,11 +4,15 @@
 // file that was distributed with this source code.
 // spell-checker:ignore (formats) cymdhm cymdhms mdhm mdhms ymdhm ymdhms datetime mktime
 
-use crate::common::util::{AtPath, TestScenario};
-use chrono::TimeZone;
-use filetime::{self, FileTime};
+use filetime::FileTime;
+#[cfg(not(target_os = "freebsd"))]
+use filetime::set_symlink_file_times;
 use std::fs::remove_file;
 use std::path::PathBuf;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::{AtPath, TestScenario};
+use uutests::util_name;
 
 fn get_file_times(at: &AtPath, path: &str) -> (FileTime, FileTime) {
     let m = at.metadata(path);
@@ -32,13 +36,16 @@ fn set_file_times(at: &AtPath, path: &str, atime: FileTime, mtime: FileTime) {
 }
 
 fn str_to_filetime(format: &str, s: &str) -> FileTime {
-    let tm = chrono::Utc.datetime_from_str(s, format).unwrap();
-    FileTime::from_unix_time(tm.timestamp(), tm.timestamp_subsec_nanos())
+    let tm = chrono::NaiveDateTime::parse_from_str(s, format).unwrap();
+    FileTime::from_unix_time(
+        tm.and_utc().timestamp(),
+        tm.and_utc().timestamp_subsec_nanos(),
+    )
 }
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -114,6 +121,69 @@ fn test_touch_set_mdhms_time() {
     assert_eq!(mtime.unix_seconds() - start_of_year.unix_seconds(), 45296);
 }
 
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn test_touch_2_digit_years_68() {
+    // 68 and before are 20xx
+    // it will fail on 32 bits, because of wraparound for anything after
+    // 2038-01-19
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_set_two_digit_68_time";
+
+    ucmd.args(&["-t", "6801010000", file])
+        .succeeds()
+        .no_output();
+
+    assert!(at.file_exists(file));
+
+    //  January 1, 2068, 00:00:00
+    let expected = FileTime::from_unix_time(3_092_601_600, 0);
+    let (atime, mtime) = get_file_times(&at, file);
+    assert_eq!(atime, mtime);
+    assert_eq!(atime, expected);
+    assert_eq!(mtime, expected);
+}
+
+#[test]
+fn test_touch_2_digit_years_2038() {
+    // Same as test_touch_2_digit_years_68 but for 32 bits systems
+    // we test a date before the y2038 bug
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_set_two_digit_68_time";
+
+    ucmd.args(&["-t", "3801010000", file])
+        .succeeds()
+        .no_output();
+
+    assert!(at.file_exists(file));
+
+    // January 1, 2038, 00:00:00
+    let expected = FileTime::from_unix_time(2_145_916_800, 0);
+    let (atime, mtime) = get_file_times(&at, file);
+    assert_eq!(atime, mtime);
+    assert_eq!(atime, expected);
+    assert_eq!(mtime, expected);
+}
+
+#[test]
+fn test_touch_2_digit_years_69() {
+    // 69 and after are 19xx
+    let (at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_set_two_digit_69_time";
+
+    ucmd.args(&["-t", "6901010000", file])
+        .succeeds()
+        .no_output();
+
+    assert!(at.file_exists(file));
+    // January 1, 1969, 00:00:00
+    let expected = FileTime::from_unix_time(-31_536_000, 0);
+    let (atime, mtime) = get_file_times(&at, file);
+    assert_eq!(atime, mtime);
+    assert_eq!(atime, expected);
+    assert_eq!(mtime, expected);
+}
+
 #[test]
 fn test_touch_set_ymdhm_time() {
     let (at, mut ucmd) = at_and_ucmd!();
@@ -188,7 +258,14 @@ fn test_touch_set_cymdhms_time() {
 
 #[test]
 fn test_touch_set_only_atime() {
-    let atime_args = ["-a", "--time=access", "--time=atime", "--time=use"];
+    let atime_args = [
+        "-a",
+        "--time=access",
+        "--time=atime",
+        "--time=atim", // spell-checker:disable-line
+        "--time=a",
+        "--time=use",
+    ];
     let file = "test_touch_set_only_atime";
 
     for atime_arg in atime_args {
@@ -202,7 +279,7 @@ fn test_touch_set_only_atime() {
 
         let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
         let (atime, mtime) = get_file_times(&at, file);
-        assert!(atime != mtime);
+        assert_ne!(atime, mtime);
         assert_eq!(atime.unix_seconds() - start_of_year.unix_seconds(), 45240);
     }
 }
@@ -289,7 +366,7 @@ fn test_touch_set_both_time_and_date() {
 
 #[test]
 fn test_touch_set_only_mtime() {
-    let mtime_args = ["-m", "--time=modify", "--time=mtime"];
+    let mtime_args = ["-m", "--time=modify", "--time=mtime", "--time=m"];
     let file = "test_touch_set_only_mtime";
 
     for mtime_arg in mtime_args {
@@ -303,7 +380,7 @@ fn test_touch_set_only_mtime() {
 
         let start_of_year = str_to_filetime("%Y%m%d%H%M", "201501010000");
         let (atime, mtime) = get_file_times(&at, file);
-        assert!(atime != mtime);
+        assert_ne!(atime, mtime);
         assert_eq!(mtime.unix_seconds() - start_of_year.unix_seconds(), 45240);
     }
 }
@@ -678,10 +755,23 @@ fn test_touch_system_fails() {
 }
 
 #[test]
+#[cfg(not(target_os = "windows"))]
 fn test_touch_trailing_slash() {
     let (_at, mut ucmd) = at_and_ucmd!();
     let file = "no-file/";
-    ucmd.args(&[file]).fails();
+    ucmd.args(&[file]).fails().stderr_only(format!(
+        "touch: cannot touch '{file}': No such file or directory\n"
+    ));
+}
+
+#[test]
+#[cfg(target_os = "windows")]
+fn test_touch_trailing_slash_windows() {
+    let (_at, mut ucmd) = at_and_ucmd!();
+    let file = "no-file/";
+    ucmd.args(&[file]).fails().stderr_only(format!(
+        "touch: cannot touch '{file}': The filename, directory name, or volume label syntax is incorrect.\n"
+    ));
 }
 
 #[test]
@@ -697,7 +787,7 @@ fn test_touch_no_such_file_error_msg() {
 }
 
 #[test]
-#[cfg(not(target_os = "freebsd"))]
+#[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))]
 fn test_touch_changes_time_of_file_in_stdout() {
     // command like: `touch - 1< ./c`
     // should change the timestamp of c
@@ -715,7 +805,7 @@ fn test_touch_changes_time_of_file_in_stdout() {
         .no_stderr();
 
     let (_, mtime_after) = get_file_times(&at, file);
-    assert!(mtime_after != mtime);
+    assert_ne!(mtime_after, mtime);
 }
 
 #[test]
@@ -734,8 +824,7 @@ fn test_touch_permission_denied_error_msg() {
 
     let full_path = at.plus_as_string(path_str);
     ucmd.arg(&full_path).fails().stderr_only(format!(
-        "touch: cannot touch '{}': Permission denied\n",
-        &full_path
+        "touch: cannot touch '{full_path}': Permission denied\n",
     ));
 }
 
@@ -782,7 +871,7 @@ fn test_touch_leap_second() {
 fn test_touch_trailing_slash_no_create() {
     let (at, mut ucmd) = at_and_ucmd!();
     at.touch("file");
-    ucmd.args(&["-c", "file/"]).fails().code_is(1);
+    ucmd.args(&["-c", "file/"]).fails_with_code(1);
 
     let (at, mut ucmd) = at_and_ucmd!();
     ucmd.args(&["-c", "no-file/"]).succeeds();
@@ -798,7 +887,7 @@ fn test_touch_trailing_slash_no_create() {
 
     let (at, mut ucmd) = at_and_ucmd!();
     at.relative_symlink_file("loop", "loop");
-    ucmd.args(&["-c", "loop/"]).fails().code_is(1);
+    ucmd.args(&["-c", "loop/"]).fails_with_code(1);
     assert!(!at.file_exists("loop"));
 
     #[cfg(not(target_os = "macos"))]
@@ -807,7 +896,7 @@ fn test_touch_trailing_slash_no_create() {
         let (at, mut ucmd) = at_and_ucmd!();
         at.touch("file2");
         at.relative_symlink_file("file2", "link1");
-        ucmd.args(&["-c", "link1/"]).fails().code_is(1);
+        ucmd.args(&["-c", "link1/"]).fails_with_code(1);
         assert!(at.file_exists("file2"));
         assert!(at.symlink_exists("link1"));
     }
@@ -840,8 +929,80 @@ fn test_touch_no_dereference_dangling() {
 }
 
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_touch_dash() {
     let (_, mut ucmd) = at_and_ucmd!();
 
     ucmd.args(&["-h", "-"]).succeeds().no_stderr().no_stdout();
 }
+
+#[test]
+fn test_touch_invalid_date_format() {
+    let (_at, mut ucmd) = at_and_ucmd!();
+    let file = "test_touch_invalid_date_format";
+
+    ucmd.args(&["-m", "-t", "+1000000000000 years", file])
+        .fails()
+        .stderr_contains("touch: invalid date format '+1000000000000 years'");
+}
+
+#[test]
+#[cfg(not(target_os = "freebsd"))]
+fn test_touch_symlink_with_no_deref() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let target = "foo.txt";
+    let symlink = "bar.txt";
+    let time = FileTime::from_unix_time(123, 0);
+
+    at.touch(target);
+    at.relative_symlink_file(target, symlink);
+    set_symlink_file_times(at.plus(symlink), time, time).unwrap();
+
+    ucmd.args(&["-a", "--no-dereference", symlink]).succeeds();
+    // Modification time shouldn't be set to the destination's modification time
+    assert_eq!(time, get_symlink_times(&at, symlink).1);
+}
+
+#[test]
+#[cfg(not(target_os = "freebsd"))]
+fn test_touch_reference_symlink_with_no_deref() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let target = "foo.txt";
+    let symlink = "bar.txt";
+    let arg = "baz.txt";
+    let time = FileTime::from_unix_time(123, 0);
+
+    at.touch(target);
+    at.relative_symlink_file(target, symlink);
+    set_symlink_file_times(at.plus(symlink), time, time).unwrap();
+    at.touch(arg);
+
+    ucmd.args(&["--reference", symlink, "--no-dereference", arg])
+        .succeeds();
+    // Times should be taken from the symlink, not the destination
+    assert_eq!((time, time), get_symlink_times(&at, arg));
+}
+
+#[test]
+fn test_obsolete_posix_format() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.env("_POSIX2_VERSION", "199209")
+        .env("POSIXLY_CORRECT", "1")
+        .args(&["01010000", "11111111"])
+        .succeeds()
+        .no_output();
+    assert!(at.file_exists("11111111"));
+    assert!(!at.file_exists("01010000"));
+}
+
+#[test]
+fn test_obsolete_posix_format_with_year() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    ucmd.env("_POSIX2_VERSION", "199209")
+        .env("POSIXLY_CORRECT", "1")
+        .args(&["0101000090", "11111111"])
+        .succeeds()
+        .no_output();
+    assert!(at.file_exists("11111111"));
+    assert!(!at.file_exists("0101000090"));
+}
diff --git a/tests/by-util/test_tr.rs b/tests/by-util/test_tr.rs
index 7c475a492ef..84721119255 100644
--- a/tests/by-util/test_tr.rs
+++ b/tests/by-util/test_tr.rs
@@ -2,12 +2,33 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-// 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::TestScenario;
+// spell-checker:ignore aabbaa aabbcc aabc abbb abbbcddd 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 XXXYYY xycde xyyye xyyz xyzzzzxyzzzz ZABCDEF Zamz Cdefghijkl Cdefghijklmn asdfqqwweerr qwerr asdfqwer qwer aassddffqwer asdfqwer
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+#[cfg(unix)]
+use std::{ffi::OsStr, os::unix::ffi::OsStrExt};
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_invalid_input() {
+    new_ucmd!()
+        .args(&["1", "1", "<", "."])
+        .fails_with_code(1)
+        .stderr_contains("tr: extra operand '<'");
+    #[cfg(unix)]
+    new_ucmd!()
+        .args(&["1", "1"])
+        // will test "tr 1 1 < ."
+        .set_stdin(std::process::Stdio::from(std::fs::File::open(".").unwrap()))
+        .fails_with_code(1)
+        .stderr_contains("tr: read error: Is a directory");
 }
 
 #[test]
@@ -15,7 +36,7 @@ fn test_to_upper() {
     new_ucmd!()
         .args(&["a-z", "A-Z"])
         .pipe_in("!abcd!")
-        .run()
+        .succeeds()
         .stdout_is("!ABCD!");
 }
 
@@ -24,17 +45,17 @@ fn test_small_set2() {
     new_ucmd!()
         .args(&["0-9", "X"])
         .pipe_in("@0123456789")
-        .run()
+        .succeeds()
         .stdout_is("@XXXXXXXXXX");
 }
 
 #[test]
-fn test_unicode() {
+fn test_invalid_unicode() {
     new_ucmd!()
-        .args(&[", ┬─┬", "╯︵┻�┻"])
-        .pipe_in("(,°□°）, ┬─┬")
-        .run()
-        .stdout_is("(╯°□°）╯︵┻�┻");
+        .args(&["-dc", "abc"])
+        .pipe_in([0o200, b'a', b'b', b'c'])
+        .succeeds()
+        .stdout_is("abc");
 }
 
 #[test]
@@ -42,16 +63,42 @@ fn test_delete() {
     new_ucmd!()
         .args(&["-d", "a-z"])
         .pipe_in("aBcD")
-        .run()
+        .succeeds()
         .stdout_is("BD");
 }
 
+#[test]
+fn test_delete_afterwards_is_not_flag() {
+    new_ucmd!()
+        .args(&["a-z", "-d"])
+        .pipe_in("aBcD")
+        .succeeds()
+        .stdout_is("-BdD");
+}
+
+#[test]
+fn test_delete_multi() {
+    new_ucmd!()
+        .args(&["-d", "-d", "a-z"])
+        .pipe_in("aBcD")
+        .succeeds()
+        .stdout_is("BD");
+}
+
+#[test]
+fn test_delete_late() {
+    new_ucmd!()
+        .args(&["-d", "a-z", "-d"])
+        .fails()
+        .stderr_contains("extra operand '-d'");
+}
+
 #[test]
 fn test_delete_complement() {
     new_ucmd!()
         .args(&["-d", "-c", "a-z"])
         .pipe_in("aBcD")
-        .run()
+        .succeeds()
         .stdout_is("ac");
 }
 
@@ -74,26 +121,34 @@ fn test_complement1() {
     new_ucmd!()
         .args(&["-c", "a", "X"])
         .pipe_in("ab")
-        .run()
+        .succeeds()
         .stdout_is("aX");
 }
 
+#[test]
+fn test_complement_afterwards_is_not_flag() {
+    new_ucmd!()
+        .args(&["a", "X", "-c"])
+        .fails()
+        .stderr_contains("extra operand '-c'");
+}
+
 #[test]
 fn test_complement2() {
     new_ucmd!()
         .args(&["-c", "0-9", "x"])
         .pipe_in("Phone: 01234 567890")
-        .run()
+        .succeeds()
         .stdout_is("xxxxxxx01234x567890");
 }
 
 #[test]
 fn test_complement3() {
     new_ucmd!()
-        .args(&["-c", "abcdefgh", "123"]) // spell-checker:disable-line
+        .args(&["-c", "abcdefgh", "123"])
         .pipe_in("the cat and the bat")
-        .run()
-        .stdout_is("3he3ca33a3d33he3ba3"); // spell-checker:disable-line
+        .succeeds()
+        .stdout_is("3he3ca33a3d33he3ba3");
 }
 
 #[test]
@@ -103,7 +158,7 @@ fn test_complement4() {
     new_ucmd!()
         .args(&["-c", "0-@", "*-~"])
         .pipe_in("0x1y2z3")
-        .run()
+        .succeeds()
         .stdout_is("0~1~2~3");
 }
 
@@ -114,16 +169,50 @@ fn test_complement5() {
     new_ucmd!()
         .args(&["-c", r"\0-@", "*-~"])
         .pipe_in("0x1y2z3")
-        .run()
+        .succeeds()
         .stdout_is("0a1b2c3");
 }
 
+#[test]
+fn test_complement_multi_early() {
+    new_ucmd!()
+        .args(&["-c", "-c", "a", "X"])
+        .pipe_in("ab")
+        .succeeds()
+        .stdout_is("aX");
+}
+
+#[test]
+fn test_complement_multi_middle() {
+    new_ucmd!()
+        .args(&["-c", "a", "-c", "X"])
+        .fails()
+        .stderr_contains("tr: extra operand 'X'");
+}
+
+#[test]
+fn test_complement_multi_late() {
+    new_ucmd!()
+        .args(&["-c", "a", "X", "-c"])
+        .fails()
+        .stderr_contains("tr: extra operand '-c'");
+}
+
 #[test]
 fn test_squeeze() {
     new_ucmd!()
         .args(&["-s", "a-z"])
         .pipe_in("aaBBcDcc")
-        .run()
+        .succeeds()
+        .stdout_is("aBBcDc");
+}
+
+#[test]
+fn test_squeeze_multi() {
+    new_ucmd!()
+        .args(&["-ss", "-s", "a-z"])
+        .pipe_in("aaBBcDcc")
+        .succeeds()
         .stdout_is("aBBcDc");
 }
 
@@ -132,7 +221,16 @@ fn test_squeeze_complement() {
     new_ucmd!()
         .args(&["-sc", "a-z"])
         .pipe_in("aaBBcDcc")
-        .run()
+        .succeeds()
+        .stdout_is("aaBcDcc");
+}
+
+#[test]
+fn test_squeeze_complement_multi() {
+    new_ucmd!()
+        .args(&["-scsc", "a-z"]) // spell-checker:disable-line
+        .pipe_in("aaBBcDcc")
+        .succeeds()
         .stdout_is("aaBcDcc");
 }
 
@@ -141,7 +239,7 @@ fn test_squeeze_complement_two_sets() {
     new_ucmd!()
         .args(&["-sc", "a", "_"])
         .pipe_in("test a aa with 3 ___ spaaaces +++") // spell-checker:disable-line
-        .run()
+        .succeeds()
         .stdout_is("_a_aa_aaa_");
 }
 
@@ -150,7 +248,7 @@ fn test_translate_and_squeeze() {
     new_ucmd!()
         .args(&["-s", "x", "y"])
         .pipe_in("xx")
-        .run()
+        .succeeds()
         .stdout_is("y");
 }
 
@@ -159,16 +257,25 @@ fn test_translate_and_squeeze_multiple_lines() {
     new_ucmd!()
         .args(&["-s", "x", "y"])
         .pipe_in("xxaax\nxaaxx") // spell-checker:disable-line
-        .run()
+        .succeeds()
         .stdout_is("yaay\nyaay"); // spell-checker:disable-line
 }
 
+#[test]
+fn test_delete_and_squeeze_one_set() {
+    new_ucmd!()
+        .args(&["-ds", "a-z"])
+        .fails()
+        .stderr_contains("missing operand after 'a-z'")
+        .stderr_contains("Two strings must be given when deleting and squeezing.");
+}
+
 #[test]
 fn test_delete_and_squeeze() {
     new_ucmd!()
         .args(&["-ds", "a-z", "A-Z"])
         .pipe_in("abBcB")
-        .run()
+        .succeeds()
         .stdout_is("B");
 }
 
@@ -177,16 +284,25 @@ fn test_delete_and_squeeze_complement() {
     new_ucmd!()
         .args(&["-dsc", "a-z", "A-Z"])
         .pipe_in("abBcB")
-        .run()
+        .succeeds()
         .stdout_is("abc");
 }
 
+#[test]
+fn test_delete_and_squeeze_complement_squeeze_set2() {
+    new_ucmd!()
+        .args(&["-dsc", "abX", "XYZ"])
+        .pipe_in("abbbcdddXXXYYY")
+        .succeeds()
+        .stdout_is("abbbX");
+}
+
 #[test]
 fn test_set1_longer_than_set2() {
     new_ucmd!()
         .args(&["abc", "xy"])
         .pipe_in("abcde")
-        .run()
+        .succeeds()
         .stdout_is("xyyde"); // spell-checker:disable-line
 }
 
@@ -195,8 +311,8 @@ fn test_set1_shorter_than_set2() {
     new_ucmd!()
         .args(&["ab", "xyz"])
         .pipe_in("abcde")
-        .run()
-        .stdout_is("xycde"); // spell-checker:disable-line
+        .succeeds()
+        .stdout_is("xycde");
 }
 
 #[test]
@@ -205,8 +321,17 @@ fn test_truncate() {
     new_ucmd!()
         .args(&["-t", "abc", "xy"])
         .pipe_in("abcde")
-        .run()
-        .stdout_is("xycde"); // spell-checker:disable-line
+        .succeeds()
+        .stdout_is("xycde");
+}
+
+#[test]
+fn test_truncate_multi() {
+    new_ucmd!()
+        .args(&["-tt", "-t", "abc", "xy"])
+        .pipe_in("abcde")
+        .succeeds()
+        .stdout_is("xycde");
 }
 
 #[test]
@@ -214,8 +339,8 @@ fn test_truncate_with_set1_shorter_than_set2() {
     new_ucmd!()
         .args(&["-t", "ab", "xyz"])
         .pipe_in("abcde")
-        .run()
-        .stdout_is("xycde"); // spell-checker:disable-line
+        .succeeds()
+        .stdout_is("xycde");
 }
 
 #[test]
@@ -534,7 +659,6 @@ fn check_against_gnu_tr_tests_d() {
 }
 
 #[test]
-#[ignore = "I cannot tell if this means that tr preserve the octal representation?"]
 fn check_against_gnu_tr_tests_e() {
     // ['e', qw(-s '[\0-\5]'), {IN=>"\0\0a\1\1b\2\2\2c\3\3\3d\4\4\4\4e\5\5"}, {OUT=>"\0a\1b\2c\3d\4e\5"}],
     new_ucmd!()
@@ -733,10 +857,11 @@ fn check_against_gnu_tr_tests_w() {
     //  {IN=>"\300\301\377\345\345\350\345"},
     //  {OUT=>"\300\301\377\345"}],
     new_ucmd!()
-        .args(&["-ds", "\u{350}", "\u{345}"])
-        .pipe_in("\u{300}\u{301}\u{377}\u{345}\u{345}\u{350}\u{345}")
+        .arg("-ds")
+        .args(&["\\350", "\\345"])
+        .pipe_in([0o300, 0o301, 0o377, 0o345, 0o345, 0o350, 0o345])
         .succeeds()
-        .stdout_is("\u{300}\u{301}\u{377}\u{345}");
+        .stdout_is_bytes([0o300, 0o301, 0o377, 0o345]);
 }
 
 #[test]
@@ -919,7 +1044,8 @@ fn check_against_gnu_tr_tests_bs_055() {
 }
 
 #[test]
-#[ignore = "Failing in Windows because it will not separate '\' and 'x' as separate arguments"]
+// Fails on Windows because it will not separate '\' and 'x' as separate arguments
+#[cfg(unix)]
 fn check_against_gnu_tr_tests_bs_at_end() {
     // ['bs-at-end', qw('\\' x), {IN=>"\\"}, {OUT=>'x'},
     //  {ERR=>"$prog: warning: an unescaped backslash at end of "
@@ -933,7 +1059,6 @@ fn check_against_gnu_tr_tests_bs_at_end() {
 }
 
 #[test]
-#[ignore = "not sure why GNU bails here. `[Y*]` should be able to generate all the mapping"]
 fn check_against_gnu_tr_tests_ross_0a() {
     // # From Ross
     // ['ross-0a', qw(-cs '[:upper:]' 'X[Y*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
@@ -946,7 +1071,6 @@ fn check_against_gnu_tr_tests_ross_0a() {
 }
 
 #[test]
-#[ignore = "not sure why GNU bails here. `[Y*]` should be able to generate all the mapping"]
 fn check_against_gnu_tr_tests_ross_0b() {
     // ['ross-0b', qw(-cs '[:cntrl:]' 'X[Y*]'), {IN=>''}, {OUT=>''}, {EXIT=>1},
     //  {ERR=>$map_all_to_1}],
@@ -954,7 +1078,7 @@ fn check_against_gnu_tr_tests_ross_0b() {
         .args(&["-cs", "[:cntrl:]", "X[Y*]"])
         .pipe_in("")
         .fails()
-        .stderr_is("tr: when translating with complemented character classes,\nstring2 must map all characters in the domain to one");
+        .stderr_is("tr: when translating with complemented character classes,\nstring2 must map all characters in the domain to one\n");
 }
 
 #[test]
@@ -1043,6 +1167,15 @@ fn check_against_gnu_tr_tests_empty_eq() {
         .stderr_is("tr: missing equivalence class character '[==]'\n");
 }
 
+#[test]
+fn check_too_many_chars_in_eq() {
+    new_ucmd!()
+        .args(&["-d", "[=aa=]"])
+        .pipe_in("")
+        .fails()
+        .stderr_contains("aa: equivalence class operand must be a single character\n");
+}
+
 #[test]
 fn check_against_gnu_tr_tests_empty_cc() {
     // ['empty-cc', qw('[::]' x), {IN=>''}, {OUT=>''}, {EXIT=>1},
@@ -1125,7 +1258,6 @@ fn check_against_gnu_tr_tests_repeat_x_c() {
 }
 
 #[test]
-#[ignore = "I think either clap-rs or uutils is parsing the '-H' as an argument..."]
 fn check_against_gnu_tr_tests_fowler_1() {
     // # From Glenn Fowler.
     // ['fowler-1', qw(ah -H), {IN=>'aha'}, {OUT=>'-H-'}],
@@ -1146,3 +1278,281 @@ fn check_against_gnu_tr_tests_no_abort_1() {
         .succeeds()
         .stdout_is("abb");
 }
+
+#[test]
+fn test_delete_flag_takes_only_one_operand() {
+    // gnu tr -d fails with more than 1 argument
+    new_ucmd!().args(&["-d", "a", "p"]).fails().stderr_contains(
+        "extra operand 'p'\nOnly one string may be given when deleting without squeezing repeats.",
+    );
+}
+
+#[test]
+fn test_truncate_flag_fails_with_more_than_two_operand() {
+    new_ucmd!()
+        .args(&["-t", "a", "b", "c"])
+        .fails()
+        .stderr_contains("extra operand 'c'");
+}
+
+#[test]
+fn test_squeeze_flag_fails_with_more_than_two_operand() {
+    new_ucmd!()
+        .args(&["-s", "a", "b", "c"])
+        .fails()
+        .stderr_contains("extra operand 'c'");
+}
+
+#[test]
+fn test_complement_flag_fails_with_more_than_two_operand() {
+    new_ucmd!()
+        .args(&["-c", "a", "b", "c"])
+        .fails()
+        .stderr_contains("extra operand 'c'");
+}
+
+#[test]
+fn check_regression_class_space() {
+    // This invocation checks:
+    // 1. that the [:space:] class has exactly 6 characters,
+    // 2. that the [:space:] class contains at least the given 6 characters (and therefore no other characters), and
+    // 3. that the given characters occur in exactly this order.
+    new_ucmd!()
+        .args(&["[:space:][:upper:]", "123456[:lower:]"])
+        // 0x0B = "\v" ("VERTICAL TAB")
+        // 0x0C = "\f" ("FEED FORWARD")
+        .pipe_in("A\t\n\u{0B}\u{0C}\r B")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("a123456b");
+}
+
+#[test]
+fn check_regression_class_blank() {
+    // This invocation checks:
+    // 1. that the [:blank:] class has exactly 2 characters,
+    // 2. that the [:blank:] class contains at least the given 2 characters (and therefore no other characters), and
+    // 3. that the given characters occur in exactly this order.
+    new_ucmd!()
+        .args(&["[:blank:][:upper:]", "12[:lower:]"])
+        .pipe_in("A\t B")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("a12b");
+}
+
+// Check regression found in https://github.com/uutils/coreutils/issues/6163
+#[test]
+fn check_regression_issue_6163_no_match() {
+    new_ucmd!()
+        .args(&["-c", "-t", "Y", "Z"])
+        .pipe_in("X\n")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("X\n");
+}
+
+#[test]
+fn check_regression_issue_6163_match() {
+    new_ucmd!()
+        .args(&["-c", "-t", "Y", "Z"])
+        .pipe_in("\0\n")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("Z\n");
+}
+
+#[test]
+fn check_ignore_truncate_when_deleting_and_squeezing() {
+    new_ucmd!()
+        .args(&["-dts", "asdf", "qwe"])
+        .pipe_in("asdfqqwweerr\n")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("qwerr\n");
+}
+
+#[test]
+fn check_ignore_truncate_when_deleting() {
+    new_ucmd!()
+        .args(&["-dt", "asdf"])
+        .pipe_in("asdfqwer\n")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("qwer\n");
+}
+
+#[test]
+fn check_ignore_truncate_when_squeezing() {
+    new_ucmd!()
+        .args(&["-ts", "asdf"])
+        .pipe_in("aassddffqwer\n")
+        .succeeds()
+        .no_stderr()
+        .stdout_only("asdfqwer\n");
+}
+
+#[test]
+fn check_disallow_blank_in_set2_when_translating() {
+    new_ucmd!().args(&["-t", "1234", "[:blank:]"]).fails();
+}
+
+#[test]
+fn check_class_in_set2_must_be_matched_in_set1() {
+    new_ucmd!().args(&["-t", "1[:upper:]", "[:upper:]"]).fails();
+}
+
+#[test]
+fn check_class_in_set2_must_be_matched_in_set1_right_length_check() {
+    new_ucmd!()
+        .args(&["-t", "a-z[:upper:]", "abcdefghijklmnopqrstuvwxyz[:upper:]"])
+        .succeeds();
+}
+
+#[test]
+fn check_set1_longer_set2_ends_in_class() {
+    new_ucmd!().args(&["[:lower:]a", "[:upper:]"]).fails();
+}
+
+#[test]
+fn check_set1_longer_set2_ends_in_class_with_trunc() {
+    new_ucmd!()
+        .args(&["-t", "[:lower:]a", "[:upper:]"])
+        .succeeds();
+}
+
+#[test]
+fn check_complement_2_unique_in_set2() {
+    let x226 = "x".repeat(226);
+
+    // [y*] is expanded tp "y" here
+    let arg = x226 + "[y*]xxx";
+    new_ucmd!().args(&["-c", "[:upper:]", arg.as_str()]).fails();
+}
+
+#[test]
+fn check_complement_1_unique_in_set2() {
+    let x226 = "x".repeat(226);
+
+    // [y*] is expanded to "" here
+    let arg = x226 + "[y*]xxxx";
+    new_ucmd!()
+        .args(&["-c", "[:upper:]", arg.as_str()])
+        .succeeds();
+}
+
+#[test]
+fn check_complement_set2_too_big() {
+    let x231 = "x".repeat(231);
+    let x230 = &x231[..230];
+
+    // The complement of [:upper:] expands to 230 characters,
+    // putting more characters in set2 should fail.
+    new_ucmd!().args(&["-c", "[:upper:]", x230]).succeeds();
+    new_ucmd!()
+        .args(&["-c", "[:upper:]", x231.as_str()])
+        .fails()
+        .stderr_contains("when translating with complemented character classes,\nstring2 must map all characters in the domain to one");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_truncate_non_utf8_set() {
+    let stdin = b"\x01amp\xfe\xff";
+    let set1 = OsStr::from_bytes(b"a\xfe\xffz"); // spell-checker:disable-line
+    let set2 = OsStr::from_bytes(b"01234");
+
+    new_ucmd!()
+        .arg(set1)
+        .arg(set2)
+        .pipe_in(*stdin)
+        .succeeds()
+        .stdout_is_bytes(b"\x010mp12");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_unescaped_backslash_warning_false_positive() {
+    // Was erroneously printing this warning (even though the backslash was escaped):
+    // "tr: warning: an unescaped backslash at end of string is not portable"
+    new_ucmd!()
+        .args(&["-d", r"\\"])
+        .pipe_in(r"a\b\c\")
+        .succeeds()
+        .stdout_only("abc");
+    new_ucmd!()
+        .args(&["-d", r"\\\\"])
+        .pipe_in(r"a\b\c\")
+        .succeeds()
+        .stdout_only("abc");
+    new_ucmd!()
+        .args(&["-d", r"\\\\\\"])
+        .pipe_in(r"a\b\c\")
+        .succeeds()
+        .stdout_only("abc");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_trailing_backslash() {
+    new_ucmd!()
+        .args(&["-d", r"\"])
+        .pipe_in(r"a\b\c\")
+        .succeeds()
+        .stderr_is("tr: warning: an unescaped backslash at end of string is not portable\n")
+        .stdout_is("abc");
+    new_ucmd!()
+        .args(&["-d", r"\\\"])
+        .pipe_in(r"a\b\c\")
+        .succeeds()
+        .stderr_is("tr: warning: an unescaped backslash at end of string is not portable\n")
+        .stdout_is("abc");
+    new_ucmd!()
+        .args(&["-d", r"\\\\\"])
+        .pipe_in(r"a\b\c\")
+        .succeeds()
+        .stderr_is("tr: warning: an unescaped backslash at end of string is not portable\n")
+        .stdout_is("abc");
+}
+
+#[test]
+fn test_multibyte_octal_sequence() {
+    new_ucmd!()
+        .args(&["-d", r"\501"])
+        .pipe_in("(1�)")
+        .succeeds()
+        .stderr_is("tr: warning: the ambiguous octal escape \\501 is being\n        interpreted as the 2-byte sequence \\050, 1\n")
+        .stdout_is("�)");
+}
+
+#[test]
+fn test_backwards_range() {
+    new_ucmd!()
+        .args(&["-d", r"\046-\048"])
+        .pipe_in("")
+        .fails()
+        .stderr_only(
+            r"tr: range-endpoints of '&-\004' are in reverse collating sequence order
+",
+        );
+}
+
+#[test]
+fn test_non_digit_repeat() {
+    new_ucmd!()
+        .args(&["a", "[b*c]"])
+        .pipe_in("")
+        .fails()
+        .stderr_only("tr: invalid repeat count 'c' in [c*n] construct\n");
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .pipe_in("hello")
+        .args(&["e", "a"])
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("tr: write error: No space left on device\n");
+}
diff --git a/tests/by-util/test_true.rs b/tests/by-util/test_true.rs
index 750c60132e8..34f82c60284 100644
--- a/tests/by-util/test_true.rs
+++ b/tests/by-util/test_true.rs
@@ -2,21 +2,26 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use regex::Regex;
 #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "netbsd"))]
 use std::fs::OpenOptions;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
-fn test_exit_code() {
-    new_ucmd!().succeeds();
+fn test_no_args() {
+    new_ucmd!().succeeds().no_output();
 }
 
 #[test]
 fn test_version() {
+    let re = Regex::new(r"^true .*\d+\.\d+\.\d+\n$").unwrap();
+
     new_ucmd!()
         .args(&["--version"])
         .succeeds()
-        .stdout_contains("true");
+        .stdout_matches(&re);
 }
 
 #[test]
@@ -30,7 +35,7 @@ fn test_help() {
 #[test]
 fn test_short_options() {
     for option in ["-h", "-V"] {
-        new_ucmd!().arg(option).succeeds().stdout_is("");
+        new_ucmd!().arg(option).succeeds().no_output();
     }
 }
 
@@ -39,7 +44,7 @@ fn test_conflict() {
     new_ucmd!()
         .args(&["--help", "--version"])
         .succeeds()
-        .stdout_is("");
+        .no_output();
 }
 
 #[test]
diff --git a/tests/by-util/test_truncate.rs b/tests/by-util/test_truncate.rs
index 972b4fc5bfd..789bd1d66e1 100644
--- a/tests/by-util/test_truncate.rs
+++ b/tests/by-util/test_truncate.rs
@@ -5,8 +5,11 @@
 
 // spell-checker:ignore (words) RFILE
 
-use crate::common::util::TestScenario;
 use std::io::{Seek, SeekFrom, Write};
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 static FILE1: &str = "truncate_test_1";
 static FILE2: &str = "truncate_test_2";
@@ -20,7 +23,7 @@ fn test_increase_file_size() {
 
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -32,7 +35,7 @@ fn test_increase_file_size_kb() {
 
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -43,9 +46,6 @@ fn test_reference() {
     let mut file = at.make_file(FILE2);
 
     // manpage: "A FILE argument that does not exist is created."
-    // TODO: 'truncate' does not create the file in this case,
-    //        but should because '--no-create' wasn't specified.
-    at.touch(FILE1); // TODO: remove this when 'no-create' is fixed
     scene.ucmd().arg("-s").arg("+5KB").arg(FILE1).succeeds();
 
     scene
@@ -57,7 +57,7 @@ fn test_reference() {
 
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -69,7 +69,7 @@ fn test_decrease_file_size() {
     ucmd.args(&["--size=-4", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -81,7 +81,7 @@ fn test_space_in_size() {
     ucmd.args(&["--size", " 4", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -110,7 +110,7 @@ fn test_at_most_shrinks() {
     ucmd.args(&["--size", "<4", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -122,7 +122,7 @@ fn test_at_most_no_change() {
     ucmd.args(&["--size", "<40", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -134,7 +134,7 @@ fn test_at_least_grows() {
     ucmd.args(&["--size", ">15", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -146,7 +146,7 @@ fn test_at_least_no_change() {
     ucmd.args(&["--size", ">4", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -158,7 +158,7 @@ fn test_round_down() {
     ucmd.args(&["--size", "/4", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -170,7 +170,7 @@ fn test_round_up() {
     ucmd.args(&["--size", "%4", FILE2]).succeeds();
     file.seek(SeekFrom::End(0)).unwrap();
     let actual = file.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -184,7 +184,7 @@ fn test_size_and_reference() {
         .succeeds();
     file2.seek(SeekFrom::End(0)).unwrap();
     let actual = file2.stream_position().unwrap();
-    assert!(expected == actual, "expected '{expected}' got '{actual}'");
+    assert_eq!(expected, actual, "expected '{expected}' got '{actual}'");
 }
 
 #[test]
@@ -192,8 +192,7 @@ fn test_error_filename_only() {
     // truncate: you must specify either '--size' or '--reference'
     new_ucmd!()
         .args(&["file"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_contains("error: the following required arguments were not provided:");
 }
 
@@ -202,8 +201,7 @@ fn test_invalid_option() {
     // truncate: cli parsing error returns 1
     new_ucmd!()
         .args(&["--this-arg-does-not-exist"])
-        .fails()
-        .code_is(1);
+        .fails_with_code(1);
 }
 
 #[test]
@@ -240,20 +238,16 @@ fn test_reference_with_size_file_not_found() {
 
 #[test]
 fn test_truncate_bytes_size() {
-    // TODO: this should succeed without error, uncomment when '--no-create' is fixed
-    // new_ucmd!()
-    //     .args(&["--no-create", "--size", "K", "file"])
-    //     .succeeds();
+    new_ucmd!()
+        .args(&["--no-create", "--size", "K", "file"])
+        .succeeds();
     new_ucmd!()
         .args(&["--size", "1024R", "file"])
-        .fails()
-        .code_is(1)
-        .stderr_only("truncate: Invalid number: '1024R'\n");
-    #[cfg(not(target_pointer_width = "128"))]
+        .fails_with_code(1)
+        .stderr_only("truncate: Invalid number: '1024R': Value too large for defined data type\n");
     new_ucmd!()
         .args(&["--size", "1Y", "file"])
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stderr_only("truncate: Invalid number: '1Y': Value too large for defined data type\n");
 }
 
@@ -270,9 +264,39 @@ fn test_new_file() {
     assert_eq!(at.read_bytes(filename), vec![b'\0'; 8]);
 }
 
+/// Test that truncating a non-existent file creates that file, even in reference-mode.
+#[test]
+fn test_new_file_reference() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut old_file = at.make_file(FILE1);
+    old_file.write_all(b"1234567890").unwrap();
+    let filename = "new_file_that_does_not_exist_yet";
+    ucmd.args(&["-r", FILE1, filename])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(at.file_exists(filename));
+    assert_eq!(at.read_bytes(filename), vec![b'\0'; 10]);
+}
+
+/// Test that truncating a non-existent file creates that file, even in size-and-reference-mode.
+#[test]
+fn test_new_file_size_and_reference() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut old_file = at.make_file(FILE1);
+    old_file.write_all(b"1234567890").unwrap();
+    let filename = "new_file_that_does_not_exist_yet";
+    ucmd.args(&["-s", "+3", "-r", FILE1, filename])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(at.file_exists(filename));
+    assert_eq!(at.read_bytes(filename), vec![b'\0'; 13]);
+}
+
 /// Test for not creating a non-existent file.
 #[test]
-fn test_new_file_no_create() {
+fn test_new_file_no_create_size_only() {
     let (at, mut ucmd) = at_and_ucmd!();
     let filename = "new_file_that_does_not_exist_yet";
     ucmd.args(&["-s", "8", "-c", filename])
@@ -282,6 +306,34 @@ fn test_new_file_no_create() {
     assert!(!at.file_exists(filename));
 }
 
+/// Test for not creating a non-existent file.
+#[test]
+fn test_new_file_no_create_reference_only() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut old_file = at.make_file(FILE1);
+    old_file.write_all(b"1234567890").unwrap();
+    let filename = "new_file_that_does_not_exist_yet";
+    ucmd.args(&["-r", FILE1, "-c", filename])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(!at.file_exists(filename));
+}
+
+/// Test for not creating a non-existent file.
+#[test]
+fn test_new_file_no_create_size_and_reference() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let mut old_file = at.make_file(FILE1);
+    old_file.write_all(b"1234567890").unwrap();
+    let filename = "new_file_that_does_not_exist_yet";
+    ucmd.args(&["-r", FILE1, "-s", "+8", "-c", filename])
+        .succeeds()
+        .no_stdout()
+        .no_stderr();
+    assert!(!at.file_exists(filename));
+}
+
 #[test]
 fn test_division_by_zero_size_only() {
     new_ucmd!()
diff --git a/tests/by-util/test_tsort.rs b/tests/by-util/test_tsort.rs
index 18889451629..c957a59a1cc 100644
--- a/tests/by-util/test_tsort.rs
+++ b/tests/by-util/test_tsort.rs
@@ -2,17 +2,22 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+#![allow(clippy::cast_possible_wrap)]
+
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 #[test]
 fn test_sort_call_graph() {
     new_ucmd!()
         .arg("call_graph.txt")
-        .run()
+        .succeeds()
         .stdout_is_fixture("call_graph.expected");
 }
 
@@ -64,3 +69,46 @@ fn test_multiple_arguments() {
         .fails()
         .stderr_contains("unexpected argument 'invalid_file' found");
 }
+
+#[test]
+fn test_error_on_dir() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.mkdir("tsort_test_dir");
+    ucmd.arg("tsort_test_dir")
+        .fails()
+        .stderr_contains("tsort: tsort_test_dir: read error: Is a directory");
+}
+
+#[test]
+fn test_split_on_any_whitespace() {
+    new_ucmd!()
+        .pipe_in("a\nb\n")
+        .succeeds()
+        .stdout_only("a\nb\n");
+}
+
+#[test]
+fn test_cycle() {
+    // The graph looks like:  a --> b <==> c --> d
+    new_ucmd!()
+        .pipe_in("a b b c c d c b")
+        .fails_with_code(1)
+        .stdout_is("a\nc\nd\nb\n")
+        .stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\n");
+}
+
+#[test]
+fn test_two_cycles() {
+    // The graph looks like:
+    //
+    //        a
+    //        |
+    //        V
+    // c <==> b <==> d
+    //
+    new_ucmd!()
+        .pipe_in("a b b c c b b d d b")
+        .fails_with_code(1)
+        .stdout_is("a\nc\nd\nb\n")
+        .stderr_is("tsort: -: input contains a loop:\ntsort: b\ntsort: c\ntsort: -: input contains a loop:\ntsort: b\ntsort: d\n");
+}
diff --git a/tests/by-util/test_tty.rs b/tests/by-util/test_tty.rs
index 0f2c588063a..c0124328c46 100644
--- a/tests/by-util/test_tty.rs
+++ b/tests/by-util/test_tty.rs
@@ -4,15 +4,16 @@
 // file that was distributed with this source code.
 use std::fs::File;
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 #[cfg(not(windows))]
 fn test_dev_null() {
     new_ucmd!()
         .set_stdin(File::open("/dev/null").unwrap())
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_is("not a tty\n");
 }
 
@@ -22,8 +23,7 @@ fn test_dev_null_silent() {
     new_ucmd!()
         .args(&["-s"])
         .set_stdin(File::open("/dev/null").unwrap())
-        .fails()
-        .code_is(1)
+        .fails_with_code(1)
         .stdout_is("");
 }
 
@@ -57,7 +57,7 @@ fn test_close_stdin_silent_alias() {
 
 #[test]
 fn test_wrong_argument() {
-    new_ucmd!().args(&["a"]).fails().code_is(2);
+    new_ucmd!().args(&["a"]).fails_with_code(2);
 }
 
 #[test]
diff --git a/tests/by-util/test_uname.rs b/tests/by-util/test_uname.rs
index 3676eefbaaf..986312f68e7 100644
--- a/tests/by-util/test_uname.rs
+++ b/tests/by-util/test_uname.rs
@@ -2,11 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_unexpand.rs b/tests/by-util/test_unexpand.rs
index ddbe3343efa..8b447ecdb5f 100644
--- a/tests/by-util/test_unexpand.rs
+++ b/tests/by-util/test_unexpand.rs
@@ -2,11 +2,15 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+// spell-checker:ignore contenta
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -14,7 +18,7 @@ fn unexpand_init_0() {
     new_ucmd!()
         .args(&["-t4"])
         .pipe_in(" 1\n  2\n   3\n    4\n")
-        .run()
+        .succeeds()
         .stdout_is(" 1\n  2\n   3\n\t4\n");
 }
 
@@ -23,7 +27,7 @@ fn unexpand_init_1() {
     new_ucmd!()
         .args(&["-t4"])
         .pipe_in("     5\n      6\n       7\n        8\n")
-        .run()
+        .succeeds()
         .stdout_is("\t 5\n\t  6\n\t   7\n\t\t8\n");
 }
 
@@ -32,7 +36,7 @@ fn unexpand_init_list_0() {
     new_ucmd!()
         .args(&["-t2,4"])
         .pipe_in(" 1\n  2\n   3\n    4\n")
-        .run()
+        .succeeds()
         .stdout_is(" 1\n\t2\n\t 3\n\t\t4\n");
 }
 
@@ -42,7 +46,7 @@ fn unexpand_init_list_1() {
     new_ucmd!()
         .args(&["-t2,4"])
         .pipe_in("     5\n      6\n       7\n        8\n")
-        .run()
+        .succeeds()
         .stdout_is("\t\t 5\n\t\t  6\n\t\t   7\n\t\t    8\n");
 }
 
@@ -51,7 +55,7 @@ fn unexpand_flag_a_0() {
     new_ucmd!()
         .args(&["--"])
         .pipe_in("e     E\nf      F\ng       G\nh        H\n")
-        .run()
+        .succeeds()
         .stdout_is("e     E\nf      F\ng       G\nh        H\n");
 }
 
@@ -60,7 +64,7 @@ fn unexpand_flag_a_1() {
     new_ucmd!()
         .args(&["-a"])
         .pipe_in("e     E\nf      F\ng       G\nh        H\n")
-        .run()
+        .succeeds()
         .stdout_is("e     E\nf      F\ng\tG\nh\t H\n");
 }
 
@@ -69,7 +73,7 @@ fn unexpand_flag_a_2() {
     new_ucmd!()
         .args(&["-t8"])
         .pipe_in("e     E\nf      F\ng       G\nh        H\n")
-        .run()
+        .succeeds()
         .stdout_is("e     E\nf      F\ng\tG\nh\t H\n");
 }
 
@@ -78,7 +82,7 @@ fn unexpand_first_only_0() {
     new_ucmd!()
         .args(&["-t3"])
         .pipe_in("        A     B")
-        .run()
+        .succeeds()
         .stdout_is("\t\t  A\t  B");
 }
 
@@ -87,7 +91,7 @@ fn unexpand_first_only_1() {
     new_ucmd!()
         .args(&["-t3", "--first-only"])
         .pipe_in("        A     B")
-        .run()
+        .succeeds()
         .stdout_is("\t\t  A     B");
 }
 
@@ -99,7 +103,7 @@ fn unexpand_trailing_space_0() {
     new_ucmd!()
         .args(&["-t4"])
         .pipe_in("123 \t1\n123 1\n123 \n123 ")
-        .run()
+        .succeeds()
         .stdout_is("123\t\t1\n123 1\n123 \n123 ");
 }
 
@@ -109,7 +113,7 @@ fn unexpand_trailing_space_1() {
     new_ucmd!()
         .args(&["-t1"])
         .pipe_in(" abc d e  f  g ")
-        .run()
+        .succeeds()
         .stdout_is("\tabc d e\t\tf\t\tg ");
 }
 
@@ -118,7 +122,7 @@ fn unexpand_spaces_follow_tabs_0() {
     // The two first spaces can be included into the first tab.
     new_ucmd!()
         .pipe_in("  \t\t   A")
-        .run()
+        .succeeds()
         .stdout_is("\t\t   A");
 }
 
@@ -133,7 +137,7 @@ fn unexpand_spaces_follow_tabs_1() {
     new_ucmd!()
         .args(&["-t1,4,5"])
         .pipe_in("a \t   B \t")
-        .run()
+        .succeeds()
         .stdout_is("a\t\t  B \t");
 }
 
@@ -142,17 +146,13 @@ fn unexpand_spaces_after_fields() {
     new_ucmd!()
         .args(&["-a"])
         .pipe_in("   \t        A B C D             A\t\n")
-        .run()
+        .succeeds()
         .stdout_is("\t\tA B C D\t\t    A\t\n");
 }
 
 #[test]
 fn unexpand_read_from_file() {
-    new_ucmd!()
-        .arg("with_spaces.txt")
-        .arg("-t4")
-        .run()
-        .success();
+    new_ucmd!().arg("with_spaces.txt").arg("-t4").succeeds();
 }
 
 #[test]
@@ -161,8 +161,7 @@ fn unexpand_read_from_two_file() {
         .arg("with_spaces.txt")
         .arg("with_spaces.txt")
         .arg("-t4")
-        .run()
-        .success();
+        .succeeds();
 }
 
 #[test]
@@ -170,7 +169,7 @@ fn test_tabs_shortcut() {
     new_ucmd!()
         .arg("-3")
         .pipe_in("   a   b")
-        .run()
+        .succeeds()
         .stdout_is("\ta   b");
 }
 
@@ -180,7 +179,7 @@ fn test_tabs_shortcut_combined_with_all_arg() {
         new_ucmd!()
             .args(&[all_arg, "-3"])
             .pipe_in("a  b  c")
-            .run()
+            .succeeds()
             .stdout_is("a\tb\tc");
     }
 
@@ -196,7 +195,7 @@ fn test_comma_separated_tabs_shortcut() {
     new_ucmd!()
         .args(&["-a", "-3,9"])
         .pipe_in("a  b     c")
-        .run()
+        .succeeds()
         .stdout_is("a\tb\tc");
 }
 
@@ -235,3 +234,34 @@ fn test_tabs_shortcut_with_too_large_size() {
 
     new_ucmd!().arg(arg).fails().stderr_contains(expected_error);
 }
+
+#[test]
+fn test_is_directory() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    let dir_name = "dir";
+    at.mkdir(dir_name);
+
+    ucmd.arg(dir_name)
+        .fails()
+        .stderr_contains(format!("unexpand: {dir_name}: Is a directory"));
+}
+
+#[test]
+fn test_multiple_files() {
+    let (at, mut ucmd) = at_and_ucmd!();
+
+    at.write("file", "content");
+    at.write("file1", "a        b");
+
+    ucmd.args(&["file", "file1"])
+        .succeeds()
+        .stdout_is("contenta        b");
+}
+
+#[test]
+fn test_one_nonexisting_file() {
+    new_ucmd!()
+        .arg("asdf.txt")
+        .fails()
+        .stderr_contains("asdf.txt: No such file or directory");
+}
diff --git a/tests/by-util/test_uniq.rs b/tests/by-util/test_uniq.rs
index 97a829b9f7a..e1d983f9956 100644
--- a/tests/by-util/test_uniq.rs
+++ b/tests/by-util/test_uniq.rs
@@ -2,10 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use std::io::Write;
 
-// spell-checker:ignore nabcd
-use crate::common::util::TestScenario;
+// spell-checker:ignore nabcd badoption schar
+use uucore::posix::OBSOLETE;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 static INPUT: &str = "sorted.txt";
 static OUTPUT: &str = "sorted-output.txt";
@@ -15,14 +18,28 @@ static SORTED_ZERO_TERMINATED: &str = "sorted-zero-terminated.txt";
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
+}
+
+#[test]
+fn test_help_and_version_on_stdout() {
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("Usage");
+    new_ucmd!()
+        .arg("--version")
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("uniq");
 }
 
 #[test]
 fn test_stdin_default() {
     new_ucmd!()
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-simple.expected");
 }
 
@@ -30,7 +47,7 @@ fn test_stdin_default() {
 fn test_single_default() {
     new_ucmd!()
         .arg(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-simple.expected");
 }
 
@@ -38,7 +55,7 @@ fn test_single_default() {
 fn test_single_default_output() {
     let (at, mut ucmd) = at_and_ucmd!();
     let expected = at.read("sorted-simple.expected");
-    ucmd.args(&[INPUT, OUTPUT]).run();
+    ucmd.args(&[INPUT, OUTPUT]).succeeds();
     let found = at.read(OUTPUT);
     assert_eq!(found, expected);
 }
@@ -48,7 +65,7 @@ fn test_stdin_counts() {
     new_ucmd!()
         .args(&["-c"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-counts.expected");
 }
 
@@ -57,7 +74,7 @@ fn test_stdin_skip_1_char() {
     new_ucmd!()
         .args(&["-s1"])
         .pipe_in_fixture(SKIP_CHARS)
-        .run()
+        .succeeds()
         .stdout_is_fixture("skip-1-char.expected");
 }
 
@@ -66,7 +83,7 @@ fn test_stdin_skip_5_chars() {
     new_ucmd!()
         .args(&["-s5"])
         .pipe_in_fixture(SKIP_CHARS)
-        .run()
+        .succeeds()
         .stdout_is_fixture("skip-5-chars.expected");
 }
 
@@ -75,25 +92,75 @@ fn test_stdin_skip_and_check_2_chars() {
     new_ucmd!()
         .args(&["-s3", "-w2"])
         .pipe_in_fixture(SKIP_CHARS)
-        .run()
+        .succeeds()
         .stdout_is_fixture("skip-3-check-2-chars.expected");
 }
 
 #[test]
-fn test_stdin_skip_1_field() {
+fn test_stdin_skip_2_fields() {
     new_ucmd!()
         .args(&["-f2"])
         .pipe_in_fixture(SKIP_FIELDS)
-        .run()
+        .succeeds()
         .stdout_is_fixture("skip-2-fields.expected");
 }
 
+#[test]
+fn test_stdin_skip_2_fields_obsolete() {
+    new_ucmd!()
+        .args(&["-2"])
+        .pipe_in_fixture(SKIP_FIELDS)
+        .succeeds()
+        .stdout_is_fixture("skip-2-fields.expected");
+}
+
+#[test]
+fn test_stdin_skip_21_fields() {
+    new_ucmd!()
+        .args(&["-f21"])
+        .pipe_in_fixture(SKIP_FIELDS)
+        .succeeds()
+        .stdout_is_fixture("skip-21-fields.expected");
+}
+
+#[test]
+fn test_stdin_skip_21_fields_obsolete() {
+    new_ucmd!()
+        .args(&["-21"])
+        .pipe_in_fixture(SKIP_FIELDS)
+        .succeeds()
+        .stdout_is_fixture("skip-21-fields.expected");
+}
+
+#[test]
+fn test_stdin_skip_invalid_fields_obsolete() {
+    new_ucmd!()
+        .args(&["-5q"])
+        .fails()
+        .stderr_contains("error: unexpected argument '-q' found\n");
+}
+
 #[test]
 fn test_stdin_all_repeated() {
     new_ucmd!()
         .args(&["--all-repeated"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=none"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=non"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=n"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("sorted-all-repeated.expected");
 }
 
@@ -102,12 +169,10 @@ fn test_all_repeated_followed_by_filename() {
     let filename = "test.txt";
     let (at, mut ucmd) = at_and_ucmd!();
 
-    let mut file = at.make_file(filename);
-    file.write_all(b"a\na\n").unwrap();
+    at.write(filename, "a\na\n");
 
     ucmd.args(&["--all-repeated", filename])
-        .run()
-        .success()
+        .succeeds()
         .stdout_is("a\na\n");
 }
 
@@ -116,7 +181,17 @@ fn test_stdin_all_repeated_separate() {
     new_ucmd!()
         .args(&["--all-repeated=separate"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated-separate.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=separat"]) // spell-checker:disable-line
+        .pipe_in_fixture(INPUT)
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated-separate.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=s"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("sorted-all-repeated-separate.expected");
 }
 
@@ -125,7 +200,17 @@ fn test_stdin_all_repeated_prepend() {
     new_ucmd!()
         .args(&["--all-repeated=prepend"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated-prepend.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=prepen"]) // spell-checker:disable-line
+        .pipe_in_fixture(INPUT)
+        .succeeds()
+        .stdout_is_fixture("sorted-all-repeated-prepend.expected");
+    new_ucmd!()
+        .args(&["--all-repeated=p"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("sorted-all-repeated-prepend.expected");
 }
 
@@ -134,7 +219,7 @@ fn test_stdin_unique_only() {
     new_ucmd!()
         .args(&["-u"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-unique-only.expected");
 }
 
@@ -143,7 +228,7 @@ fn test_stdin_repeated_only() {
     new_ucmd!()
         .args(&["-d"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-repeated-only.expected");
 }
 
@@ -152,7 +237,7 @@ fn test_stdin_ignore_case() {
     new_ucmd!()
         .args(&["-i"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-ignore-case.expected");
 }
 
@@ -161,19 +246,17 @@ fn test_stdin_zero_terminated() {
     new_ucmd!()
         .args(&["-z"])
         .pipe_in_fixture(SORTED_ZERO_TERMINATED)
-        .run()
+        .succeeds()
         .stdout_is_fixture("sorted-zero-terminated.expected");
 }
 
 #[test]
-fn test_invalid_utf8() {
+fn test_gnu_locale_fr_schar() {
     new_ucmd!()
-        .arg("not-utf8-sequence.txt")
-        .run()
-        .failure()
-        .stderr_only(
-        "uniq: failed to convert line to utf8: invalid utf-8 sequence of 1 bytes from index 0\n",
-    );
+        .args(&["-f1", "locale-fr-schar.txt"])
+        .env("LC_ALL", "C")
+        .succeeds()
+        .stdout_is_fixture_bytes("locale-fr-schar.txt");
 }
 
 #[test]
@@ -181,7 +264,7 @@ fn test_group() {
     new_ucmd!()
         .args(&["--group"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
         .stdout_is_fixture("group.expected");
 }
 
@@ -190,12 +273,10 @@ fn test_group_followed_by_filename() {
     let filename = "test.txt";
     let (at, mut ucmd) = at_and_ucmd!();
 
-    let mut file = at.make_file(filename);
-    file.write_all(b"a\na\n").unwrap();
+    at.write(filename, "a\na\n");
 
     ucmd.args(&["--group", filename])
-        .run()
-        .success()
+        .succeeds()
         .stdout_is("a\na\n");
 }
 
@@ -204,7 +285,12 @@ fn test_group_prepend() {
     new_ucmd!()
         .args(&["--group=prepend"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("group-prepend.expected");
+    new_ucmd!()
+        .args(&["--group=p"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("group-prepend.expected");
 }
 
@@ -213,7 +299,12 @@ fn test_group_append() {
     new_ucmd!()
         .args(&["--group=append"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("group-append.expected");
+    new_ucmd!()
+        .args(&["--group=a"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("group-append.expected");
 }
 
@@ -222,7 +313,17 @@ fn test_group_both() {
     new_ucmd!()
         .args(&["--group=both"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("group-both.expected");
+    new_ucmd!()
+        .args(&["--group=bot"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
+        .stdout_is_fixture("group-both.expected");
+    new_ucmd!()
+        .args(&["--group=b"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("group-both.expected");
 }
 
@@ -231,13 +332,18 @@ fn test_group_separate() {
     new_ucmd!()
         .args(&["--group=separate"])
         .pipe_in_fixture(INPUT)
-        .run()
+        .succeeds()
+        .stdout_is_fixture("group.expected");
+    new_ucmd!()
+        .args(&["--group=s"])
+        .pipe_in_fixture(INPUT)
+        .succeeds()
         .stdout_is_fixture("group.expected");
 }
 
 #[test]
 fn test_case2() {
-    new_ucmd!().pipe_in("a\na\n").run().stdout_is("a\n");
+    new_ucmd!().pipe_in("a\na\n").succeeds().stdout_is("a\n");
 }
 
 struct TestCase {
@@ -250,6 +356,7 @@ struct TestCase {
 }
 
 #[test]
+#[allow(clippy::too_many_lines)]
 fn gnu_tests() {
     let cases = [
         TestCase {
@@ -436,15 +543,15 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
-        // // Obsolete syntax for "-f 1"
-        // TestCase {
-        //     name: "obs30",
-        //     args: &["-1"],
-        //     input: "a a\nb a\n",
-        //     stdout: Some("a a\n"),
-        //     stderr: None,
-        //     exit: None,
-        // },
+        // Obsolete syntax for "-f 1"
+        TestCase {
+            name: "obs30",
+            args: &["-1"],
+            input: "a a\nb a\n",
+            stdout: Some("a a\n"),
+            stderr: None,
+            exit: None,
+        },
         TestCase {
             name: "31",
             args: &["-f", "1"],
@@ -485,23 +592,23 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
-        // // Obsolete syntax for "-s 1"
-        // TestCase {
-        //     name: "obs-plus40",
-        //     args: &["+1"],
-        //     input: "aaa\naaa\n",
-        //     stdout: Some("aaa\n"),
-        //     stderr: None,
-        //     exit: None,
-        // },
-        // TestCase {
-        //     name: "obs-plus41",
-        //     args: &["+1"],
-        //     input: "baa\naaa\n",
-        //     stdout: Some("baa\n"),
-        //     stderr: None,
-        //     exit: None,
-        // },
+        // Obsolete syntax for "-s 1"
+        TestCase {
+            name: "obs-plus40",
+            args: &["+1"],
+            input: "aaa\naaa\n",
+            stdout: Some("aaa\n"),
+            stderr: None,
+            exit: None,
+        },
+        TestCase {
+            name: "obs-plus41",
+            args: &["+1"],
+            input: "baa\naaa\n",
+            stdout: Some("baa\n"),
+            stderr: None,
+            exit: None,
+        },
         TestCase {
             name: "42",
             args: &["-s", "1"],
@@ -518,23 +625,23 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
-        // // Obsolete syntax for "-s 1"
-        // TestCase {
-        //     name: "obs-plus44",
-        //     args: &["+1", "--"],
-        //     input: "aaa\naaa\n",
-        //     stdout: Some("aaa\n"),
-        //     stderr: None,
-        //     exit: None,
-        // },
-        // TestCase {
-        //     name: "obs-plus45",
-        //     args: &["+1", "--"],
-        //     input: "baa\naaa\n",
-        //     stdout: Some("baa\n"),
-        //     stderr: None,
-        //     exit: None,
-        // },
+        // Obsolete syntax for "-s 1"
+        TestCase {
+            name: "obs-plus44",
+            args: &["+1", "--"],
+            input: "aaa\naaa\n",
+            stdout: Some("aaa\n"),
+            stderr: None,
+            exit: None,
+        },
+        TestCase {
+            name: "obs-plus45",
+            args: &["+1", "--"],
+            input: "baa\naaa\n",
+            stdout: Some("baa\n"),
+            stderr: None,
+            exit: None,
+        },
         TestCase {
             name: "50",
             args: &["-f", "1", "-s", "1"],
@@ -719,17 +826,17 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
-        /*
-        Disable as it fails too often. See:
-        https://github.com/uutils/coreutils/issues/3509
         TestCase {
             name: "112",
             args: &["-D", "-c"],
-            input: "a a\na b\n",
+            input: "", // Note: Different from GNU test, but should not matter
             stdout: Some(""),
-            stderr: Some("uniq: printing all duplicated lines and repeat counts is meaningless"),
+            stderr: Some(concat!(
+                "uniq: printing all duplicated lines and repeat counts is meaningless\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
             exit: Some(1),
-        },*/
+        },
         TestCase {
             name: "113",
             args: &["--all-repeated=separate"],
@@ -778,6 +885,21 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
+        TestCase {
+            name: "119",
+            args: &["--all-repeated=badoption"],
+            input: "", // Note: Different from GNU test, but should not matter
+            stdout: Some(""),
+            stderr: Some(concat!(
+                "uniq: invalid argument 'badoption' for '--all-repeated'\n",
+                "Valid arguments are:\n",
+                "  - 'none'\n",
+                "  - 'prepend'\n",
+                "  - 'separate'\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
+            exit: Some(1),
+        },
         // \x08 is the backspace char
         TestCase {
             name: "120",
@@ -787,6 +909,16 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
+        // u128::MAX = 340282366920938463463374607431768211455
+        TestCase {
+            name: "121",
+            args: &["-d", "-u", "-w340282366920938463463374607431768211456"],
+            input: "a\na\n\x08",
+            stdout: Some(""),
+            stderr: None,
+            exit: None,
+        },
+        // Test 122 is the same as 121, just different big int overflow number
         TestCase {
             name: "123",
             args: &["--zero-terminated"],
@@ -931,19 +1063,132 @@ fn gnu_tests() {
             stderr: None,
             exit: None,
         },
+        TestCase {
+            name: "141",
+            args: &["--group", "-c"],
+            input: "",
+            stdout: Some(""),
+            stderr: Some(concat!(
+                "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
+            exit: Some(1),
+        },
+        TestCase {
+            name: "142",
+            args: &["--group", "-d"],
+            input: "",
+            stdout: Some(""),
+            stderr: Some(concat!(
+                "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
+            exit: Some(1),
+        },
+        TestCase {
+            name: "143",
+            args: &["--group", "-u"],
+            input: "",
+            stdout: Some(""),
+            stderr: Some(concat!(
+                "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
+            exit: Some(1),
+        },
+        TestCase {
+            name: "144",
+            args: &["--group", "-D"],
+            input: "",
+            stdout: Some(""),
+            stderr: Some(concat!(
+                "uniq: --group is mutually exclusive with -c/-d/-D/-u\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
+            exit: Some(1),
+        },
+        TestCase {
+            name: "145",
+            args: &["--group=badoption"],
+            input: "",
+            stdout: Some(""),
+            stderr: Some(concat!(
+                "uniq: invalid argument 'badoption' for '--group'\n",
+                "Valid arguments are:\n",
+                "  - 'prepend'\n",
+                "  - 'append'\n",
+                "  - 'separate'\n",
+                "  - 'both'\n",
+                "Try 'uniq --help' for more information.\n"
+            )),
+            exit: Some(1),
+        },
     ];
 
+    // run regular version of tests with regular file as input
     for case in cases {
+        // prep input file
+        let (at, mut ucmd) = at_and_ucmd!();
+        at.write("input-file", case.input);
+
+        // first - run a version of tests with regular file as input
         eprintln!("Test {}", case.name);
-        let result = new_ucmd!().args(case.args).run_piped_stdin(case.input);
+        // set environment variable for obsolete skip char option tests
+        if case.name.starts_with("obs-plus") {
+            ucmd.env("_POSIX2_VERSION", OBSOLETE.to_string());
+        }
+        let result = ucmd.args(case.args).arg("input-file").run();
         if let Some(stdout) = case.stdout {
             result.stdout_is(stdout);
         }
         if let Some(stderr) = case.stderr {
-            result.stderr_contains(stderr);
+            result.stderr_is(stderr);
+        }
+        if let Some(exit) = case.exit {
+            result.code_is(exit);
+        }
+
+        // then - ".stdin" version of tests with input piped in
+        // NOTE: GNU has another variant for stdin redirect from a file
+        // as in `uniq < input-file`
+        // For now we treat it as equivalent of piped in stdin variant
+        // as in `cat input-file | uniq`
+        eprintln!("Test {}.stdin", case.name);
+        // set environment variable for obsolete skip char option tests
+        let mut ucmd = new_ucmd!();
+        if case.name.starts_with("obs-plus") {
+            ucmd.env("_POSIX2_VERSION", OBSOLETE.to_string());
+        }
+        let result = ucmd.args(case.args).run_piped_stdin(case.input);
+        if let Some(stdout) = case.stdout {
+            result.stdout_is(stdout);
+        }
+        if let Some(stderr) = case.stderr {
+            result.stderr_is(stderr);
         }
         if let Some(exit) = case.exit {
             result.code_is(exit);
         }
     }
 }
+
+#[test]
+fn test_stdin_w1_multibyte() {
+    let input = "à\ná\n";
+    new_ucmd!()
+        .args(&["-w1"])
+        .pipe_in(input)
+        .succeeds()
+        .stdout_is("à\ná\n");
+}
+
+#[cfg(target_os = "linux")]
+#[test]
+fn test_failed_write_is_reported() {
+    new_ucmd!()
+        .pipe_in("hello")
+        .args(&["-z"])
+        .set_stdout(std::fs::File::create("/dev/full").unwrap())
+        .fails()
+        .stderr_is("uniq: write error: No space left on device\n");
+}
diff --git a/tests/by-util/test_unlink.rs b/tests/by-util/test_unlink.rs
index 055f47f1076..36d1630d300 100644
--- a/tests/by-util/test_unlink.rs
+++ b/tests/by-util/test_unlink.rs
@@ -2,11 +2,14 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/by-util/test_uptime.rs b/tests/by-util/test_uptime.rs
index 3967d025251..7ec71cebad9 100644
--- a/tests/by-util/test_uptime.rs
+++ b/tests/by-util/test_uptime.rs
@@ -2,12 +2,31 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+//
+// spell-checker:ignore bincode serde utmp runlevel testusr testx
+#![allow(clippy::cast_possible_wrap, clippy::unreadable_literal)]
+
+#[cfg(not(any(target_os = "openbsd", target_os = "freebsd")))]
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
+
+#[cfg(not(any(target_os = "macos", target_os = "openbsd", target_env = "musl")))]
+use bincode::{config, serde::encode_to_vec};
 use regex::Regex;
+#[cfg(not(any(target_os = "macos", target_os = "openbsd", target_env = "musl")))]
+use serde::Serialize;
+#[cfg(not(any(target_os = "macos", target_os = "openbsd", target_env = "musl")))]
+use serde_big_array::BigArray;
+#[cfg(not(any(target_os = "macos", target_os = "openbsd", target_env = "musl")))]
+use std::fs::File;
+#[cfg(not(any(target_os = "macos", target_os = "openbsd", target_env = "musl")))]
+use std::{io::Write, path::PathBuf};
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -21,14 +40,245 @@ fn test_uptime() {
     // Don't check for users as it doesn't show in some CI
 }
 
+/// Checks for files without utmpx records for which boot time cannot be calculated
 #[test]
-fn test_uptime_since() {
-    let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}").unwrap();
+#[cfg(not(any(target_os = "openbsd", target_os = "freebsd")))]
+// Disabled for freebsd, since it doesn't use the utmpxname() sys call to change the default utmpx
+// file that is accessed using getutxent()
+fn test_uptime_for_file_without_utmpx_records() {
+    let (at, mut ucmd) = at_and_ucmd!();
+    at.write("file1", "hello");
 
-    new_ucmd!().arg("--since").succeeds().stdout_matches(&re);
+    ucmd.arg(at.plus_as_string("file1"))
+        .fails()
+        .stderr_contains("uptime: couldn't get boot time")
+        .stdout_contains("up ???? days ??:??")
+        .stdout_contains("load average");
+}
+
+/// Checks whether uptime displays the correct stderr msg when its called with a fifo
+#[test]
+#[cfg(all(unix, feature = "cp"))]
+fn test_uptime_with_fifo() {
+    // This test can go on forever in the CI in some cases, might need aborting
+    // Sometimes writing to the pipe is broken
+    let ts = TestScenario::new(util_name!());
+
+    let at = &ts.fixtures;
+    at.mkfifo("fifo1");
+
+    at.write("a", "hello");
+    // Creating a child process to write to the fifo
+    let mut child = ts
+        .ccmd("cp")
+        .arg(at.plus_as_string("a"))
+        .arg(at.plus_as_string("fifo1"))
+        .run_no_wait();
+
+    ts.ucmd()
+        .arg("fifo1")
+        .fails()
+        .stderr_contains("uptime: couldn't get boot time")
+        .stdout_contains("up ???? days ??:??")
+        .stdout_contains("load average");
+
+    child.kill();
+}
+
+#[test]
+#[cfg(not(target_os = "freebsd"))]
+fn test_uptime_with_non_existent_file() {
+    // Disabled for freebsd, since it doesn't use the utmpxname() sys call to change the default utmpx
+    // file that is accessed using getutxent()
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .arg("file1")
+        .fails()
+        .stderr_contains("uptime: couldn't get boot time: No such file or directory")
+        .stdout_contains("up ???? days ??:??");
 }
 
+// TODO create a similar test for macos
+// This will pass
 #[test]
-fn test_failed() {
-    new_ucmd!().arg("will-fail").fails();
+#[cfg(not(any(target_os = "openbsd", target_os = "macos")))]
+#[cfg(not(target_env = "musl"))]
+#[cfg_attr(
+    all(target_arch = "aarch64", target_os = "linux"),
+    ignore = "Issue #7159 - Test not supported on ARM64 Linux"
+)]
+#[allow(clippy::too_many_lines, clippy::items_after_statements)]
+fn test_uptime_with_file_containing_valid_boot_time_utmpx_record() {
+    // This test will pass for freebsd but we currently don't support changing the utmpx file for
+    // freebsd.
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    // Regex matches for "up   00::00" ,"up 12 days  00::00", the time can be any valid time and
+    // the days can be more than 1 digit or not there. This will match even if the amount of whitespace is
+    // wrong between the days and the time.
+
+    let re = Regex::new(r"up [(\d){1,} days]*\d{1,2}:\d\d").unwrap();
+    utmp(&at.plus("testx"));
+    ts.ucmd()
+        .arg("testx")
+        .succeeds()
+        .stdout_matches(&re)
+        .stdout_contains("load average");
+
+    // Helper function to create byte sequences
+    fn slice_32(slice: &[u8]) -> [i8; 32] {
+        let mut arr: [i8; 32] = [0; 32];
+
+        for (i, val) in slice.iter().enumerate() {
+            arr[i] = *val as i8;
+        }
+        arr
+    }
+
+    // Creates a file utmp records of three different types including a valid BOOT_TIME entry
+    fn utmp(path: &PathBuf) {
+        // Definitions of our utmpx structs
+        const BOOT_TIME: i32 = 2;
+        const RUN_LVL: i32 = 1;
+        const USER_PROCESS: i32 = 7;
+
+        #[derive(Serialize)]
+        #[repr(C)]
+        pub struct TimeVal {
+            pub tv_sec: i32,
+            pub tv_usec: i32,
+        }
+
+        #[derive(Serialize)]
+        #[repr(C)]
+        pub struct ExitStatus {
+            e_termination: i16,
+            e_exit: i16,
+        }
+
+        #[derive(Serialize)]
+        #[repr(C, align(4))]
+        pub struct Utmp {
+            pub ut_type: i32,
+            pub ut_pid: i32,
+            pub ut_line: [i8; 32],
+            pub ut_id: [i8; 4],
+
+            pub ut_user: [i8; 32],
+            #[serde(with = "BigArray")]
+            pub ut_host: [i8; 256],
+            pub ut_exit: ExitStatus,
+            pub ut_session: i32,
+            pub ut_tv: TimeVal,
+
+            pub ut_addr_v6: [i32; 4],
+            glibc_reserved: [i8; 20],
+        }
+
+        let utmp = Utmp {
+            ut_type: BOOT_TIME,
+            ut_pid: 0,
+            ut_line: slice_32("~".as_bytes()),
+            ut_id: [126, 126, 0, 0],
+            ut_user: slice_32("reboot".as_bytes()),
+            ut_host: [0; 256],
+            ut_exit: ExitStatus {
+                e_termination: 0,
+                e_exit: 0,
+            },
+            ut_session: 0,
+            ut_tv: TimeVal {
+                tv_sec: 1716371201,
+                tv_usec: 290913,
+            },
+            ut_addr_v6: [127, 0, 0, 1],
+            glibc_reserved: [0; 20],
+        };
+        let utmp1 = Utmp {
+            ut_type: RUN_LVL,
+            ut_pid: std::process::id() as i32,
+            ut_line: slice_32("~".as_bytes()),
+            ut_id: [126, 126, 0, 0],
+            ut_user: slice_32("runlevel".as_bytes()),
+            ut_host: [0; 256],
+            ut_exit: ExitStatus {
+                e_termination: 0,
+                e_exit: 0,
+            },
+            ut_session: 0,
+            ut_tv: TimeVal {
+                tv_sec: 1716371209,
+                tv_usec: 162250,
+            },
+            ut_addr_v6: [0, 0, 0, 0],
+            glibc_reserved: [0; 20],
+        };
+        let utmp2 = Utmp {
+            ut_type: USER_PROCESS,
+            ut_pid: std::process::id() as i32,
+            ut_line: slice_32(":1".as_bytes()),
+            ut_id: [126, 126, 0, 0],
+            ut_user: slice_32("testusr".as_bytes()),
+            ut_host: [0; 256],
+            ut_exit: ExitStatus {
+                e_termination: 0,
+                e_exit: 0,
+            },
+            ut_session: 0,
+            ut_tv: TimeVal {
+                tv_sec: 1716371283,
+                tv_usec: 858764,
+            },
+            ut_addr_v6: [0, 0, 0, 0],
+            glibc_reserved: [0; 20],
+        };
+
+        let config = config::legacy();
+        let mut buf = encode_to_vec(utmp, config).unwrap();
+        buf.append(&mut encode_to_vec(utmp1, config).unwrap());
+        buf.append(&mut encode_to_vec(utmp2, config).unwrap());
+        let mut f = File::create(path).unwrap();
+        f.write_all(&buf).unwrap();
+    }
+}
+
+#[test]
+fn test_uptime_with_extra_argument() {
+    let ts = TestScenario::new(util_name!());
+
+    ts.ucmd()
+        .arg("a")
+        .arg("b")
+        .fails()
+        .stderr_contains("unexpected value 'b'");
+}
+/// Checks whether uptime displays the correct stderr msg when its called with a directory
+#[test]
+fn test_uptime_with_dir() {
+    let ts = TestScenario::new(util_name!());
+    let at = &ts.fixtures;
+    at.mkdir("dir1");
+
+    ts.ucmd()
+        .arg("dir1")
+        .fails()
+        .stderr_contains("uptime: couldn't get boot time: Is a directory")
+        .stdout_contains("up ???? days ??:??");
+}
+
+#[test]
+#[cfg(target_os = "openbsd")]
+fn test_uptime_check_users_openbsd() {
+    new_ucmd!()
+        .args(&["openbsd_utmp"])
+        .succeeds()
+        .stdout_contains("4 users");
+}
+
+#[test]
+fn test_uptime_since() {
+    let re = Regex::new(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}").unwrap();
+
+    new_ucmd!().arg("--since").succeeds().stdout_matches(&re);
 }
diff --git a/tests/by-util/test_users.rs b/tests/by-util/test_users.rs
index 766378a9dca..ec77ffff5e0 100644
--- a/tests/by-util/test_users.rs
+++ b/tests/by-util/test_users.rs
@@ -2,11 +2,13 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -21,11 +23,9 @@ fn test_users_check_name() {
     #[cfg(target_os = "linux")]
     let util_name = util_name!();
     #[cfg(target_vendor = "apple")]
-    let util_name = format!("g{}", util_name!());
+    let util_name = &format!("g{}", util_name!());
 
-    // note: clippy::needless_borrow *false positive*
-    #[allow(clippy::needless_borrow)]
-    let expected = TestScenario::new(&util_name)
+    let expected = TestScenario::new(util_name)
         .cmd(util_name)
         .env("LC_ALL", "C")
         .succeeds()
@@ -33,3 +33,12 @@ fn test_users_check_name() {
 
     new_ucmd!().succeeds().stdout_is(&expected);
 }
+
+#[test]
+#[cfg(target_os = "openbsd")]
+fn test_users_check_name_openbsd() {
+    new_ucmd!()
+        .args(&["openbsd_utmp"])
+        .succeeds()
+        .stdout_contains("test");
+}
diff --git a/tests/by-util/test_vdir.rs b/tests/by-util/test_vdir.rs
index 97d5b847fb8..cf389f45e1b 100644
--- a/tests/by-util/test_vdir.rs
+++ b/tests/by-util/test_vdir.rs
@@ -2,8 +2,10 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::TestScenario;
 use regex::Regex;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 /*
  * 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 6417470c57f..b97d6c471be 100644
--- a/tests/by-util/test_wc.rs
+++ b/tests/by-util/test_wc.rs
@@ -2,13 +2,17 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-use crate::common::util::{vec_of_size, TestScenario};
 
-// spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars
+#[cfg(target_os = "linux")]
+use uutests::at_and_ucmd;
+use uutests::new_ucmd;
+use uutests::util::{TestScenario, vec_of_size};
+use uutests::util_name;
 
+// spell-checker:ignore (flags) lwmcL clmwL ; (path) bogusfile emptyfile manyemptylines moby notrailingnewline onelongemptyline onelongword weirdchars
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
@@ -43,7 +47,7 @@ fn test_count_bytes_large_stdin() {
 fn test_stdin_default() {
     new_ucmd!()
         .pipe_in_fixture("lorem_ipsum.txt")
-        .run()
+        .succeeds()
         .stdout_is("     13     109     772\n");
 }
 
@@ -52,7 +56,7 @@ fn test_stdin_explicit() {
     new_ucmd!()
         .pipe_in_fixture("lorem_ipsum.txt")
         .arg("-")
-        .run()
+        .succeeds()
         .stdout_is("     13     109     772 -\n");
 }
 
@@ -61,7 +65,7 @@ fn test_utf8() {
     new_ucmd!()
         .args(&["-lwmcL"])
         .pipe_in_fixture("UTF_8_test.txt")
-        .run()
+        .succeeds()
         .stdout_is("    303    2119   22457   23025      79\n");
 }
 
@@ -70,8 +74,8 @@ fn test_utf8_words() {
     new_ucmd!()
         .arg("-w")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("87\n");
+        .succeeds()
+        .stdout_is("89\n");
 }
 
 #[test]
@@ -79,8 +83,8 @@ fn test_utf8_line_length_words() {
     new_ucmd!()
         .arg("-Lw")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("     87      48\n");
+        .succeeds()
+        .stdout_is("     89      48\n");
 }
 
 #[test]
@@ -88,7 +92,7 @@ fn test_utf8_line_length_chars() {
     new_ucmd!()
         .arg("-Lm")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("    442      48\n");
 }
 
@@ -97,8 +101,8 @@ fn test_utf8_line_length_chars_words() {
     new_ucmd!()
         .arg("-Lmw")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("     87     442      48\n");
+        .succeeds()
+        .stdout_is("     89     442      48\n");
 }
 
 #[test]
@@ -106,7 +110,7 @@ fn test_utf8_chars() {
     new_ucmd!()
         .arg("-m")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("442\n");
 }
 
@@ -115,7 +119,7 @@ fn test_utf8_bytes_chars() {
     new_ucmd!()
         .arg("-cm")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("    442     513\n");
 }
 
@@ -124,7 +128,7 @@ fn test_utf8_bytes_lines() {
     new_ucmd!()
         .arg("-cl")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("     25     513\n");
 }
 
@@ -133,7 +137,7 @@ fn test_utf8_bytes_chars_lines() {
     new_ucmd!()
         .arg("-cml")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("     25     442     513\n");
 }
 
@@ -142,8 +146,8 @@ fn test_utf8_chars_words() {
     new_ucmd!()
         .arg("-mw")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("     87     442\n");
+        .succeeds()
+        .stdout_is("     89     442\n");
 }
 
 #[test]
@@ -151,7 +155,7 @@ fn test_utf8_line_length_lines() {
     new_ucmd!()
         .arg("-Ll")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("     25      48\n");
 }
 
@@ -160,8 +164,8 @@ fn test_utf8_line_length_lines_words() {
     new_ucmd!()
         .arg("-Llw")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("     25      87      48\n");
+        .succeeds()
+        .stdout_is("     25      89      48\n");
 }
 
 #[test]
@@ -169,7 +173,7 @@ fn test_utf8_lines_chars() {
     new_ucmd!()
         .arg("-ml")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("     25     442\n");
 }
 
@@ -178,8 +182,8 @@ fn test_utf8_lines_words_chars() {
     new_ucmd!()
         .arg("-mlw")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("     25      87     442\n");
+        .succeeds()
+        .stdout_is("     25      89     442\n");
 }
 
 #[test]
@@ -187,7 +191,7 @@ fn test_utf8_line_length_lines_chars() {
     new_ucmd!()
         .arg("-Llm")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
+        .succeeds()
         .stdout_is("     25     442      48\n");
 }
 
@@ -196,8 +200,18 @@ fn test_utf8_all() {
     new_ucmd!()
         .arg("-lwmcL")
         .pipe_in_fixture("UTF_8_weirdchars.txt")
-        .run()
-        .stdout_is("     25      87     442     513      48\n");
+        .succeeds()
+        .stdout_is("     25      89     442     513      48\n");
+}
+
+#[test]
+fn test_ascii_control() {
+    // GNU coreutils "d1" test
+    new_ucmd!()
+        .arg("-w")
+        .pipe_in(*b"\x01\n")
+        .succeeds()
+        .stdout_is("1\n");
 }
 
 #[test]
@@ -205,7 +219,7 @@ fn test_stdin_line_len_regression() {
     new_ucmd!()
         .args(&["-L"])
         .pipe_in("\n123456")
-        .run()
+        .succeeds()
         .stdout_is("6\n");
 }
 
@@ -214,7 +228,7 @@ fn test_stdin_only_bytes() {
     new_ucmd!()
         .args(&["-c"])
         .pipe_in_fixture("lorem_ipsum.txt")
-        .run()
+        .succeeds()
         .stdout_is("772\n");
 }
 
@@ -223,7 +237,7 @@ fn test_stdin_all_counts() {
     new_ucmd!()
         .args(&["-c", "-m", "-l", "-L", "-w"])
         .pipe_in_fixture("alice_in_wonderland.txt")
-        .run()
+        .succeeds()
         .stdout_is("      5      57     302     302      66\n");
 }
 
@@ -231,7 +245,7 @@ fn test_stdin_all_counts() {
 fn test_single_default() {
     new_ucmd!()
         .arg("moby_dick.txt")
-        .run()
+        .succeeds()
         .stdout_is("  18  204 1115 moby_dick.txt\n");
 }
 
@@ -239,15 +253,23 @@ fn test_single_default() {
 fn test_single_only_lines() {
     new_ucmd!()
         .args(&["-l", "moby_dick.txt"])
-        .run()
+        .succeeds()
         .stdout_is("18 moby_dick.txt\n");
 }
 
+#[test]
+fn test_single_only_bytes() {
+    new_ucmd!()
+        .args(&["-c", "lorem_ipsum.txt"])
+        .succeeds()
+        .stdout_is("772 lorem_ipsum.txt\n");
+}
+
 #[test]
 fn test_single_all_counts() {
     new_ucmd!()
         .args(&["-c", "-l", "-L", "-m", "-w", "alice_in_wonderland.txt"])
-        .run()
+        .succeeds()
         .stdout_is("  5  57 302 302  66 alice_in_wonderland.txt\n");
 }
 
@@ -261,10 +283,36 @@ fn test_gnu_compatible_quotation() {
     scene
         .ucmd()
         .args(&["some-dir1/12\n34.txt"])
-        .run()
+        .succeeds()
         .stdout_is("0 0 0 'some-dir1/12'$'\\n''34.txt'\n");
 }
 
+#[cfg(feature = "test_risky_names")]
+#[test]
+fn test_non_unicode_names() {
+    let scene = TestScenario::new(util_name!());
+    let target1 = uucore::os_str_from_bytes(b"some-dir1/1\xC0\n.txt")
+        .expect("Only unix platforms can test non-unicode names");
+    let target2 = uucore::os_str_from_bytes(b"some-dir1/2\xC0\t.txt")
+        .expect("Only unix platforms can test non-unicode names");
+    let at = &scene.fixtures;
+    at.mkdir("some-dir1");
+    at.touch(&target1);
+    at.touch(&target2);
+    scene
+        .ucmd()
+        .args(&[target1, target2])
+        .succeeds()
+        .stdout_is_bytes(
+            [
+                b"0 0 0 'some-dir1/1'$'\\300\\n''.txt'\n".to_vec(),
+                b"0 0 0 some-dir1/2\xC0\t.txt\n".to_vec(),
+                b"0 0 0 total\n".to_vec(),
+            ]
+            .concat(),
+        );
+}
+
 #[test]
 fn test_multiple_default() {
     new_ucmd!()
@@ -274,7 +322,7 @@ fn test_multiple_default() {
             "alice_in_wonderland.txt",
             "alice in wonderland.txt",
         ])
-        .run()
+        .succeeds()
         .stdout_is(concat!(
             "  13  109  772 lorem_ipsum.txt\n",
             "  18  204 1115 moby_dick.txt\n",
@@ -289,7 +337,7 @@ fn test_multiple_default() {
 fn test_file_empty() {
     new_ucmd!()
         .args(&["-clmwL", "emptyfile.txt"])
-        .run()
+        .succeeds()
         .stdout_is("0 0 0 0 0 emptyfile.txt\n");
 }
 
@@ -299,7 +347,7 @@ fn test_file_empty() {
 fn test_file_single_line_no_trailing_newline() {
     new_ucmd!()
         .args(&["-clmwL", "notrailingnewline.txt"])
-        .run()
+        .succeeds()
         .stdout_is("1 1 2 2 1 notrailingnewline.txt\n");
 }
 
@@ -309,7 +357,7 @@ fn test_file_single_line_no_trailing_newline() {
 fn test_file_many_empty_lines() {
     new_ucmd!()
         .args(&["-clmwL", "manyemptylines.txt"])
-        .run()
+        .succeeds()
         .stdout_is("100   0 100 100   0 manyemptylines.txt\n");
 }
 
@@ -318,7 +366,7 @@ fn test_file_many_empty_lines() {
 fn test_file_one_long_line_only_spaces() {
     new_ucmd!()
         .args(&["-clmwL", "onelongemptyline.txt"])
-        .run()
+        .succeeds()
         .stdout_is("    1     0 10001 10001 10000 onelongemptyline.txt\n");
 }
 
@@ -327,7 +375,7 @@ fn test_file_one_long_line_only_spaces() {
 fn test_file_one_long_word() {
     new_ucmd!()
         .args(&["-clmwL", "onelongword.txt"])
-        .run()
+        .succeeds()
         .stdout_is("    1     1 10001 10001 10000 onelongword.txt\n");
 }
 
@@ -339,48 +387,49 @@ fn test_file_one_long_word() {
 /// bytes are displayed.
 #[test]
 fn test_file_bytes_dictate_width() {
+    // . is a directory, so minimum_width should get set to 7
+    #[cfg(not(windows))]
+    const STDOUT: &str = concat!(
+        "      0       0       0 emptyfile.txt\n",
+        "      0       0       0 .\n",
+        "      0       0       0 total\n",
+    );
+    #[cfg(windows)]
+    const STDOUT: &str = concat!(
+        "      0       0       0 emptyfile.txt\n",
+        "      0       0       0 total\n",
+    );
+
     // This file has 10,001 bytes. Five digits are required to
     // represent that. Even though the number of lines is 1 and the
     // number of words is 0, each of those counts is formatted with
     // five characters, filled with whitespace.
     new_ucmd!()
         .args(&["-lw", "onelongemptyline.txt"])
-        .run()
+        .succeeds()
         .stdout_is("    1     0 onelongemptyline.txt\n");
 
     // This file has zero bytes. Only one digit is required to
     // represent that.
     new_ucmd!()
         .args(&["-lw", "emptyfile.txt"])
-        .run()
+        .succeeds()
         .stdout_is("0 0 emptyfile.txt\n");
 
     // lorem_ipsum.txt contains 772 bytes, and alice_in_wonderland.txt contains
     // 302 bytes. The total is 1074 bytes, which has a width of 4
     new_ucmd!()
         .args(&["-lwc", "alice_in_wonderland.txt", "lorem_ipsum.txt"])
-        .run()
+        .succeeds()
         .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 = concat!(
-        "      0       0       0 emptyfile.txt\n",
-        "      0       0       0 .\n",
-        "      0       0       0 total\n",
-    );
-    #[cfg(windows)]
-    const STDOUT: &str = concat!(
-        "      0       0       0 emptyfile.txt\n",
-        "      0       0       0 total\n",
-    );
     new_ucmd!()
         .args(&["-lwc", "emptyfile.txt", "."])
-        .run()
+        .fails()
         .stdout_is(STDOUT);
 }
 
@@ -419,11 +468,24 @@ fn test_files_from_pseudo_filesystem() {
     use pretty_assertions::assert_ne;
     let result = new_ucmd!().arg("-c").arg("/proc/cpuinfo").succeeds();
     assert_ne!(result.stdout_str(), "0 /proc/cpuinfo\n");
+
+    // the following block fails on Android with a "Permission denied" error
+    #[cfg(target_os = "linux")]
+    {
+        let (at, mut ucmd) = at_and_ucmd!();
+        let result = ucmd.arg("-c").arg("/sys/kernel/profiling").succeeds();
+        let actual = at.read("/sys/kernel/profiling").len();
+        assert_eq!(
+            result.stdout_str(),
+            format!("{actual} /sys/kernel/profiling\n")
+        );
+    }
 }
 
 #[test]
 fn test_files0_disabled_files_argument() {
-    const MSG: &str = "file operands cannot be combined with --files0-from";
+    const MSG: &str =
+        "extra operand 'lorem_ipsum.txt'\nfile operands cannot be combined with --files0-from";
     new_ucmd!()
         .args(&["--files0-from=files0_list.txt"])
         .arg("lorem_ipsum.txt")
@@ -437,8 +499,7 @@ fn test_files0_from() {
     // file
     new_ucmd!()
         .args(&["--files0-from=files0_list.txt"])
-        .run()
-        .success()
+        .succeeds()
         .stdout_is(concat!(
             "  13  109  772 lorem_ipsum.txt\n",
             "  18  204 1115 moby_dick.txt\n",
@@ -450,8 +511,7 @@ fn test_files0_from() {
     new_ucmd!()
         .args(&["--files0-from=-"])
         .pipe_in_fixture("files0_list.txt")
-        .run()
-        .success()
+        .succeeds()
         .stdout_is(concat!(
             "13 109 772 lorem_ipsum.txt\n",
             "18 204 1115 moby_dick.txt\n",
@@ -465,7 +525,7 @@ fn test_files0_from_with_stdin() {
     new_ucmd!()
         .args(&["--files0-from=-"])
         .pipe_in("lorem_ipsum.txt")
-        .run()
+        .succeeds()
         .stdout_is("13 109 772 lorem_ipsum.txt\n");
 }
 
@@ -474,7 +534,7 @@ fn test_files0_from_with_stdin_in_file() {
     new_ucmd!()
         .args(&["--files0-from=files0_list_with_stdin.txt"])
         .pipe_in_fixture("alice_in_wonderland.txt")
-        .run()
+        .succeeds()
         .stdout_is(concat!(
             "     13     109     772 lorem_ipsum.txt\n",
             "     18     204    1115 moby_dick.txt\n",
@@ -498,12 +558,16 @@ fn test_files0_from_with_stdin_try_read_from_stdin() {
 fn test_total_auto() {
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "--total=auto"])
-        .run()
+        .succeeds()
+        .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "--tot=au"])
+        .succeeds()
         .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
 
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=auto"])
-        .run()
+        .succeeds()
         .stdout_is(concat!(
             "  13  109  772 lorem_ipsum.txt\n",
             "  18  204 1115 moby_dick.txt\n",
@@ -515,7 +579,14 @@ fn test_total_auto() {
 fn test_total_always() {
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "--total=always"])
-        .run()
+        .succeeds()
+        .stdout_is(concat!(
+            " 13 109 772 lorem_ipsum.txt\n",
+            " 13 109 772 total\n",
+        ));
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "--total=al"])
+        .succeeds()
         .stdout_is(concat!(
             " 13 109 772 lorem_ipsum.txt\n",
             " 13 109 772 total\n",
@@ -523,7 +594,7 @@ fn test_total_always() {
 
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=always"])
-        .run()
+        .succeeds()
         .stdout_is(concat!(
             "  13  109  772 lorem_ipsum.txt\n",
             "  18  204 1115 moby_dick.txt\n",
@@ -535,12 +606,19 @@ fn test_total_always() {
 fn test_total_never() {
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "--total=never"])
-        .run()
+        .succeeds()
         .stdout_is(" 13 109 772 lorem_ipsum.txt\n");
 
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=never"])
-        .run()
+        .succeeds()
+        .stdout_is(concat!(
+            "  13  109  772 lorem_ipsum.txt\n",
+            "  18  204 1115 moby_dick.txt\n",
+        ));
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=n"])
+        .succeeds()
         .stdout_is(concat!(
             "  13  109  772 lorem_ipsum.txt\n",
             "  18  204 1115 moby_dick.txt\n",
@@ -551,12 +629,16 @@ fn test_total_never() {
 fn test_total_only() {
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "--total=only"])
-        .run()
+        .succeeds()
         .stdout_is("13 109 772\n");
 
     new_ucmd!()
         .args(&["lorem_ipsum.txt", "moby_dick.txt", "--total=only"])
-        .run()
+        .succeeds()
+        .stdout_is("31 313 1887\n");
+    new_ucmd!()
+        .args(&["lorem_ipsum.txt", "moby_dick.txt", "--t=o"])
+        .succeeds()
         .stdout_is("31 313 1887\n");
 }
 
@@ -570,8 +652,7 @@ fn test_zero_length_files() {
         new_ucmd!()
             .args(&["--files0-from=-"])
             .pipe_in(&LIST[..l])
-            .run()
-            .failure()
+            .fails()
             .stdout_is(concat!(
                 "18 204 1115 moby_dick.txt\n",
                 "5 57 302 alice_in_wonderland.txt\n",
@@ -595,8 +676,7 @@ fn test_zero_length_files() {
                 .copied()
                 .collect::<Vec<_>>(),
         )
-        .run()
-        .failure()
+        .fails()
         .stdout_is(concat!(
             "18 204 1115 moby_dick.txt\n",
             "5 57 302 alice_in_wonderland.txt\n",
@@ -615,8 +695,7 @@ fn test_zero_length_files() {
 fn test_files0_errors_quoting() {
     new_ucmd!()
         .args(&["--files0-from=files0 with nonexistent.txt"])
-        .run()
-        .failure()
+        .fails()
         .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",
@@ -684,6 +763,10 @@ fn files0_from_dir() {
             concat!("wc: cannot open ", $p, " for reading: Permission denied\n")
         };
     }
+    #[cfg(windows)]
+    const DOT_ERR: &str = dir_err!("'.'");
+    #[cfg(not(windows))]
+    const DOT_ERR: &str = dir_err!(".");
 
     new_ucmd!()
         .args(&["--files0-from=dir with spaces"])
@@ -691,10 +774,6 @@ fn files0_from_dir() {
         .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()
@@ -708,3 +787,16 @@ fn files0_from_dir() {
         .fails()
         .stderr_only(dir_err!("-"));
 }
+
+#[test]
+fn test_args_override() {
+    new_ucmd!()
+        .args(&["-ll", "-l", "alice_in_wonderland.txt"])
+        .succeeds()
+        .stdout_is("5 alice_in_wonderland.txt\n");
+
+    new_ucmd!()
+        .args(&["--total=always", "--total=never", "alice_in_wonderland.txt"])
+        .succeeds()
+        .stdout_is("  5  57 302 alice_in_wonderland.txt\n");
+}
diff --git a/tests/by-util/test_who.rs b/tests/by-util/test_who.rs
index 3bacc38c112..74475895cb0 100644
--- a/tests/by-util/test_who.rs
+++ b/tests/by-util/test_who.rs
@@ -5,11 +5,13 @@
 
 // spell-checker:ignore (flags) runlevel mesg
 
-use crate::common::util::{expected_result, TestScenario};
-
+use uutests::new_ucmd;
+use uutests::unwrap_or_return;
+use uutests::util::{TestScenario, expected_result};
+use uutests::util_name;
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[cfg(unix)]
@@ -25,6 +27,11 @@ fn test_count() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
+#[cfg_attr(
+    all(target_arch = "aarch64", target_os = "linux"),
+    ignore = "Issue #7174 - Test not supported on ARM64 Linux"
+)]
 fn test_boot() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-b", "--boot", "--b"] {
@@ -65,6 +72,7 @@ fn test_short() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_login() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-l", "--login", "--log"] {
@@ -75,6 +83,7 @@ fn test_login() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_m() {
     let ts = TestScenario::new(util_name!());
     let expected_stdout = unwrap_or_return!(expected_result(&ts, &["-m"])).stdout_move_str();
@@ -83,6 +92,7 @@ fn test_m() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_process() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-p", "--process", "--p"] {
@@ -93,6 +103,7 @@ fn test_process() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_runlevel() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-r", "--runlevel", "--r"] {
@@ -106,6 +117,7 @@ fn test_runlevel() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_time() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-t", "--time", "--t"] {
@@ -141,6 +153,7 @@ fn test_mesg() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_arg1_arg2() {
     let args = ["am", "i"];
     let ts = TestScenario::new(util_name!());
@@ -195,6 +208,7 @@ fn test_lookup() {
 
 #[cfg(unix)]
 #[test]
+#[cfg(not(target_os = "openbsd"))]
 fn test_dead() {
     let ts = TestScenario::new(util_name!());
     for opt in ["-d", "--dead", "--de"] {
diff --git a/tests/by-util/test_whoami.rs b/tests/by-util/test_whoami.rs
index d32c4ec243c..32fdf719aa7 100644
--- a/tests/by-util/test_whoami.rs
+++ b/tests/by-util/test_whoami.rs
@@ -3,26 +3,29 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use uutests::new_ucmd;
 #[cfg(unix)]
-use crate::common::util::expected_result;
-use crate::common::util::{is_ci, whoami, TestScenario};
+use uutests::unwrap_or_return;
+#[cfg(unix)]
+use uutests::util::expected_result;
+use uutests::util::{TestScenario, is_ci, whoami};
+use uutests::util_name;
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
 #[cfg(unix)]
 fn test_normal() {
     let ts = TestScenario::new(util_name!());
-    let result = ts.ucmd().run();
     let exp_result = unwrap_or_return!(expected_result(&ts, &[]));
+    let result = ts.ucmd().succeeds();
 
     result
         .stdout_is(exp_result.stdout_str())
-        .stderr_is(exp_result.stderr_str())
-        .code_is(exp_result.code());
+        .stderr_is(exp_result.stderr_str());
 }
 
 #[test]
diff --git a/tests/by-util/test_yes.rs b/tests/by-util/test_yes.rs
index f40d6d5b8e2..b2706de75eb 100644
--- a/tests/by-util/test_yes.rs
+++ b/tests/by-util/test_yes.rs
@@ -3,12 +3,14 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 use std::ffi::OsStr;
-use std::process::{ExitStatus, Stdio};
+use std::process::ExitStatus;
 
 #[cfg(unix)]
 use std::os::unix::process::ExitStatusExt;
 
-use crate::common::util::TestScenario;
+use uutests::new_ucmd;
+use uutests::util::TestScenario;
+use uutests::util_name;
 
 #[cfg(unix)]
 fn check_termination(result: ExitStatus) {
@@ -22,21 +24,15 @@ fn check_termination(result: ExitStatus) {
 
 const NO_ARGS: &[&str] = &[];
 
-/// Run `yes`, capture some of the output, close the pipe, and verify it.
+/// Run `yes`, capture some of the output, then check exit status.
 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);
-    assert_eq!(buf.as_slice(), expected);
+    let result = new_ucmd!().args(args).run_stdout_starts_with(expected);
+    check_termination(result.exit_status());
 }
 
 #[test]
 fn test_invalid_arg() {
-    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    new_ucmd!().arg("--definitely-invalid").fails_with_code(1);
 }
 
 #[test]
diff --git a/tests/fixtures/cksum/base64/blake2b_single_file.expected b/tests/fixtures/cksum/base64/blake2b_single_file.expected
new file mode 100644
index 00000000000..18bec38f017
--- /dev/null
+++ b/tests/fixtures/cksum/base64/blake2b_single_file.expected
@@ -0,0 +1 @@
+BLAKE2b (lorem_ipsum.txt) = DpegkYnlYMN4nAv/HwIBZoYe+FfR+/5FdN4YQuPAbKu5V15K9jCaFmFYwrQI08A4wbSdgos1FYFCzcA5bRGVww==
diff --git a/tests/fixtures/cksum/base64/bsd_single_file.expected b/tests/fixtures/cksum/base64/bsd_single_file.expected
new file mode 100644
index 00000000000..293ada3bd61
--- /dev/null
+++ b/tests/fixtures/cksum/base64/bsd_single_file.expected
@@ -0,0 +1 @@
+08109     1 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/base64/crc_single_file.expected b/tests/fixtures/cksum/base64/crc_single_file.expected
new file mode 100644
index 00000000000..e9fc1ca7cf4
--- /dev/null
+++ b/tests/fixtures/cksum/base64/crc_single_file.expected
@@ -0,0 +1 @@
+378294376 772 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/base64/md5_multiple_files.expected b/tests/fixtures/cksum/base64/md5_multiple_files.expected
new file mode 100644
index 00000000000..e7f844b9ac7
--- /dev/null
+++ b/tests/fixtures/cksum/base64/md5_multiple_files.expected
@@ -0,0 +1,2 @@
+MD5 (lorem_ipsum.txt) = zXJGkPfcYXdd+sQApx8sqg==
+MD5 (alice_in_wonderland.txt) = 9vpwM+FhZqlYmqHAOI/9WA==
diff --git a/tests/fixtures/cksum/base64/md5_single_file.expected b/tests/fixtures/cksum/base64/md5_single_file.expected
new file mode 100644
index 00000000000..8a12f79278c
--- /dev/null
+++ b/tests/fixtures/cksum/base64/md5_single_file.expected
@@ -0,0 +1 @@
+MD5 (lorem_ipsum.txt) = zXJGkPfcYXdd+sQApx8sqg==
diff --git a/tests/fixtures/cksum/base64/sha1_single_file.expected b/tests/fixtures/cksum/base64/sha1_single_file.expected
new file mode 100644
index 00000000000..b12608e77c7
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha1_single_file.expected
@@ -0,0 +1 @@
+SHA1 (lorem_ipsum.txt) = qx3QuuHYiDo9GKZt5q+9KCUs++8=
diff --git a/tests/fixtures/cksum/base64/sha224_single_file.expected b/tests/fixtures/cksum/base64/sha224_single_file.expected
new file mode 100644
index 00000000000..69d85abdb86
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha224_single_file.expected
@@ -0,0 +1 @@
+SHA224 (lorem_ipsum.txt) = PeZvvK0QbhtAqzkb5WxR0gB+sfnGVdD04pv8AQ==
diff --git a/tests/fixtures/cksum/base64/sha256_single_file.expected b/tests/fixtures/cksum/base64/sha256_single_file.expected
new file mode 100644
index 00000000000..d9a8814a30b
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha256_single_file.expected
@@ -0,0 +1 @@
+SHA256 (lorem_ipsum.txt) = 98QgUBxQ4AswklAQDWfqXpEJgVNrRYL+nENb2Ss/HwI=
diff --git a/tests/fixtures/cksum/base64/sha384_single_file.expected b/tests/fixtures/cksum/base64/sha384_single_file.expected
new file mode 100644
index 00000000000..8a8333d3553
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha384_single_file.expected
@@ -0,0 +1 @@
+SHA384 (lorem_ipsum.txt) = S+S5Cg0NMpZpkpIQGfJKvIJNz7ixxAgQLx9niPuAupqaTFp7V1ozU6kKjucZSB3L
diff --git a/tests/fixtures/cksum/base64/sha512_single_file.expected b/tests/fixtures/cksum/base64/sha512_single_file.expected
new file mode 100644
index 00000000000..da36c4295fb
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sha512_single_file.expected
@@ -0,0 +1 @@
+SHA512 (lorem_ipsum.txt) = llRkqyVWqtWOvHPYmtIh5Vl5dSnsr8D0ZsEXlc/21uLGD5agfFQs/R9Cbl5P4KSKoVZnukQJayE9CBPNA436BQ==
diff --git a/tests/fixtures/cksum/base64/sm3_single_file.expected b/tests/fixtures/cksum/base64/sm3_single_file.expected
new file mode 100644
index 00000000000..e4ca582c938
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sm3_single_file.expected
@@ -0,0 +1 @@
+SM3 (lorem_ipsum.txt) = bSlrgF0GC/7SKAjfMI27m0MXeU3U7WdAoQdwp4Jpm8I=
diff --git a/tests/fixtures/cksum/base64/sysv_single_file.expected b/tests/fixtures/cksum/base64/sysv_single_file.expected
new file mode 100644
index 00000000000..e0f7252cbe8
--- /dev/null
+++ b/tests/fixtures/cksum/base64/sysv_single_file.expected
@@ -0,0 +1 @@
+6985 2 lorem_ipsum.txt
diff --git a/tests/fixtures/cksum/length_is_zero.expected b/tests/fixtures/cksum/length_is_zero.expected
new file mode 100644
index 00000000000..97d06eb6fea
--- /dev/null
+++ b/tests/fixtures/cksum/length_is_zero.expected
@@ -0,0 +1,2 @@
+BLAKE2b (lorem_ipsum.txt) = 0e97a09189e560c3789c0bff1f020166861ef857d1fbfe4574de1842e3c06cabb9575e4af6309a166158c2b408d3c038c1b49d828b35158142cdc0396d1195c3
+BLAKE2b (alice_in_wonderland.txt) = 91b8b0f0868e905ad18b8ac35e4a1dacd289857b19258ab5d1e071761af758b0134ec152d4f011fe1825ca889c80c2e072ca70eb50548c25fc49a98937515af4
diff --git a/tests/fixtures/cksum/length_larger_than_512.expected b/tests/fixtures/cksum/length_larger_than_512.expected
new file mode 100644
index 00000000000..312b6230e9a
--- /dev/null
+++ b/tests/fixtures/cksum/length_larger_than_512.expected
@@ -0,0 +1,2 @@
+cksum: invalid length: ‘1024’
+cksum: maximum digest length for ‘BLAKE2b’ is 512 bits
diff --git a/tests/fixtures/cksum/raw/blake2b_single_file.expected b/tests/fixtures/cksum/raw/blake2b_single_file.expected
new file mode 100644
index 00000000000..19b3112206d
--- /dev/null
+++ b/tests/fixtures/cksum/raw/blake2b_single_file.expected
@@ -0,0 +1 @@
+— ‘‰å`Ãxœÿ
f†øWÑûþEtÞBãÀl«¹W^Jö0šaX´ÓÀ8Á´�‚‹5�BÍÀ9m•Ã
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/bsd_single_file.expected b/tests/fixtures/cksum/raw/bsd_single_file.expected
new file mode 100644
index 00000000000..538ab19f728
--- /dev/null
+++ b/tests/fixtures/cksum/raw/bsd_single_file.expected
@@ -0,0 +1 @@
+­
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/crc_single_file.expected b/tests/fixtures/cksum/raw/crc_single_file.expected
new file mode 100644
index 00000000000..de175b04582
--- /dev/null
+++ b/tests/fixtures/cksum/raw/crc_single_file.expected
@@ -0,0 +1 @@
+ŒPh
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/md5_single_file.expected b/tests/fixtures/cksum/raw/md5_single_file.expected
new file mode 100644
index 00000000000..e7b47aebbcb
Binary files /dev/null and b/tests/fixtures/cksum/raw/md5_single_file.expected differ
diff --git a/tests/fixtures/cksum/raw/sha1_single_file.expected b/tests/fixtures/cksum/raw/sha1_single_file.expected
new file mode 100644
index 00000000000..0f634be4749
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha1_single_file.expected
@@ -0,0 +1 @@
+«кá؈:=¦m毽(%,ûï
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha224_single_file.expected b/tests/fixtures/cksum/raw/sha224_single_file.expected
new file mode 100644
index 00000000000..bc3fa6bf18f
Binary files /dev/null and b/tests/fixtures/cksum/raw/sha224_single_file.expected differ
diff --git a/tests/fixtures/cksum/raw/sha256_single_file.expected b/tests/fixtures/cksum/raw/sha256_single_file.expected
new file mode 100644
index 00000000000..b9ce06f39d9
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha256_single_file.expected
@@ -0,0 +1 @@
+÷Ä PPà0’P
gê^‘	�SkE‚þœC[Ù+?
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha384_single_file.expected b/tests/fixtures/cksum/raw/sha384_single_file.expected
new file mode 100644
index 00000000000..4b337f859ed
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha384_single_file.expected
@@ -0,0 +1,3 @@
+Kä¹
+

2–i’’òJ¼‚Mϸ±Ä/gˆû€ºššLZ{WZ3S©
+ŽçHË
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sha512_single_file.expected b/tests/fixtures/cksum/raw/sha512_single_file.expected
new file mode 100644
index 00000000000..79f78cf00cb
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sha512_single_file.expected
@@ -0,0 +1 @@
+–Td«%VªÕŽ¼sØšÒ!åYyu)ì¯ÀôfÁ•ÏöÖâÆ– |T,ýBn^Oऊ¡VgºD	k!=Í�ú
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sm3_single_file.expected b/tests/fixtures/cksum/raw/sm3_single_file.expected
new file mode 100644
index 00000000000..3506406dc42
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sm3_single_file.expected
@@ -0,0 +1 @@
+m)k€]þÒ(ß0�»›CyMÔíg@¡p§‚i›Â
\ No newline at end of file
diff --git a/tests/fixtures/cksum/raw/sysv_single_file.expected b/tests/fixtures/cksum/raw/sysv_single_file.expected
new file mode 100644
index 00000000000..b975da49c01
--- /dev/null
+++ b/tests/fixtures/cksum/raw/sysv_single_file.expected
@@ -0,0 +1 @@
+I
\ No newline at end of file
diff --git a/tests/fixtures/cksum/zero_multiple_file.expected b/tests/fixtures/cksum/zero_multiple_file.expected
new file mode 100644
index 00000000000..46ad77aca49
Binary files /dev/null and b/tests/fixtures/cksum/zero_multiple_file.expected differ
diff --git a/tests/fixtures/cksum/zero_single_file.expected b/tests/fixtures/cksum/zero_single_file.expected
new file mode 100644
index 00000000000..23292d9b58c
Binary files /dev/null and b/tests/fixtures/cksum/zero_single_file.expected differ
diff --git a/tests/fixtures/comm/a b/tests/fixtures/comm/a
deleted file mode 100644
index 58f424cdb4f..00000000000
--- a/tests/fixtures/comm/a
+++ /dev/null
@@ -1,2 +0,0 @@
-a
-z
diff --git a/tests/fixtures/comm/a_nul b/tests/fixtures/comm/a_nul
deleted file mode 100644
index 3142c801ccd..00000000000
Binary files a/tests/fixtures/comm/a_nul and /dev/null differ
diff --git a/tests/fixtures/comm/ab.expected b/tests/fixtures/comm/ab.expected
deleted file mode 100644
index 0efac0666b0..00000000000
--- a/tests/fixtures/comm/ab.expected
+++ /dev/null
@@ -1,3 +0,0 @@
-a
-	b
-		z
diff --git a/tests/fixtures/comm/ab1.expected b/tests/fixtures/comm/ab1.expected
deleted file mode 100644
index 7c81c8ba7cb..00000000000
--- a/tests/fixtures/comm/ab1.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-b
-	z
diff --git a/tests/fixtures/comm/ab2.expected b/tests/fixtures/comm/ab2.expected
deleted file mode 100644
index c98cd0da66d..00000000000
--- a/tests/fixtures/comm/ab2.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-a
-	z
diff --git a/tests/fixtures/comm/ab3.expected b/tests/fixtures/comm/ab3.expected
deleted file mode 100644
index 1898bc804f2..00000000000
--- a/tests/fixtures/comm/ab3.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-a
-	b
diff --git a/tests/fixtures/comm/ab_delimiter_nul.expected b/tests/fixtures/comm/ab_delimiter_nul.expected
deleted file mode 100644
index e56ec5cd789..00000000000
Binary files a/tests/fixtures/comm/ab_delimiter_nul.expected and /dev/null differ
diff --git a/tests/fixtures/comm/ab_delimiter_word.expected b/tests/fixtures/comm/ab_delimiter_word.expected
deleted file mode 100644
index a0c510e2071..00000000000
--- a/tests/fixtures/comm/ab_delimiter_word.expected
+++ /dev/null
@@ -1,3 +0,0 @@
-a
-wordb
-wordwordz
diff --git a/tests/fixtures/comm/ab_nul.expected b/tests/fixtures/comm/ab_nul.expected
deleted file mode 100644
index f826106bb19..00000000000
Binary files a/tests/fixtures/comm/ab_nul.expected and /dev/null differ
diff --git a/tests/fixtures/comm/ab_nul_total.expected b/tests/fixtures/comm/ab_nul_total.expected
deleted file mode 100644
index 9f46f9558b1..00000000000
Binary files a/tests/fixtures/comm/ab_nul_total.expected and /dev/null differ
diff --git a/tests/fixtures/comm/ab_total.expected b/tests/fixtures/comm/ab_total.expected
deleted file mode 100644
index 430354a6620..00000000000
--- a/tests/fixtures/comm/ab_total.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-a
-	b
-		z
-1	1	1	total
diff --git a/tests/fixtures/comm/ab_total_delimiter_word.expected b/tests/fixtures/comm/ab_total_delimiter_word.expected
deleted file mode 100644
index f7215ea28a3..00000000000
--- a/tests/fixtures/comm/ab_total_delimiter_word.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-a
-wordb
-wordwordz
-1word1word1wordtotal
diff --git a/tests/fixtures/comm/ab_total_suppressed_regular_output.expected b/tests/fixtures/comm/ab_total_suppressed_regular_output.expected
deleted file mode 100644
index 733c1d344e5..00000000000
--- a/tests/fixtures/comm/ab_total_suppressed_regular_output.expected
+++ /dev/null
@@ -1 +0,0 @@
-1	1	1	total
diff --git a/tests/fixtures/comm/aempty.expected b/tests/fixtures/comm/aempty.expected
deleted file mode 100644
index 58f424cdb4f..00000000000
--- a/tests/fixtures/comm/aempty.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-a
-z
diff --git a/tests/fixtures/comm/b b/tests/fixtures/comm/b
deleted file mode 100644
index 63d7d705891..00000000000
--- a/tests/fixtures/comm/b
+++ /dev/null
@@ -1,2 +0,0 @@
-b
-z
diff --git a/tests/fixtures/comm/b_nul b/tests/fixtures/comm/b_nul
deleted file mode 100644
index ca4569669d4..00000000000
Binary files a/tests/fixtures/comm/b_nul and /dev/null differ
diff --git a/tests/fixtures/comm/bad_order11.defaultcheck_order.expected b/tests/fixtures/comm/bad_order11.defaultcheck_order.expected
deleted file mode 100644
index 81aa48629c9..00000000000
--- a/tests/fixtures/comm/bad_order11.defaultcheck_order.expected
+++ /dev/null
@@ -1,4 +0,0 @@
-		e
-		d
-		b
-		a
diff --git a/tests/fixtures/comm/bad_order12.check_order.expected b/tests/fixtures/comm/bad_order12.check_order.expected
deleted file mode 100644
index 3930ff03699..00000000000
--- a/tests/fixtures/comm/bad_order12.check_order.expected
+++ /dev/null
@@ -1 +0,0 @@
-		e
diff --git a/tests/fixtures/comm/bad_order12.nocheck_order.expected b/tests/fixtures/comm/bad_order12.nocheck_order.expected
deleted file mode 100644
index b5711801391..00000000000
--- a/tests/fixtures/comm/bad_order12.nocheck_order.expected
+++ /dev/null
@@ -1,7 +0,0 @@
-		e
-	c
-	b
-	a
-d
-b
-a
diff --git a/tests/fixtures/comm/bad_order_1 b/tests/fixtures/comm/bad_order_1
deleted file mode 100644
index 2ebde65a6a1..00000000000
--- a/tests/fixtures/comm/bad_order_1
+++ /dev/null
@@ -1,4 +0,0 @@
-e
-d
-b
-a
diff --git a/tests/fixtures/comm/bad_order_2 b/tests/fixtures/comm/bad_order_2
deleted file mode 100644
index 76603aeded1..00000000000
--- a/tests/fixtures/comm/bad_order_2
+++ /dev/null
@@ -1,4 +0,0 @@
-e
-c
-b
-a
diff --git a/tests/fixtures/comm/defaultcheck_unintuitive.expected b/tests/fixtures/comm/defaultcheck_unintuitive.expected
deleted file mode 100644
index 132eab5b250..00000000000
--- a/tests/fixtures/comm/defaultcheck_unintuitive.expected
+++ /dev/null
@@ -1,6 +0,0 @@
-		m
-		h
-		n
-		o
-c
-		p
diff --git a/tests/fixtures/comm/defaultcheck_unintuitive_1 b/tests/fixtures/comm/defaultcheck_unintuitive_1
deleted file mode 100644
index f32fc1fd758..00000000000
--- a/tests/fixtures/comm/defaultcheck_unintuitive_1
+++ /dev/null
@@ -1,6 +0,0 @@
-m
-h
-n
-o
-c
-p
diff --git a/tests/fixtures/comm/defaultcheck_unintuitive_2 b/tests/fixtures/comm/defaultcheck_unintuitive_2
deleted file mode 100644
index 212de88c4d0..00000000000
--- a/tests/fixtures/comm/defaultcheck_unintuitive_2
+++ /dev/null
@@ -1,5 +0,0 @@
-m
-h
-n
-o
-p
diff --git a/tests/fixtures/comm/emptyempty.expected b/tests/fixtures/comm/emptyempty.expected
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/tests/fixtures/comm/lowercase_uppercase b/tests/fixtures/comm/lowercase_uppercase
deleted file mode 100644
index 768ebc2b947..00000000000
--- a/tests/fixtures/comm/lowercase_uppercase
+++ /dev/null
@@ -1,2 +0,0 @@
-a
-A
\ No newline at end of file
diff --git a/tests/fixtures/comm/lowercase_uppercase.c.expected b/tests/fixtures/comm/lowercase_uppercase.c.expected
deleted file mode 100644
index 8458d7960bc..00000000000
--- a/tests/fixtures/comm/lowercase_uppercase.c.expected
+++ /dev/null
@@ -1 +0,0 @@
-		a
diff --git a/tests/fixtures/comm/lowercase_uppercase.en_us.expected b/tests/fixtures/comm/lowercase_uppercase.en_us.expected
deleted file mode 100644
index 3992b34d039..00000000000
--- a/tests/fixtures/comm/lowercase_uppercase.en_us.expected
+++ /dev/null
@@ -1,2 +0,0 @@
-		a
-		A
diff --git a/tests/fixtures/cut/8bit-delim.txt b/tests/fixtures/cut/8bit-delim.txt
new file mode 100644
index 00000000000..2312c916aef
--- /dev/null
+++ b/tests/fixtures/cut/8bit-delim.txt
@@ -0,0 +1 @@
+a­b­c
diff --git a/tests/fixtures/dircolors/internal.expected b/tests/fixtures/dircolors/internal.expected
index 7bc91ef470c..feea46455f4 100644
--- a/tests/fixtures/dircolors/internal.expected
+++ b/tests/fixtures/dircolors/internal.expected
@@ -1,8 +1,5 @@
 # Configuration file for dircolors, a utility to help you set the
 # LS_COLORS environment variable used by GNU ls with the --color option.
-# Copyright (C) 1996-2022 Free Software Foundation, Inc.
-# Copying and distribution of this file, with or without modification,
-# are permitted provided the copyright notice and this notice are preserved.
 # The keywords COLOR, OPTIONS, and EIGHTBIT (honored by the
 # slackware version of dircolors) are recognized but ignored.
 # Global config options can be specified before TERM or COLORTERM entries
@@ -10,6 +7,7 @@
 # restrict following config to systems with matching environment variables.
 COLORTERM ?*
 TERM Eterm
+TERM alacritty*
 TERM ansi
 TERM *color*
 TERM con[0-9]*x[0-9]*
@@ -18,6 +16,7 @@ TERM console
 TERM cygwin
 TERM *direct*
 TERM dtterm
+TERM foot
 TERM gnome
 TERM hurd
 TERM jfbterm
@@ -46,40 +45,26 @@ TERM xterm*
 # 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
 #NORMAL 00 # no color code at all
 #FILE 00 # regular file: use no color at all
-RESET 0 # reset to "normal" color
-DIR 01;34 # directory
-LINK 01;36 # symbolic link. (If you set this to 'target' instead of a
- # numerical value, the color is as for the file pointed to.)
-MULTIHARDLINK 00 # regular file with more than one link
-FIFO 40;33 # pipe
-SOCK 01;35 # socket
-DOOR 01;35 # door
-BLK 40;33;01 # block device driver
-CHR 40;33;01 # character device driver
-ORPHAN 40;31;01 # symlink to nonexistent file, or non-stat'able file ...
-MISSING 00 # ... and the files they point to
-SETUID 37;41 # file that is setuid (u+s)
-SETGID 30;43 # file that is setgid (g+s)
-CAPABILITY 00 # file with capability (very expensive to lookup)
-STICKY_OTHER_WRITABLE 30;42 # dir that is sticky and other-writable (+t,o+w)
-OTHER_WRITABLE 34;42 # dir that is other-writable (o+w) and not sticky
-STICKY 37;44 # dir with the sticky bit set (+t) and not other-writable
-# This is for files with execute permission:
+RESET 0
+DIR 01;34
+LINK 01;36
+MULTIHARDLINK 00
+FIFO 40;33
+SOCK 01;35
+DOOR 01;35
+BLK 40;33;01
+CHR 40;33;01
+ORPHAN 40;31;01
+MISSING 00
+SETUID 37;41
+SETGID 30;43
+CAPABILITY 00
+STICKY_OTHER_WRITABLE 30;42
+OTHER_WRITABLE 34;42
+STICKY 37;44
 EXEC 01;32
 # List any file extensions like '.gz' or '.tar' that you would like ls
 # to color below. Put the extension, a space, and the color init string.
-# (and any comments you want to add after a '#')
-# If you use DOS-style suffixes, you may want to uncomment the following:
-#.cmd 01;32 # executables (bright green)
-#.exe 01;32
-#.com 01;32
-#.btm 01;32
-#.bat 01;32
-# Or if you want to color scripts even if they do not have the
-# executable bit actually set.
-#.sh 01;32
-#.csh 01;32
- # archives or compressed (bright red)
 .tar 01;31
 .tgz 01;31
 .arc 01;31
@@ -126,7 +111,6 @@ EXEC 01;32
 .swm 01;31
 .dwm 01;31
 .esd 01;31
-# image formats
 .avif 01;35
 .jpg 01;35
 .jpeg 01;35
@@ -176,10 +160,8 @@ EXEC 01;32
 .yuv 01;35
 .cgm 01;35
 .emf 01;35
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
 .ogv 01;35
 .ogx 01;35
-# audio formats
 .aac 00;36
 .au 00;36
 .flac 00;36
@@ -192,12 +174,10 @@ EXEC 01;32
 .ogg 00;36
 .ra 00;36
 .wav 00;36
-# https://wiki.xiph.org/MIME_Types_and_File_Extensions
 .oga 00;36
 .opus 00;36
 .spx 00;36
 .xspf 00;36
-# backup files
 *~ 00;90
 *# 00;90
 .bak 00;90
diff --git a/tests/fixtures/comm/empty b/tests/fixtures/env/empty
similarity index 100%
rename from tests/fixtures/comm/empty
rename to tests/fixtures/env/empty
diff --git a/tests/fixtures/env/runBat.bat b/tests/fixtures/env/runBat.bat
new file mode 100644
index 00000000000..63ab744d3ab
--- /dev/null
+++ b/tests/fixtures/env/runBat.bat
@@ -0,0 +1 @@
+echo Hello Windows World!
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line.txt b/tests/fixtures/fmt/prefixed-one-word-per-line.txt
new file mode 100644
index 00000000000..afb9aeec0df
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line.txt
@@ -0,0 +1,19 @@
+- this
+- is
+- a
+- file
+- with
+- one
+- word
+- per
+- line
+
+=1this
+=1is
+=1a
+=2file
+=2with
+=2one
+=3word
+=3per
+=3line
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line_p-.txt b/tests/fixtures/fmt/prefixed-one-word-per-line_p-.txt
new file mode 100644
index 00000000000..4d1073550d9
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line_p-.txt
@@ -0,0 +1,11 @@
+- this is a file with one word per line
+
+=1this
+=1is
+=1a
+=2file
+=2with
+=2one
+=3word
+=3per
+=3line
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line_p=.txt b/tests/fixtures/fmt/prefixed-one-word-per-line_p=.txt
new file mode 100644
index 00000000000..488cf86de76
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line_p=.txt
@@ -0,0 +1,11 @@
+- this
+- is
+- a
+- file
+- with
+- one
+- word
+- per
+- line
+
+=1this 1is 1a 2file 2with 2one 3word 3per 3line
diff --git a/tests/fixtures/fmt/prefixed-one-word-per-line_p=_P=2.txt b/tests/fixtures/fmt/prefixed-one-word-per-line_p=_P=2.txt
new file mode 100644
index 00000000000..19e951096a3
--- /dev/null
+++ b/tests/fixtures/fmt/prefixed-one-word-per-line_p=_P=2.txt
@@ -0,0 +1,15 @@
+- this
+- is
+- a
+- file
+- with
+- one
+- word
+- per
+- line
+
+=1this 1is 1a
+=2file
+=2with
+=2one
+=3word 3per 3line
diff --git a/tests/fixtures/hashsum/binary.png b/tests/fixtures/hashsum/binary.png
new file mode 100644
index 00000000000..6c4161338f2
Binary files /dev/null and b/tests/fixtures/hashsum/binary.png differ
diff --git a/tests/fixtures/hashsum/binary.sha256.checkfile b/tests/fixtures/hashsum/binary.sha256.checkfile
new file mode 100644
index 00000000000..87fde491a09
--- /dev/null
+++ b/tests/fixtures/hashsum/binary.sha256.checkfile
@@ -0,0 +1 @@
+ac10c6d06f343e26875366263d486a1e9f71115b9b80f0565902f79e947dca51  binary.png
diff --git a/tests/fixtures/hashsum/binary.sha256.expected b/tests/fixtures/hashsum/binary.sha256.expected
new file mode 100644
index 00000000000..3003abf463b
--- /dev/null
+++ b/tests/fixtures/hashsum/binary.sha256.expected
@@ -0,0 +1 @@
+ac10c6d06f343e26875366263d486a1e9f71115b9b80f0565902f79e947dca51
\ No newline at end of file
diff --git a/tests/fixtures/head/lorem_ipsum_backwards_15_lines.expected b/tests/fixtures/head/lorem_ipsum_backwards_15_lines.expected
new file mode 100644
index 00000000000..9865c1b35ab
--- /dev/null
+++ b/tests/fixtures/head/lorem_ipsum_backwards_15_lines.expected
@@ -0,0 +1,9 @@
+Lorem ipsum dolor sit amet,
+consectetur adipiscing elit.
+Nunc interdum suscipit sem vel ornare.
+Proin euismod,
+justo sed mollis dictum,
+eros urna ultricies augue,
+eu pharetra mi ex id ante.
+Duis convallis porttitor aliquam.
+Nunc vitae tincidunt ex.
diff --git a/tests/fixtures/install/helloworld_freebsd b/tests/fixtures/install/helloworld_freebsd
new file mode 100755
index 00000000000..bfd78863030
Binary files /dev/null and b/tests/fixtures/install/helloworld_freebsd differ
diff --git a/tests/fixtures/join/contiguous_separators.txt b/tests/fixtures/join/contiguous_separators.txt
new file mode 100644
index 00000000000..bfc290229c4
--- /dev/null
+++ b/tests/fixtures/join/contiguous_separators.txt
@@ -0,0 +1 @@
+ a  ,,,b
diff --git a/tests/fixtures/join/multibyte_sep.expected b/tests/fixtures/join/multibyte_sep.expected
new file mode 100644
index 00000000000..c8a6aacfd18
--- /dev/null
+++ b/tests/fixtures/join/multibyte_sep.expected
@@ -0,0 +1 @@
+a§b§c
diff --git a/tests/fixtures/join/multibyte_sep_1.txt b/tests/fixtures/join/multibyte_sep_1.txt
new file mode 100644
index 00000000000..a42f9eefae1
--- /dev/null
+++ b/tests/fixtures/join/multibyte_sep_1.txt
@@ -0,0 +1 @@
+a§b
diff --git a/tests/fixtures/join/multibyte_sep_2.txt b/tests/fixtures/join/multibyte_sep_2.txt
new file mode 100644
index 00000000000..81288ad520b
--- /dev/null
+++ b/tests/fixtures/join/multibyte_sep_2.txt
@@ -0,0 +1 @@
+a§c
diff --git a/tests/fixtures/nohup/is_a_tty.sh b/tests/fixtures/nohup/is_a_tty.sh
new file mode 100644
index 00000000000..1eb0fb5229e
--- /dev/null
+++ b/tests/fixtures/nohup/is_a_tty.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+if [ -t 0 ] ; then
+    echo "stdin is a tty"
+else
+    echo "stdin is not a tty"
+fi
+
+if [ -t 1 ] ; then
+    echo "stdout is a tty"
+else
+    echo "stdout is not a tty"
+fi
+
+if [ -t 2 ] ; then
+    echo "stderr is a tty"
+else
+    echo "stderr is not a tty"
+fi
+
+true
diff --git a/tests/fixtures/numfmt/df_expected.txt b/tests/fixtures/numfmt/df_expected.txt
index ea8c3d79f4e..a3b5977616f 100644
--- a/tests/fixtures/numfmt/df_expected.txt
+++ b/tests/fixtures/numfmt/df_expected.txt
@@ -3,6 +3,6 @@ udev                           8.2G            0         8.2G   0% /dev
 tmpfs                          1.7G         2.1M         1.7G   1% /run
 /dev/nvme0n1p2                 1.1T         433G         523G  46% /
 tmpfs                          8.3G         145M         8.1G   2% /dev/shm
-tmpfs                          5.3M         4.1K         5.3M   1% /run/lock
+tmpfs                          5.3M         4.1k         5.3M   1% /run/lock
 tmpfs                          8.3G            0         8.3G   0% /sys/fs/cgroup
 /dev/nvme0n1p1                 536M         8.2M         528M   2% /boot/efi
diff --git a/tests/fixtures/numfmt/gnutest_si_result.txt b/tests/fixtures/numfmt/gnutest_si_result.txt
index 7238ba40c78..e62393d35b7 100644
--- a/tests/fixtures/numfmt/gnutest_si_result.txt
+++ b/tests/fixtures/numfmt/gnutest_si_result.txt
@@ -1,34 +1,34 @@
--1.1K
--1.0K
+-1.1k
+-1.0k
 -999
 1
 500
 999
-1.0K
-1.0K
-1.1K
-1.1K
-9.9K
-10K
-10K
-10K
-10K
-10K
-11K
-11K
-11K
-50K
-99K
-100K
-100K
-100K
-100K
-100K
-101K
-101K
-101K
-102K
-999K
+1.0k
+1.0k
+1.1k
+1.1k
+9.9k
+10k
+10k
+10k
+10k
+10k
+11k
+11k
+11k
+50k
+99k
+100k
+100k
+100k
+100k
+100k
+101k
+101k
+101k
+102k
+999k
 1.0M
 1.0M
 1.0M
diff --git a/tests/fixtures/ptx/break_file_regex_escaping.expected b/tests/fixtures/ptx/break_file_regex_escaping.expected
new file mode 100644
index 00000000000..48e3b151996
--- /dev/null
+++ b/tests/fixtures/ptx/break_file_regex_escaping.expected
@@ -0,0 +1,28 @@
+.xx "" "" """quotes"", for roff" ""
+.xx "" "and some other like" "%a, b#, c$c" ""
+.xx "" "and some other like %a, b#" ", c$c" ""
+.xx "" "maybe" "also~or^" ""
+.xx "" "" "and some other like %a, b#, c$c" ""
+.xx "" "oh," "and back\slash" ""
+.xx "" "and some other like %a," "b#, c$c" ""
+.xx "" "oh, and" "back\slash" ""
+.xx "" "{" "brackets} for tex" ""
+.xx "" "and some other like %a, b#," "c$c" ""
+.xx "" "and some other like %a, b#, c$" "c" ""
+.xx "" "let's check special" "characters:" ""
+.xx "" "let's" "check special characters:" ""
+.xx "" """quotes""," "for roff" ""
+.xx "" "{brackets}" "for tex" ""
+.xx "" "" "hello world!" ""
+.xx "" "" "let's check special characters:" ""
+.xx "" "and some other" "like %a, b#, c$c" ""
+.xx "" "" "maybe also~or^" ""
+.xx "" "" "oh, and back\slash" ""
+.xx "" "maybe also~" "or^" ""
+.xx "" "and some" "other like %a, b#, c$c" ""
+.xx "" """quotes"", for" "roff" ""
+.xx "" "oh, and back\" "slash" ""
+.xx "" "and" "some other like %a, b#, c$c" ""
+.xx "" "let's check" "special characters:" ""
+.xx "" "{brackets} for" "tex" ""
+.xx "" "hello" "world!" ""
diff --git a/tests/fixtures/sort/keys_closed_range.expected.debug b/tests/fixtures/sort/keys_closed_range.expected.debug
index b78db4af181..e317d4079ad 100644
--- a/tests/fixtures/sort/keys_closed_range.expected.debug
+++ b/tests/fixtures/sort/keys_closed_range.expected.debug
@@ -11,8 +11,8 @@ ________
    _
 ________
 👩�🔬 👩�🔬 👩�🔬
-     __
-______________
+   __
+________
 💣💣 💣💣 💣💣
      __
 ______________
diff --git a/tests/fixtures/sort/keys_multiple_ranges.expected.debug b/tests/fixtures/sort/keys_multiple_ranges.expected.debug
index 830e9afd091..41b7e210df8 100644
--- a/tests/fixtures/sort/keys_multiple_ranges.expected.debug
+++ b/tests/fixtures/sort/keys_multiple_ranges.expected.debug
@@ -15,9 +15,9 @@ ________
      ___
 ________
 👩�🔬 👩�🔬 👩�🔬
-    _____
-         _____
-______________
+  ___
+     ___
+________
 💣💣 💣💣 💣💣
     _____
          _____
diff --git a/tests/fixtures/sort/keys_no_field_match.expected.debug b/tests/fixtures/sort/keys_no_field_match.expected.debug
index 60197b1deaa..0a3ea83034f 100644
--- a/tests/fixtures/sort/keys_no_field_match.expected.debug
+++ b/tests/fixtures/sort/keys_no_field_match.expected.debug
@@ -11,8 +11,8 @@ ________
         ^ no match for key
 ________
 👩�🔬 👩�🔬 👩�🔬
-              ^ no match for key
-______________
+        ^ no match for key
+________
 💣💣 💣💣 💣💣
               ^ no match for key
 ______________
diff --git a/tests/fixtures/sort/keys_open_ended.expected.debug b/tests/fixtures/sort/keys_open_ended.expected.debug
index d3a56ffd6f6..c8e4ad9ae83 100644
--- a/tests/fixtures/sort/keys_open_ended.expected.debug
+++ b/tests/fixtures/sort/keys_open_ended.expected.debug
@@ -11,8 +11,8 @@ ________
     ____
 ________
 👩�🔬 👩�🔬 👩�🔬
-       _______
-______________
+     _____
+________
 💣💣 💣💣 💣💣
        _______
 ______________
diff --git a/tests/fixtures/split/separator_nul.txt b/tests/fixtures/split/separator_nul.txt
new file mode 100644
index 00000000000..c4c49609dbd
Binary files /dev/null and b/tests/fixtures/split/separator_nul.txt differ
diff --git a/tests/fixtures/split/separator_semicolon.txt b/tests/fixtures/split/separator_semicolon.txt
new file mode 100644
index 00000000000..a8396d8eef5
--- /dev/null
+++ b/tests/fixtures/split/separator_semicolon.txt
@@ -0,0 +1 @@
+1;2;3;4;5;
\ No newline at end of file
diff --git a/tests/fixtures/uniq/locale-fr-schar.txt b/tests/fixtures/uniq/locale-fr-schar.txt
new file mode 100644
index 00000000000..4e285f37aef
--- /dev/null
+++ b/tests/fixtures/uniq/locale-fr-schar.txt
@@ -0,0 +1,2 @@
+ y z
+  y z
diff --git a/tests/fixtures/uniq/skip-2-fields.expected b/tests/fixtures/uniq/skip-2-fields.expected
index b971c2b2b39..c7f9bde9d28 100644
--- a/tests/fixtures/uniq/skip-2-fields.expected
+++ b/tests/fixtures/uniq/skip-2-fields.expected
@@ -1,2 +1,5 @@
 	  aaa  ⟪⟫  a
 aa  a
+a a a a a a a a a a a a a a a a a a a b a a a
+a a a a a a a a a a a a a a a a a a a a b a a
+a a a a a a a a a a a a a a a a a a a a a b a
diff --git a/tests/fixtures/uniq/skip-21-fields.expected b/tests/fixtures/uniq/skip-21-fields.expected
new file mode 100644
index 00000000000..1f5295afa5f
--- /dev/null
+++ b/tests/fixtures/uniq/skip-21-fields.expected
@@ -0,0 +1,3 @@
+	  aaa  ⟪⟫  a
+a a a a a a a a a a a a a a a a a a a b a a a
+a a a a a a a a a a a a a a a a a a a a a b a
diff --git a/tests/fixtures/uniq/skip-fields.txt b/tests/fixtures/uniq/skip-fields.txt
index 4ec2744c61d..0ca708a74ca 100644
--- a/tests/fixtures/uniq/skip-fields.txt
+++ b/tests/fixtures/uniq/skip-fields.txt
@@ -6,3 +6,6 @@ ZZZ     aa  a
 aa  a
 a
 
+a a a a a a a a a a a a a a a a a a a b a a a
+a a a a a a a a a a a a a a a a a a a a b a a
+a a a a a a a a a a a a a a a a a a a a a b a
diff --git a/tests/fixtures/uptime/openbsd_utmp b/tests/fixtures/uptime/openbsd_utmp
new file mode 100644
index 00000000000..958d7510c38
Binary files /dev/null and b/tests/fixtures/uptime/openbsd_utmp differ
diff --git a/tests/fixtures/users/openbsd_utmp b/tests/fixtures/users/openbsd_utmp
new file mode 100644
index 00000000000..958d7510c38
Binary files /dev/null and b/tests/fixtures/users/openbsd_utmp differ
diff --git a/tests/fixtures/util/is_a_tty.sh b/tests/fixtures/util/is_a_tty.sh
new file mode 100644
index 00000000000..0a6d64494f0
--- /dev/null
+++ b/tests/fixtures/util/is_a_tty.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+if [ -t 0 ] ; then
+    echo "stdin is a tty"
+    echo "terminal size: $(stty size)"
+else
+    echo "stdin is not a tty"
+fi
+
+if [ -t 1 ] ; then
+    echo "stdout is a tty"
+else
+    echo "stdout is not a tty"
+fi
+
+if [ -t 2 ] ; then
+    echo "stderr is a tty"
+else
+    echo "stderr is not a tty"
+fi
+
+>&2 echo "This is an error message."
+
+true
diff --git a/tests/test_util_name.rs b/tests/test_util_name.rs
index 45edc7dc782..7a8a076e893 100644
--- a/tests/test_util_name.rs
+++ b/tests/test_util_name.rs
@@ -2,49 +2,47 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-#![allow(unused_imports)]
-mod common;
-
-use common::util::TestScenario;
+use uutests::util::TestScenario;
 
 #[cfg(unix)]
 use std::os::unix::fs::symlink as symlink_file;
-#[cfg(windows)]
-use std::os::windows::fs::symlink_file;
 
-#[test]
-#[cfg(feature = "ls")]
-fn execution_phrase_double() {
-    use std::process::Command;
+use std::env;
+pub const TESTS_BINARY: &str = env!("CARGO_BIN_EXE_coreutils");
 
-    let scenario = TestScenario::new("ls");
-    let output = Command::new(&scenario.bin_path)
-        .arg("ls")
-        .arg("--some-invalid-arg")
-        .output()
-        .unwrap();
-    assert!(String::from_utf8(output.stderr)
-        .unwrap()
-        .contains(&format!("Usage: {} ls", scenario.bin_path.display(),)));
+// Set the environment variable for any tests
+
+// Use the ctor attribute to run this function before any tests
+#[ctor::ctor]
+fn init() {
+    // No need for unsafe here
+    unsafe {
+        std::env::set_var("UUTESTS_BINARY_PATH", TESTS_BINARY);
+    }
+    // Print for debugging
+    eprintln!("Setting UUTESTS_BINARY_PATH={TESTS_BINARY}");
 }
 
 #[test]
 #[cfg(feature = "ls")]
-#[cfg(any(unix, windows))]
-fn execution_phrase_single() {
+fn execution_phrase_double() {
     use std::process::Command;
 
     let scenario = TestScenario::new("ls");
-    symlink_file(scenario.bin_path, scenario.fixtures.plus("uu-ls")).unwrap();
-    let output = Command::new(scenario.fixtures.plus("uu-ls"))
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+    let output = Command::new(&scenario.bin_path)
+        .arg("ls")
         .arg("--some-invalid-arg")
         .output()
         .unwrap();
-    dbg!(String::from_utf8(output.stderr.clone()).unwrap());
-    assert!(String::from_utf8(output.stderr).unwrap().contains(&format!(
-        "Usage: {}",
-        scenario.fixtures.plus("uu-ls").display()
-    )));
+    assert!(
+        String::from_utf8(output.stderr)
+            .unwrap()
+            .contains(&format!("Usage: {} ls", scenario.bin_path.display()))
+    );
 }
 
 #[test]
@@ -56,7 +54,11 @@ fn util_name_double() {
     };
 
     let scenario = TestScenario::new("sort");
-    let mut child = Command::new(scenario.bin_path)
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+    let mut child = Command::new(&scenario.bin_path)
         .arg("sort")
         .stdin(Stdio::piped())
         .stderr(Stdio::piped())
@@ -70,7 +72,7 @@ fn util_name_double() {
 
 #[test]
 #[cfg(feature = "sort")]
-#[cfg(any(unix, windows))]
+#[cfg(unix)]
 fn util_name_single() {
     use std::{
         io::Write,
@@ -78,7 +80,12 @@ fn util_name_single() {
     };
 
     let scenario = TestScenario::new("sort");
-    symlink_file(scenario.bin_path, scenario.fixtures.plus("uu-sort")).unwrap();
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+
+    symlink_file(&scenario.bin_path, scenario.fixtures.plus("uu-sort")).unwrap();
     let mut child = Command::new(scenario.fixtures.plus("uu-sort"))
         .stdin(Stdio::piped())
         .stderr(Stdio::piped())
@@ -92,3 +99,155 @@ fn util_name_single() {
         scenario.fixtures.plus("uu-sort").display()
     )));
 }
+
+#[test]
+#[cfg(unix)]
+fn util_invalid_name_help() {
+    use std::process::{Command, Stdio};
+
+    let scenario = TestScenario::new("invalid_name");
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+    symlink_file(&scenario.bin_path, scenario.fixtures.plus("invalid_name")).unwrap();
+    let child = Command::new(scenario.fixtures.plus("invalid_name"))
+        .arg("--help")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.status.code(), Some(0));
+    assert_eq!(output.stderr, b"");
+    let output_str = String::from_utf8(output.stdout).unwrap();
+    assert!(output_str.contains("(multi-call binary)"), "{output_str:?}");
+    assert!(
+        output_str.contains("Usage: invalid_name [function "),
+        "{output_str:?}"
+    );
+}
+
+#[test]
+// The exact set of permitted filenames depends on many factors. Non-UTF-8 strings
+// work on very few platforms, but linux works, especially because it also increases
+// the likelihood that a filesystem is being used that supports non-UTF-8 filenames.
+#[cfg(target_os = "linux")]
+fn util_non_utf8_name_help() {
+    // Make sure we don't crash even if the util name is invalid UTF-8.
+    use std::{
+        ffi::OsStr,
+        os::unix::ffi::OsStrExt,
+        process::{Command, Stdio},
+    };
+
+    let scenario = TestScenario::new("invalid_name");
+    let non_utf8_path = scenario.fixtures.plus(OsStr::from_bytes(b"\xff"));
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+
+    symlink_file(&scenario.bin_path, &non_utf8_path).unwrap();
+    let child = Command::new(&non_utf8_path)
+        .arg("--help")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.status.code(), Some(0));
+    assert_eq!(output.stderr, b"");
+    let output_str = String::from_utf8(output.stdout).unwrap();
+    assert!(output_str.contains("(multi-call binary)"), "{output_str:?}");
+    assert!(
+        output_str.contains("Usage: <unknown binary name> [function "),
+        "{output_str:?}"
+    );
+}
+
+#[test]
+#[cfg(unix)]
+fn util_invalid_name_invalid_command() {
+    use std::process::{Command, Stdio};
+
+    let scenario = TestScenario::new("invalid_name");
+    symlink_file(&scenario.bin_path, scenario.fixtures.plus("invalid_name")).unwrap();
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+
+    let child = Command::new(scenario.fixtures.plus("invalid_name"))
+        .arg("definitely_invalid")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.status.code(), Some(1));
+    assert_eq!(output.stderr, b"");
+    assert_eq!(
+        output.stdout,
+        b"definitely_invalid: function/utility not found\n"
+    );
+}
+
+#[test]
+#[cfg(feature = "true")]
+fn util_completion() {
+    use std::process::{Command, Stdio};
+
+    let scenario = TestScenario::new("completion");
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+
+    let child = Command::new(&scenario.bin_path)
+        .arg("completion")
+        .arg("true")
+        .arg("powershell")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.status.code(), Some(0));
+    assert_eq!(output.stderr, b"");
+    let output_str = String::from_utf8(output.stdout).unwrap();
+    assert!(
+        output_str.contains("using namespace System.Management.Automation"),
+        "{output_str:?}"
+    );
+}
+
+#[test]
+#[cfg(feature = "true")]
+fn util_manpage() {
+    use std::process::{Command, Stdio};
+
+    let scenario = TestScenario::new("completion");
+    if !scenario.bin_path.exists() {
+        println!("Skipping test: Binary not found at {:?}", scenario.bin_path);
+        return;
+    }
+
+    let child = Command::new(&scenario.bin_path)
+        .arg("manpage")
+        .arg("true")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let output = child.wait_with_output().unwrap();
+    assert_eq!(output.status.code(), Some(0));
+    assert_eq!(output.stderr, b"");
+    let output_str = String::from_utf8(output.stdout).unwrap();
+    assert!(output_str.contains("\n.TH true 1 "), "{output_str:?}");
+}
diff --git a/tests/tests.rs b/tests/tests.rs
index 8d4a6855c9e..90d7c6e553a 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -2,8 +2,19 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-#[macro_use]
-mod common;
+
+use std::env;
+
+pub const TESTS_BINARY: &str = env!("CARGO_BIN_EXE_coreutils");
+
+// Use the ctor attribute to run this function before any tests
+#[ctor::ctor]
+fn init() {
+    unsafe {
+        // Necessary for uutests to be able to find the binary
+        std::env::set_var("UUTESTS_BINARY_PATH", TESTS_BINARY);
+    }
+}
 
 #[cfg(feature = "arch")]
 #[path = "by-util/test_arch.rs"]
@@ -269,10 +280,6 @@ mod test_readlink;
 #[path = "by-util/test_realpath.rs"]
 mod test_realpath;
 
-#[cfg(feature = "relpath")]
-#[path = "by-util/test_relpath.rs"]
-mod test_relpath;
-
 #[cfg(feature = "rm")]
 #[path = "by-util/test_rm.rs"]
 mod test_rm;
diff --git a/tests/uutests/Cargo.toml b/tests/uutests/Cargo.toml
new file mode 100644
index 00000000000..e7a0dbef9b3
--- /dev/null
+++ b/tests/uutests/Cargo.toml
@@ -0,0 +1,44 @@
+# spell-checker:ignore (features) zerocopy serde
+
+[package]
+name = "uutests"
+description = "uutils ~ 'core' uutils test library (cross-platform)"
+repository = "https://github.com/uutils/coreutils/tree/main/tests/uutests"
+# readme = "README.md"
+authors.workspace = true
+categories.workspace = true
+edition.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+license.workspace = true
+version.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+path = "src/lib/lib.rs"
+
+[dependencies]
+glob = { workspace = true }
+libc = { workspace = true }
+pretty_assertions = "1.4.0"
+rand = { workspace = true }
+regex = { workspace = true }
+tempfile = { workspace = true }
+time = { workspace = true, features = ["local-offset"] }
+uucore = { workspace = true, features = [
+  "mode",
+  "entries",
+  "process",
+  "signals",
+  "utmpx",
+] }
+ctor = "0.4.1"
+
+[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
+
+[target.'cfg(unix)'.dependencies]
+nix = { workspace = true, features = ["process", "signal", "user", "term"] }
+rlimit = "0.10.1"
+xattr = { workspace = true }
diff --git a/tests/common/mod.rs b/tests/uutests/src/lib/lib.rs
similarity index 100%
rename from tests/common/mod.rs
rename to tests/uutests/src/lib/lib.rs
diff --git a/tests/common/macros.rs b/tests/uutests/src/lib/macros.rs
similarity index 88%
rename from tests/common/macros.rs
rename to tests/uutests/src/lib/macros.rs
index 4902ca49b4d..3fe57856fdb 100644
--- a/tests/common/macros.rs
+++ b/tests/uutests/src/lib/macros.rs
@@ -47,8 +47,8 @@ macro_rules! util_name {
 /// This macro is intended for quick, single-call tests. For more complex tests
 /// that require multiple invocations of the tested binary, see [`TestScenario`]
 ///
-/// [`UCommand`]: crate::tests::common::util::UCommand
-/// [`TestScenario]: crate::tests::common::util::TestScenario
+/// [`UCommand`]: crate::util::UCommand
+/// [`TestScenario`]: crate::util::TestScenario
 #[macro_export]
 macro_rules! new_ucmd {
     () => {
@@ -65,9 +65,9 @@ macro_rules! new_ucmd {
 /// This macro is intended for quick, single-call tests. For more complex tests
 /// that require multiple invocations of the tested binary, see [`TestScenario`]
 ///
-/// [`UCommand`]: crate::tests::common::util::UCommand
-/// [`AtPath`]: crate::tests::common::util::AtPath
-/// [`TestScenario]: crate::tests::common::util::TestScenario
+/// [`UCommand`]: crate::util::UCommand
+/// [`AtPath`]: crate::util::AtPath
+/// [`TestScenario`]: crate::util::TestScenario
 #[macro_export]
 macro_rules! at_and_ucmd {
     () => {{
@@ -85,7 +85,7 @@ macro_rules! unwrap_or_return {
         match $e {
             Ok(x) => x,
             Err(e) => {
-                println!("test skipped: {}", e);
+                println!("test skipped: {e}");
                 return;
             }
         }
diff --git a/src/uu/printf/src/mod.rs b/tests/uutests/src/lib/mod.rs
similarity index 75%
rename from src/uu/printf/src/mod.rs
rename to tests/uutests/src/lib/mod.rs
index 759b823ccda..05e2b13824c 100644
--- a/src/uu/printf/src/mod.rs
+++ b/tests/uutests/src/lib/mod.rs
@@ -2,4 +2,7 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-mod cli;
+#[macro_use]
+pub mod macros;
+pub mod random;
+pub mod util;
diff --git a/tests/common/random.rs b/tests/uutests/src/lib/random.rs
similarity index 74%
rename from tests/common/random.rs
rename to tests/uutests/src/lib/random.rs
index 42b6eaa7703..7a13f1e1de0 100644
--- a/tests/common/random.rs
+++ b/tests/uutests/src/lib/random.rs
@@ -2,18 +2,19 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
+#![allow(clippy::naive_bytecount)]
 
-use rand::distributions::{Distribution, Uniform};
-use rand::{thread_rng, Rng};
+use rand::distr::{Distribution, Uniform};
+use rand::{Rng, rng};
 
 /// Samples alphanumeric characters `[A-Za-z0-9]` including newline `\n`
 ///
 /// # Examples
 ///
 /// ```rust,ignore
-/// use rand::{Rng, thread_rng};
+/// use rand::{Rng, rng};
 ///
-/// let vec = thread_rng()
+/// let vec = rng()
 ///     .sample_iter(AlphanumericNewline)
 ///     .take(10)
 ///     .collect::<Vec<u8>>();
@@ -38,7 +39,7 @@ impl AlphanumericNewline {
     where
         R: Rng + ?Sized,
     {
-        let idx = rng.gen_range(0..Self::CHARSET.len());
+        let idx = rng.random_range(0..Self::CHARSET.len());
         Self::CHARSET[idx]
     }
 }
@@ -54,20 +55,20 @@ impl Distribution<u8> for AlphanumericNewline {
 /// # Examples
 ///
 /// ```rust,ignore
-/// use crate::common::random::{AlphanumericNewline, RandomString};
+/// use crate::common::random::{AlphanumericNewline, RandomizedString};
 /// use rand::distributions::Alphanumeric;
 ///
 /// // generates a 100 byte string with characters from AlphanumericNewline
-/// let random_string = RandomString::generate(AlphanumericNewline, 100);
+/// let random_string = RandomizedString::generate(AlphanumericNewline, 100);
 /// assert_eq!(100, random_string.len());
 ///
 /// // generates a 100 byte string with 10 newline characters not ending with a newline
-/// let string = RandomString::generate_with_delimiter(Alphanumeric, b'\n', 10, false, 100);
+/// let string = RandomizedString::generate_with_delimiter(Alphanumeric, b'\n', 10, false, 100);
 /// assert_eq!(100, random_string.len());
 /// ```
-pub struct RandomString;
+pub struct RandomizedString;
 
-impl RandomString {
+impl RandomizedString {
     /// Generate a random string from the given [`Distribution`] with the given `length` in bytes.
     ///
     /// # Arguments
@@ -80,7 +81,7 @@ impl RandomString {
     where
         D: Distribution<u8>,
     {
-        thread_rng()
+        rng()
             .sample_iter(dist)
             .take(length)
             .map(|b| b as char)
@@ -105,10 +106,10 @@ impl RandomString {
     /// # Examples
     ///
     /// ```rust,ignore
-    /// use crate::common::random::{AlphanumericNewline, RandomString};
+    /// use crate::common::random::{AlphanumericNewline, RandomizedString};
     ///
     /// // generates a 100 byte string with 10 '\0' byte characters not ending with a '\0' byte
-    /// let string = RandomString::generate_with_delimiter(AlphanumericNewline, 0, 10, false, 100);
+    /// let string = RandomizedString::generate_with_delimiter(AlphanumericNewline, 0, 10, false, 100);
     /// assert_eq!(100, random_string.len());
     /// assert_eq!(
     ///     10,
@@ -132,15 +133,15 @@ impl RandomString {
             return if num_delimiter > 0 {
                 String::from(delimiter as char)
             } else {
-                String::from(thread_rng().sample(&dist) as char)
+                String::from(rng().sample(&dist) as char)
             };
         }
 
         let samples = length - 1;
-        let mut result: Vec<u8> = thread_rng().sample_iter(&dist).take(samples).collect();
+        let mut result: Vec<u8> = rng().sample_iter(&dist).take(samples).collect();
 
         if num_delimiter == 0 {
-            result.push(thread_rng().sample(&dist));
+            result.push(rng().sample(&dist));
             return String::from_utf8(result).unwrap();
         }
 
@@ -150,9 +151,10 @@ impl RandomString {
             num_delimiter
         };
 
-        let between = Uniform::new(0, samples);
+        // it's safe to unwrap because samples is always > 0, thus low < high
+        let between = Uniform::new(0, samples).unwrap();
         for _ in 0..num_delimiter {
-            let mut pos = between.sample(&mut thread_rng());
+            let mut pos = between.sample(&mut rng());
             let turn = pos;
             while result[pos] == delimiter {
                 pos += 1;
@@ -169,7 +171,7 @@ impl RandomString {
         if end_with_delimiter {
             result.push(delimiter);
         } else {
-            result.push(thread_rng().sample(&dist));
+            result.push(rng().sample(&dist));
         }
 
         String::from_utf8(result).unwrap()
@@ -179,37 +181,38 @@ impl RandomString {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rand::distributions::Alphanumeric;
+    use rand::distr::Alphanumeric;
 
     #[test]
     fn test_random_string_generate() {
-        let random_string = RandomString::generate(AlphanumericNewline, 0);
+        let random_string = RandomizedString::generate(AlphanumericNewline, 0);
         assert_eq!(0, random_string.len());
 
-        let random_string = RandomString::generate(AlphanumericNewline, 1);
+        let random_string = RandomizedString::generate(AlphanumericNewline, 1);
         assert_eq!(1, random_string.len());
 
-        let random_string = RandomString::generate(AlphanumericNewline, 100);
+        let random_string = RandomizedString::generate(AlphanumericNewline, 100);
         assert_eq!(100, random_string.len());
     }
 
     #[test]
     fn test_random_string_generate_with_delimiter_when_length_is_zero() {
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 0, false, 0);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 0, false, 0);
         assert_eq!(0, random_string.len());
     }
 
     #[test]
     fn test_random_string_generate_with_delimiter_when_num_delimiter_is_greater_than_length() {
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 2, false, 1);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 2, false, 1);
         assert_eq!(1, random_string.len());
         assert!(random_string.as_bytes().contains(&0));
         assert!(random_string.as_bytes().ends_with(&[0]));
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)] // Ignore clippy lint of too long function sign
     fn test_random_string_generate_with_delimiter_should_end_with_delimiter() {
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, true, 1);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 1, true, 1);
         assert_eq!(1, random_string.len());
         assert_eq!(
             1,
@@ -217,7 +220,7 @@ mod tests {
         );
         assert!(random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, false, 1);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 1, false, 1);
         assert_eq!(1, random_string.len());
         assert_eq!(
             1,
@@ -225,7 +228,7 @@ mod tests {
         );
         assert!(random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, true, 2);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 1, true, 2);
         assert_eq!(2, random_string.len());
         assert_eq!(
             1,
@@ -233,7 +236,7 @@ mod tests {
         );
         assert!(random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 2, true, 2);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 2, true, 2);
         assert_eq!(2, random_string.len());
         assert_eq!(
             2,
@@ -241,7 +244,7 @@ mod tests {
         );
         assert!(random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, true, 3);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 1, true, 3);
         assert_eq!(3, random_string.len());
         assert_eq!(
             1,
@@ -251,22 +254,23 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::cognitive_complexity)] // Ignore clippy lint of too long function sign
     fn test_random_string_generate_with_delimiter_should_not_end_with_delimiter() {
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 0, false, 1);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 0, false, 1);
         assert_eq!(1, random_string.len());
         assert_eq!(
             0,
             random_string.as_bytes().iter().filter(|p| **p == 0).count()
         );
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 0, true, 1);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 0, true, 1);
         assert_eq!(1, random_string.len());
         assert_eq!(
             0,
             random_string.as_bytes().iter().filter(|p| **p == 0).count()
         );
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, false, 2);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 1, false, 2);
         assert_eq!(2, random_string.len());
         assert_eq!(
             1,
@@ -274,7 +278,7 @@ mod tests {
         );
         assert!(!random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 1, false, 3);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 1, false, 3);
         assert_eq!(3, random_string.len());
         assert_eq!(
             1,
@@ -282,7 +286,7 @@ mod tests {
         );
         assert!(!random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 2, false, 3);
+        let random_string = RandomizedString::generate_with_delimiter(Alphanumeric, 0, 2, false, 3);
         assert_eq!(3, random_string.len());
         assert_eq!(
             2,
@@ -294,7 +298,7 @@ mod tests {
     #[test]
     fn test_generate_with_delimiter_with_greater_length() {
         let random_string =
-            RandomString::generate_with_delimiter(Alphanumeric, 0, 100, false, 1000);
+            RandomizedString::generate_with_delimiter(Alphanumeric, 0, 100, false, 1000);
         assert_eq!(1000, random_string.len());
         assert_eq!(
             100,
@@ -302,7 +306,8 @@ mod tests {
         );
         assert!(!random_string.as_bytes().ends_with(&[0]));
 
-        let random_string = RandomString::generate_with_delimiter(Alphanumeric, 0, 100, true, 1000);
+        let random_string =
+            RandomizedString::generate_with_delimiter(Alphanumeric, 0, 100, true, 1000);
         assert_eq!(1000, random_string.len());
         assert_eq!(
             100,
@@ -319,12 +324,12 @@ mod tests {
     #[test]
     fn test_generate_random_strings_when_length_is_around_critical_buffer_sizes() {
         let length = 8192 * 3;
-        let random_string = RandomString::generate(AlphanumericNewline, length);
+        let random_string = RandomizedString::generate(AlphanumericNewline, length);
         assert_eq!(length, random_string.len());
 
         let length = 8192 * 3 + 1;
         let random_string =
-            RandomString::generate_with_delimiter(Alphanumeric, b'\n', 100, true, length);
+            RandomizedString::generate_with_delimiter(Alphanumeric, b'\n', 100, true, length);
         assert_eq!(length, random_string.len());
         assert_eq!(
             100,
diff --git a/tests/common/util.rs b/tests/uutests/src/lib/util.rs
similarity index 77%
rename from tests/common/util.rs
rename to tests/uutests/src/lib/util.rs
index 0fbc58cd540..964b24e86b5 100644
--- a/tests/common/util.rs
+++ b/tests/uutests/src/lib/util.rs
@@ -2,41 +2,55 @@
 //
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
-
-//spell-checker: ignore (linux) rlimit prlimit coreutil ggroups uchild uncaptured scmd SHLVL canonicalized
+//spell-checker: ignore (linux) rlimit prlimit coreutil ggroups uchild uncaptured scmd SHLVL canonicalized openpty
+//spell-checker: ignore (linux) winsize xpixel ypixel setrlimit FSIZE SIGBUS SIGSEGV sigbus tmpfs
 
 #![allow(dead_code)]
+#![allow(
+    clippy::too_many_lines,
+    clippy::should_panic_without_expect,
+    clippy::missing_errors_doc
+)]
 
+#[cfg(unix)]
+use libc::mode_t;
+#[cfg(unix)]
+use nix::pty::OpenptyResult;
+#[cfg(unix)]
+use nix::sys;
 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 rlimit::setrlimit;
 use std::borrow::Cow;
 use std::collections::VecDeque;
 #[cfg(not(windows))]
 use std::ffi::CString;
 use std::ffi::{OsStr, OsString};
-use std::fs::{self, hard_link, remove_file, File, OpenOptions};
+use std::fs::{self, File, OpenOptions, hard_link, remove_file};
 use std::io::{self, BufWriter, Read, Result, Write};
 #[cfg(unix)]
-use std::os::unix::fs::{symlink as symlink_dir, symlink as symlink_file, PermissionsExt};
+use std::os::fd::OwnedFd;
+#[cfg(unix)]
+use std::os::unix::fs::{PermissionsExt, symlink as symlink_dir, symlink as symlink_file};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt;
 #[cfg(unix)]
 use std::os::unix::process::ExitStatusExt;
 #[cfg(windows)]
 use std::os::windows::fs::{symlink_dir, symlink_file};
 #[cfg(windows)]
-use std::path::MAIN_SEPARATOR;
+use std::path::MAIN_SEPARATOR_STR;
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, ExitStatus, Output, Stdio};
 use std::rc::Rc;
 use std::sync::mpsc::{self, RecvTimeoutError};
-use std::thread::{sleep, JoinHandle};
+use std::thread::{JoinHandle, sleep};
 use std::time::{Duration, Instant};
-use std::{env, hint, thread};
+use std::{env, hint, mem, thread};
 use tempfile::{Builder, TempDir};
 
+use std::sync::OnceLock;
+
 static TESTS_DIR: &str = "tests";
 static FIXTURES_DIR: &str = "fixtures";
 
@@ -46,8 +60,30 @@ static ALREADY_RUN: &str = " you have already run this UCommand, if you want to
 static MULTIPLE_STDIN_MEANINGLESS: &str = "Ucommand is designed around a typical use case of: provide args and input stream -> spawn process -> block until completion -> return output streams. For verifying that a particular section of the input stream is what causes a particular behavior, use the Command type directly.";
 
 static NO_STDIN_MEANINGLESS: &str = "Setting this flag has no effect if there is no stdin";
+static END_OF_TRANSMISSION_SEQUENCE: &[u8] = b"\n\x04";
+
+static TESTS_BINARY_PATH: OnceLock<PathBuf> = OnceLock::new();
+/// This function needs the env variable UUTESTS_BINARY_PATH
+/// which will very probably be env!("`CARGO_BIN_EXE_<program>`")
+/// because here, we are in a crate but we need the name of the final binary
+pub fn get_tests_binary() -> &'static str {
+    TESTS_BINARY_PATH.get_or_init(|| {
+        if let Ok(path) = env::var("UUTESTS_BINARY_PATH") {
+            return PathBuf::from(path);
+        }
+        panic!("Could not determine coreutils binary path. Please set UUTESTS_BINARY_PATH environment variable");
+    })
+    .to_str()
+    .unwrap()
+}
+
+#[macro_export]
+macro_rules! get_tests_binary {
+    () => {
+        $crate::util::get_tests_binary()
+    };
+}
 
-pub const TESTS_BINARY: &str = env!("CARGO_BIN_EXE_coreutils");
 pub const PATH: &str = env!("PATH");
 
 /// Default environment variables to run the commands with
@@ -55,13 +91,11 @@ const DEFAULT_ENV: [(&str, &str); 2] = [("LC_ALL", "C"), ("TZ", "UTC")];
 
 /// Test if the program is running under CI
 pub fn is_ci() -> bool {
-    std::env::var("CI")
-        .unwrap_or_else(|_| String::from("false"))
-        .eq_ignore_ascii_case("true")
+    std::env::var("CI").is_ok_and(|s| s.eq_ignore_ascii_case("true"))
 }
 
 /// Read a test scenario fixture, returning its bytes
-fn read_scenario_fixture<S: AsRef<OsStr>>(tmpd: &Option<Rc<TempDir>>, file_rel_path: S) -> Vec<u8> {
+fn read_scenario_fixture<S: AsRef<OsStr>>(tmpd: Option<&Rc<TempDir>>, file_rel_path: S) -> Vec<u8> {
     let tmpdir_path = tmpd.as_ref().unwrap().as_ref().path();
     AtPath::new(tmpdir_path).read_bytes(file_rel_path.as_ref().to_str().unwrap())
 }
@@ -70,9 +104,9 @@ fn read_scenario_fixture<S: AsRef<OsStr>>(tmpd: &Option<Rc<TempDir>>, file_rel_p
 /// within a struct which has convenience assertion functions about those outputs
 #[derive(Debug, Clone)]
 pub struct CmdResult {
-    /// bin_path provided by `TestScenario` or `UCommand`
+    /// `bin_path` provided by `TestScenario` or `UCommand`
     bin_path: PathBuf,
-    /// util_name provided by `TestScenario` or `UCommand`
+    /// `util_name` provided by `TestScenario` or `UCommand`
     util_name: Option<String>,
     //tmpd is used for convenience functions for asserts against fixtures
     tmpd: Option<Rc<TempDir>>,
@@ -175,22 +209,22 @@ impl CmdResult {
 
     /// Assert `stdout` as bytes with a predicate function returning a `bool`.
     #[track_caller]
-    pub fn stdout_check<'a, F>(&'a self, predicate: F) -> &Self
+    pub fn stdout_check<'a, F>(&'a self, predicate: F) -> &'a Self
     where
         F: Fn(&'a [u8]) -> bool,
     {
         assert!(
             predicate(&self.stdout),
             "Predicate for stdout as `bytes` evaluated to false.\nstdout='{:?}'\nstderr='{:?}'\n",
-            &self.stdout,
-            &self.stderr
+            self.stdout,
+            self.stderr
         );
         self
     }
 
     /// Assert `stdout` as `&str` with a predicate function returning a `bool`.
     #[track_caller]
-    pub fn stdout_str_check<'a, F>(&'a self, predicate: F) -> &Self
+    pub fn stdout_str_check<'a, F>(&'a self, predicate: F) -> &'a Self
     where
         F: Fn(&'a str) -> bool,
     {
@@ -205,22 +239,22 @@ impl CmdResult {
 
     /// Assert `stderr` as bytes with a predicate function returning a `bool`.
     #[track_caller]
-    pub fn stderr_check<'a, F>(&'a self, predicate: F) -> &Self
+    pub fn stderr_check<'a, F>(&'a self, predicate: F) -> &'a Self
     where
         F: Fn(&'a [u8]) -> bool,
     {
         assert!(
             predicate(&self.stderr),
             "Predicate for stderr as `bytes` evaluated to false.\nstdout='{:?}'\nstderr='{:?}'\n",
-            &self.stdout,
-            &self.stderr
+            self.stdout,
+            self.stderr
         );
         self
     }
 
     /// Assert `stderr` as `&str` with a predicate function returning a `bool`.
     #[track_caller]
-    pub fn stderr_str_check<'a, F>(&'a self, predicate: F) -> &Self
+    pub fn stderr_str_check<'a, F>(&'a self, predicate: F) -> &'a Self
     where
         F: Fn(&'a str) -> bool,
     {
@@ -272,8 +306,7 @@ impl CmdResult {
     pub fn signal_is(&self, value: i32) -> &Self {
         let actual = self.signal().unwrap_or_else(|| {
             panic!(
-                "Expected process to be terminated by the '{}' signal, but exit status is: '{}'",
-                value,
+                "Expected process to be terminated by the '{value}' signal, but exit status is: '{}'",
                 self.try_exit_status()
                     .map_or("Not available".to_string(), |e| e.to_string())
             )
@@ -303,8 +336,7 @@ impl CmdResult {
 
         let actual = self.signal().unwrap_or_else(|| {
             panic!(
-                "Expected process to be terminated by the '{}' signal, but exit status is: '{}'",
-                name,
+                "Expected process to be terminated by the '{name}' signal, but exit status is: '{}'",
                 self.try_exit_status()
                     .map_or("Not available".to_string(), |e| e.to_string())
             )
@@ -346,6 +378,11 @@ impl CmdResult {
         std::str::from_utf8(&self.stderr).unwrap()
     }
 
+    /// Returns the program's standard error as a string slice, automatically handling invalid utf8
+    pub fn stderr_str_lossy(&self) -> Cow<'_, str> {
+        String::from_utf8_lossy(&self.stderr)
+    }
+
     /// Returns the program's standard error as a string
     /// consumes self
     pub fn stderr_move_str(self) -> String {
@@ -364,8 +401,23 @@ impl CmdResult {
         self.exit_status().code().unwrap()
     }
 
+    /// Verify the exit code of the program
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+    /// ```
     #[track_caller]
     pub fn code_is(&self, expected_code: i32) -> &Self {
+        let fails = self.code() != expected_code;
+        if fails {
+            eprintln!(
+                "stdout:\n{}\nstderr:\n{}",
+                self.stdout_str(),
+                self.stderr_str()
+            );
+        }
         assert_eq!(self.code(), expected_code);
         self
     }
@@ -381,7 +433,7 @@ impl CmdResult {
 
     /// Returns whether the program succeeded
     pub fn succeeded(&self) -> bool {
-        self.exit_status.map_or(true, |e| e.success())
+        self.exit_status.is_none_or(|e| e.success())
     }
 
     /// asserts that the command resulted in a success (zero) status code
@@ -389,7 +441,8 @@ impl CmdResult {
     pub fn success(&self) -> &Self {
         assert!(
             self.succeeded(),
-            "Command was expected to succeed.\nstdout = {}\n stderr = {}",
+            "Command was expected to succeed. code: {}\nstdout = {}\n stderr = {}",
+            self.code(),
             self.stdout_str(),
             self.stderr_str()
         );
@@ -413,6 +466,12 @@ impl CmdResult {
     /// but you might find yourself using this function if
     /// 1.  you can not know exactly what stdout will be or
     /// 2.  you know that stdout will also be empty
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    ///  scene.ucmd().fails().no_stderr();
+    /// ```
     #[track_caller]
     pub fn no_stderr(&self) -> &Self {
         assert!(
@@ -429,6 +488,13 @@ impl CmdResult {
     /// but you might find yourself using this function if
     /// 1.  you can not know exactly what stderr will be or
     /// 2.  you know that stderr will also be empty
+    ///     new_ucmd!()
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    ///  scene.ucmd().fails().no_stdout();
+    /// ```
     #[track_caller]
     pub fn no_stdout(&self) -> &Self {
         assert!(
@@ -459,9 +525,8 @@ impl CmdResult {
     pub fn stdout_is_any<T: AsRef<str> + std::fmt::Debug>(&self, expected: &[T]) -> &Self {
         assert!(
             expected.iter().any(|msg| self.stdout_str() == msg.as_ref()),
-            "stdout was {}\nExpected any of {:#?}",
+            "stdout was {}\nExpected any of {expected:#?}",
             self.stdout_str(),
-            expected
         );
         self
     }
@@ -478,7 +543,9 @@ impl CmdResult {
     /// whose bytes equal those of the passed in slice
     #[track_caller]
     pub fn stdout_is_bytes<T: AsRef<[u8]>>(&self, msg: T) -> &Self {
-        assert_eq!(self.stdout, msg.as_ref(),
+        assert_eq!(
+            self.stdout,
+            msg.as_ref(),
             "stdout as bytes wasn't equal to expected bytes. Result as strings:\nstdout  ='{:?}'\nexpected='{:?}'",
             std::str::from_utf8(&self.stdout),
             std::str::from_utf8(msg.as_ref()),
@@ -489,7 +556,7 @@ impl CmdResult {
     /// like `stdout_is()`, but expects the contents of the file at the provided relative path
     #[track_caller]
     pub fn stdout_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
-        let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
+        let contents = read_scenario_fixture(self.tmpd.as_ref(), file_rel_path);
         self.stdout_is(String::from_utf8(contents).unwrap())
     }
 
@@ -511,7 +578,7 @@ impl CmdResult {
     /// ```
     #[track_caller]
     pub fn stdout_is_fixture_bytes<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
-        let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
+        let contents = read_scenario_fixture(self.tmpd.as_ref(), file_rel_path);
         self.stdout_is_bytes(contents)
     }
 
@@ -524,7 +591,7 @@ impl CmdResult {
         template_vars: &[(&str, &str)],
     ) -> &Self {
         let mut contents =
-            String::from_utf8(read_scenario_fixture(&self.tmpd, file_rel_path)).unwrap();
+            String::from_utf8(read_scenario_fixture(self.tmpd.as_ref(), file_rel_path)).unwrap();
         for kv in template_vars {
             contents = contents.replace(kv.0, kv.1);
         }
@@ -538,7 +605,8 @@ impl CmdResult {
         file_rel_path: T,
         template_vars: &[Vec<(String, String)>],
     ) {
-        let contents = String::from_utf8(read_scenario_fixture(&self.tmpd, file_rel_path)).unwrap();
+        let contents =
+            String::from_utf8(read_scenario_fixture(self.tmpd.as_ref(), file_rel_path)).unwrap();
         let possible_values = template_vars.iter().map(|vars| {
             let mut contents = contents.clone();
             for kv in vars {
@@ -576,7 +644,7 @@ impl CmdResult {
     /// Like `stdout_is_fixture`, but for stderr
     #[track_caller]
     pub fn stderr_is_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
-        let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
+        let contents = read_scenario_fixture(self.tmpd.as_ref(), file_rel_path);
         self.stderr_is(String::from_utf8(contents).unwrap())
     }
 
@@ -601,7 +669,7 @@ impl CmdResult {
     /// like `stdout_only()`, but expects the contents of the file at the provided relative path
     #[track_caller]
     pub fn stdout_only_fixture<T: AsRef<OsStr>>(&self, file_rel_path: T) -> &Self {
-        let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
+        let contents = read_scenario_fixture(self.tmpd.as_ref(), file_rel_path);
         self.stdout_only_bytes(contents)
     }
 
@@ -648,6 +716,16 @@ impl CmdResult {
         ))
     }
 
+    /// Verify if stdout contains a specific string
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// new_ucmd!()
+    /// .arg("--help")
+    /// .succeeds()
+    /// .stdout_contains("Options:");
+    /// ```
     #[track_caller]
     pub fn stdout_contains<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
@@ -659,6 +737,16 @@ impl CmdResult {
         self
     }
 
+    /// Verify if stdout contains a specific line
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    /// new_ucmd!()
+    /// .arg("--help")
+    /// .succeeds()
+    /// .stdout_contains_line("Options:");
+    /// ```
     #[track_caller]
     pub fn stdout_contains_line<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
@@ -670,6 +758,17 @@ impl CmdResult {
         self
     }
 
+    /// Verify if stderr contains a specific string
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    ///     new_ucmd!()
+    /// .arg("-l")
+    /// .arg("IaMnOtAsIgNaL")
+    /// .fails()
+    /// .stderr_contains("IaMnOtAsIgNaL");
+    /// ```
     #[track_caller]
     pub fn stderr_contains<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
@@ -681,6 +780,17 @@ impl CmdResult {
         self
     }
 
+    /// Verify if stdout does not contain a specific string
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    ///  new_ucmd!()
+    /// .arg("-l")
+    /// .arg("IaMnOtAsIgNaL")
+    /// .fails()
+    /// .stdout_does_not_contain("Valid-signal");
+    /// ```
     #[track_caller]
     pub fn stdout_does_not_contain<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(
@@ -692,6 +802,17 @@ impl CmdResult {
         self
     }
 
+    /// Verify if st stderr does not contain a specific string
+    ///
+    /// # Examples
+    ///
+    /// ```rust,ignore
+    ///  new_ucmd!()
+    /// .arg("-l")
+    /// .arg("IaMnOtAsIgNaL")
+    /// .fails()
+    /// .stderr_does_not_contain("Valid-signal");
+    /// ```
     #[track_caller]
     pub fn stderr_does_not_contain<T: AsRef<str>>(&self, cmp: T) -> &Self {
         assert!(!self.stderr_str().contains(cmp.as_ref()));
@@ -751,11 +872,27 @@ pub fn recursive_copy(src: &Path, dest: &Path) -> Result<()> {
 }
 
 pub fn get_root_path() -> &'static str {
-    if cfg!(windows) {
-        "C:\\"
-    } else {
-        "/"
-    }
+    if cfg!(windows) { "C:\\" } else { "/" }
+}
+
+/// Compares the extended attributes (xattrs) of two files or directories.
+///
+/// # Returns
+///
+/// `true` if both paths have the same set of extended attributes, `false` otherwise.
+#[cfg(all(unix, not(any(target_os = "macos", target_os = "openbsd"))))]
+pub fn compare_xattrs<P: AsRef<std::path::Path>>(path1: P, path2: P) -> bool {
+    let get_sorted_xattrs = |path: P| {
+        xattr::list(path)
+            .map(|attrs| {
+                let mut attrs = attrs.collect::<Vec<_>>();
+                attrs.sort();
+                attrs
+            })
+            .unwrap_or_default()
+    };
+
+    get_sorted_xattrs(path1) == get_sorted_xattrs(path2)
 }
 
 /// Object-oriented path struct that represents and operates on
@@ -843,22 +980,21 @@ impl AtPath {
             .unwrap_or_else(|e| panic!("Couldn't write {name}: {e}"));
     }
 
-    pub fn append(&self, name: &str, contents: &str) {
+    pub fn append(&self, name: impl AsRef<Path>, contents: &str) {
+        let name = name.as_ref();
         log_info("write(append)", self.plus_as_string(name));
         let mut f = OpenOptions::new()
-            .write(true)
             .append(true)
             .create(true)
             .open(self.plus(name))
             .unwrap();
         f.write_all(contents.as_bytes())
-            .unwrap_or_else(|e| panic!("Couldn't write(append) {name}: {e}"));
+            .unwrap_or_else(|e| panic!("Couldn't write(append) {}: {e}", name.display()));
     }
 
     pub fn append_bytes(&self, name: &str, contents: &[u8]) {
         log_info("write(append)", self.plus_as_string(name));
         let mut f = OpenOptions::new()
-            .write(true)
             .append(true)
             .create(true)
             .open(self.plus(name))
@@ -920,7 +1056,7 @@ impl AtPath {
     pub fn make_file(&self, name: &str) -> File {
         match File::create(self.plus(name)) {
             Ok(f) => f,
-            Err(e) => panic!("{}", e),
+            Err(e) => panic!("{e}"),
         }
     }
 
@@ -979,10 +1115,10 @@ impl AtPath {
 
     pub fn relative_symlink_file(&self, original: &str, link: &str) {
         #[cfg(windows)]
-        let original = original.replace('/', &MAIN_SEPARATOR.to_string());
+        let original = original.replace('/', MAIN_SEPARATOR_STR);
         log_info(
             "symlink",
-            format!("{},{}", &original, &self.plus_as_string(link)),
+            format!("{original},{}", self.plus_as_string(link)),
         );
         symlink_file(original, self.plus(link)).unwrap();
     }
@@ -1001,10 +1137,10 @@ impl AtPath {
 
     pub fn relative_symlink_dir(&self, original: &str, link: &str) {
         #[cfg(windows)]
-        let original = original.replace('/', &MAIN_SEPARATOR.to_string());
+        let original = original.replace('/', MAIN_SEPARATOR_STR);
         log_info(
             "symlink",
-            format!("{},{}", &original, &self.plus_as_string(link)),
+            format!("{original},{}", self.plus_as_string(link)),
         );
         symlink_dir(original, self.plus(link)).unwrap();
     }
@@ -1037,14 +1173,14 @@ impl AtPath {
     pub fn symlink_metadata(&self, path: &str) -> fs::Metadata {
         match fs::symlink_metadata(self.plus(path)) {
             Ok(m) => m,
-            Err(e) => panic!("{}", e),
+            Err(e) => panic!("{e}"),
         }
     }
 
     pub fn metadata(&self, path: &str) -> fs::Metadata {
         match fs::metadata(self.plus(path)) {
             Ok(m) => m,
-            Err(e) => panic!("{}", e),
+            Err(e) => panic!("{e}"),
         }
     }
 
@@ -1122,6 +1258,8 @@ pub struct TestScenario {
     pub util_name: String,
     pub fixtures: AtPath,
     tmpd: Rc<TempDir>,
+    #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+    tmp_fs_mountpoint: Option<String>,
 }
 
 impl TestScenario {
@@ -1130,11 +1268,14 @@ impl TestScenario {
         T: AsRef<str>,
     {
         let tmpd = Rc::new(TempDir::new().unwrap());
+        println!("bin: {:?}", get_tests_binary!());
         let ts = Self {
-            bin_path: PathBuf::from(TESTS_BINARY),
+            bin_path: PathBuf::from(get_tests_binary!()),
             util_name: util_name.as_ref().into(),
             fixtures: AtPath::new(tmpd.as_ref().path()),
             tmpd,
+            #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+            tmp_fs_mountpoint: None,
         };
         let mut fixture_path_builder = env::current_dir().unwrap();
         fixture_path_builder.push(TESTS_DIR);
@@ -1163,18 +1304,76 @@ impl TestScenario {
         command
     }
 
+    /// Returns builder for invoking a command in shell (e.g. sh -c 'cmd').
+    /// Paths given are treated relative to the environment's unique temporary
+    /// test directory.
+    pub fn cmd_shell<S: AsRef<OsStr>>(&self, cmd: S) -> UCommand {
+        let mut command = UCommand::new();
+        // Intentionally leave bin_path unset.
+        command.arg(cmd);
+        command.temp_dir(self.tmpd.clone());
+        command
+    }
+
     /// Returns builder for invoking any uutils command. Paths given are treated
     /// relative to the environment's unique temporary test directory.
     pub fn ccmd<S: AsRef<str>>(&self, util_name: S) -> UCommand {
         UCommand::with_util(util_name, self.tmpd.clone())
     }
+
+    /// Mounts a temporary filesystem at the specified mount point.
+    #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+    pub fn mount_temp_fs(&mut self, mount_point: &str) -> core::result::Result<(), String> {
+        if self.tmp_fs_mountpoint.is_some() {
+            return Err("already mounted".to_string());
+        }
+        let cmd_result = self
+            .cmd("mount")
+            .arg("-t")
+            .arg("tmpfs")
+            .arg("-o")
+            .arg("size=640k") // ought to be enough
+            .arg("tmpfs")
+            .arg(mount_point)
+            .run();
+        if !cmd_result.succeeded() {
+            return Err(format!("mount failed: {}", cmd_result.stderr_str()));
+        }
+        self.tmp_fs_mountpoint = Some(mount_point.to_string());
+        Ok(())
+    }
+
+    #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+    /// Unmounts the temporary filesystem if it is currently mounted.
+    pub fn umount_temp_fs(&mut self) {
+        if let Some(mount_point) = self.tmp_fs_mountpoint.as_ref() {
+            self.cmd("umount").arg(mount_point).succeeds();
+            self.tmp_fs_mountpoint = None;
+        }
+    }
+}
+
+impl Drop for TestScenario {
+    fn drop(&mut self) {
+        #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
+        self.umount_temp_fs();
+    }
+}
+
+#[cfg(unix)]
+#[derive(Debug, Default)]
+pub struct TerminalSimulation {
+    pub size: Option<libc::winsize>,
+    pub stdin: bool,
+    pub stdout: bool,
+    pub stderr: bool,
 }
 
 /// A `UCommand` is a builder wrapping an individual Command that provides several additional features:
 /// 1. it has convenience functions that are more ergonomic to use for piping in stdin, spawning the command
-///       and asserting on the results.
+///    and asserting on the results.
 /// 2. it tracks arguments provided so that in test cases which may provide variations of an arg in loops
-///     the test failure can display the exact call which preceded an assertion failure.
+///    the test failure can display the exact call which preceded an assertion failure.
 /// 3. it provides convenience construction methods to set the Command uutils utility and temporary directory.
 ///
 /// Per default `UCommand` runs a command given as an argument in a shell, platform independently.
@@ -1200,11 +1399,15 @@ pub struct UCommand {
     stdout: Option<Stdio>,
     stderr: Option<Stdio>,
     bytes_into_stdin: Option<Vec<u8>>,
-    #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[cfg(unix)]
     limits: Vec<(rlimit::Resource, u64, u64)>,
     stderr_to_stdout: bool,
     timeout: Option<Duration>,
+    #[cfg(unix)]
+    terminal_simulation: Option<TerminalSimulation>,
     tmpd: Option<Rc<TempDir>>, // drop last
+    #[cfg(unix)]
+    umask: Option<mode_t>,
 }
 
 impl UCommand {
@@ -1231,7 +1434,7 @@ impl UCommand {
     {
         let mut ucmd = Self::new();
         ucmd.util_name = Some(util_name.as_ref().into());
-        ucmd.bin_path(TESTS_BINARY).temp_dir(tmpd);
+        ucmd.bin_path(&*get_tests_binary!()).temp_dir(tmpd);
         ucmd
     }
 
@@ -1268,7 +1471,8 @@ impl UCommand {
 
     /// Set the working directory for this [`UCommand`]
     ///
-    /// Per default the working directory is set to the [`UCommands`] temporary directory.
+    /// Per default the working directory is set to the [`UCommand`] temporary directory.
+    ///
     pub fn current_dir<T>(&mut self, current_dir: T) -> &mut Self
     where
         T: Into<PathBuf>,
@@ -1315,8 +1519,7 @@ impl UCommand {
     pub fn pipe_in<T: Into<Vec<u8>>>(&mut self, input: T) -> &mut Self {
         assert!(
             self.bytes_into_stdin.is_none(),
-            "{}",
-            MULTIPLE_STDIN_MEANINGLESS
+            "{MULTIPLE_STDIN_MEANINGLESS}",
         );
         self.set_stdin(Stdio::piped());
         self.bytes_into_stdin = Some(input.into());
@@ -1325,7 +1528,7 @@ impl UCommand {
 
     /// like `pipe_in()`, but uses the contents of the file at the provided relative path as the piped in data
     pub fn pipe_in_fixture<S: AsRef<OsStr>>(&mut self, file_rel_path: S) -> &mut Self {
-        let contents = read_scenario_fixture(&self.tmpd, file_rel_path);
+        let contents = read_scenario_fixture(self.tmpd.as_ref(), file_rel_path);
         self.pipe_in(contents)
     }
 
@@ -1359,7 +1562,7 @@ impl UCommand {
         self
     }
 
-    #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[cfg(unix)]
     pub fn limit(
         &mut self,
         resource: rlimit::Resource,
@@ -1370,11 +1573,18 @@ impl UCommand {
         self
     }
 
+    #[cfg(unix)]
+    /// The umask is a value that restricts the permissions of newly created files and directories.
+    pub fn umask(&mut self, umask: mode_t) -> &mut Self {
+        self.umask = Some(umask);
+        self
+    }
+
     /// Set the timeout for [`UCommand::run`] and similar methods in [`UCommand`].
     ///
     /// After the timeout elapsed these `run` methods (besides [`UCommand::run_no_wait`]) will
     /// panic. When [`UCommand::run_no_wait`] is used, this timeout is applied to
-    /// [`UChild::wait_with_output`] including all other waiting methods in [`UChild`] implicitly
+    /// `wait_with_output` including all other waiting methods in [`UChild`] implicitly
     /// using `wait_with_output()` and additionally [`UChild::kill`]. The default timeout of `kill`
     /// will be overwritten by this `timeout`.
     pub fn timeout(&mut self, timeout: Duration) -> &mut Self {
@@ -1382,17 +1592,88 @@ impl UCommand {
         self
     }
 
+    /// Set if process should be run in a simulated terminal
+    ///
+    /// This is useful to test behavior that is only active if e.g. [`stdout.is_terminal()`] is [`true`].
+    /// This function uses default terminal size and attaches stdin, stdout and stderr to that terminal.
+    /// For more control over the terminal simulation, use `terminal_sim_stdio`
+    /// (unix: pty, windows: `ConPTY`[not yet supported])
+    #[cfg(unix)]
+    pub fn terminal_simulation(&mut self, enable: bool) -> &mut Self {
+        if enable {
+            self.terminal_simulation = Some(TerminalSimulation {
+                stdin: true,
+                stdout: true,
+                stderr: true,
+                ..Default::default()
+            });
+        } else {
+            self.terminal_simulation = None;
+        }
+        self
+    }
+
+    /// Allows to simulate a terminal use-case with specific properties.
+    ///
+    /// This is useful to test behavior that is only active if e.g. [`stdout.is_terminal()`] is [`true`].
+    /// This function allows to set a specific size and to attach the terminal to only parts of the in/out.
+    #[cfg(unix)]
+    pub fn terminal_sim_stdio(&mut self, config: TerminalSimulation) -> &mut Self {
+        self.terminal_simulation = Some(config);
+        self
+    }
+
+    #[cfg(unix)]
+    fn read_from_pty(pty_fd: std::os::fd::OwnedFd, out: File) {
+        let read_file = std::fs::File::from(pty_fd);
+        let mut reader = std::io::BufReader::new(read_file);
+        let mut writer = std::io::BufWriter::new(out);
+        let result = std::io::copy(&mut reader, &mut writer);
+        match result {
+            Ok(_) => {}
+            // Input/output error (os error 5) is returned due to pipe closes. Buffer gets content anyway.
+            Err(e) if e.raw_os_error().unwrap_or_default() == 5 => {}
+            Err(e) => {
+                eprintln!("Unexpected error: {e:?}");
+                panic!("error forwarding output of pty");
+            }
+        }
+    }
+
+    #[cfg(unix)]
+    fn spawn_reader_thread(
+        captured_output: Option<CapturedOutput>,
+        pty_fd_master: OwnedFd,
+        name: String,
+    ) -> Option<CapturedOutput> {
+        if let Some(mut captured_output_i) = captured_output {
+            let fd = captured_output_i.try_clone().unwrap();
+
+            let handle = std::thread::Builder::new()
+                .name(name)
+                .spawn(move || {
+                    Self::read_from_pty(pty_fd_master, fd);
+                })
+                .unwrap();
+
+            captured_output_i.reader_thread_handle = Some(handle);
+            Some(captured_output_i)
+        } else {
+            None
+        }
+    }
+
     /// Build the `std::process::Command` and apply the defaults on fields which were not specified
     /// by the user.
     ///
     /// These __defaults__ are:
     /// * `bin_path`: Depending on the platform and os, the native shell (unix -> `/bin/sh` etc.).
-    /// This default also requires to set the first argument to `-c` on unix (`/C` on windows) if
-    /// this argument wasn't specified explicitly by the user.
+    ///   This default also requires to set the first argument to `-c` on unix (`/C` on windows) if
+    ///   this argument wasn't specified explicitly by the user.
     /// * `util_name`: `None`. If neither `bin_path` nor `util_name` were given the arguments are
-    /// run in a shell (See `bin_path` above).
+    ///   run in a shell (See `bin_path` above).
     /// * `temp_dir`: If `current_dir` was not set, a new temporary directory will be created in
-    /// which this command will be run and `current_dir` will be set to this `temp_dir`.
+    ///   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`
     /// * `stdin`: `Stdio::null()`
@@ -1401,13 +1682,20 @@ impl UCommand {
     /// * `stderr_to_stdout`: `false`
     /// * `bytes_into_stdin`: `None`
     /// * `limits`: `None`.
-    fn build(&mut self) -> (Command, Option<CapturedOutput>, Option<CapturedOutput>) {
+    fn build(
+        &mut self,
+    ) -> (
+        Command,
+        Option<CapturedOutput>,
+        Option<CapturedOutput>,
+        Option<File>,
+    ) {
         if self.bin_path.is_some() {
             if let Some(util_name) = &self.util_name {
                 self.args.push_front(util_name.into());
             }
         } else if let Some(util_name) = &self.util_name {
-            self.bin_path = Some(PathBuf::from(TESTS_BINARY));
+            self.bin_path = Some(PathBuf::from(&*get_tests_binary!()));
             self.args.push_front(util_name.into());
         // neither `bin_path` nor `util_name` was set so we apply the default to run the arguments
         // in a platform specific shell
@@ -1470,6 +1758,11 @@ impl UCommand {
             }
         }
 
+        // Forward the LLVM_PROFILE_FILE variable to the call, for coverage purposes.
+        if let Some(ld_preload) = env::var_os("LLVM_PROFILE_FILE") {
+            command.env("LLVM_PROFILE_FILE", ld_preload);
+        }
+
         command
             .envs(DEFAULT_ENV)
             .envs(self.env_vars.iter().cloned());
@@ -1480,6 +1773,10 @@ impl UCommand {
 
         let mut captured_stdout = None;
         let mut captured_stderr = None;
+        #[cfg(unix)]
+        let mut stdin_pty: Option<File> = None;
+        #[cfg(not(unix))]
+        let stdin_pty: Option<File> = None;
         if self.stderr_to_stdout {
             let mut output = CapturedOutput::default();
 
@@ -1513,32 +1810,94 @@ impl UCommand {
                 .stderr(stderr);
         };
 
-        (command, captured_stdout, captured_stderr)
+        #[cfg(unix)]
+        if let Some(simulated_terminal) = &self.terminal_simulation {
+            let terminal_size = simulated_terminal.size.unwrap_or(libc::winsize {
+                ws_col: 80,
+                ws_row: 30,
+                ws_xpixel: 80 * 8,
+                ws_ypixel: 30 * 10,
+            });
+
+            if simulated_terminal.stdin {
+                let OpenptyResult {
+                    slave: pi_slave,
+                    master: pi_master,
+                } = nix::pty::openpty(&terminal_size, None).unwrap();
+                stdin_pty = Some(File::from(pi_master));
+                command.stdin(pi_slave);
+            }
+
+            if simulated_terminal.stdout {
+                let OpenptyResult {
+                    slave: po_slave,
+                    master: po_master,
+                } = nix::pty::openpty(&terminal_size, None).unwrap();
+                captured_stdout = Self::spawn_reader_thread(
+                    captured_stdout,
+                    po_master,
+                    "stdout_reader".to_string(),
+                );
+                command.stdout(po_slave);
+            }
+
+            if simulated_terminal.stderr {
+                let OpenptyResult {
+                    slave: pe_slave,
+                    master: pe_master,
+                } = nix::pty::openpty(&terminal_size, None).unwrap();
+                captured_stderr = Self::spawn_reader_thread(
+                    captured_stderr,
+                    pe_master,
+                    "stderr_reader".to_string(),
+                );
+                command.stderr(pe_slave);
+            }
+        }
+
+        #[cfg(unix)]
+        if !self.limits.is_empty() {
+            // just to be safe: move a copy of the limits list into the closure.
+            // this way the closure is fully self-contained.
+            let limits_copy = self.limits.clone();
+            let closure = move || -> Result<()> {
+                for &(resource, soft_limit, hard_limit) in &limits_copy {
+                    setrlimit(resource, soft_limit, hard_limit)?;
+                }
+                Ok(())
+            };
+            // SAFETY: the closure is self-contained and doesn't do any memory
+            // writes that would need to be propagated back to the parent process.
+            // also, the closure doesn't access stdin, stdout and stderr.
+            unsafe {
+                command.pre_exec(closure);
+            }
+        }
+
+        #[cfg(unix)]
+        if let Some(umask) = self.umask {
+            unsafe {
+                command.pre_exec(move || {
+                    libc::umask(umask);
+                    Ok(())
+                });
+            }
+        }
+
+        (command, captured_stdout, captured_stderr, stdin_pty)
     }
 
     /// Spawns the command, feeds the stdin if any, and returns the
     /// child process immediately.
     pub fn run_no_wait(&mut self) -> UChild {
-        assert!(!self.has_run, "{}", ALREADY_RUN);
+        assert!(!self.has_run, "{ALREADY_RUN}");
         self.has_run = true;
 
-        let (mut command, captured_stdout, captured_stderr) = self.build();
+        let (mut command, captured_stdout, captured_stderr, stdin_pty) = self.build();
         log_info("run", self.to_string());
-
         let child = command.spawn().unwrap();
 
-        #[cfg(any(target_os = "linux", target_os = "android"))]
-        for &(resource, soft_limit, hard_limit) in &self.limits {
-            prlimit(
-                child.id() as i32,
-                resource,
-                Some((soft_limit, hard_limit)),
-                None,
-            )
-            .unwrap();
-        }
-
-        let mut child = UChild::from(self, child, captured_stdout, captured_stderr);
+        let mut child = UChild::from(self, child, captured_stdout, captured_stderr, stdin_pty);
 
         if let Some(input) = self.bytes_into_stdin.take() {
             child.pipe_in(input);
@@ -1549,7 +1908,7 @@ impl UCommand {
 
     /// Spawns the command, feeds the stdin if any, waits for the result
     /// and returns a command result.
-    /// It is recommended that you instead use succeeds() or fails()
+    /// It is recommended that you instead use `succeeds()` or `fails()`
     pub fn run(&mut self) -> CmdResult {
         self.run_no_wait().wait().unwrap()
     }
@@ -1557,7 +1916,7 @@ impl UCommand {
     /// Spawns the command, feeding the passed in stdin, waits for the result
     /// and returns a command result.
     /// It is recommended that, instead of this, you use a combination of `pipe_in()`
-    /// with succeeds() or fails()
+    /// with `succeeds()` or `fails()`
     pub fn run_piped_stdin<T: Into<Vec<u8>>>(&mut self, input: T) -> CmdResult {
         self.pipe_in(input).run()
     }
@@ -1580,18 +1939,39 @@ impl UCommand {
         cmd_result
     }
 
+    #[track_caller]
+    pub fn fails_with_code(&mut self, expected_code: i32) -> CmdResult {
+        let cmd_result = self.run();
+        cmd_result.failure();
+        cmd_result.code_is(expected_code);
+        cmd_result
+    }
+
     pub fn get_full_fixture_path(&self, file_rel_path: &str) -> String {
         let tmpdir_path = self.tmpd.as_ref().unwrap().path();
         format!("{}/{file_rel_path}", tmpdir_path.to_str().unwrap())
     }
+
+    /// Runs the command, checks that the stdout starts with "expected",
+    /// then terminates the command.
+    #[track_caller]
+    pub fn run_stdout_starts_with(&mut self, expected: &[u8]) -> CmdResult {
+        let mut child = self.set_stdout(Stdio::piped()).run_no_wait();
+        let buf = child.stdout_exact_bytes(expected.len());
+        child.close_stdout();
+
+        assert_eq!(buf.as_slice(), expected);
+        child.wait().unwrap()
+    }
 }
 
 impl std::fmt::Display for UCommand {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut comm_string: Vec<String> = vec![self
-            .bin_path
-            .as_ref()
-            .map_or(String::new(), |p| p.display().to_string())];
+        let mut comm_string: Vec<String> = vec![
+            self.bin_path
+                .as_ref()
+                .map_or(String::new(), |p| p.display().to_string()),
+        ];
         comm_string.extend(self.args.iter().map(|s| s.to_string_lossy().to_string()));
         f.write_str(&comm_string.join(" "))
     }
@@ -1603,6 +1983,7 @@ impl std::fmt::Display for UCommand {
 struct CapturedOutput {
     current_file: File,
     output: tempfile::NamedTempFile, // drop last
+    reader_thread_handle: Option<thread::JoinHandle<()>>,
 }
 
 impl CapturedOutput {
@@ -1611,6 +1992,7 @@ impl CapturedOutput {
         Self {
             current_file: output.reopen().unwrap(),
             output,
+            reader_thread_handle: None,
         }
     }
 
@@ -1687,6 +2069,7 @@ impl Default for CapturedOutput {
         Self {
             current_file: file.reopen().unwrap(),
             output: file,
+            reader_thread_handle: None,
         }
     }
 }
@@ -1773,15 +2156,10 @@ impl<'a> UChildAssertion<'a> {
     // Assert that the child process is alive
     #[track_caller]
     pub fn is_alive(&mut self) -> &mut Self {
-        match self
-            .uchild
-            .raw
-            .try_wait()
-        {
+        match self.uchild.raw.try_wait() {
             Ok(Some(status)) => panic!(
-                "Assertion failed. Expected '{}' to be running but exited with status={}.\nstdout: {}\nstderr: {}",
+                "Assertion failed. Expected '{}' to be running but exited with status={status}.\nstdout: {}\nstderr: {}",
                 uucore::util_name(),
-                status,
                 self.uchild.stdout_all(),
                 self.uchild.stderr_all()
             ),
@@ -1795,17 +2173,14 @@ impl<'a> UChildAssertion<'a> {
     // Assert that the child process has exited
     #[track_caller]
     pub fn is_not_alive(&mut self) -> &mut Self {
-        match self
-            .uchild
-            .raw
-            .try_wait()
-        {
+        match self.uchild.raw.try_wait() {
             Ok(None) => panic!(
                 "Assertion failed. Expected '{}' to be not running but was alive.\nstdout: {}\nstderr: {}",
                 uucore::util_name(),
                 self.uchild.stdout_all(),
-                self.uchild.stderr_all()),
-            Ok(_) =>  {},
+                self.uchild.stderr_all()
+            ),
+            Ok(_) => {}
             Err(error) => panic!("Assertion failed with error '{error:?}'"),
         }
 
@@ -1820,6 +2195,7 @@ pub struct UChild {
     util_name: Option<String>,
     captured_stdout: Option<CapturedOutput>,
     captured_stderr: Option<CapturedOutput>,
+    stdin_pty: Option<File>,
     ignore_stdin_write_error: bool,
     stderr_to_stdout: bool,
     join_handle: Option<JoinHandle<io::Result<()>>>,
@@ -1833,6 +2209,7 @@ impl UChild {
         child: Child,
         captured_stdout: Option<CapturedOutput>,
         captured_stderr: Option<CapturedOutput>,
+        stdin_pty: Option<File>,
     ) -> Self {
         Self {
             raw: child,
@@ -1840,6 +2217,7 @@ impl UChild {
             util_name: ucommand.util_name.clone(),
             captured_stdout,
             captured_stderr,
+            stdin_pty,
             ignore_stdin_write_error: ucommand.ignore_stdin_write_error,
             stderr_to_stdout: ucommand.stderr_to_stdout,
             join_handle: None,
@@ -1880,7 +2258,7 @@ impl UChild {
         self.delay(millis).make_assertion()
     }
 
-    /// Try to kill the child process and wait for it's termination.
+    /// Try to kill the child process and wait for its termination.
     ///
     /// This method blocks until the child process is killed, but returns an error if `self.timeout`
     /// or the default of 60s was reached. If no such error happened, the process resources are
@@ -1908,10 +2286,10 @@ impl UChild {
             if start.elapsed() < timeout {
                 self.delay(10);
             } else {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("kill: Timeout of '{}s' reached", timeout.as_secs_f64()),
-                ));
+                return Err(io::Error::other(format!(
+                    "kill: Timeout of '{}s' reached",
+                    timeout.as_secs_f64()
+                )));
             }
             hint::spin_loop();
         }
@@ -1940,14 +2318,83 @@ impl UChild {
         self
     }
 
+    /// Try to kill the child process and wait for its termination.
+    ///
+    /// This method blocks until the child process is killed, but returns an error if `self.timeout`
+    /// or the default of 60s was reached. If no such error happened, the process resources are
+    /// released, so there is usually no need to call `wait` or alike on unix systems although it's
+    /// still possible to do so.
+    ///
+    /// # Platform specific behavior
+    ///
+    /// On unix systems the child process resources will be released like a call to [`Child::wait`]
+    /// or alike would do.
+    ///
+    /// # Error
+    ///
+    /// If [`Child::kill`] returned an error or if the child process could not be terminated within
+    /// `self.timeout` or the default of 60s.
+    #[cfg(unix)]
+    pub fn try_kill_with_custom_signal(
+        &mut self,
+        signal_name: sys::signal::Signal,
+    ) -> io::Result<()> {
+        let start = Instant::now();
+        sys::signal::kill(
+            nix::unistd::Pid::from_raw(self.raw.id().try_into().unwrap()),
+            signal_name,
+        )
+        .unwrap();
+
+        let timeout = self.timeout.unwrap_or(Duration::from_secs(60));
+        // As a side effect, we're cleaning up the killed child process with the implicit call to
+        // `Child::try_wait` in `self.is_alive`, which reaps the process id on unix systems. We
+        // always fail with error on timeout if `self.timeout` is set to zero.
+        while self.is_alive() || timeout == Duration::ZERO {
+            if start.elapsed() < timeout {
+                self.delay(10);
+            } else {
+                return Err(io::Error::other(format!(
+                    "kill: Timeout of '{}s' reached",
+                    timeout.as_secs_f64()
+                )));
+            }
+            hint::spin_loop();
+        }
+
+        Ok(())
+    }
+
+    /// Terminate the child process using custom signal parameter and wait for the termination.
+    ///
+    /// Ignores any errors happening during [`Child::kill`] (i.e. child process already exited) but
+    /// still panics on timeout.
+    ///
+    /// # Panics
+    /// If the child process could not be terminated within `self.timeout` or the default of 60s.
+    #[cfg(unix)]
+    pub fn kill_with_custom_signal(&mut self, signal_name: sys::signal::Signal) -> &mut Self {
+        self.try_kill_with_custom_signal(signal_name)
+            .or_else(|error| {
+                // We still throw the error on timeout in the `try_kill` function
+                if error.kind() == io::ErrorKind::Other {
+                    Err(error)
+                } else {
+                    Ok(())
+                }
+            })
+            .unwrap();
+        self
+    }
+
     /// Wait for the child process to terminate and return a [`CmdResult`].
     ///
-    /// See [`UChild::wait_with_output`] for details on timeouts etc. This method can also be run if
+    /// See `wait_with_output` for details on timeouts etc. This method can also be run if
     /// the child process was killed with [`UChild::kill`].
     ///
     /// # Errors
     ///
-    /// Returns the error from the call to [`UChild::wait_with_output`] if any
+    /// Returns the error from the call to `wait_with_output` if any
     pub fn wait(self) -> io::Result<CmdResult> {
         let (bin_path, util_name, tmpd) = (
             self.bin_path.clone(),
@@ -1955,7 +2402,6 @@ impl UChild {
             self.tmpd.clone(),
         );
 
-        #[allow(deprecated)]
         let output = self.wait_with_output()?;
 
         Ok(CmdResult {
@@ -1978,13 +2424,20 @@ impl UChild {
     ///
     /// If `self.timeout` is reached while waiting or [`Child::wait_with_output`] returned an
     /// error.
-    #[deprecated = "Please use wait() -> io::Result<CmdResult> instead."]
-    pub fn wait_with_output(mut self) -> io::Result<Output> {
+    fn wait_with_output(mut self) -> io::Result<Output> {
+        // some apps do not stop execution until their stdin gets closed.
+        // to prevent a endless waiting here, we close the stdin.
+        self.join(); // ensure that all pending async input is piped in
+        self.close_stdin();
+
         let output = if let Some(timeout) = self.timeout {
             let child = self.raw;
 
             let (sender, receiver) = mpsc::channel();
-            let handle = thread::spawn(move || sender.send(child.wait_with_output()));
+            let handle = thread::Builder::new()
+                .name("wait_with_output".to_string())
+                .spawn(move || sender.send(child.wait_with_output()))
+                .unwrap();
 
             match receiver.recv_timeout(timeout) {
                 Ok(result) => {
@@ -1993,10 +2446,10 @@ impl UChild {
                     handle.join().unwrap().unwrap();
                     result
                 }
-                Err(RecvTimeoutError::Timeout) => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("wait: Timeout of '{}s' reached", timeout.as_secs_f64()),
-                )),
+                Err(RecvTimeoutError::Timeout) => Err(io::Error::other(format!(
+                    "wait: Timeout of '{}s' reached",
+                    timeout.as_secs_f64()
+                ))),
                 Err(RecvTimeoutError::Disconnected) => {
                     handle.join().expect("Panic caused disconnect").unwrap();
                     panic!("Error receiving from waiting thread because of unexpected disconnect");
@@ -2016,9 +2469,15 @@ impl UChild {
         };
 
         if let Some(stdout) = self.captured_stdout.as_mut() {
+            if let Some(handle) = stdout.reader_thread_handle.take() {
+                handle.join().unwrap();
+            }
             output.stdout = stdout.output_bytes();
         }
         if let Some(stderr) = self.captured_stderr.as_mut() {
+            if let Some(handle) = stderr.reader_thread_handle.take() {
+                handle.join().unwrap();
+            }
             output.stderr = stderr.output_bytes();
         }
 
@@ -2180,6 +2639,29 @@ impl UChild {
         }
     }
 
+    fn access_stdin_as_writer<'a>(&'a mut self) -> Box<dyn Write + Send + 'a> {
+        if let Some(stdin_fd) = &self.stdin_pty {
+            Box::new(BufWriter::new(stdin_fd.try_clone().unwrap()))
+        } else {
+            let stdin: &mut std::process::ChildStdin = self.raw.stdin.as_mut().unwrap();
+            Box::new(BufWriter::new(stdin))
+        }
+    }
+
+    fn take_stdin_as_writer(&mut self) -> Box<dyn Write + Send> {
+        if let Some(stdin_fd) = mem::take(&mut self.stdin_pty) {
+            Box::new(BufWriter::new(stdin_fd))
+        } else {
+            let stdin = self
+                .raw
+                .stdin
+                .take()
+                .expect("Could not pipe into child process. Was it set to Stdio::null()?");
+
+            Box::new(BufWriter::new(stdin))
+        }
+    }
+
     /// Pipe data into [`Child`] stdin in a separate thread to avoid deadlocks.
     ///
     /// In contrast to [`UChild::write_in`], this method is designed to simulate a pipe on the
@@ -2191,9 +2673,7 @@ impl UChild {
     /// the methods below when exiting the child process.
     ///
     /// * [`UChild::wait`]
-    /// * [`UChild::wait_with_output`]
     /// * [`UChild::pipe_in_and_wait`]
-    /// * [`UChild::pipe_in_and_wait_with_output`]
     ///
     /// Usually, there's no need to join manually but if needed, the [`UChild::join`] method can be
     /// used .
@@ -2201,24 +2681,23 @@ impl UChild {
     /// [`JoinHandle`]: std::thread::JoinHandle
     pub fn pipe_in<T: Into<Vec<u8>>>(&mut self, content: T) -> &mut Self {
         let ignore_stdin_write_error = self.ignore_stdin_write_error;
-        let content = content.into();
-        let stdin = self
-            .raw
-            .stdin
-            .take()
-            .expect("Could not pipe into child process. Was it set to Stdio::null()?");
-
-        let join_handle = thread::spawn(move || {
-            let mut writer = BufWriter::new(stdin);
-
-            match writer.write_all(&content).and_then(|()| writer.flush()) {
-                Err(error) if !ignore_stdin_write_error => Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("failed to write to stdin of child: {error}"),
-                )),
-                Ok(()) | Err(_) => Ok(()),
-            }
-        });
+        let mut content: Vec<u8> = content.into();
+        if self.stdin_pty.is_some() {
+            content.append(&mut END_OF_TRANSMISSION_SEQUENCE.to_vec());
+        }
+        let mut writer = self.take_stdin_as_writer();
+
+        let join_handle = std::thread::Builder::new()
+            .name("pipe_in".to_string())
+            .spawn(
+                move || match writer.write_all(&content).and_then(|()| writer.flush()) {
+                    Err(error) if !ignore_stdin_write_error => Err(io::Error::other(format!(
+                        "failed to write to stdin of child: {error}"
+                    ))),
+                    Ok(()) | Err(_) => Ok(()),
+                },
+            )
+            .unwrap();
 
         self.join_handle = Some(join_handle);
         self
@@ -2243,15 +2722,6 @@ impl UChild {
         self.wait().unwrap()
     }
 
-    /// Convenience method for [`UChild::pipe_in`] and then [`UChild::wait_with_output`]
-    #[deprecated = "Please use pipe_in_and_wait() -> CmdResult instead."]
-    pub fn pipe_in_and_wait_with_output<T: Into<Vec<u8>>>(mut self, content: T) -> Output {
-        self.pipe_in(content);
-
-        #[allow(deprecated)]
-        self.wait_with_output().unwrap()
-    }
-
     /// Write some bytes to the child process stdin.
     ///
     /// This function is meant for small data and faking user input like typing a `yes` or `no`.
@@ -2259,15 +2729,15 @@ impl UChild {
     /// [`UChild::pipe_in`].
     ///
     /// # Errors
-    /// If [`ChildStdin::write_all`] or [`ChildStdin::flush`] returned an error
+    /// If [`std::process::ChildStdin::write_all`] or [`std::process::ChildStdin::flush`] returned an error
     pub fn try_write_in<T: Into<Vec<u8>>>(&mut self, data: T) -> io::Result<()> {
-        let stdin = self.raw.stdin.as_mut().unwrap();
+        let ignore_stdin_write_error = self.ignore_stdin_write_error;
+        let mut writer = self.access_stdin_as_writer();
 
-        match stdin.write_all(&data.into()).and_then(|()| stdin.flush()) {
-            Err(error) if !self.ignore_stdin_write_error => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("failed to write to stdin of child: {error}"),
-            )),
+        match writer.write_all(&data.into()).and_then(|()| writer.flush()) {
+            Err(error) if !ignore_stdin_write_error => Err(io::Error::other(format!(
+                "failed to write to stdin of child: {error}"
+            ))),
             Ok(()) | Err(_) => Ok(()),
         }
     }
@@ -2280,7 +2750,7 @@ impl UChild {
 
     /// Close the child process stdout.
     ///
-    /// Note this will have no effect if the output was captured with [`CapturedOutput`] which is the
+    /// Note this will have no effect if the output was captured with CapturedOutput which is the
     /// default if [`UCommand::set_stdout`] wasn't called.
     pub fn close_stdout(&mut self) -> &mut Self {
         self.raw.stdout.take();
@@ -2289,7 +2759,7 @@ impl UChild {
 
     /// Close the child process stderr.
     ///
-    /// Note this will have no effect if the output was captured with [`CapturedOutput`] which is the
+    /// Note this will have no effect if the output was captured with CapturedOutput which is the
     /// default if [`UCommand::set_stderr`] wasn't called.
     pub fn close_stderr(&mut self) -> &mut Self {
         self.raw.stderr.take();
@@ -2301,6 +2771,11 @@ impl UChild {
     /// Note, this does not have any effect if using the [`UChild::pipe_in`] method.
     pub fn close_stdin(&mut self) -> &mut Self {
         self.raw.stdin.take();
+        if self.stdin_pty.is_some() {
+            // a pty can not be closed. We need to send a EOT:
+            let _ = self.try_write_in(END_OF_TRANSMISSION_SEQUENCE);
+            self.stdin_pty.take();
+        }
         self
     }
 }
@@ -2377,7 +2852,7 @@ const UUTILS_INFO: &str = "uutils-tests-info";
 /// Example:
 ///
 /// ```no_run
-/// use crate::common::util::*;
+/// use uutests::util::*;
 /// const VERSION_MIN_MULTIPLE_USERS: &str = "8.31";
 ///
 /// #[test]
@@ -2453,7 +2928,7 @@ fn parse_coreutil_version(version_string: &str) -> f32 {
 /// Example:
 ///
 /// ```no_run
-/// use crate::common::util::*;
+/// use uutests::util::*;
 /// #[test]
 /// fn test_xyz() {
 ///     let ts = TestScenario::new(util_name!());
@@ -2481,7 +2956,7 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
     let (stdout, stderr): (String, String) = if cfg!(target_os = "linux") {
         (
             result.stdout_str().to_string(),
-            result.stderr_str().to_string(),
+            result.stderr_str_lossy().to_string(),
         )
     } else {
         // `host_name_for` added prefix, strip 'g' prefix from results:
@@ -2489,7 +2964,7 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
         let to = &from[1..];
         (
             result.stdout_str().replace(&from, to),
-            result.stderr_str().replace(&from, to),
+            result.stderr_str_lossy().replace(&from, to),
         )
     };
 
@@ -2516,7 +2991,7 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
 /// Example:
 ///
 /// ```no_run
-/// use crate::common::util::*;
+/// use uutests::util::*;
 /// #[test]
 /// fn test_xyz() {
 ///    let ts = TestScenario::new("whoami");
@@ -2532,6 +3007,16 @@ pub fn expected_result(ts: &TestScenario, args: &[&str]) -> std::result::Result<
 pub fn run_ucmd_as_root(
     ts: &TestScenario,
     args: &[&str],
+) -> std::result::Result<CmdResult, String> {
+    run_ucmd_as_root_with_stdin_stdout(ts, args, None, None)
+}
+
+#[cfg(unix)]
+pub fn run_ucmd_as_root_with_stdin_stdout(
+    ts: &TestScenario,
+    args: &[&str],
+    stdin: Option<&str>,
+    stdout: Option<&str>,
 ) -> std::result::Result<CmdResult, String> {
     if is_ci() {
         Err(format!("{UUTILS_INFO}: {}", "cannot run inside CI"))
@@ -2546,16 +3031,21 @@ pub fn run_ucmd_as_root(
             Ok(output) if String::from_utf8_lossy(&output.stdout).eq("root\n") => {
                 // we can run sudo and we're root
                 // run ucmd as root:
-                Ok(ts
-                    .cmd("sudo")
-                    .env("PATH", PATH)
+                let mut cmd = ts.cmd("sudo");
+                cmd.env("PATH", PATH)
                     .envs(DEFAULT_ENV)
                     .arg("-E")
                     .arg("--non-interactive")
                     .arg(&ts.bin_path)
                     .arg(&ts.util_name)
-                    .args(args)
-                    .run())
+                    .args(args);
+                if let Some(stdin) = stdin {
+                    cmd.set_stdin(File::open(stdin).unwrap());
+                }
+                if let Some(stdout) = stdout {
+                    cmd.set_stdout(File::open(stdout).unwrap());
+                }
+                Ok(cmd.run())
             }
             Ok(output)
                 if String::from_utf8_lossy(&output.stderr).eq("sudo: a password is required\n") =>
@@ -2574,6 +3064,15 @@ mod tests {
     // spell-checker:ignore (tests) asdfsadfa
     use super::*;
 
+    // Create a init for the test with a fake value (not needed)
+    #[cfg(test)]
+    #[ctor::ctor]
+    fn init() {
+        unsafe {
+            std::env::set_var("UUTESTS_BINARY_PATH", "");
+        }
+    }
+
     pub fn run_cmd<T: AsRef<OsStr>>(cmd: T) -> CmdResult {
         UCommand::new().arg(cmd).run()
     }
@@ -2781,159 +3280,6 @@ mod tests {
         res.stdout_does_not_match(&positive);
     }
 
-    #[cfg(feature = "echo")]
-    #[test]
-    fn test_normalized_newlines_stdout_is() {
-        let ts = TestScenario::new("echo");
-        let res = ts.ucmd().args(&["-ne", "A\r\nB\nC"]).run();
-
-        res.normalized_newlines_stdout_is("A\r\nB\nC");
-        res.normalized_newlines_stdout_is("A\nB\nC");
-        res.normalized_newlines_stdout_is("A\nB\r\nC");
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    #[should_panic]
-    fn test_normalized_newlines_stdout_is_fail() {
-        let ts = TestScenario::new("echo");
-        let res = ts.ucmd().args(&["-ne", "A\r\nB\nC"]).run();
-
-        res.normalized_newlines_stdout_is("A\r\nB\nC\n");
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    fn test_cmd_result_stdout_check_and_stdout_str_check() {
-        let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
-
-        result.stdout_str_check(|stdout| stdout.ends_with("world\n"));
-        result.stdout_check(|stdout| stdout.get(0..2).unwrap().eq(&[b'H', b'e']));
-        result.no_stderr();
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    fn test_cmd_result_stderr_check_and_stderr_str_check() {
-        let ts = TestScenario::new("echo");
-        let result = run_cmd(format!(
-            "{} {} Hello world >&2",
-            ts.bin_path.display(),
-            ts.util_name
-        ));
-
-        result.stderr_str_check(|stderr| stderr.ends_with("world\n"));
-        result.stderr_check(|stderr| stderr.get(0..2).unwrap().eq(&[b'H', b'e']));
-        result.no_stdout();
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    #[should_panic]
-    fn test_cmd_result_stdout_str_check_when_false_then_panics() {
-        let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
-        result.stdout_str_check(str::is_empty);
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    #[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(<[u8]>::is_empty);
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    #[should_panic]
-    fn test_cmd_result_stderr_str_check_when_false_then_panics() {
-        let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
-        result.stderr_str_check(|s| !s.is_empty());
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    #[should_panic]
-    fn test_cmd_result_stderr_check_when_false_then_panics() {
-        let result = TestScenario::new("echo").ucmd().arg("Hello world").run();
-        result.stderr_check(|s| !s.is_empty());
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    #[should_panic]
-    fn test_cmd_result_stdout_check_when_predicate_panics_then_panic() {
-        let result = TestScenario::new("echo").ucmd().run();
-        result.stdout_str_check(|_| panic!("Just testing"));
-    }
-
-    #[cfg(feature = "echo")]
-    #[cfg(unix)]
-    #[test]
-    fn test_cmd_result_signal_when_normal_exit_then_no_signal() {
-        let result = TestScenario::new("echo").ucmd().run();
-        assert!(result.signal().is_none());
-    }
-
-    #[cfg(feature = "sleep")]
-    #[cfg(unix)]
-    #[test]
-    #[should_panic = "Program must be run first or has not finished"]
-    fn test_cmd_result_signal_when_still_running_then_panic() {
-        let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
-
-        child
-            .make_assertion()
-            .is_alive()
-            .with_current_output()
-            .signal();
-    }
-
-    #[cfg(feature = "sleep")]
-    #[cfg(unix)]
-    #[test]
-    fn test_cmd_result_signal_when_kill_then_signal() {
-        let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
-
-        child.kill();
-        child
-            .make_assertion()
-            .is_not_alive()
-            .with_current_output()
-            .signal_is(9)
-            .signal_name_is("SIGKILL")
-            .signal_name_is("KILL")
-            .signal_name_is("9")
-            .signal()
-            .expect("Signal was none");
-
-        let result = child.wait().unwrap();
-        result
-            .signal_is(9)
-            .signal_name_is("SIGKILL")
-            .signal_name_is("KILL")
-            .signal_name_is("9")
-            .signal()
-            .expect("Signal was none");
-    }
-
-    #[cfg(feature = "sleep")]
-    #[cfg(unix)]
-    #[rstest]
-    #[case::signal_full_name_lower_case("sigkill")]
-    #[case::signal_short_name_lower_case("kill")]
-    #[case::signal_only_part_of_name("IGKILL")] // spell-checker: disable-line
-    #[case::signal_just_sig("SIG")]
-    #[case::signal_value_too_high("100")]
-    #[case::signal_value_negative("-1")]
-    #[should_panic = "Invalid signal name or value"]
-    fn test_cmd_result_signal_when_invalid_signal_name_then_panic(#[case] signal_name: &str) {
-        let mut child = TestScenario::new("sleep").ucmd().arg("60").run_no_wait();
-        child.kill();
-        let result = child.wait().unwrap();
-        result.signal_name_is(signal_name);
-    }
-
     #[test]
     #[cfg(unix)]
     fn test_parse_coreutil_version() {
@@ -3016,7 +3362,6 @@ mod tests {
 
     #[test]
     #[cfg(unix)]
-    #[cfg(feature = "whoami")]
     fn test_run_ucmd_as_root() {
         if is_ci() {
             println!("TEST SKIPPED (cannot run inside CI)");
@@ -3042,324 +3387,98 @@ mod tests {
         }
     }
 
-    // This error was first detected when running tail so tail is used here but
-    // should fail with any command that takes piped input.
-    // See also https://github.com/uutils/coreutils/issues/3895
-    #[cfg(feature = "tail")]
-    #[test]
-    #[cfg_attr(not(feature = "expensive_tests"), ignore)]
-    fn test_when_piped_input_then_no_broken_pipe() {
-        let ts = TestScenario::new("tail");
-        for i in 0..10000 {
-            dbg!(i);
-            let test_string = "a\nb\n";
-            ts.ucmd()
-                .args(&["-n", "0"])
-                .pipe_in(test_string)
-                .succeeds()
-                .no_stdout()
-                .no_stderr();
-        }
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    fn test_uchild_when_run_with_a_non_blocking_util() {
-        let ts = TestScenario::new("echo");
-        ts.ucmd()
-            .arg("hello world")
-            .run()
-            .success()
-            .stdout_only("hello world\n");
-    }
-
-    // Test basically that most of the methods of UChild are working
-    #[cfg(feature = "echo")]
+    #[cfg(all(unix, not(any(target_os = "macos", target_os = "openbsd"))))]
     #[test]
-    fn test_uchild_when_run_no_wait_with_a_non_blocking_util() {
-        let ts = TestScenario::new("echo");
-        let mut child = ts.ucmd().arg("hello world").run_no_wait();
-
-        // check `child.is_alive()` and `child.delay()` is working
-        let mut trials = 10;
-        while child.is_alive() {
-            assert!(
-                trials > 0,
-                "Assertion failed: child process is still alive."
-            );
-
-            child.delay(500);
-            trials -= 1;
-        }
-
-        assert!(!child.is_alive());
+    fn test_compare_xattrs() {
+        use tempfile::tempdir;
 
-        // check `child.is_not_alive()` is working
-        assert!(child.is_not_alive());
+        let temp_dir = tempdir().unwrap();
+        let file_path1 = temp_dir.path().join("test_file1.txt");
+        let file_path2 = temp_dir.path().join("test_file2.txt");
 
-        // check the current output is correct
-        std::assert_eq!(child.stdout(), "hello world\n");
-        assert!(child.stderr().is_empty());
+        File::create(&file_path1).unwrap();
+        File::create(&file_path2).unwrap();
 
-        // check the current output of echo is empty. We already called `child.stdout()` and `echo`
-        // exited so there's no additional output after the first call of `child.stdout()`
-        assert!(child.stdout().is_empty());
-        assert!(child.stderr().is_empty());
+        let test_attr = "user.test_attr";
+        let test_value = b"test value";
+        xattr::set(&file_path1, test_attr, test_value).unwrap();
 
-        // check that we're still able to access all output of the child process, even after exit
-        // and call to `child.stdout()`
-        std::assert_eq!(child.stdout_all(), "hello world\n");
-        assert!(child.stderr_all().is_empty());
+        assert!(!compare_xattrs(&file_path1, &file_path2));
 
-        // we should be able to call kill without panics, even if the process already exited
-        child.make_assertion().is_not_alive();
-        child.kill();
-
-        // we should be able to call wait without panics and apply some assertions
-        child.wait().unwrap().code_is(0).no_stdout().no_stderr();
-    }
-
-    #[cfg(feature = "cat")]
-    #[test]
-    fn test_uchild_when_pipe_in() {
-        let ts = TestScenario::new("cat");
-        let mut child = ts.ucmd().set_stdin(Stdio::piped()).run_no_wait();
-        child.pipe_in("content");
-        child.wait().unwrap().stdout_only("content").success();
-
-        ts.ucmd().pipe_in("content").run().stdout_is("content");
-    }
-
-    #[cfg(feature = "rm")]
-    #[test]
-    fn test_uchild_when_run_no_wait_with_a_blocking_command() {
-        let ts = TestScenario::new("rm");
-        let at = &ts.fixtures;
-
-        at.mkdir("a");
-        at.touch("a/empty");
-
-        #[cfg(target_vendor = "apple")]
-        let delay: u64 = 2000;
-        #[cfg(not(target_vendor = "apple"))]
-        let delay: u64 = 1000;
-
-        let yes = if cfg!(windows) { "y\r\n" } else { "y\n" };
-
-        let mut child = ts
-            .ucmd()
-            .set_stdin(Stdio::piped())
-            .stderr_to_stdout()
-            .args(&["-riv", "a"])
-            .run_no_wait();
-        child
-            .make_assertion_with_delay(delay)
-            .is_alive()
-            .with_current_output()
-            .stdout_is("rm: descend into directory 'a'? ");
-
-        #[cfg(windows)]
-        let expected = "rm: descend into directory 'a'? \
-                        rm: remove regular empty file 'a\\empty'? ";
-        #[cfg(unix)]
-        let expected = "rm: descend into directory 'a'? \
-                              rm: remove regular empty file 'a/empty'? ";
-        child.write_in(yes);
-        child
-            .make_assertion_with_delay(delay)
-            .is_alive()
-            .with_all_output()
-            .stdout_is(expected);
-
-        #[cfg(windows)]
-        let expected = "removed 'a\\empty'\nrm: remove directory 'a'? ";
-        #[cfg(unix)]
-        let expected = "removed 'a/empty'\nrm: remove directory 'a'? ";
-
-        child
-            .write_in(yes)
-            .make_assertion_with_delay(delay)
-            .is_alive()
-            .with_exact_output(44, 0)
-            .stdout_only(expected);
-
-        let expected = "removed directory 'a'\n";
-
-        child.write_in(yes);
-        child.wait().unwrap().stdout_only(expected).success();
+        xattr::set(&file_path2, test_attr, test_value).unwrap();
+        assert!(compare_xattrs(&file_path1, &file_path2));
     }
 
-    #[cfg(feature = "tail")]
+    #[cfg(unix)]
     #[test]
-    fn test_uchild_when_run_with_stderr_to_stdout() {
-        let ts = TestScenario::new("tail");
-        let at = &ts.fixtures;
-
-        at.write("data", "file data\n");
-
-        let expected_stdout = "==> data <==\n\
-                                    file data\n\
-                                    tail: cannot open 'missing' for reading: No such file or directory\n";
-        ts.ucmd()
-            .args(&["data", "missing"])
-            .stderr_to_stdout()
-            .fails()
-            .stdout_only(expected_stdout);
+    fn test_application_of_process_resource_limits_unlimited_file_size() {
+        let ts = TestScenario::new("util");
+        ts.cmd("sh")
+            .args(&["-c", "ulimit -Sf; ulimit -Hf"])
+            .succeeds()
+            .no_stderr()
+            .stdout_is("unlimited\nunlimited\n");
     }
 
-    #[cfg(feature = "cat")]
     #[cfg(unix)]
     #[test]
-    fn test_uchild_when_no_capture_reading_from_infinite_source() {
-        use regex::Regex;
-
-        let ts = TestScenario::new("cat");
-
-        let expected_stdout = b"\0".repeat(12345);
-        let mut child = ts
-            .ucmd()
-            .set_stdin(Stdio::from(File::open("/dev/zero").unwrap()))
-            .set_stdout(Stdio::piped())
-            .run_no_wait();
-
-        child
-            .make_assertion()
-            .with_exact_output(12345, 0)
-            .stdout_only_bytes(expected_stdout);
-
-        child
-            .kill()
-            .make_assertion()
-            .with_current_output()
-            .stdout_matches(&Regex::new("[\0].*").unwrap())
-            .no_stderr();
+    fn test_application_of_process_resource_limits_limited_file_size() {
+        let unit_size_bytes = if cfg!(target_os = "macos") { 1024 } else { 512 };
+
+        let ts = TestScenario::new("util");
+        ts.cmd("sh")
+            .args(&["-c", "ulimit -Sf; ulimit -Hf"])
+            .limit(
+                rlimit::Resource::FSIZE,
+                8 * unit_size_bytes,
+                16 * unit_size_bytes,
+            )
+            .succeeds()
+            .no_stderr()
+            .stdout_is("8\n16\n");
     }
 
-    #[cfg(feature = "sleep")]
+    #[cfg(unix)]
+    #[cfg(not(target_os = "openbsd"))]
     #[test]
-    fn test_uchild_when_wait_and_timeout_is_reached_then_timeout_error() {
-        let ts = TestScenario::new("sleep");
-        let child = ts
-            .ucmd()
-            .timeout(Duration::from_secs(1))
-            .arg("10.0")
-            .run_no_wait();
-
-        match child.wait() {
-            Err(error) if error.kind() == io::ErrorKind::Other => {
-                std::assert_eq!(error.to_string(), "wait: Timeout of '1s' reached");
-            }
-            Err(error) => panic!("Assertion failed: Expected error with timeout but was: {error}"),
-            Ok(_) => panic!("Assertion failed: Expected timeout of `wait`."),
-        }
-    }
-
-    #[cfg(feature = "sleep")]
-    #[rstest]
-    #[timeout(Duration::from_secs(5))]
-    fn test_uchild_when_kill_and_timeout_higher_than_kill_time_then_no_panic() {
-        let ts = TestScenario::new("sleep");
-        let mut child = ts
-            .ucmd()
-            .timeout(Duration::from_secs(60))
-            .arg("20.0")
-            .run_no_wait();
+    fn test_altering_umask() {
+        use uucore::mode::get_umask;
+        let p_umask = get_umask();
+        // make sure we are not testing against the same umask
+        let c_umask = if p_umask == 0o002 { 0o007 } else { 0o002 };
+        let expected = if cfg!(target_os = "android") {
+            if p_umask == 0o002 { "007\n" } else { "002\n" }
+        } else if p_umask == 0o002 {
+            "0007\n"
+        } else {
+            "0002\n"
+        };
 
-        child.kill().make_assertion().is_not_alive();
+        let ts = TestScenario::new("util");
+        ts.cmd_shell("umask")
+            .umask(c_umask)
+            .succeeds()
+            .stdout_is(expected);
+        std::assert_eq!(p_umask, get_umask()); // make sure parent umask didn't change
     }
 
-    #[cfg(feature = "sleep")]
+    #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
     #[test]
-    fn test_uchild_when_try_kill_and_timeout_is_reached_then_error() {
-        let ts = TestScenario::new("sleep");
-        let mut child = ts.ucmd().timeout(Duration::ZERO).arg("10.0").run_no_wait();
-
-        match child.try_kill() {
-            Err(error) if error.kind() == io::ErrorKind::Other => {
-                std::assert_eq!(error.to_string(), "kill: Timeout of '0s' reached");
-            }
-            Err(error) => panic!("Assertion failed: Expected error with timeout but was: {error}"),
-            Ok(()) => panic!("Assertion failed: Expected timeout of `try_kill`."),
+    fn test_mount_temp_fs() {
+        let mut scene = TestScenario::new("util");
+        let at = &scene.fixtures;
+        // Test must be run as root (or with `sudo -E`)
+        if scene.cmd("whoami").run().stdout_str() != "root\n" {
+            return;
         }
-    }
-
-    #[cfg(feature = "sleep")]
-    #[test]
-    #[should_panic = "kill: Timeout of '0s' reached"]
-    fn test_uchild_when_kill_with_timeout_and_timeout_is_reached_then_panic() {
-        let ts = TestScenario::new("sleep");
-        let mut child = ts.ucmd().timeout(Duration::ZERO).arg("10.0").run_no_wait();
-
-        child.kill();
-        panic!("Assertion failed: Expected timeout of `kill`.");
-    }
-
-    #[cfg(feature = "sleep")]
-    #[test]
-    #[should_panic(expected = "wait: Timeout of '1.1s' reached")]
-    fn test_ucommand_when_run_with_timeout_and_timeout_is_reached_then_panic() {
-        let ts = TestScenario::new("sleep");
-        ts.ucmd()
-            .timeout(Duration::from_millis(1100))
-            .arg("10.0")
-            .run();
-
-        panic!("Assertion failed: Expected timeout of `run`.")
-    }
-
-    #[cfg(feature = "sleep")]
-    #[rstest]
-    #[timeout(Duration::from_secs(10))]
-    fn test_ucommand_when_run_with_timeout_higher_then_execution_time_then_no_panic() {
-        let ts = TestScenario::new("sleep");
-        ts.ucmd().timeout(Duration::from_secs(60)).arg("1.0").run();
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    fn test_ucommand_when_default() {
-        let shell_cmd = format!("{TESTS_BINARY} echo -n hello");
-
-        let mut command = UCommand::new();
-        command.arg(&shell_cmd).succeeds().stdout_is("hello");
-
-        #[cfg(target_os = "android")]
-        let (expected_bin, expected_arg) = (PathBuf::from("/system/bin/sh"), OsString::from("-c"));
-        #[cfg(all(unix, not(target_os = "android")))]
-        let (expected_bin, expected_arg) = (PathBuf::from("/bin/sh"), OsString::from("-c"));
-        #[cfg(windows)]
-        let (expected_bin, expected_arg) = (PathBuf::from("cmd"), OsString::from("/C"));
-
-        std::assert_eq!(&expected_bin, command.bin_path.as_ref().unwrap());
-        assert!(command.util_name.is_none());
-        std::assert_eq!(command.args, &[expected_arg, OsString::from(&shell_cmd)]);
-        assert!(command.tmpd.is_some());
-    }
-
-    #[cfg(feature = "echo")]
-    #[test]
-    fn test_ucommand_with_util() {
-        let tmpd = tempfile::tempdir().unwrap();
-        let mut command = UCommand::with_util("echo", Rc::new(tmpd));
-
-        command
-            .args(&["-n", "hello"])
+        at.mkdir("mountpoint");
+        let mountpoint = at.plus("mountpoint");
+        scene.mount_temp_fs(mountpoint.to_str().unwrap()).unwrap();
+        scene
+            .cmd("df")
+            .arg("-h")
+            .arg(mountpoint)
             .succeeds()
-            .stdout_only("hello");
-
-        std::assert_eq!(
-            &PathBuf::from(TESTS_BINARY),
-            command.bin_path.as_ref().unwrap()
-        );
-        std::assert_eq!("echo", &command.util_name.unwrap());
-        std::assert_eq!(
-            &[
-                OsString::from("echo"),
-                OsString::from("-n"),
-                OsString::from("hello")
-            ],
-            command.args.make_contiguous()
-        );
-        assert!(command.tmpd.is_some());
+            .stdout_contains("tmpfs");
     }
 }
diff --git a/util/analyze-gnu-results.py b/util/analyze-gnu-results.py
new file mode 100644
index 00000000000..b9e8534b30f
--- /dev/null
+++ b/util/analyze-gnu-results.py
@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+
+"""
+GNU Test Results Analyzer and Aggregator
+
+This script analyzes and aggregates test results from the GNU test suite.
+It parses JSON files containing test results (PASS/FAIL/SKIP/ERROR) and:
+1. Counts the number of tests in each result category
+2. Can aggregate results from multiple JSON files with priority ordering
+3. Outputs shell export statements for use in GitHub Actions workflows
+
+Priority order for aggregation (highest to lowest):
+- PASS: Takes precedence over all other results (best outcome)
+- FAIL: Takes precedence over ERROR and SKIP
+- ERROR: Takes precedence over SKIP
+- SKIP: Lowest priority
+
+Usage:
+  - Single file:
+    python analyze-gnu-results.py test-results.json
+
+  - Multiple files (with aggregation):
+    python analyze-gnu-results.py file1.json file2.json
+
+  - With output file for aggregated results:
+    python analyze-gnu-results.py -o=output.json file1.json file2.json
+
+Output:
+  Prints shell export statements for TOTAL, PASS, FAIL, SKIP, XPASS, and ERROR
+  that can be evaluated in a shell environment.
+"""
+
+import json
+import sys
+from collections import defaultdict
+
+
+def get_priority(result):
+    """Return a priority value for result status (lower is higher priority)"""
+    priorities = {
+        "PASS": 0,  # PASS is highest priority (best result)
+        "FAIL": 1,  # FAIL is second priority
+        "ERROR": 2,  # ERROR is third priority
+        "SKIP": 3,  # SKIP is lowest priority
+    }
+    return priorities.get(result, 4)  # Unknown states have lowest priority
+
+
+def aggregate_results(json_files):
+    """
+    Aggregate test results from multiple JSON files.
+    Prioritizes results in the order: SKIP > ERROR > FAIL > PASS
+    """
+    # Combined results dictionary
+    combined_results = defaultdict(dict)
+
+    # Process each JSON file
+    for json_file in json_files:
+        try:
+            with open(json_file, "r") as f:
+                data = json.load(f)
+
+            # For each utility and its tests
+            for utility, tests in data.items():
+                for test_name, result in tests.items():
+                    # If this test hasn't been seen yet, add it
+                    if test_name not in combined_results[utility]:
+                        combined_results[utility][test_name] = result
+                    else:
+                        # If it has been seen, apply priority rules
+                        current_priority = get_priority(
+                            combined_results[utility][test_name]
+                        )
+                        new_priority = get_priority(result)
+
+                        # Lower priority value means higher precedence
+                        if new_priority < current_priority:
+                            combined_results[utility][test_name] = result
+        except FileNotFoundError:
+            print(f"Warning: File '{json_file}' not found.", file=sys.stderr)
+            continue
+        except json.JSONDecodeError:
+            print(f"Warning: '{json_file}' is not a valid JSON file.", file=sys.stderr)
+            continue
+
+    return combined_results
+
+
+def analyze_test_results(json_data):
+    """
+    Analyze test results from GNU test suite JSON data.
+    Counts PASS, FAIL, SKIP results for all tests.
+    """
+    # Counters for test results
+    total_tests = 0
+    pass_count = 0
+    fail_count = 0
+    skip_count = 0
+    xpass_count = 0  # Not in JSON data but included for compatibility
+    error_count = 0  # Not in JSON data but included for compatibility
+
+    # Analyze each utility's tests
+    for utility, tests in json_data.items():
+        for test_name, result in tests.items():
+            total_tests += 1
+
+            match result:
+                case "PASS":
+                    pass_count += 1
+                case "FAIL":
+                    fail_count += 1
+                case "SKIP":
+                    skip_count += 1
+                case "ERROR":
+                    error_count += 1
+                case "XPASS":
+                    xpass_count += 1
+
+    # Return the statistics
+    return {
+        "TOTAL": total_tests,
+        "PASS": pass_count,
+        "FAIL": fail_count,
+        "SKIP": skip_count,
+        "XPASS": xpass_count,
+        "ERROR": error_count,
+    }
+
+
+def main():
+    """
+    Main function to process JSON files and export variables.
+    Supports both single file analysis and multi-file aggregation.
+    """
+    # Check if file arguments were provided
+    if len(sys.argv) < 2:
+        print("Usage: python analyze-gnu-results.py <json> [json ...]")
+        print("       For multiple files, results will be aggregated")
+        print("       Priority SKIP > ERROR > FAIL > PASS")
+        sys.exit(1)
+
+    json_files = sys.argv[1:]
+    output_file = None
+
+    # Check if the first argument is an output file (starts with -)
+    if json_files[0].startswith("-o="):
+        output_file = json_files[0][3:]
+        json_files = json_files[1:]
+
+    # Process the files
+    if len(json_files) == 1:
+        # Single file analysis
+        try:
+            with open(json_files[0], "r") as file:
+                json_data = json.load(file)
+            results = analyze_test_results(json_data)
+        except FileNotFoundError:
+            print(f"Error: File '{json_files[0]}' not found.", file=sys.stderr)
+            sys.exit(1)
+        except json.JSONDecodeError:
+            print(
+                f"Error: '{json_files[0]}' is not a valid JSON file.", file=sys.stderr
+            )
+            sys.exit(1)
+    else:
+        # Multiple files - aggregate them
+        json_data = aggregate_results(json_files)
+        results = analyze_test_results(json_data)
+
+        # Save aggregated data if output file is specified
+        if output_file:
+            with open(output_file, "w") as f:
+                json.dump(json_data, f, indent=2)
+
+    # Print export statements for shell evaluation
+    print(f"export TOTAL={results['TOTAL']}")
+    print(f"export PASS={results['PASS']}")
+    print(f"export SKIP={results['SKIP']}")
+    print(f"export FAIL={results['FAIL']}")
+    print(f"export XPASS={results['XPASS']}")
+    print(f"export ERROR={results['ERROR']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/util/analyze-gnu-results.sh b/util/analyze-gnu-results.sh
deleted file mode 100644
index 045e3b93dfb..00000000000
--- a/util/analyze-gnu-results.sh
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/bin/bash
-# spell-checker:ignore xpass XPASS testsuite
-set -e
-
-# As we do two builds (with and without root), we need to do some trivial maths
-# to present the merge results
-# this script will export the values in the term
-
-if test $# -ne 2; then
-    echo "syntax:"
-    echo "$0 testsuite.log root-testsuite.log"
-fi
-
-SUITE_LOG_FILE=$1
-ROOT_SUITE_LOG_FILE=$2
-
-if test ! -f "${SUITE_LOG_FILE}"; then
-    echo "${SUITE_LOG_FILE} has not been found"
-    exit 1
-fi
-if test ! -f "${ROOT_SUITE_LOG_FILE}"; then
-    echo "${ROOT_SUITE_LOG_FILE} has not been found"
-    exit 1
-fi
-
-function get_total {
-    # Total of tests executed
-    # They are the normal number of tests as they are skipped in the normal run
-    NON_ROOT=$(sed -n "s/.*# TOTAL: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    echo $NON_ROOT
-}
-
-function get_pass {
-    # This is the sum of the two test suites.
-    # In the normal run, they are SKIP
-    NON_ROOT=$(sed -n "s/.*# PASS: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    AS_ROOT=$(sed -n "s/.*# PASS: \(.*\)/\1/p" "${ROOT_SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    echo $((NON_ROOT + AS_ROOT))
-}
-
-function get_skip {
-    # As some of the tests executed as root as still SKIP (ex: selinux), we
-    # need to some maths:
-    # Number of tests skip as user - total test as root + skipped as root
-    TOTAL_AS_ROOT=$(sed -n "s/.*# TOTAL: \(.*\)/\1/p" "${ROOT_SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    NON_ROOT=$(sed -n "s/.*# SKIP: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    AS_ROOT=$(sed -n "s/.*# SKIP: \(.*\)/\1/p" "${ROOT_SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    echo $((NON_ROOT - TOTAL_AS_ROOT + AS_ROOT))
-}
-
-function get_fail {
-    # They used to be SKIP, now they fail (this is a good news)
-    NON_ROOT=$(sed -n "s/.*# FAIL: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    AS_ROOT=$(sed -n "s/.*# FAIL: \(.*\)/\1/p" "${ROOT_SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    echo $((NON_ROOT + AS_ROOT))
-}
-
-function get_xpass {
-    NON_ROOT=$(sed -n "s/.*# XPASS: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    echo $NON_ROOT
-}
-
-function get_error {
-    # They used to be SKIP, now they error (this is a good news)
-    NON_ROOT=$(sed -n "s/.*# ERROR: \(.*\)/\1/p" "${SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    AS_ROOT=$(sed -n "s/.*# ERROR:: \(.*\)/\1/p" "${ROOT_SUITE_LOG_FILE}" | tr -d '\r' | head -n1)
-    echo $((NON_ROOT + AS_ROOT))
-}
-
-# we don't need the return codes indeed, ignore them
-# shellcheck disable=SC2155
-{
-    export TOTAL=$(get_total)
-    export PASS=$(get_pass)
-    export SKIP=$(get_skip)
-    export FAIL=$(get_fail)
-    export XPASS=$(get_xpass)
-    export ERROR=$(get_error)
-}
diff --git a/util/android-commands.sh b/util/android-commands.sh
index 4b504de5649..aa02e5b347d 100755
--- a/util/android-commands.sh
+++ b/util/android-commands.sh
@@ -1,22 +1,72 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # 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
-# environment on the emulated device (to e.g. run cargo). So we use adb to
-# launch termux, then to send keystrokes to it while it's running.
-# This means that the commands sent to termux are first parsed as arguments in
+# spell-checker:ignore screencap reinit PIPESTATUS keygen sourceslist
+
+# There are four shells: the host's, adb, termux and termux via ssh.
+# But only termux and termux via ssh provides a GNU environment on the
+# emulated device (to e.g. run cargo).
+# Initially, only adb lets us run commands directly on the emulated device.
+# Thus we first establish a ssh connection which then can be used to access
+# the termux shell directly, getting output and return code as usual.
+# So we use adb to launch termux, then to send keystrokes to it while it's running.
+# This way we install sshd and a public key from the host. After that we can
+# use ssh to directly run commands in termux environment.
+
+# Before ssh, we need to consider some inconvenient, limiting specialties:
+# The commands sent to termux via adb keystrokes 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 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.
+# Using this approach 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.
+
+# Additionally, we can use adb screenshot functionality to investigate issues
+# when there is no feedback arriving from the android device.
 
 this_repo="$(dirname "$(dirname -- "$(readlink -- "${0}")")")"
 cache_dir_name="__rust_cache__"
+dev_probe_dir=/sdcard
+dev_home_dir=/data/data/com.termux/files/home
+
+# This is a list of termux package mirrors approved to be used.
+# The default mirror list contains entries that do not function properly anymore.
+# To avoid failures due to broken mirrors, we use our own list.
+# Choose only reliable mirrors here:
+repo_url_list=(
+    "deb https://packages-cf.termux.org/apt/termux-main/ stable main"
+    "deb https://packages-cf.termux.dev/apt/termux-main/ stable main"
+#    "deb https://grimler.se/termux/termux-main stable main"  # slow
+    "deb https://ftp.fau.de/termux/termux-main stable main"
+)
+number_repo_urls=${#repo_url_list[@]}
+repo_url_round_robin=$RANDOM
+
+move_to_next_repo_url() {
+    repo_url_round_robin=$(((repo_url_round_robin + 1) % number_repo_urls))
+    echo "next round robin repo_url: $repo_url_round_robin"
+}
+move_to_next_repo_url # first call needed for modulo
+
+get_current_repo_url() {
+    echo "${repo_url_list[$repo_url_round_robin]}"
+}
+
+# dump some information about the runners system for debugging purposes:
+echo "====== runner information ======"
+echo "hostname: $(hostname)"
+echo "uname -a: $(uname -a)"
+echo "pwd: $(pwd)"
+echo "\$*: $*"
+echo "\$0: $0"
+# shellcheck disable=SC2140
+echo "\$(readlink -- "\$\{0\}"): $(readlink -- "${0}")"
+echo "\$this_repo: $this_repo"
+echo "readlink -f \$this_repo: $(readlink -f "$this_repo")"
+this_repo=$(readlink -f "$this_repo")
+echo "====== runner info end ========="
 
 help() {
     echo \
@@ -48,23 +98,99 @@ hit_enter() {
 }
 
 exit_termux() {
-    adb shell input text "exit" && hit_enter && hit_enter
+    adb shell input text \"exit\" && hit_enter && hit_enter
+}
+
+timestamp() {
+  date +"%H%M%S%Z"
+}
+
+add_timestamp_to_lines() {
+    while IFS= read -r line; do printf '[%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$line"; done
+}
+
+# takes a screenshot with given name from the android device. Filename is prefixed with timestamp.
+# screenshots are collected at the end of the github workflow and provided as download link.
+take_screen_shot() {
+    filename_prefix="$1"
+    filename="$this_repo/output/$(timestamp)_${filename_prefix}_screen.png"
+    echo "take screenshot: $filename"
+    mkdir -p "$this_repo/output"
+    adb exec-out screencap -p > "$filename"
+}
+
+get_app_user() {
+    app="$1"
+    app_user="$(adb shell dumpsys package $app | grep 'userId=' | cut -d= -f2 | sort -u)"
+    if [[ -z "$app_user" ]]; then
+        echo "Couldn't find user for app: $app">&2
+        exit 1
+    fi
+    echo "$app_user"
+}
+
+termux_user() {
+    if [[ -z "$TERMUX_USER" ]]; then
+        TERMUX_USER="$(get_app_user com.termux)"
+    fi
+    echo "$TERMUX_USER"
 }
 
 launch_termux() {
     echo "launching termux"
+    take_screen_shot "launch_termux_enter"
+
+    adb shell input tap 120 380  # close potential dialog "System UI isn't responding" with "wait".
+                                 # should not cause side effects when dialog is not there as there are
+                                 # no relevant GUI elements at this position otherwise.
+
     if ! adb shell 'am start -n com.termux/.HomeActivity'; then
         echo "failed to launch termux"
         exit 1
     fi
+
+    take_screen_shot "launch_termux_after_start_activity"
+
     # the emulator can sometimes be a little slow to launch the app
-    while ! adb shell 'ls /sdcard/launch.probe' 2>/dev/null; do
-        echo "waiting for launch.probe"
-        sleep 5
-        adb shell input text 'touch\ /sdcard/launch.probe' && hit_enter
+    loop_count=0
+    while ! adb shell "dumpsys window windows" | \
+            grep -E "imeInputTarget in display# 0 Window{[^}]+com.termux\/com\.termux\.HomeActivity}"
+    do
+        sleep 1
+        loop_count=$((loop_count + 1))
+        if [[ loop_count -ge 20 ]]; then
+            break
+        fi
+    done
+
+    take_screen_shot "launch_termux_after_wait_activity"
+
+    touch_cmd() {
+        adb shell input text "\"touch $dev_probe_dir/launch.probe\"" && hit_enter
+        sleep 1
+    }
+
+    local timeout_start=120
+    local timeout=$timeout_start
+    touch_cmd
+    while ! adb shell "ls $dev_probe_dir/launch.probe" 2>/dev/null
+    do
+        echo "waiting for launch.probe - ($timeout / $timeout_start seconds)"
+        take_screen_shot "launch_termux_touch_probe"
+        sleep 4
+        touch_cmd
+
+        timeout=$((timeout - 4))
+        if [[ timeout -le 0 ]]; then
+            take_screen_shot "error_launch_termux"
+            echo "timeout waiting for termux to start up"
+            return 1
+        fi
+
     done
     echo "found launch.probe"
-    adb shell 'rm /sdcard/launch.probe' && echo "removed launch.probe"
+    take_screen_shot "launch_termux_found_probe"
+    adb shell "rm $dev_probe_dir/launch.probe" && echo "removed launch.probe"
 }
 
 # Usage: run_termux_command
@@ -99,7 +225,7 @@ run_termux_command() {
     local debug=${debug:-1}
 
     log_name="$(basename -s .probe "${probe}").log" # probe name must have suffix .probe
-    log_file="/sdcard/${log_name}"
+    log_file="$dev_probe_dir/${log_name}"
     log_read="${log_name}.read"
     echo 0 >"${log_read}"
     if [[ $debug -eq 1 ]]; then
@@ -108,12 +234,22 @@ run_termux_command() {
         shell_command="'{ ${command}; } &> ${log_file}'"
     fi
 
-    launch_termux
+    launch_termux || return
+
+    take_screen_shot "run_termux_command_before_input_of_shell_command"
+
+    # remove artificial quoting
+    shell_command="${shell_command%\'}"
+    shell_command="${shell_command#\'}"
+
     echo "Running command: ${command}"
+    echo "Running shell-command: ${shell_command}"
     start=$(date +%s)
-    adb shell input text "$shell_command" && sleep 3 && hit_enter
+    adb_input_text_long "$shell_command" && sleep 1 && hit_enter
     # just for safety wait a little bit before polling for the probe and the log file
-    sleep 5
+    sleep 1
+
+    take_screen_shot "run_termux_command_after_input_of_shell_command"
 
     local timeout=${timeout:-3600}
     local retries=${retries:-10}
@@ -136,6 +272,7 @@ run_termux_command() {
 
         if [[ retries -le 0 ]]; then
             echo "Maximum retries reached running command. Aborting ..."
+            take_screen_shot "run_termux_command_maximum_tries_reached"
             return 1
         elif [[ try_fix -le 0 ]]; then
             retries=$((retries - 1))
@@ -144,7 +281,10 @@ run_termux_command() {
             # 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)"
+            take_screen_shot "run_termux_command_before_trying_to_fix"
             hit_enter
+            sleep 1
+            take_screen_shot "run_termux_command_after_trying_to_fix"
         fi
 
         sleep "$sleep_interval"
@@ -152,6 +292,7 @@ run_termux_command() {
 
         if [[ $timeout -le 0 ]]; then
             echo "Timeout reached running command. Aborting ..."
+            take_screen_shot "run_termux_command_timeout_reached"
             return 1
         fi
     done
@@ -160,7 +301,7 @@ run_termux_command() {
     return_code=$(adb shell "cat $probe") || return_code=0
     adb shell "rm ${probe}"
 
-    adb pull "$log_file" .
+    adb shell "cat $log_file" > "$log_name"
     echo "==================================== SUMMARY ==================================="
     echo "Command: ${command}"
     echo "Finished in $((end - start)) seconds."
@@ -173,61 +314,233 @@ run_termux_command() {
     [[ $keep_log -ne 1 ]] && rm -f "$log_name"
     rm -f "$log_read" "$probe"
 
+    take_screen_shot "run_termux_command_finished_normally"
+
     # shellcheck disable=SC2086
     return $return_code
 }
 
 init() {
     arch="$1"
+    # shellcheck disable=SC2034
     api_level="$2"
     termux="$3"
 
+    snapshot_name="${AVD_CACHE_KEY}"
+
     # shellcheck disable=SC2015
-    wget "https://github.com/termux/termux-app/releases/download/${termux}/termux-app_${termux}+github-debug_${arch}.apk" &&
+    wget -nv "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." || {
+        adb -s emulator-5554 emu avd snapshot save "$snapshot_name" &&
+        echo "Emulator image created. Name: $snapshot_name" || {
         pkill -9 qemu-system-x86_64
         return 1
     }
     pkill -9 qemu-system-x86_64 || true
 }
 
+reinit_ssh_connection() {
+    setup_ssh_forwarding
+    test_ssh_connection && return
+
+    start_sshd_via_adb_shell && (
+        test_ssh_connection && return
+        generate_and_install_public_key && test_ssh_connection && return
+    ) || (
+        install_packages_via_adb_shell openssh openssl
+        generate_and_install_public_key
+        start_sshd_via_adb_shell
+        test_ssh_connection && return
+    ) || (
+        echo "failed to setup ssh connection"
+        return 1
+    )
+}
+
+start_sshd_via_adb_shell() {
+    echo "start sshd via adb shell"
+    probe="$dev_probe_dir/sshd.probe"
+    command="'sshd; echo \$? > $probe'"
+    run_termux_command "$command" "$probe"
+}
+
+setup_ssh_forwarding() {
+    echo "setup ssh forwarding"
+    adb forward tcp:9022 tcp:8022
+}
+
+copy_file_or_dir_to_device_via_ssh() {
+    scp -r "$1" "scp://$(termux_user)@127.0.0.1:9022/$2"
+}
+
+copy_file_or_dir_from_device_via_ssh() {
+    scp -r "scp://$(termux_user)@127.0.0.1:9022/$1" "$2"
+}
+
+# runs the in args provided command on android side via ssh. forwards return code.
+# adds a timestamp to every line to be able to see where delays are
+run_command_via_ssh() {
+    ssh -p 9022 "$(termux_user)@127.0.0.1" -o StrictHostKeyChecking=accept-new "$@" 2>&1 | add_timestamp_to_lines
+    return "${PIPESTATUS[0]}"
+}
+
+test_ssh_connection() {
+    run_command_via_ssh echo ssh connection is working
+}
+
+# takes a local (on runner side) script file and runs it via ssh on the virtual android device. forwards return code.
+# adds a timestamp to every line to be able to see where delays are
+run_script_file_via_ssh() {
+    ssh -p 9022 "$(termux_user)@127.0.0.1" -o StrictHostKeyChecking=accept-new "bash -s" < "$1" 2>&1 | add_timestamp_to_lines
+    return "${PIPESTATUS[0]}"
+}
+
+# Experiments showed that the adb shell input text functionality has a limitation for the input length.
+# If input length is too big, the input is not fully provided to the android device.
+# To avoid this, we divide large inputs into smaller chunks and put them one-by-one.
+adb_input_text_long() {
+    string=$1
+    length=${#string}
+    step=20
+    p=0
+    for ((i = 0; i < length-step; i = i + step)); do
+        chunk="${string:i:$step}"
+        adb shell input text "'$chunk'"
+        p=$((i+step))
+    done
+
+    remaining="${string:p}"
+    adb shell input text "'$remaining'"
+}
+
+generate_rsa_key_local() {
+    yes "" | ssh-keygen -t rsa -b 4096 -C "Github Action" -N ""
+}
+
+install_rsa_pub() {
+
+    run_command_via_ssh "echo hello" && return  # if this works, we are already fine. Skipping
+
+    # remove old host identity:
+    ssh-keygen -f ~/.ssh/known_hosts -R "[127.0.0.1]:9022"
+
+    rsa_pub_key=$(cat ~/.ssh/id_rsa.pub)
+    echo "====================================="
+    echo "$rsa_pub_key"
+    echo "====================================="
+
+    adb shell input text \"echo \"
+
+    adb_input_text_long "$rsa_pub_key"
+
+    adb shell input text "\" >> ~/.ssh/authorized_keys\"" && hit_enter
+    sleep 1
+}
+
+install_packages_via_adb_shell() {
+    install_package_list="$*"
+
+    install_packages_via_adb_shell_using_apt "$install_package_list"
+    if [[ $? -ne 0 ]]; then
+        echo "apt failed. Now try install with pkg as fallback."
+        probe="$dev_probe_dir/pkg.probe"
+        command="'mkdir -vp ~/.cargo/bin; yes | pkg install $install_package_list -y; echo \$? > $probe'"
+        run_termux_command "$command" "$probe" || return 1
+    fi
+
+    return 0
+}
+
+# We use apt to install the packages as pkg doesn't respect any pre-defined mirror list.
+# Its important to have a defined mirror list to avoid issues with broken mirrors.
+install_packages_via_adb_shell_using_apt() {
+    install_package_list="$*"
+
+    repo_url=$(get_current_repo_url)
+    move_to_next_repo_url
+    echo "set apt repository url: $repo_url"
+    probe="$dev_probe_dir/sourceslist.probe"
+    command="'echo $repo_url | dd of=\$PREFIX/etc/apt/sources.list; echo \$? > $probe'"
+    run_termux_command "$command" "$probe"
+
+    probe="$dev_probe_dir/adb_install.probe"
+    command="'mkdir -vp ~/.cargo/bin; apt update; yes | apt install $install_package_list -y; echo \$? > $probe'"
+    run_termux_command "$command" "$probe"
+}
+
+install_packages_via_ssh_using_apt() {
+    install_package_list="$*"
+
+    repo_url=$(get_current_repo_url)
+    move_to_next_repo_url
+    echo "set apt repository url: $repo_url"
+    run_command_via_ssh "echo $repo_url | dd of=\$PREFIX/etc/apt/sources.list"
+
+    run_command_via_ssh "apt update; yes | apt install $install_package_list -y"
+}
+
+apt_upgrade_all_packages() {
+    repo_url=$(get_current_repo_url)
+    move_to_next_repo_url
+    echo "set apt repository url: $repo_url"
+    run_command_via_ssh "echo $repo_url | dd of=\$PREFIX/etc/apt/sources.list"
+
+    run_command_via_ssh "apt update; yes | apt upgrade -y"
+}
+
+generate_and_install_public_key() {
+    echo "generate local public private key pair"
+    generate_rsa_key_local
+    echo "install public key via 'adb shell input'"
+    install_rsa_pub
+    echo "installed ssh public key on device"
+}
+
+run_with_retry() {
+    tries=$1
+    shift 1
+
+    for i in $(seq 1 $tries); do
+        echo "Try #$i of $tries: run $*"
+        "$@" && echo "Done in try#$i" && return 0
+    done
+
+    exit_code=$?
+
+    echo "Still failing after $tries. Code: $exit_code"
+
+    return $exit_code
+}
+
 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
+
+    reinit_ssh_connection || return 1
+
+    apt_upgrade_all_packages
+
+    install_packages_via_ssh_using_apt "rust binutils openssl tar mount-utils"
+
+    echo "Read /proc/cpuinfo"
+    run_command_via_ssh "cat /proc/cpuinfo"
 
     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"
+    # explicitly set CARGO_TARGET_DIR as otherwise a random generated tmp directory is used,
+    # which prevents incremental build for the retries.
+    command="export CARGO_TERM_COLOR=always && export CARGO_TARGET_DIR=\"cargo_install_target_dir\" && cargo install cargo-nextest"
+
+    run_with_retry 3 run_command_via_ssh "$command"
     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 "Info about cargo and rust - via SSH Script"
+    run_script_file_via_ssh "$this_repo/util/android-scripts/collect-info.sh"
 
     echo "Snapshot complete"
     # shellcheck disable=SC2086
@@ -237,50 +550,16 @@ touch $probe'"
 sync_host() {
     repo="$1"
     cache_home="${HOME}/${cache_dir_name}"
-    cache_dest="/sdcard/${cache_dir_name}"
+    cache_dest="$dev_home_dir/${cache_dir_name}"
 
-    echo "Running sync host -> image: ${repo}"
+    reinit_ssh_connection
 
-    # 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 "Running sync host -> image: ${repo}"
 
-    git -C "$repo" diff --name-status | cut -f 2 >modified
-    modified_links=$(join symlinks modified)
-    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
+    # run_command_via_ssh "mkdir $dev_home_dir/coreutils"
 
-    #shellcheck disable=SC2086
-    rm $symlinks
-    # adb's shell user only has access to shared dirs...
-    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/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
+    copy_file_or_dir_to_device_via_ssh "$repo" "$dev_home_dir"
+    [[ -e "$cache_home" ]] && copy_file_or_dir_to_device_via_ssh "$cache_home" "$cache_dest"
 
     echo "Finished sync host -> image: ${repo}"
 }
@@ -288,22 +567,22 @@ touch $probe'"
 sync_image() {
     repo="$1"
     cache_home="${HOME}/${cache_dir_name}"
-    cache_dest="/sdcard/${cache_dir_name}"
+    cache_dest="$dev_probe_dir/${cache_dir_name}"
+
+    reinit_ssh_connection
 
     echo "Running sync image -> host: ${repo}"
 
-    probe='/sdcard/cache.probe'
-    command="'rm -rf /sdcard/coreutils ${cache_dest}; \
+    command="rm -rf $dev_probe_dir/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
+ls -la ${cache_dest}"
+    run_command_via_ssh "$command" || return
 
     rm -rf "$cache_home"
-    adb pull -a "$cache_dest" "$cache_home" || return
+    copy_file_or_dir_from_device_via_ssh "$cache_dest" "$cache_home" || return
 
     echo "Finished sync image -> host: ${repo}"
 }
@@ -311,12 +590,14 @@ echo \$? > ${probe}'"
 build() {
     echo "Running build"
 
-    probe='/sdcard/build.probe'
-    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
+    reinit_ssh_connection
+
+    run_script_file_via_ssh "$this_repo/util/android-scripts/collect-info.sh"
+
+    command="export CARGO_TERM_COLOR=always;
+             export CARGO_INCREMENTAL=0; \
+             cd ~/coreutils && cargo build --features feat_os_unix_android"
+    run_with_retry 3 run_command_via_ssh "$command" || return
 
     echo "Finished build"
 }
@@ -324,31 +605,24 @@ echo \$? >$probe'"
 tests() {
     echo "Running tests"
 
-    probe='/sdcard/tests.probe'
-    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
+    reinit_ssh_connection
+
+    run_script_file_via_ssh "$this_repo/util/android-scripts/collect-info.sh"
+
+    run_script_file_via_ssh "$this_repo/util/android-scripts/run-tests.sh" || return
 
     echo "Finished tests"
 }
 
 hash_rustc() {
-    probe='/sdcard/rustc.probe'
     tmp_hash="__rustc_hash__.tmp"
     hash="__rustc_hash__"
 
+    reinit_ssh_connection
+
     echo "Hashing rustc version: ${HOME}/${hash}"
 
-    command="'rustc -Vv; echo \$? > ${probe}'"
-    keep_log=1
-    debug=0
-    run_termux_command "$command" "$probe" || return
+    run_command_via_ssh "rustc -Vv" > rustc.log || return
     rm -f "$tmp_hash"
     mv "rustc.log" "$tmp_hash" || return
     # sha256sum is not available. shasum is the macos native program.
diff --git a/util/android-scripts/collect-info.sh b/util/android-scripts/collect-info.sh
new file mode 100644
index 00000000000..412423bd135
--- /dev/null
+++ b/util/android-scripts/collect-info.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# spell-checker:ignore nextest watchplus PIPESTATUS
+
+echo "system resources - RAM:"
+free -hm
+echo "system resources - CPU:"
+lscpu
+echo "system resources - file systems:"
+mount
+
+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
diff --git a/util/android-scripts/run-tests.sh b/util/android-scripts/run-tests.sh
new file mode 100644
index 00000000000..17eed8808e0
--- /dev/null
+++ b/util/android-scripts/run-tests.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# spell-checker:ignore nextest watchplus PIPESTATUS
+
+echo "PATH: $PATH"
+
+export PATH=$HOME/.cargo/bin:$PATH
+export RUST_BACKTRACE=full
+export CARGO_TERM_COLOR=always
+export CARGO_INCREMENTAL=0
+
+echo "PATH: $PATH"
+
+run_with_retry() {
+    tries=$1
+    shift 1
+
+    for i in $(seq 1 $tries); do
+        echo "Try #$i of $tries: run $*"
+        "$@" && echo "Done in try#$i" && return 0
+    done
+
+    exit_code=$?
+
+    echo "Still failing after $tries. Code: $exit_code"
+
+    return $exit_code
+}
+
+run_tests_in_subprocess() (
+
+    # limit virtual memory to 3GB to avoid that OS kills sshd
+    ulimit -v $((1024 * 1024 * 3))
+
+    watchplus() {
+        # call: watchplus <interval> <command>
+        while true; do
+            "${@:2}"
+            sleep "$1"
+        done
+    }
+
+    kill_all_background_jobs() {
+        jobs -p | xargs -I{} kill -- {}
+    }
+
+    # observe (log) every 2 seconds the system resource usage to judge if we are at a limit
+    watchplus 2 df -h &
+    watchplus 2 free -hm &
+
+    nextest_params=(--profile ci --hide-progress-bar --features feat_os_unix_android)
+
+    # run tests
+    cd ~/coreutils && \
+        run_with_retry 3 timeout --preserve-status --verbose -k 1m 10m \
+            cargo nextest run --no-run "${nextest_params[@]}" &&
+        timeout --preserve-status --verbose -k 1m 60m \
+            cargo nextest run "${nextest_params[@]}"
+
+    result=$?
+
+    kill_all_background_jobs
+
+    return $result
+)
+
+# run sub-shell to be able to use ulimit without affecting the sshd
+run_tests_in_subprocess
diff --git a/util/build-code_coverage.BAT b/util/build-code_coverage.BAT
deleted file mode 100644
index 25d3f618ba5..00000000000
--- a/util/build-code_coverage.BAT
+++ /dev/null
@@ -1,59 +0,0 @@
-@setLocal
-@echo off
-set "ERRORLEVEL="
-
-@rem ::# spell-checker:ignore (abbrevs/acronyms) gcno
-@rem ::# spell-checker:ignore (CMD) COMSPEC ERRORLEVEL
-@rem ::# spell-checker:ignore (jargon) toolchain
-@rem ::# spell-checker:ignore (rust) Ccodegen Cinline Coverflow Cpanic RUSTC RUSTDOCFLAGS RUSTFLAGS RUSTUP Zpanic
-@rem ::# spell-checker:ignore (utils) genhtml grcov lcov sccache uutils
-
-@rem ::# ref: https://github.com/uutils/coreutils/pull/1476
-
-set "FEATURES_OPTION=--features feat_os_windows"
-
-cd "%~dp0.."
-call echo [ "%CD%" ]
-
-for /f "tokens=*" %%G in ('%~dp0\show-utils.BAT %FEATURES_OPTION%') do set UTIL_LIST=%%G
-REM echo UTIL_LIST=%UTIL_LIST%
-set "CARGO_INDIVIDUAL_PACKAGE_OPTIONS="
-for %%H in (%UTIL_LIST%) do (
-    if DEFINED CARGO_INDIVIDUAL_PACKAGE_OPTIONS call set "CARGO_INDIVIDUAL_PACKAGE_OPTIONS=%%CARGO_INDIVIDUAL_PACKAGE_OPTIONS%% "
-    call set "CARGO_INDIVIDUAL_PACKAGE_OPTIONS=%%CARGO_INDIVIDUAL_PACKAGE_OPTIONS%%-puu_%%H"
-)
-REM echo CARGO_INDIVIDUAL_PACKAGE_OPTIONS=%CARGO_INDIVIDUAL_PACKAGE_OPTIONS%
-
-REM call cargo clean
-
-set "CARGO_INCREMENTAL=0"
-set "RUSTC_WRAPPER="    &@REM ## NOTE: RUSTC_WRAPPER=='sccache' breaks code coverage calculations (uu_*.gcno files are not created during build)
-@REM set "RUSTFLAGS=-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads"
-set "RUSTFLAGS=-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
-set "RUSTDOCFLAGS=-Cpanic=abort"
-set "RUSTUP_TOOLCHAIN=nightly-gnu"
-call cargo build %FEATURES_OPTION%
-call cargo test --no-run %FEATURES_OPTION%
-call cargo test --quiet %FEATURES_OPTION%
-call cargo test --quiet %FEATURES_OPTION% %CARGO_INDIVIDUAL_PACKAGE_OPTIONS%
-
-if NOT DEFINED COVERAGE_REPORT_DIR set COVERAGE_REPORT_DIR=target\debug\coverage-win
-call rm -r "%COVERAGE_REPORT_DIR%" 2>NUL
-
-set GRCOV_IGNORE_OPTION=--ignore build.rs --ignore "/*" --ignore "[A-Za-z]:/*" --ignore "C:/Users/*"
-set GRCOV_EXCLUDE_OPTION=--excl-br-line "^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()"
-@rem ::# * build LCOV coverage file
-REM echo call grcov . --output-type lcov --output-path "%COVERAGE_REPORT_DIR%/../lcov.info" --branch %GRCOV_IGNORE_OPTION% %GRCOV_EXCLUDE_OPTION%
-call grcov . --output-type lcov --output-path "%COVERAGE_REPORT_DIR%/../lcov.info" --branch %GRCOV_IGNORE_OPTION% %GRCOV_EXCLUDE_OPTION%
-@rem ::# * build HTML
-@rem ::# -- use `genhtml` if available for display of additional branch coverage information
-set "ERRORLEVEL="
-call genhtml --version 2>NUL 1>&2
-if NOT ERRORLEVEL 1 (
-    echo call genhtml target/debug/lcov.info --prefix "%CD%" --output-directory "%COVERAGE_REPORT_DIR%" --branch-coverage --function-coverage ^| grep ": [0-9]"
-    call genhtml target/debug/lcov.info --prefix "%CD%" --output-directory "%COVERAGE_REPORT_DIR%" --branch-coverage --function-coverage | grep ": [0-9]"
-) else (
-    echo call grcov . --output-type html --output-path "%COVERAGE_REPORT_DIR%" --branch %GRCOV_IGNORE_OPTION%
-    call grcov . --output-type html --output-path "%COVERAGE_REPORT_DIR%" --branch %GRCOV_IGNORE_OPTION%
-)
-if ERRORLEVEL 1 goto _undefined_ 2>NUL || @for %%G in ("%COMSPEC%") do @title %%nG & @"%COMSPEC%" /d/c exit %ERRORLEVEL%
diff --git a/util/build-code_coverage.sh b/util/build-code_coverage.sh
deleted file mode 100755
index 4082bc13dcf..00000000000
--- a/util/build-code_coverage.sh
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/bin/sh
-
-# spell-checker:ignore (abbrevs/acronyms) HTML gcno llvm
-# spell-checker:ignore (jargon) toolchain
-# spell-checker:ignore (rust) Ccodegen Cinline Coverflow Cpanic RUSTC RUSTDOCFLAGS RUSTFLAGS RUSTUP Zpanic
-# spell-checker:ignore (shell) OSID esac
-# spell-checker:ignore (utils) genhtml grcov lcov readlink sccache shellcheck uutils
-
-FEATURES_OPTION="--features feat_os_unix"
-
-ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
-REPO_main_dir="$(dirname -- "${ME_dir}")"
-
-cd "${REPO_main_dir}" &&
-    echo "[ \"$PWD\" ]"
-
-#shellcheck disable=SC2086
-UTIL_LIST=$("${ME_dir}"/show-utils.sh ${FEATURES_OPTION})
-CARGO_INDIVIDUAL_PACKAGE_OPTIONS=""
-for UTIL in ${UTIL_LIST}; do
-    if [ -n "${CARGO_INDIVIDUAL_PACKAGE_OPTIONS}" ]; then CARGO_INDIVIDUAL_PACKAGE_OPTIONS="${CARGO_INDIVIDUAL_PACKAGE_OPTIONS} "; fi
-    CARGO_INDIVIDUAL_PACKAGE_OPTIONS="${CARGO_INDIVIDUAL_PACKAGE_OPTIONS}-puu_${UTIL}"
-done
-# echo "CARGO_INDIVIDUAL_PACKAGE_OPTIONS=${CARGO_INDIVIDUAL_PACKAGE_OPTIONS}"
-
-# cargo clean
-
-export CARGO_INCREMENTAL=0
-export RUSTC_WRAPPER="" ## NOTE: RUSTC_WRAPPER=='sccache' breaks code coverage calculations (uu_*.gcno files are not created during build)
-# export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads"
-export RUSTFLAGS="-Zprofile -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
-export RUSTDOCFLAGS="-Cpanic=abort"
-export RUSTUP_TOOLCHAIN="nightly-gnu"
-#shellcheck disable=SC2086
-{
-    cargo build ${FEATURES_OPTION}
-    cargo test --no-run ${FEATURES_OPTION}
-    cargo test --quiet ${FEATURES_OPTION}
-    cargo test --quiet ${FEATURES_OPTION} ${CARGO_INDIVIDUAL_PACKAGE_OPTIONS}
-}
-
-export COVERAGE_REPORT_DIR
-if [ -z "${COVERAGE_REPORT_DIR}" ]; then COVERAGE_REPORT_DIR="${REPO_main_dir}/target/debug/coverage-nix"; fi
-rm -r "${COVERAGE_REPORT_DIR}" 2>/dev/null
-mkdir -p "${COVERAGE_REPORT_DIR}"
-
-## NOTE: `grcov` is not accepting environment variable contents as options for `--ignore` or `--excl_br_line`
-# export GRCOV_IGNORE_OPTION="--ignore build.rs --ignore '/*' --ignore '[A-Za-z]:/*' --ignore 'C:/Users/*'"
-# export GRCOV_EXCLUDE_OPTION="--excl-br-line '^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()'"
-# * build LCOV coverage file
-grcov . --output-type lcov --output-path "${COVERAGE_REPORT_DIR}/../lcov.info" --branch --ignore build.rs --ignore '/*' --ignore '[A-Za-z]:/*' --ignore 'C:/Users/*' --excl-br-line '^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()'
-# * build HTML
-# -- use `genhtml` if available for display of additional branch coverage information
-if genhtml --version 2>/dev/null 1>&2; then
-    genhtml "${COVERAGE_REPORT_DIR}/../lcov.info" --output-directory "${COVERAGE_REPORT_DIR}" --branch-coverage --function-coverage | grep ": [0-9]"
-else
-    grcov . --output-type html --output-path "${COVERAGE_REPORT_DIR}" --branch --ignore build.rs --ignore '/*' --ignore '[A-Za-z]:/*' --ignore 'C:/Users/*' --excl-br-line '^\s*((debug_)?assert(_eq|_ne)?!|#\[derive\()'
-fi
-# shellcheck disable=SC2181
-if [ $? -ne 0 ]; then exit 1; fi
diff --git a/util/build-gnu.sh b/util/build-gnu.sh
index a3dd0b9ad53..cf2bcaa8f7b 100755
--- a/util/build-gnu.sh
+++ b/util/build-gnu.sh
@@ -1,27 +1,77 @@
-#!/bin/bash
+#!/usr/bin/env 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 '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
+# spell-checker:ignore (paths) abmon deref discrim eacces getlimits getopt ginstall inacc infloop inotify reflink ; (misc) INT_OFLOW OFLOW
+# spell-checker:ignore baddecode submodules xstrtol distros ; (vars/env) SRCDIR vdir rcexp xpart dired OSTYPE ; (utils) gnproc greadlink gsed multihardlink texinfo CARGOFLAGS
 
 set -e
 
+# Use GNU version for make, nproc, readlink and sed on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        MAKE="gmake"
+        NPROC="gnproc"
+        READLINK="greadlink"
+        SED="gsed"
+        ;;
+    *)
+        MAKE="make"
+        NPROC="nproc"
+        READLINK="readlink"
+        SED="sed"
+        ;;
+esac
+
 ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "${ME}")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
+# Default profile is 'debug'
+UU_MAKE_PROFILE='debug'
+CARGO_FEATURE_FLAGS=""
+
+for arg in "$@"
+do
+    if [ "$arg" == "--release-build" ]; then
+        UU_MAKE_PROFILE='release'
+        break
+    fi
+done
+
+echo "UU_MAKE_PROFILE='${UU_MAKE_PROFILE}'"
+
 ### * config (from environment with fallback defaults); note: GNU is expected to be a sibling repo directory
 
 path_UUTILS=${path_UUTILS:-${REPO_main_dir}}
-path_GNU="$(readlink -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
+path_GNU="$("${READLINK}" -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
 
 ###
 
+# On MacOS there is no system /usr/bin/timeout
+# and trying to add it to /usr/bin (with symlink of copy binary) will fail unless system integrity protection is disabled (not ideal)
+# ref: https://support.apple.com/en-us/102149
+# On MacOS the Homebrew coreutils could be installed and then "sudo ln -s /opt/homebrew/bin/timeout /usr/local/bin/timeout"
+# Set to /usr/local/bin/timeout instead if /usr/bin/timeout is not found
+SYSTEM_TIMEOUT="timeout"
+if [ -x /usr/bin/timeout ]; then
+    SYSTEM_TIMEOUT="/usr/bin/timeout"
+elif [ -x /usr/local/bin/timeout ]; then
+    SYSTEM_TIMEOUT="/usr/local/bin/timeout"
+fi
+
+###
+
+release_tag_GNU="v9.7"
+
 if test ! -d "${path_GNU}"; then
     echo "Could not find GNU coreutils (expected at '${path_GNU}')"
     echo "Run the following to download into the expected path:"
     echo "git clone --recurse-submodules https://github.com/coreutils/coreutils.git \"${path_GNU}\""
+    echo "After downloading GNU coreutils to \"${path_GNU}\" run the following commands to checkout latest release tag"
+    echo "cd \"${path_GNU}\""
+    echo "git fetch --all --tags"
+    echo "git checkout tags/${release_tag_GNU}"
     exit 1
 fi
 
@@ -36,28 +86,58 @@ echo "path_GNU='${path_GNU}'"
 
 ###
 
-UU_MAKE_PROFILE=${UU_MAKE_PROFILE:-release}
-echo "UU_MAKE_PROFILE='${UU_MAKE_PROFILE}'"
-
+if [[ ! -z  "$CARGO_TARGET_DIR" ]]; then
+UU_BUILD_DIR="${CARGO_TARGET_DIR}/${UU_MAKE_PROFILE}"
+else
 UU_BUILD_DIR="${path_UUTILS}/target/${UU_MAKE_PROFILE}"
+fi
 echo "UU_BUILD_DIR='${UU_BUILD_DIR}'"
 
 cd "${path_UUTILS}" && echo "[ pwd:'${PWD}' ]"
 
+# Check for SELinux support
 if [ "$(uname)" == "Linux" ]; then
-    # only set on linux
+    # Only attempt to enable SELinux features on Linux
     export SELINUX_ENABLED=1
+    CARGO_FEATURE_FLAGS="${CARGO_FEATURE_FLAGS} selinux"
+fi
+
+# Trim leading whitespace from feature flags
+CARGO_FEATURE_FLAGS="$(echo "${CARGO_FEATURE_FLAGS}" | sed -e 's/^[[:space:]]*//')"
+
+# If we have feature flags, format them correctly for cargo
+if [ ! -z "${CARGO_FEATURE_FLAGS}" ]; then
+    CARGO_FEATURE_FLAGS="--features ${CARGO_FEATURE_FLAGS}"
+    echo "Building with cargo flags: ${CARGO_FEATURE_FLAGS}"
+fi
+
+# Set up quilt for patch management
+export QUILT_PATCHES="${ME_dir}/gnu-patches/"
+cd "$path_GNU"
+
+# Check if all patches are already applied
+if [ "$(quilt applied | wc -l)" -eq "$(quilt series | wc -l)" ]; then
+    echo "All patches are already applied"
+else
+    # Push all patches
+    quilt push -a || { echo "Failed to apply patches"; exit 1; }
 fi
+cd -
+
+# Pass the feature flags to make, which will pass them to cargo
+"${MAKE}" PROFILE="${UU_MAKE_PROFILE}" CARGOFLAGS="${CARGO_FEATURE_FLAGS}"
+touch g
+echo "stat with selinux support"
+./target/debug/stat -c%C g || true
 
-make PROFILE="${UU_MAKE_PROFILE}"
 
 cp "${UU_BUILD_DIR}/install" "${UU_BUILD_DIR}/ginstall" # The GNU tests rename this script before running, to avoid confusion with the make target
 # Create *sum binaries
 for sum in b2sum b3sum md5sum sha1sum sha224sum sha256sum sha384sum sha512sum; do
     sum_path="${UU_BUILD_DIR}/${sum}"
-    test -f "${sum_path}" || cp "${UU_BUILD_DIR}/hashsum" "${sum_path}"
+    test -f "${sum_path}" || (cd ${UU_BUILD_DIR} && ln -s "hashsum" "${sum}")
 done
-test -f "${UU_BUILD_DIR}/[" || cp "${UU_BUILD_DIR}/test" "${UU_BUILD_DIR}/["
+test -f "${UU_BUILD_DIR}/[" || (cd ${UU_BUILD_DIR} && ln -s "test" "[")
 
 ##
 
@@ -73,107 +153,74 @@ 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
+    # Disable useless checks
+    sed -i 's|check-texinfo: $(syntax_checks)|check-texinfo:|' doc/local.mk
     ./bootstrap --skip-po
-    ./configure --quiet --disable-gcc-warnings
+    ./configure --quiet --disable-gcc-warnings --disable-nls --disable-dependency-tracking --disable-bold-man-page-references
     #Add timeout to to protect against hangs
-    sed -i 's|^"\$@|/usr/bin/timeout 600 "\$@|' build-aux/test-driver
+    sed -i 's|^"\$@|'"${SYSTEM_TIMEOUT}"' 600 "\$@|' build-aux/test-driver
     # 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
     sed -i 's| tr | /usr/bin/tr |' tests/init.sh
-    make -j "$(nproc)"
+    # Use a better diff
+    sed -i 's|diff -c|diff -u|g' tests/Coreutils.pm
+    "${MAKE}" -j "$("${NPROC}")"
+
+    # Handle generated factor tests
+    t_first=00
+    t_max=37
+    seq=$(
+        i=${t_first}
+        while test "${i}" -le "${t_max}"; do
+            printf '%02d ' ${i}
+            i=$((i + 1))
+        done
+       )
+    for i in ${seq}; do
+        echo "strip t${i}.sh from Makefile"
+        sed -i -e "s/\$(tf)\/t${i}.sh//g" Makefile
+    done
+
+    # Remove tests checking for --version & --help
+    # Not really interesting for us and logs are too big
+    sed -i -e '/tests\/help\/help-version.sh/ D' \
+        -e '/tests\/help\/help-version-getopt.sh/ D' \
+        Makefile
     touch gnu-built
 fi
 
-# Handle generated factor tests
-t_first=00
-t_max=36
-# t_max_release=20
-# if test "${UU_MAKE_PROFILE}" != "debug"; then
-#     # Generate the factor tests, so they can be fixed
-#     # * reduced to 20 to decrease log size (down from 36 expected by GNU)
-#     # * only for 'release', skipped for 'debug' as redundant and too time consuming (causing timeout errors)
-#     seq=$(
-#         i=${t_first}
-#         while test "${i}" -le "${t_max_release}"; do
-#             printf '%02d ' $i
-#             i=$((i + 1))
-#         done
-#     )
-#     for i in ${seq}; do
-#         make "tests/factor/t${i}.sh"
-#     done
-#     cat
-#     sed -i -e 's|^seq |/usr/bin/seq |' -e 's|sha1sum |/usr/bin/sha1sum |' tests/factor/t*.sh
-#     t_first=$((t_max_release + 1))
-# fi
-# strip all (debug) or just the longer (release) factor tests from Makefile
-seq=$(
-    i=${t_first}
-    while test "${i}" -le "${t_max}"; do
-        printf '%02d ' ${i}
-        i=$((i + 1))
-    done
-)
-for i in ${seq}; do
-    echo "strip t${i}.sh from Makefile"
-    sed -i -e "s/\$(tf)\/t${i}.sh//g" Makefile
-done
-
 grep -rl 'path_prepend_' tests/* | xargs sed -i 's| path_prepend_ ./src||'
 
-# Remove tests checking for --version & --help
-# Not really interesting for us and logs are too big
-sed -i -e '/tests\/misc\/invalid-opt.pl/ D' \
-    -e '/tests\/help\/help-version.sh/ D' \
-    -e '/tests\/help\/help-version-getopt.sh/ D' \
-    Makefile
+# Use the system coreutils where the test fails due to error in a util that is not the one being tested
+sed -i "s|grep '^#define HAVE_CAP 1' \$CONFIG_HEADER > /dev/null|true|"  tests/ls/capability.sh
+# tests/ls/abmon-align.sh - https://github.com/uutils/coreutils/issues/3505
+sed -i 's|touch |/usr/bin/touch |' tests/test/test-N.sh tests/ls/abmon-align.sh
 
-# logs are clotted because of this test
-sed -i -e '/tests\/seq\/seq-precision.sh/ D' \
-    Makefile
+# our messages are better
+sed -i "s|cannot stat 'symlink': Permission denied|not writing through dangling symlink 'symlink'|" tests/cp/fail-perm.sh
+sed -i "s|cp: target directory 'symlink': Permission denied|cp: 'symlink' is not a directory|" tests/cp/fail-perm.sh
 
-# printf doesn't limit the values used in its arg, so this produced ~2GB of output
-sed -i '/INT_OFLOW/ D' tests/printf/printf.sh
+# Our message is a bit better
+sed -i "s|cannot create regular file 'no-such/': Not a directory|'no-such/' is not a directory|" tests/mv/trailing-slash.sh
 
-# Use the system coreutils where the test fails due to error in a util that is not the one being tested
-sed -i 's|stat|/usr/bin/stat|' tests/touch/60-seconds.sh tests/sort/sort-compress-proc.sh
-sed -i 's|ls -|/usr/bin/ls -|' tests/cp/same-file.sh tests/misc/mknod.sh tests/mv/part-symlink.sh
-sed -i 's|chmod |/usr/bin/chmod |' tests/du/inacc-dir.sh tests/tail/tail-n0f.sh tests/cp/fail-perm.sh tests/mv/i-2.sh tests/shuf/shuf.sh
-sed -i 's|sort |/usr/bin/sort |' tests/ls/hyperlink.sh tests/test/test-N.sh
-sed -i 's|split |/usr/bin/split |' tests/factor/factor-parallel.sh
-sed -i 's|id -|/usr/bin/id -|' tests/runcon/runcon-no-reorder.sh
-# tests/ls/abmon-align.sh - https://github.com/uutils/coreutils/issues/3505
-sed -i 's|touch |/usr/bin/touch |' tests/cp/reflink-perm.sh tests/ls/block-size.sh tests/mv/update.sh tests/ls/ls-time.sh tests/stat/stat-nanoseconds.sh tests/misc/time-style.sh tests/test/test-N.sh tests/ls/abmon-align.sh
-sed -i 's|ln -|/usr/bin/ln -|' tests/cp/link-deref.sh
-sed -i 's|cp |/usr/bin/cp |' tests/mv/hard-2.sh
-sed -i 's|paste |/usr/bin/paste |' tests/od/od-endian.sh
-sed -i 's|timeout |/usr/bin/timeout |' tests/tail/follow-stdin.sh
+# Our message is better
+sed -i "s|warning: unrecognized escape|warning: incomplete hex escape|" tests/stat/stat-printf.pl
 
-# Add specific timeout to tests that currently hang to limit time spent waiting
-sed -i 's|\(^\s*\)seq \$|\1/usr/bin/timeout 0.1 seq \$|' tests/seq/seq-precision.sh tests/seq/seq-long-double.sh
+sed -i 's|timeout |'"${SYSTEM_TIMEOUT}"' |' tests/tail/follow-stdin.sh
 
-# Remove dup of /usr/bin/ when executed several times
-grep -rlE '/usr/bin/\s?/usr/bin' init.cfg tests/* | xargs --no-run-if-empty sed -Ei 's|/usr/bin/\s?/usr/bin/|/usr/bin/|g'
+# Remove dup of /usr/bin/ and /usr/local/bin/ when executed several times
+grep -rlE '/usr/bin/\s?/usr/bin' init.cfg tests/* | xargs -r sed -Ei 's|/usr/bin/\s?/usr/bin/|/usr/bin/|g'
+grep -rlE '/usr/local/bin/\s?/usr/local/bin' init.cfg tests/* | xargs -r sed -Ei 's|/usr/local/bin/\s?/usr/local/bin/|/usr/local/bin/|g'
 
 #### Adjust tests to make them work with Rust/coreutils
 # in some cases, what we are doing in rust/coreutils is good (or better)
 # we should not regress our project just to match what GNU is going.
 # So, do some changes on the fly
 
-sed -i -e "s|rm: cannot remove 'e/slink'|rm: cannot remove 'e'|g" tests/rm/fail-eacces.sh
-
-sed -i -e "s|rm: cannot remove 'a/b/file'|rm: cannot remove 'a'|g" tests/rm/cycle.sh
-
-sed -i -e "s|rm: cannot remove directory 'b/a/p'|rm: cannot remove 'b'|g" tests/rm/rm1.sh
-
-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.
@@ -183,22 +230,38 @@ sed -i -e "s|rm: cannot remove 'rel': Permission denied|rm: cannot remove 'rel':
 # however there's a bug because `---dis` is an alias for: `---disable-inotify`
 sed -i -e "s|---dis ||g" tests/tail/overlay-headers.sh
 
+# Do not FAIL, just do a regular ERROR
+sed -i -e "s|framework_failure_ 'no inotify_add_watch';|fail=1;|" tests/tail/inotify-rotate-resources.sh
+
 test -f "${UU_BUILD_DIR}/getlimits" || cp src/getlimits "${UU_BUILD_DIR}"
 
+# pr produces very long log and this command isn't super interesting
+# SKIP for now
+sed -i -e "s|my \$prog = 'pr';$|my \$prog = 'pr';CuSkip::skip \"\$prog: SKIP for producing too long logs\";|" tests/pr/pr-tests.pl
+
+# We don't have the same error message and no need to be that specific
+sed -i -e "s|invalid suffix in --pages argument|invalid --pages argument|" \
+    -e "s|--pages argument '\$too_big' too large|invalid --pages argument '\$too_big'|"  \
+    -e "s|invalid page range|invalid --pages argument|" tests/misc/xstrtol.pl
+
 # When decoding an invalid base32/64 string, gnu writes everything it was able to decode until
 # it hit the decode error, while we don't write anything if the input is invalid.
-sed -i "s/\(baddecode.*OUT=>\"\).*\"/\1\"/g" tests/misc/base64.pl
-sed -i "s/\(\(b2[ml]_[69]\|b32h_[56]\|z85_8\|z85_35\).*OUT=>\)[^}]*\(.*\)/\1\"\"\3/g" tests/misc/basenc.pl
+sed -i "s/\(baddecode.*OUT=>\"\).*\"/\1\"/g" tests/basenc/base64.pl
+sed -i "s/\(\(b2[ml]_[69]\|b32h_[56]\|z85_8\|z85_35\).*OUT=>\)[^}]*\(.*\)/\1\"\"\3/g" tests/basenc/basenc.pl
 
 # add "error: " to the expected error message
-sed -i "s/\$prog: invalid input/\$prog: error: invalid input/g" tests/misc/basenc.pl
+sed -i "s/\$prog: invalid input/\$prog: error: invalid input/g" tests/basenc/basenc.pl
 
 # basenc: swap out error message for unexpected arg
-sed -i "s/  {ERR=>\"\$prog: foobar\\\\n\" \. \$try_help }/  {ERR=>\"error: Found argument '--foobar' which wasn't expected, or isn't valid in this context\n\n  If you tried to supply '--foobar' as a value rather than a flag, use '-- --foobar'\n\nUsage: basenc [OPTION]... [FILE]\n\nFor more information try '--help'\n\"}]/" tests/misc/basenc.pl
-sed -i "s/  {ERR_SUBST=>\"s\/(unrecognized|unknown) option \[-' \]\*foobar\[' \]\*\/foobar\/\"}],//" tests/misc/basenc.pl
+sed -i "s/  {ERR=>\"\$prog: foobar\\\\n\" \. \$try_help }/  {ERR=>\"error: unexpected argument '--foobar' found\n\n  tip: to pass '--foobar' as a value, use '-- --foobar'\n\nUsage: basenc [OPTION]... [FILE]\n\nFor more information, try '--help'.\n\"}]/" tests/basenc/basenc.pl
+sed -i "s/  {ERR_SUBST=>\"s\/(unrecognized|unknown) option \[-' \]\*foobar\[' \]\*\/foobar\/\"}],//" tests/basenc/basenc.pl
 
 # Remove the check whether a util was built. Otherwise tests against utils like "arch" are not run.
 sed -i "s|require_built_ |# require_built_ |g" init.cfg
+
+# exit early for the selinux check. The first is enough for us.
+sed -i "s|# Independent of whether SELinux|return 0\n  #|g" init.cfg
+
 # Some tests are executed with the "nobody" user.
 # The check to verify if it works is based on the GNU coreutils version
 # making it too restrictive for us
@@ -208,41 +271,106 @@ sed -i "s|\$PACKAGE_VERSION|[0-9]*|g" tests/rm/fail-2eperm.sh tests/mv/sticky-to
 # with the option -/ is used, clap is returning a better error than GNU's. Adjust the GNU test
 sed -i -e "s~  grep \" '\*/'\*\" err || framework_failure_~  grep \" '*-/'*\" err || framework_failure_~" tests/misc/usage_vs_getopt.sh
 sed -i -e "s~  sed -n \"1s/'\\\/'/'OPT'/p\" < err >> pat || framework_failure_~  sed -n \"1s/'-\\\/'/'OPT'/p\" < err >> pat || framework_failure_~" tests/misc/usage_vs_getopt.sh
-# Ignore some binaries (not built)
-# And change the default error code to 2
-# see issue #3331 (clap limitation).
-# Upstream returns 1 for most of the program. We do for cp, truncate & pr
-# So, keep it as it
-sed -i -e "s/rcexp=1$/rcexp=2\n  case \"\$prg\" in chcon|runcon) return;; esac/" -e "s/rcexp=125 ;;/rcexp=2 ;;\ncp|truncate|pr) rcexp=1;;/" tests/misc/usage_vs_getopt.sh
+# Ignore runcon, it needs some extra attention
+# For all other tools, we want drop-in compatibility, and that includes the exit code.
+sed -i -e "s/rcexp=1$/rcexp=1\n  case \"\$prg\" in runcon|stdbuf) return;; esac/" tests/misc/usage_vs_getopt.sh
 # GNU has option=[SUFFIX], clap is <SUFFIX>
-sed -i -e "s/cat opts/sed -i -e \"s| <.\*>$||g\" opts/" tests/misc/usage_vs_getopt.sh
+sed -i -e "s/cat opts/sed -i -e \"s| <.\*$||g\" opts/" tests/misc/usage_vs_getopt.sh
 # for some reasons, some stuff are duplicated, strip that
 sed -i -e "s/provoked error./provoked error\ncat pat |sort -u > pat/" tests/misc/usage_vs_getopt.sh
 
 # Update the GNU error message to match ours
 sed -i -e "s/link-to-dir: hard link not allowed for directory/failed to create hard link 'link-to-dir' =>/" -e "s|link-to-dir/: hard link not allowed for directory|failed to create hard link 'link-to-dir/' =>|" tests/ln/hard-to-sym.sh
 
-# GNU sleep accepts some crazy string, not sure we should match this behavior
-sed -i -e "s/timeout 10 sleep 0x.002p1/#timeout 10 sleep 0x.002p1/" tests/misc/sleep.sh
-
 # install verbose messages shows ginstall as command
 sed -i -e "s/ginstall: creating directory/install: creating directory/g" tests/install/basic-1.sh
 
 # GNU doesn't support padding < -LONG_MAX
 # disable this test case
-sed -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt supports padding = LONG_MIN\n#\1\n#\2\n#\3/" tests/misc/numfmt.pl
+# Use GNU sed because option -z is not available on BSD sed
+"${SED}" -i -Ez "s/\n([^\n#]*pad-3\.2[^\n]*)\n([^\n]*)\n([^\n]*)/\n# uutils\/numfmt supports padding = LONG_MIN\n#\1\n#\2\n#\3/" tests/misc/numfmt.pl
 
 # 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/\$prog: multiple field specifications/error: the argument '--field <FIELDS>' cannot be used multiple times\n\nUsage: numfmt [OPTION]... [NUMBER]...\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
 
+# our error message is better
+sed -i -e "s|mv: cannot overwrite 'a/t': Directory not empty|mv: cannot move 'b/t' to 'a/t': Directory not empty|" tests/mv/dir2dir.sh
+
 # GNU doesn't support width > INT_MAX
 # disable these test cases
 sed -i -E "s|^([^#]*2_31.*)$|#\1|g" tests/printf/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
+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 "s/Try 'du --help' for more information./\nFor more information, try '--help'./" tests/du/threshold.sh
+
+# Remove the extra output check
+sed -i -e "s|Try '\$prog --help' for more information.\\\n||" tests/du/files0-from.pl
+sed -i -e "s|when reading file names from stdin, no file name of\"|-: No such file or directory\n\"|" -e "s| '-' allowed\\\n||" tests/du/files0-from.pl
+sed -i -e "s|-: No such file or directory|cannot access '-': No such file or directory|g" tests/du/files0-from.pl
+
+awk 'BEGIN {count=0} /compare exp out2/ && count < 6 {sub(/compare exp out2/, "grep -q \"cannot be used with\" out2"); count++} 1' tests/df/df-output.sh > tests/df/df-output.sh.tmp && mv tests/df/df-output.sh.tmp tests/df/df-output.sh
+
+# with ls --dired, in case of error, we have a slightly different error position
+sed -i -e "s|44 45|48 49|" tests/ls/stat-failed.sh
+
+# small difference in the error message
+# Use GNU sed for /c command
+"${SED}" -i -e "/ls: invalid argument 'XX' for 'time style'/,/Try 'ls --help' for more information\./c\
+ls: invalid --time-style argument 'XX'\nPossible values are: [\"full-iso\", \"long-iso\", \"iso\", \"locale\", \"+FORMAT (e.g., +%H:%M) for a 'date'-style format\"]\n\nFor more information try --help" tests/ls/time-style-diag.sh
 
 # disable two kind of tests:
 # "hostid BEFORE --help" doesn't fail for GNU. we fail. we are probably doing better
 # "hostid BEFORE --help AFTER " same for this
 sed -i -e "s/env \$prog \$BEFORE \$opt > out2/env \$prog \$BEFORE \$opt > out2 #/" -e "s/env \$prog \$BEFORE \$opt AFTER > out3/env \$prog \$BEFORE \$opt AFTER > out3 #/" -e "s/compare exp out2/compare exp out2 #/" -e "s/compare exp out3/compare exp out3 #/" tests/help/help-version-getopt.sh
+
+# Add debug info + we have less syscall then GNU's. Adjust our check.
+# Use GNU sed for /c command
+"${SED}" -i -e '/test \$n_stat1 = \$n_stat2 \\/c\
+echo "n_stat1 = \$n_stat1"\n\
+echo "n_stat2 = \$n_stat2"\n\
+test \$n_stat1 -ge \$n_stat2 \\' tests/ls/stat-free-color.sh
+
+# no need to replicate this output with hashsum
+sed -i -e  "s|Try 'md5sum --help' for more information.\\\n||" tests/cksum/md5sum.pl
+
+# Our ls command always outputs ANSI color codes prepended with a zero. However,
+# in the case of GNU, it seems inconsistent. Nevertheless, it looks like it
+# doesn't matter whether we prepend a zero or not.
+sed -i -E 's/\^\[\[([1-9]m)/^[[0\1/g;  s/\^\[\[m/^[[0m/g' tests/ls/color-norm.sh
+# It says in the test itself that having more than one reset is a bug, so we
+# don't need to replicate that behavior.
+sed -i -E 's/(\^\[\[0m)+/\^\[\[0m/g' tests/ls/color-norm.sh
+
+# GNU's ls seems to output color codes in the order given in the environment
+# variable, but our ls seems to output them in a predefined order. Nevertheless,
+# the order doesn't matter, so it's okay.
+sed -i  's/44;37/37;44/' tests/ls/multihardlink.sh
+
+# Just like mentioned in the previous patch, GNU's ls output color codes in the
+# same way it is specified in the environment variable, but our ls emits them
+# differently. In this case, the color code is set to 0;31;42, and our ls would
+# ignore the 0; part. This would have been a bug if we output color codes
+# individually, for example, ^[[31^[[42 instead of ^[[31;42, but we don't do
+# that anywhere in our implementation, and it looks like GNU's ls also doesn't
+# do that. So, it's okay to ignore the zero.
+sed -i  "s/color_code='0;31;42'/color_code='31;42'/" tests/ls/color-clear-to-eol.sh
+
+# patching this because of the same reason as the last one.
+sed -i  "s/color_code='0;31;42'/color_code='31;42'/" tests/ls/quote-align.sh
+
+# Slightly different error message
+sed -i 's/not supported/unexpected argument/' tests/mv/mv-exchange.sh
+# Most tests check that `/usr/bin/tr` is working correctly before running.
+# However in NixOS/Nix-based distros, the tr util is located somewhere in
+# /nix/store/xxxxxxxxxxxx...xxxx/bin/tr
+# We just replace the references to `/usr/bin/tr` with the result of `$(which tr)`
+sed -i  's/\/usr\/bin\/tr/$(which tr)/' tests/init.sh
+
+# upstream doesn't having the program name in the error message
+# but we do. We should keep it that way.
+sed -i 's/echo "changing security context/echo "chcon: changing security context/' tests/chcon/chcon.sh
+
+# Disable this test, it is not relevant for us:
+# * the selinux crate is handling errors
+# * the test says "maybe we should not fail when no context available"
+sed -i -e "s|returns_ 1||g" tests/cp/no-ctx.sh
diff --git a/util/build-run-test-coverage-linux.sh b/util/build-run-test-coverage-linux.sh
new file mode 100755
index 00000000000..3eec0dda305
--- /dev/null
+++ b/util/build-run-test-coverage-linux.sh
@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+
+# spell-checker:ignore (env/flags) Ccodegen Cinstrument Coverflow Cpanic Zpanic
+# spell-checker:ignore PROFDATA PROFRAW coreutil librairies nextest profdata profraw rustlib
+
+# This script will build, run and generate coverage reports for the whole
+# testsuite.
+# The biggest challenge of this process is managing the overwhelming generation
+# of trace files that are generated after EACH SINGLE invocation of a coreutil
+# in the testsuite. Moreover, because we run the testsuite against the multicall
+# binary, each trace file contains coverage information about the WHOLE
+# multicall binary, dependencies included, which results in a 5-6 MB file.
+# Running the testsuite easily creates +80 GB of trace files, which is
+# unmanageable in a CI environment.
+#
+# A workaround is to run the testsuite util per util, generate a report per
+# util, and remove the trace files. Therefore, we end up with several reports
+# that will get uploaded to codecov afterwards. The issue with this
+# approach is that the `grcov` call, which is responsible for transforming
+# `.profraw` trace files into a `lcov` file, takes a lot of time (~20s), mainly
+# because it has to browse all the sources. So calling it for each of the 100
+# utils (with --all-features) results in an absurdly long execution time
+# (almost an hour).
+
+# TODO: Do not instrument 3rd party librairies to save space and performance
+
+# Exit the script if an unexpected error arise
+set -e
+# Treat unset variables as errors
+set -u
+# Print expanded commands to stdout before running them
+set -x
+
+ME="${0}"
+ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
+REPO_main_dir="$(dirname -- "${ME_dir}")"
+
+# Features to enable for the `coreutils` package
+FEATURES_OPTION=${FEATURES_OPTION:-"--features=feat_os_unix"}
+COVERAGE_DIR=${COVERAGE_DIR:-"${REPO_main_dir}/coverage"}
+
+LLVM_PROFDATA="$(find "$(rustc --print sysroot)" -name llvm-profdata)"
+
+PROFRAW_DIR="${COVERAGE_DIR}/traces"
+PROFDATA_DIR="${COVERAGE_DIR}/data"
+REPORT_DIR="${COVERAGE_DIR}/report"
+REPORT_PATH="${REPORT_DIR}/total.lcov.info"
+
+rm -rf "${PROFRAW_DIR}" && mkdir -p "${PROFRAW_DIR}"
+rm -rf "${PROFDATA_DIR}" && mkdir -p "${PROFDATA_DIR}"
+rm -rf "${REPORT_DIR}" && mkdir -p "${REPORT_DIR}"
+
+#shellcheck disable=SC2086
+UTIL_LIST=$("${ME_dir}"/show-utils.sh ${FEATURES_OPTION})
+
+export CARGO_INCREMENTAL=0
+export RUSTFLAGS="-Cinstrument-coverage -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
+export RUSTDOCFLAGS="-Cpanic=abort"
+export RUSTUP_TOOLCHAIN="nightly-gnu"
+export LLVM_PROFILE_FILE="${PROFRAW_DIR}/coverage-%m-%p.profraw"
+
+# Disable expanded command printing for the rest of the program
+set +x
+
+run_test_and_aggregate() {
+    echo "# Running coverage tests for ${1}"
+
+    # Build and run tests for the UTIL
+    cargo nextest run \
+        --profile coverage \
+        --no-fail-fast \
+        --color=always \
+        2>&1 \
+        ${2} \
+    | grep -v 'SKIP'
+    # Note: Do not print the skipped tests on the output as there will be many.
+
+    echo "## Tests for (${1}) generated $(du -h -d1 ${PROFRAW_DIR} | cut -f 1) of profraw files"
+
+    # Aggregate all the trace files into a profdata file
+    PROFDATA_FILE="${PROFDATA_DIR}/${1}.profdata"
+    echo "## Aggregating coverage files under ${PROFDATA_FILE}"
+    "${LLVM_PROFDATA}" merge \
+        -sparse \
+        -o ${PROFDATA_FILE} \
+        ${PROFRAW_DIR}/*.profraw \
+    || true
+    # We don't want an error in `llvm-profdata` to abort the whole program
+}
+
+for UTIL in ${UTIL_LIST}; do
+
+    run_test_and_aggregate \
+        "${UTIL}" \
+        "-p coreutils -E test(/^test_${UTIL}::/) ${FEATURES_OPTION}"
+
+    echo "## Clear the trace directory to free up space"
+    rm -rf "${PROFRAW_DIR}" && mkdir -p "${PROFRAW_DIR}"
+done;
+
+echo "Running coverage tests over uucore"
+run_test_and_aggregate "uucore" "-p uucore --all-features"
+
+echo "# Aggregating all the profraw files under ${REPORT_PATH}"
+grcov \
+    "${PROFDATA_DIR}" \
+    --binary-path "${REPO_main_dir}/target/debug/coreutils" \
+    --output-types lcov \
+    --output-path ${REPORT_PATH} \
+    --llvm \
+    --keep-only "${REPO_main_dir}"'/src/*'
+
+
+# Notify the report file to github
+echo "report=${REPORT_PATH}" >> $GITHUB_OUTPUT
diff --git a/util/compare_gnu_result.py b/util/compare_gnu_result.py
index 704951863b5..e0b017e816b 100755
--- a/util/compare_gnu_result.py
+++ b/util/compare_gnu_result.py
@@ -1,8 +1,9 @@
-#! /usr/bin/python
+#!/usr/bin/env python3
 
 """
-Compare the current results to the last results gathered from the main branch to highlight
-if a PR is making the results better/worse
+Compare the current results to the last results gathered from the main branch to
+highlight if a PR is making the results better/worse.
+Don't exit with error code if all failing tests are in the ignore-intermittent.txt list.
 """
 
 import json
@@ -10,6 +11,7 @@
 from os import environ
 
 REPO_DEFAULT_BRANCH = environ.get("REPO_DEFAULT_BRANCH", "main")
+ONLY_INTERMITTENT = environ.get("ONLY_INTERMITTENT", "false")
 
 NEW = json.load(open("gnu-result.json"))
 OLD = json.load(open("main-gnu-result.json"))
@@ -26,12 +28,23 @@
 
 # Get an annotation to highlight changes
 print(
-    f"::warning ::Changes from '{REPO_DEFAULT_BRANCH}': PASS {pass_d:+d} / FAIL {fail_d:+d} / ERROR {error_d:+d} / SKIP {skip_d:+d} "
+    f"""::warning ::Changes from '{REPO_DEFAULT_BRANCH}': PASS {pass_d:+d} /
+    FAIL {fail_d:+d} / ERROR {error_d:+d} / SKIP {skip_d:+d}"""
 )
 
-# If results are worse fail the job to draw attention
+# If results are worse, check if we should fail the job
 if pass_d < 0:
     print(
-        f"::error ::PASS count is reduced from '{REPO_DEFAULT_BRANCH}': PASS {pass_d:+d} "
+        f"""::error ::PASS count is reduced from
+        '{REPO_DEFAULT_BRANCH}': PASS {pass_d:+d}"""
     )
-    sys.exit(1)
+
+    # Check if all failing tests are intermittent based on the environment variable
+    only_intermittent = ONLY_INTERMITTENT.lower() == "true"
+
+    if only_intermittent:
+        print("::notice ::All failing tests are in the ignored intermittent list")
+        print("::notice ::Not failing the build")
+    else:
+        print("::error ::Found non-ignored failing tests")
+        sys.exit(1)
diff --git a/util/compare_test_results.py b/util/compare_test_results.py
new file mode 100644
index 00000000000..d5739deaed5
--- /dev/null
+++ b/util/compare_test_results.py
@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Compare GNU test results between current run and reference to identify
+regressions and fixes.
+
+
+Arguments:
+    CURRENT_JSON       Path to the current run's aggregated results JSON file
+    REFERENCE_JSON     Path to the reference (main branch) aggregated
+                        results JSON file
+    --ignore-file      Path to file containing list of tests to ignore
+                        (for intermittent issues)
+    --output           Path to output file for GitHub comment content
+"""
+
+import argparse
+import json
+import os
+import sys
+
+
+def flatten_test_results(results):
+    """Convert nested JSON test results to a flat dictionary of test paths to statuses."""
+    flattened = {}
+    for util, tests in results.items():
+        for test_name, status in tests.items():
+            # Build the full test path
+            test_path = f"tests/{util}/{test_name}"
+            # Remove the .log extension
+            test_path = test_path.replace(".log", "")
+            flattened[test_path] = status
+    return flattened
+
+
+def load_ignore_list(ignore_file):
+    """Load list of tests to ignore from file."""
+    if not os.path.exists(ignore_file):
+        return set()
+
+    with open(ignore_file, "r") as f:
+        return {line.strip() for line in f if line.strip() and not line.startswith("#")}
+
+
+def identify_test_changes(current_flat, reference_flat):
+    """
+    Identify different categories of test changes between current and reference results.
+
+    Args:
+        current_flat (dict): Flattened dictionary of current test results
+        reference_flat (dict): Flattened dictionary of reference test results
+
+    Returns:
+        tuple: Four lists containing regressions, fixes, newly_skipped, and newly_passing tests
+    """
+    # Find regressions (tests that were passing but now failing)
+    regressions = []
+    for test_path, status in current_flat.items():
+        if status in ("FAIL", "ERROR"):
+            if test_path in reference_flat:
+                if reference_flat[test_path] in ("PASS", "SKIP"):
+                    regressions.append(test_path)
+
+    # Find fixes (tests that were failing but now passing)
+    fixes = []
+    for test_path, status in reference_flat.items():
+        if status in ("FAIL", "ERROR"):
+            if test_path in current_flat:
+                if current_flat[test_path] == "PASS":
+                    fixes.append(test_path)
+
+    # Find newly skipped tests (were passing, now skipped)
+    newly_skipped = []
+    for test_path, status in current_flat.items():
+        if (
+            status == "SKIP"
+            and test_path in reference_flat
+            and reference_flat[test_path] == "PASS"
+        ):
+            newly_skipped.append(test_path)
+
+    # Find newly passing tests (were skipped, now passing)
+    newly_passing = []
+    for test_path, status in current_flat.items():
+        if (
+            status == "PASS"
+            and test_path in reference_flat
+            and reference_flat[test_path] == "SKIP"
+        ):
+            newly_passing.append(test_path)
+
+    return regressions, fixes, newly_skipped, newly_passing
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Compare GNU test results and identify regressions and fixes"
+    )
+    parser.add_argument("current_json", help="Path to current run JSON results")
+    parser.add_argument("reference_json", help="Path to reference JSON results")
+    parser.add_argument(
+        "--ignore-file",
+        required=True,
+        help="Path to file with tests to ignore (for intermittent issues)",
+    )
+    parser.add_argument("--output", help="Path to output file for GitHub comment")
+
+    args = parser.parse_args()
+
+    # Load test results
+    try:
+        with open(args.current_json, "r") as f:
+            current_results = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        sys.stderr.write(f"Error loading current results: {e}\n")
+        return 1
+
+    try:
+        with open(args.reference_json, "r") as f:
+            reference_results = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        sys.stderr.write(f"Error loading reference results: {e}\n")
+        sys.stderr.write("Skipping comparison as reference is not available.\n")
+        return 0
+
+    # Load ignore list (required)
+    if not os.path.exists(args.ignore_file):
+        sys.stderr.write(f"Error: Ignore file {args.ignore_file} does not exist\n")
+        return 1
+
+    ignore_list = load_ignore_list(args.ignore_file)
+    print(f"Loaded {len(ignore_list)} tests to ignore from {args.ignore_file}")
+
+    # Flatten result structures for easier comparison
+    current_flat = flatten_test_results(current_results)
+    reference_flat = flatten_test_results(reference_results)
+
+    # Identify different categories of test changes
+    regressions, fixes, newly_skipped, newly_passing = identify_test_changes(
+        current_flat, reference_flat
+    )
+
+    # Filter out intermittent issues from regressions
+    real_regressions = [r for r in regressions if r not in ignore_list]
+    intermittent_regressions = [r for r in regressions if r in ignore_list]
+
+    # Filter out intermittent issues from fixes
+    real_fixes = [f for f in fixes if f not in ignore_list]
+    intermittent_fixes = [f for f in fixes if f in ignore_list]
+
+    # Print summary stats
+    print(f"Total tests in current run: {len(current_flat)}")
+    print(f"Total tests in reference: {len(reference_flat)}")
+    print(f"New regressions: {len(real_regressions)}")
+    print(f"Intermittent regressions: {len(intermittent_regressions)}")
+    print(f"Fixed tests: {len(real_fixes)}")
+    print(f"Intermittent fixes: {len(intermittent_fixes)}")
+    print(f"Newly skipped tests: {len(newly_skipped)}")
+    print(f"Newly passing tests (previously skipped): {len(newly_passing)}")
+
+    output_lines = []
+
+    # Report regressions
+    if real_regressions:
+        print("\nREGRESSIONS (non-intermittent failures):", file=sys.stderr)
+        for test in sorted(real_regressions):
+            msg = f"GNU test failed: {test}. {test} is passing on 'main'. Maybe you have to rebase?"
+            print(f"::error ::{msg}", file=sys.stderr)
+            output_lines.append(msg)
+
+    # Report intermittent issues (regressions)
+    if intermittent_regressions:
+        print("\nINTERMITTENT ISSUES (ignored regressions):", file=sys.stderr)
+        for test in sorted(intermittent_regressions):
+            msg = f"Skip an intermittent issue {test} (fails in this run but passes in the 'main' branch)"
+            print(f"::notice ::{msg}", file=sys.stderr)
+            output_lines.append(msg)
+
+    # Report intermittent issues (fixes)
+    if intermittent_fixes:
+        print("\nINTERMITTENT ISSUES (ignored fixes):", file=sys.stderr)
+        for test in sorted(intermittent_fixes):
+            msg = f"Skipping an intermittent issue {test} (passes in this run but fails in the 'main' branch)"
+            print(f"::notice ::{msg}", file=sys.stderr)
+            output_lines.append(msg)
+
+    # Report fixes
+    if real_fixes:
+        print("\nFIXED TESTS:", file=sys.stderr)
+        for test in sorted(real_fixes):
+            msg = f"Congrats! The gnu test {test} is no longer failing!"
+            print(f"::notice ::{msg}", file=sys.stderr)
+            output_lines.append(msg)
+
+    # Report newly skipped and passing tests
+    if newly_skipped:
+        print("\nNEWLY SKIPPED TESTS:", file=sys.stderr)
+        for test in sorted(newly_skipped):
+            msg = f"Note: The gnu test {test} is now being skipped but was previously passing."
+            print(f"::warning ::{msg}", file=sys.stderr)
+            output_lines.append(msg)
+
+    if newly_passing:
+        print("\nNEWLY PASSING TESTS (previously skipped):", file=sys.stderr)
+        for test in sorted(newly_passing):
+            msg = f"Congrats! The gnu test {test} is now passing!"
+            print(f"::notice ::{msg}", file=sys.stderr)
+            output_lines.append(msg)
+
+    if args.output and output_lines:
+        with open(args.output, "w") as f:
+            for line in output_lines:
+                f.write(f"{line}\n")
+
+    # Return exit code based on whether we found regressions
+    return 1 if real_regressions else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/util/deps.nu b/util/deps.nu
new file mode 100644
index 00000000000..368048fff45
--- /dev/null
+++ b/util/deps.nu
@@ -0,0 +1,130 @@
+# This is a script to analyze the dependencies of this project.
+# It is a replacement of / complement to
+#
+#  - cargo tree (used by this script)
+#  - cargo deps
+#  - cargo deny
+#
+# The idea is that by calling all_dep_info, you get a table of all dependencies
+# in Cargo.lock, with a few additional columns based on some other tools.
+# Currently, these tools are
+#
+#  - cargo tree
+#  - the crates.io API
+#
+# The most useful columns in the table are:
+#
+#  - `name`: the name of the crate.
+#  - `version`: the version of the crate.
+#  - `num_versions`: the number of versions in Cargo.lock.
+#  - `normal_dep`: whether the crate is a normal dependency.
+#  - `build_dep`: whether the crate is a build dependency.
+#  - `dev_dep`: whether the crate is a dev dependency.
+#  - `organization`: the GitHub/GitLab organization or user of the repository of the crate.
+#  - `repository_name`: the name of the repository the crate is in. The format is "{owner}/{repo}".
+#  - `dependencies`: direct dependencies of the crate (in the format of Cargo.lock).
+#
+# To use this script, start Nushell (tested only on version 0.82.0), import the library and
+# call `all_dep_info`:
+#
+# ```
+# > nu
+# > use util/deps.nu
+# > let dep = (deps all_dep_info)
+# ```
+#
+# Then you can perform analysis. For example, to group the dependencies by organization:
+#
+# ```
+# > $dep | group-by organization
+# ```
+#
+# Or to find all crates with multiple versions (like cargo deny):
+# ```
+# > $dep | where num_versions > 1
+# ```
+#
+# Ideas to expand this:
+#
+#  - Figure out the whole dependency graph
+#  - Figure out which platforms and which features enable which crates
+#  - Figure out which utils require which crates
+#  - Count the number of crates on different platforms
+#  - Add license information
+#  - Add functions to perform common analyses
+#  - Add info from cargo bloat
+#  - Add MSRV info
+#  - Add up-to-date info (the necessary info is there, it just needs to be derived)
+#  - Check the number of owners/contributors
+#  - Make a webpage to more easily explore the data
+
+# Read the names output by cargo tree
+export def read_tree_names [edge_kind: string, features: list<string>]: any -> table<> {
+    cargo tree --edges $edge_kind --features ($features | str join ",")
+        | parse -r "(?P<name>[a-zA-Z0-9_-]+) v(?P<version>[0-9.]+)"
+}
+
+# Read the crates.io info for a list of crates names
+def read_crates_io [names: list<string>] -> any -> table<> {
+    let total = $names | length
+    $names | enumerate | par-each {|name|
+        print $"($name.index)/($total): ($name.item)"
+        http get $"https://crates.io/api/v1/crates/($name.item)" | get crate
+    }
+}
+
+# Add column for a dependency type
+def add_dep_type [dep_type: string, features: list<string>]: table<> -> table<> {
+    let input_table = $in
+    let table = read_tree_names $dep_type $features
+    $input_table | insert $"($dep_type)_dep" {|outer|
+        $table | any {|inner|
+            $inner.name == $outer.name and $inner.version == $outer.version
+        }
+    }
+}
+
+export def all_dep_info [] {
+    let features = [unix, feat_selinux]
+
+    let lock = open Cargo.lock | from toml | get package
+    
+    $lock
+    # Add number of versions
+    | join ($lock | group-by name | transpose | update column1 { length } | rename name num_versions) name
+    # Add dependency types
+    | add_dep_type normal $features
+    | add_dep_type build $features
+    | add_dep_type dev $features
+    | insert used {|x| $x.normal_dep or $x.build_dep or $x.dev_dep}
+    # Add crates.io info
+    | join (read_crates_io ($lock.name | uniq)) name
+    # Add GH org or user info
+    # The organization is an indicator that crates should be treated as one dependency.
+    # However, there are also unrelated projects by a single organization, so it's not
+    # clear.
+    | insert organization {|x|
+        let repository = $x.repository?
+        if ($repository == null) { "" } else {
+            $repository | url parse | get path | path split | get 1
+        }
+    }
+    # Add repository (truncate everything after repo name)
+    # If we get a url like
+    #  https://github.com/uutils/coreutils/tree/src/uu/ls
+    # we only keep
+    #  uutils/coreutils
+    # The idea is that crates in the same repo definitely belong to the same project and should
+    # be treated as one dependency.
+    | insert repository_name {|x|
+        let repository = $x.repository?
+        if ($repository == null) { '' } else {
+            $repository
+            | url parse
+            | get path
+            | path split
+            | select 1 2
+            | path join
+        }
+    }
+}
diff --git a/util/gnu-json-result.py b/util/gnu-json-result.py
index c1adb3ffc8b..86c2f59d0a6 100644
--- a/util/gnu-json-result.py
+++ b/util/gnu-json-result.py
@@ -9,7 +9,16 @@
 
 out = {}
 
+if len(sys.argv) != 2:
+    print("Usage: python gnu-json-result.py <gnu_test_directory>")
+    sys.exit(1)
+
 test_dir = Path(sys.argv[1])
+if not test_dir.is_dir():
+    print(f"Directory {test_dir} does not exist.")
+    sys.exit(1)
+
+# Test all the logs from the test execution
 for filepath in test_dir.glob("**/*.log"):
     path = Path(filepath)
     current = out
@@ -25,7 +34,7 @@
             )
             if result:
                 current[path.name] = result.group(1)
-    except:
-        pass
+    except Exception as e:
+        print(f"Error processing file {path}: {e}", file=sys.stderr)
 
 print(json.dumps(out, indent=2, sort_keys=True))
diff --git a/util/gnu-patches/series b/util/gnu-patches/series
new file mode 100644
index 00000000000..c4a9cc080b5
--- /dev/null
+++ b/util/gnu-patches/series
@@ -0,0 +1,11 @@
+tests_factor_factor.pl.patch
+tests_cksum_base64.patch
+tests_comm.pl.patch
+tests_cut_error_msg.patch
+tests_dup_source.patch
+tests_env_env-S.pl.patch
+tests_invalid_opt.patch
+tests_ls_no_cap.patch
+tests_sort_merge.pl.patch
+tests_tsort.patch
+tests_du_move_dir_while_traversing.patch
diff --git a/util/gnu-patches/tests_cksum_base64.patch b/util/gnu-patches/tests_cksum_base64.patch
new file mode 100644
index 00000000000..ea6bf92e164
--- /dev/null
+++ b/util/gnu-patches/tests_cksum_base64.patch
@@ -0,0 +1,15 @@
+Index: gnu/tests/cksum/cksum-base64.pl
+===================================================================
+--- gnu.orig/tests/cksum/cksum-base64.pl
++++ gnu/tests/cksum/cksum-base64.pl
+@@ -92,8 +92,8 @@ my $prog = 'cksum';
+ my $fail = run_tests ($program_name, $prog, \@Tests, $save_temps, $verbose);
+ 
+ # Ensure hash names from cksum --help match those in @pairs above.
+-my $help_algs = join ' ', map { m{^  ([[:alpha:]]\S+)} }
+-  grep { m{^  ([[:alpha:]]\S+)} } split ('\n', `cksum --help`);
++my $help_algs = join ' ', map { m{^\s*-\s*([[:alpha:]]\S+):} ? $1 : () }
++   grep { m{^\s*-\s*([[:alpha:]]\S+):} } split ('\n', `cksum --help`);
+ my $test_algs = join ' ', map {$_->[0]} @pairs;
+ $help_algs eq $test_algs or die "$help_algs not equal to\n$test_algs";
+ 
diff --git a/util/gnu-patches/tests_comm.pl.patch b/util/gnu-patches/tests_comm.pl.patch
new file mode 100644
index 00000000000..602071f483a
--- /dev/null
+++ b/util/gnu-patches/tests_comm.pl.patch
@@ -0,0 +1,44 @@
+Index: gnu/tests/misc/comm.pl
+===================================================================
+--- gnu.orig/tests/misc/comm.pl
++++ gnu/tests/misc/comm.pl
+@@ -73,18 +73,24 @@ my @Tests =
+ 
+    # invalid missing command line argument (1)
+    ['missing-arg1', $inputs[0], {EXIT=>1},
+-    {ERR => "$prog: missing operand after 'a'\n"
+-        . "Try '$prog --help' for more information.\n"}],
++    {ERR => "error: the following required arguments were not provided:\n"
++        . "  <FILE2>\n\n"
++        . "Usage: $prog [OPTION]... FILE1 FILE2\n\n"
++        . "For more information, try '--help'.\n"}],
+ 
+    # invalid missing command line argument (both)
+    ['missing-arg2', {EXIT=>1},
+-    {ERR => "$prog: missing operand\n"
+-        . "Try '$prog --help' for more information.\n"}],
++    {ERR => "error: the following required arguments were not provided:\n"
++        . "  <FILE1>\n"
++        . "  <FILE2>\n\n"
++        . "Usage: $prog [OPTION]... FILE1 FILE2\n\n"
++        . "For more information, try '--help'.\n"}],
+ 
+    # invalid extra command line argument
+    ['extra-arg', @inputs, 'no-such', {EXIT=>1},
+-    {ERR => "$prog: extra operand 'no-such'\n"
+-        . "Try '$prog --help' for more information.\n"}],
++    {ERR => "error: unexpected argument 'no-such' found\n\n"
++        . "Usage: $prog [OPTION]... FILE1 FILE2\n\n"
++        . "For more information, try '--help'.\n"}],
+ 
+    # out-of-order input
+    ['ooo', {IN=>{a=>"1\n3"}}, {IN=>{b=>"3\n2"}}, {EXIT=>1},
+@@ -163,7 +169,7 @@ my @Tests =
+ 
+    # invalid dual delimiter
+    ['delim-dual', '--output-delimiter=,', '--output-delimiter=+', @inputs,
+-    {EXIT=>1}, {ERR => "$prog: multiple output delimiters specified\n"}],
++    {EXIT=>1}, {ERR => "$prog: multiple conflicting output delimiters specified\n"}],
+ 
+    # valid dual delimiter specification
+    ['delim-dual2', '--output-delimiter=,', '--output-delimiter=,', @inputs,
diff --git a/util/gnu-patches/tests_cut_error_msg.patch b/util/gnu-patches/tests_cut_error_msg.patch
new file mode 100644
index 00000000000..1b1673fef72
--- /dev/null
+++ b/util/gnu-patches/tests_cut_error_msg.patch
@@ -0,0 +1,72 @@
+Index: gnu/tests/cut/cut.pl
+===================================================================
+--- gnu.orig/tests/cut/cut.pl
++++ gnu/tests/cut/cut.pl
+@@ -29,13 +29,15 @@ my $mb_locale = $ENV{LOCALE_FR_UTF8};
+ 
+ my $prog = 'cut';
+ my $try = "Try '$prog --help' for more information.\n";
+-my $from_field1 = "$prog: fields are numbered from 1\n$try";
+-my $from_pos1 =   "$prog: byte/character positions are numbered from 1\n$try";
+-my $inval_fld = "$prog: invalid field range\n$try";
+-my $inval_pos = "$prog: invalid byte or character range\n$try";
+-my $no_endpoint = "$prog: invalid range with no endpoint: -\n$try";
+-my $nofield = "$prog: an input delimiter may be specified only when " .
+-              "operating on fields\n$try";
++my $from_field1 = "$prog: range '' was invalid: failed to parse range\n";
++my $from_field_0 = "$prog: range '0' was invalid: fields and positions are numbered from 1\n";
++my $from_field_0_dash = "$prog: range '0-' was invalid: fields and positions are numbered from 1\n";
++my $from_field_0_2 = "$prog: range '0-2' was invalid: fields and positions are numbered from 1\n";
++my $from_pos1 =   "$prog: range '' was invalid: failed to parse range\n";
++my $inval_fld = "$prog: range '--' was invalid: failed to parse range\n";
++my $inval_pos = "$prog: range '--' was invalid: failed to parse range\n";
++my $no_endpoint = "$prog: range '-' was invalid: invalid range with no endpoint\n";
++my $nofield = "$prog: invalid input: The '--delimiter' ('-d') option only usable if printing a sequence of fields\n";
+ 
+ my @Tests =
+  (
+@@ -44,16 +46,16 @@ my @Tests =
+ 
+   # This failed (as it should) even before coreutils-6.9.90,
+   # but cut from 6.9.90 produces a more useful diagnostic.
+-  ['zero-1', '-b0',   {ERR=>$from_pos1}, {EXIT => 1} ],
++  ['zero-1', '-b0',   {ERR=>$from_field_0}, {EXIT => 1} ],
+ 
+   # Up to coreutils-6.9, specifying a range of 0-2 was not an error.
+   # It was treated just like "-2".
+-  ['zero-2', '-f0-2', {ERR=>$from_field1}, {EXIT => 1} ],
++  ['zero-2', '-f0-2', {ERR=>$from_field_0_2}, {EXIT => 1} ],
+ 
+   # Up to coreutils-8.20, specifying a range of 0- was not an error.
+-  ['zero-3b', '-b0-', {ERR=>$from_pos1}, {EXIT => 1} ],
+-  ['zero-3c', '-c0-', {ERR=>$from_pos1}, {EXIT => 1} ],
+-  ['zero-3f', '-f0-', {ERR=>$from_field1}, {EXIT => 1} ],
++  ['zero-3b', '-b0-', {ERR=>$from_field_0_dash}, {EXIT => 1} ],
++  ['zero-3c', '-c0-', {ERR=>$from_field_0_dash}, {EXIT => 1} ],
++  ['zero-3f', '-f0-', {ERR=>$from_field_0_dash}, {EXIT => 1} ],
+ 
+   ['1', '-d:', '-f1,3-', {IN=>"a:b:c\n"}, {OUT=>"a:c\n"}],
+   ['2', '-d:', '-f1,3-', {IN=>"a:b:c\n"}, {OUT=>"a:c\n"}],
+@@ -96,11 +98,10 @@ my @Tests =
+   # Errors
+   # -s may be used only with -f
+   ['y', qw(-s -b4), {IN=>":\n"}, {OUT=>""}, {EXIT=>1},
+-   {ERR=>"$prog: suppressing non-delimited lines makes sense\n"
+-    . "\tonly when operating on fields\n$try"}],
++   {ERR=>"$prog: invalid input: The '--only-delimited' ('-s') option only usable if printing a sequence of fields\n"}],
+   # You must specify bytes or fields (or chars)
+   ['z', '', {IN=>":\n"}, {OUT=>""}, {EXIT=>1},
+-   {ERR=>"$prog: you must specify a list of bytes, characters, or fields\n$try"}
++   {ERR=>"$prog: invalid usage: expects one of --fields (-f), --chars (-c) or --bytes (-b)\n"}
+   ],
+   # Empty field list
+   ['empty-fl', qw(-f ''), {IN=>":\n"}, {OUT=>""}, {EXIT=>1},
+@@ -199,7 +200,7 @@ my @Tests =
+ 
+   # None of the following invalid ranges provoked an error up to coreutils-6.9.
+   ['inval1', qw(-f 2-0), {IN=>''}, {OUT=>''}, {EXIT=>1},
+-   {ERR=>"$prog: invalid decreasing range\n$try"}],
++   {ERR=>"$prog: range '2-0' was invalid: fields and positions are numbered from 1\n"}],
+   ['inval2', qw(-f -), {IN=>''}, {OUT=>''}, {EXIT=>1}, {ERR=>$no_endpoint}],
+   ['inval3', '-f', '4,-', {IN=>''}, {OUT=>''}, {EXIT=>1}, {ERR=>$no_endpoint}],
+   ['inval4', '-f', '1-2,-', {IN=>''}, {OUT=>''}, {EXIT=>1},
diff --git a/util/gnu-patches/tests_du_move_dir_while_traversing.patch b/util/gnu-patches/tests_du_move_dir_while_traversing.patch
new file mode 100644
index 00000000000..12b7e5c36df
--- /dev/null
+++ b/util/gnu-patches/tests_du_move_dir_while_traversing.patch
@@ -0,0 +1,16 @@
+Index: gnu/tests/du/move-dir-while-traversing.sh
+===================================================================
+--- gnu.orig/tests/du/move-dir-while-traversing.sh
++++ gnu/tests/du/move-dir-while-traversing.sh
+@@ -91,9 +91,7 @@ retry_delay_ nonempty .1 5 || fail=1
+ # Before coreutils-8.10, du would abort.
+ returns_ 1 du -a $t d2 2> err || fail=1
+ 
+-# check for the new diagnostic
+-printf "du: fts_read failed: $t/3/a/b: No such file or directory\n" > exp \
+-  || fail=1
+-compare exp err || fail=1
++# check that it doesn't crash
++grep -Pq "^du: cannot read directory '$t/3/a/b.*': No such file or directory" err || fail=1
+ 
+ Exit $fail
diff --git a/util/gnu-patches/tests_dup_source.patch b/util/gnu-patches/tests_dup_source.patch
new file mode 100644
index 00000000000..4c24498253d
--- /dev/null
+++ b/util/gnu-patches/tests_dup_source.patch
@@ -0,0 +1,13 @@
+Index: gnu/tests/mv/dup-source.sh
+===================================================================
+--- gnu.orig/tests/mv/dup-source.sh
++++ gnu/tests/mv/dup-source.sh
+@@ -83,7 +83,7 @@ $i: cannot stat 'a': No such file or dir
+ $i: cannot stat 'a': No such file or directory
+ $i: cannot stat 'b': No such file or directory
+ $i: cannot move './b' to a subdirectory of itself, 'b/b'
+-$i: warning: source directory 'b' specified more than once
++$i: cannot move 'b' to a subdirectory of itself, 'b/b'
+ EOF
+   compare exp out || fail=1
+ done
diff --git a/util/gnu-patches/tests_env_env-S.pl.patch b/util/gnu-patches/tests_env_env-S.pl.patch
new file mode 100644
index 00000000000..1ea860fa07f
--- /dev/null
+++ b/util/gnu-patches/tests_env_env-S.pl.patch
@@ -0,0 +1,47 @@
+Index: gnu/tests/env/env-S.pl
+===================================================================
+--- gnu.orig/tests/env/env-S.pl
++++ gnu/tests/env/env-S.pl
+@@ -212,27 +212,28 @@ my @Tests =
+       {ERR=>"$prog: no terminating quote in -S string\n"}],
+      ['err5', q[-S'A=B\\q'], {EXIT=>125},
+       {ERR=>"$prog: invalid sequence '\\q' in -S\n"}],
+-     ['err6', q[-S'A=$B'], {EXIT=>125},
+-      {ERR=>"$prog: only \${VARNAME} expansion is supported, error at: \$B\n"}],
++     ['err6', q[-S'A=$B echo hello'], {EXIT=>0},
++      {OUT=>"hello"}],
+      ['err7', q[-S'A=${B'], {EXIT=>125},
+-      {ERR=>"$prog: only \${VARNAME} expansion is supported, " .
+-           "error at: \${B\n"}],
++      {ERR=>"$prog" . qq[: variable name issue (at 5): Missing closing brace\n]}],
+      ['err8', q[-S'A=${B%B}'], {EXIT=>125},
+-      {ERR=>"$prog: only \${VARNAME} expansion is supported, " .
+-           "error at: \${B%B}\n"}],
++      {ERR=>"$prog" . qq[: variable name issue (at 5): Unexpected character: '%', expected a closing brace ('}') or colon (':')\n]}],
+      ['err9', q[-S'A=${9B}'], {EXIT=>125},
+-      {ERR=>"$prog: only \${VARNAME} expansion is supported, " .
+-           "error at: \${9B}\n"}],
++      {ERR=>"$prog" . qq[: variable name issue (at 4): Unexpected character: '9', expected variable name must not start with 0..9\n]}],
+ 
+      # Test incorrect shebang usage (extraneous whitespace).
+      ['err_sp2', q['-v -S cat -n'], {EXIT=>125},
+-      {ERR=>"env: invalid option -- ' '\n" .
+-            "env: use -[v]S to pass options in shebang lines\n" .
+-           "Try 'env --help' for more information.\n"}],
++      {ERR=>"$prog: error: unexpected argument '- ' found\n\n" .
++            "  tip: to pass '- ' as a value, use '-- - '\n\n" .
++            "Usage: $prog [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]\n\n" .
++            "For more information, try '--help'.\n" .
++            "$prog: use -[v]S to pass options in shebang lines\n"}],
+      ['err_sp3', q['-v	-S cat -n'], {EXIT=>125}, # embedded tab after -v
+-      {ERR=>"env: invalid option -- '\t'\n" .
+-            "env: use -[v]S to pass options in shebang lines\n" .
+-           "Try 'env --help' for more information.\n"}],
++      {ERR=>"$prog: error: unexpected argument '-\t' found\n\n" .
++            "  tip: to pass '-\t' as a value, use '-- -\t'\n\n" .
++            "Usage: $prog [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]\n\n" .
++            "For more information, try '--help'.\n" .
++            "$prog: use -[v]S to pass options in shebang lines\n"}],
+ 
+      # Also diagnose incorrect shebang usage when failing to exec.
+      # This typically happens with:
diff --git a/util/gnu-patches/tests_factor_factor.pl.patch b/util/gnu-patches/tests_factor_factor.pl.patch
new file mode 100644
index 00000000000..892d526964e
--- /dev/null
+++ b/util/gnu-patches/tests_factor_factor.pl.patch
@@ -0,0 +1,22 @@
+Index: gnu/tests/factor/factor.pl
+===================================================================
+--- gnu.orig/tests/factor/factor.pl
++++ gnu/tests/factor/factor.pl
+@@ -61,12 +61,14 @@ my @Tests =
+       # Map newer glibc diagnostic to expected.
+       # Also map OpenBSD 5.1's "unknown option" to expected "invalid option".
+       {ERR_SUBST => q!s/'1'/1/;s/unknown/invalid/!},
+-      {ERR => "$prog: invalid option -- 1\n"
+-       . "Try '$prog --help' for more information.\n"},
++      {ERR => "error: unexpected argument '-1' found\n\n"
++        . "  tip: to pass '-1' as a value, use '-- -1'\n\n"
++        . "Usage: factor [OPTION]... [NUMBER]...\n\n"
++        . "For more information, try '--help'.\n"},
+       {EXIT => 1}],
+      ['cont', 'a 4',
+       {OUT => "4: 2 2\n"},
+-      {ERR => "$prog: 'a' is not a valid positive integer\n"},
++      {ERR => "$prog: warning: a: invalid digit found in string\n"},
+       {EXIT => 1}],
+      ['bug-2012-a', '465658903', {OUT => '15259 30517'}],
+      ['bug-2012-b', '2242724851', {OUT => '33487 66973'}],
diff --git a/util/gnu-patches/tests_invalid_opt.patch b/util/gnu-patches/tests_invalid_opt.patch
new file mode 100644
index 00000000000..c23476674e7
--- /dev/null
+++ b/util/gnu-patches/tests_invalid_opt.patch
@@ -0,0 +1,32 @@
+Index: gnu/tests/misc/invalid-opt.pl
+===================================================================
+--- gnu.orig/tests/misc/invalid-opt.pl
++++ gnu/tests/misc/invalid-opt.pl
+@@ -74,23 +74,13 @@ foreach my $prog (@built_programs)
+     defined $out
+       or $out = '';
+ 
+-    my $err = $expected_err{$prog};
+-    defined $err
+-      or $err = $x == 0 ? '' : "$prog: invalid option -- /\n$try";
+-
+-    # Accommodate different syntax in glibc's getopt
+-    # diagnostics by filtering out single quotes.
+-    # Also accommodate BSD getopt.
+-    my $err_subst = "s,'/',/,; s,unknown,invalid,";
+-
+-    # Depending on how this script is run, stty emits different
+-    # diagnostics.  Don't bother checking them.
+-    $prog eq 'stty'
+-      and $err_subst = 's/(.|\n)*//ms';
++    # Strip all stderr output
++    # Our output is better and more consistent
++    my $err_subst = 's/(.|\n)*//ms';
+ 
+     my @Tests = (["$prog-invalid-opt", '-/', {OUT=>$out},
+                   {ERR_SUBST => $err_subst},
+-                  {EXIT=>$x}, {ERR=>$err}]);
++                  {EXIT=>$x}]);
+ 
+     my $save_temps = $ENV{DEBUG};
+     my $verbose = $ENV{VERBOSE};
diff --git a/util/gnu-patches/tests_ls_no_cap.patch b/util/gnu-patches/tests_ls_no_cap.patch
new file mode 100644
index 00000000000..8e36512ae9c
--- /dev/null
+++ b/util/gnu-patches/tests_ls_no_cap.patch
@@ -0,0 +1,20 @@
+diff --git a/tests/ls/no-cap.sh b/tests/ls/no-cap.sh
+index 99f0563bc..f7b9e7885 100755
+--- a/tests/ls/no-cap.sh
++++ b/tests/ls/no-cap.sh
+@@ -27,11 +27,11 @@ setcap 'cap_net_bind_service=ep' file ||
+   skip_ "setcap doesn't work"
+ 
+ LS_COLORS=ca=1; export LS_COLORS
+-strace -e capget ls --color=always > /dev/null 2> out || fail=1
+-$EGREP 'capget\(' out || skip_ "your ls doesn't call capget"
++strace -e llistxattr ls --color=always > /dev/null 2> out || fail=1
++$EGREP 'llistxattr\(' out || skip_ "your ls doesn't call llistxattr"
+ 
+ LS_COLORS=ca=:; export LS_COLORS
+-strace -e capget ls --color=always > /dev/null 2> out || fail=1
+-$EGREP 'capget\(' out && fail=1
++strace -e llistxattr ls --color=always > /dev/null 2> out || fail=1
++$EGREP 'llistxattr\(' out && fail=1
+ 
+ Exit $fail
diff --git a/util/gnu-patches/tests_sort_merge.pl.patch b/util/gnu-patches/tests_sort_merge.pl.patch
new file mode 100644
index 00000000000..d6db2e09c60
--- /dev/null
+++ b/util/gnu-patches/tests_sort_merge.pl.patch
@@ -0,0 +1,32 @@
+Index: gnu/tests/sort/sort-merge.pl
+===================================================================
+--- gnu.orig/tests/sort/sort-merge.pl
++++ gnu/tests/sort/sort-merge.pl
+@@ -43,22 +43,22 @@ my @Tests =
+      # check validation of --batch-size option
+      ['nmerge-0', "-m --batch-size=0", @inputs,
+         {ERR=>"$prog: invalid --batch-size argument '0'\n".
+-              "$prog: minimum --batch-size argument is '2'\n"}, {EXIT=>2}],
++              "$prog: minimum --batch-size argument is '2'\nTry 'sort --help' for more information.\n"}, {EXIT=>2}],
+ 
+      ['nmerge-1', "-m --batch-size=1", @inputs,
+         {ERR=>"$prog: invalid --batch-size argument '1'\n".
+-              "$prog: minimum --batch-size argument is '2'\n"}, {EXIT=>2}],
++              "$prog: minimum --batch-size argument is '2'\nTry 'sort --help' for more information.\n"}, {EXIT=>2}],
+ 
+      ['nmerge-neg', "-m --batch-size=-1", @inputs,
+-        {ERR=>"$prog: invalid --batch-size argument '-1'\n"}, {EXIT=>2}],
++        {ERR=>"$prog: invalid --batch-size argument '-1'\nTry 'sort --help' for more information.\n"}, {EXIT=>2}],
+ 
+      ['nmerge-nan', "-m --batch-size=a", @inputs,
+-        {ERR=>"$prog: invalid --batch-size argument 'a'\n"}, {EXIT=>2}],
++        {ERR=>"$prog: invalid --batch-size argument 'a'\nTry 'sort --help' for more information.\n"}, {EXIT=>2}],
+ 
+      ['nmerge-big', "-m --batch-size=$bigint", @inputs,
+         {ERR_SUBST=>'s/(current rlimit is) \d+/$1/'},
+         {ERR=>"$prog: --batch-size argument '$bigint' too large\n".
+-              "$prog: maximum --batch-size argument with current rlimit is\n"},
++              "$prog: maximum --batch-size argument with current rlimit is\nTry 'sort --help' for more information.\n"},
+         {EXIT=>2}],
+ 
+      # This should work since nmerge >= the number of input files
diff --git a/util/gnu-patches/tests_tsort.patch b/util/gnu-patches/tests_tsort.patch
new file mode 100644
index 00000000000..1084f97043a
--- /dev/null
+++ b/util/gnu-patches/tests_tsort.patch
@@ -0,0 +1,17 @@
+Index: gnu/tests/misc/tsort.pl
+===================================================================
+--- gnu.orig/tests/misc/tsort.pl
++++ gnu/tests/misc/tsort.pl
+@@ -54,8 +54,10 @@ my @Tests =
+ 
+    ['only-one', {IN => {f => ""}}, {IN => {g => ""}},
+     {EXIT => 1},
+-    {ERR => "tsort: extra operand 'g'\n"
+-     . "Try 'tsort --help' for more information.\n"}],
++    {ERR => "error: unexpected argument 'g' found\n\n"
++         . "Usage: tsort [OPTIONS] FILE\n\n"
++         . "For more information, try '--help'.\n"
++    }],
+   );
+ 
+ my $save_temps = $ENV{DEBUG};
diff --git a/util/publish.sh b/util/publish.sh
index 71830f1f915..880e82e19a2 100755
--- a/util/publish.sh
+++ b/util/publish.sh
@@ -5,6 +5,22 @@ if test "$1" != "--do-it"; then
     ARG="--dry-run --allow-dirty"
 fi
 
+# Function to check if the crate is already published
+is_already_published() {
+    local crate_name=$1
+    local crate_version=$2
+
+    # Use the crates.io API to get the latest version of the crate
+    local latest_published_version
+    latest_published_version=$(curl -s https://crates.io/api/v1/crates/$crate_name | jq -r '.crate.max_version')
+
+    if [ "$latest_published_version" = "$crate_version" ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
 # Figure out any dependencies between the util via Cargo.toml
 # We store this as edges in a graph with each line:
 # [dependent] [dependency]
@@ -35,12 +51,19 @@ TOTAL_ORDER=$(echo -e $PARTIAL_ORDER | tsort | tac)
 # Remove the ROOT node from the start
 TOTAL_ORDER=${TOTAL_ORDER#ROOT}
 
+CRATE_VERSION=$(grep '^version =' Cargo.toml | head -n1 | cut -d '"' -f2)
+
 set -e
-for dir in src/uuhelp_parser/ 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/ tests/uutests/; do
     (
         cd "$dir"
+        CRATE_NAME=$(grep '^name =' "Cargo.toml" | head -n1 | cut -d '"' -f2)
         #shellcheck disable=SC2086
-        cargo publish $ARG
+        if ! is_already_published "$CRATE_NAME" "$CRATE_VERSION"; then
+            cargo publish $ARG
+        else
+            echo "Skip: $CRATE_NAME $CRATE_VERSION already published"
+        fi
     )
     sleep 2s
 done
@@ -48,8 +71,13 @@ done
 for p in $TOTAL_ORDER; do
     (
         cd "src/uu/$p"
+        CRATE_NAME=$(grep '^name =' "Cargo.toml" | head -n1 | cut -d '"' -f2)
         #shellcheck disable=SC2086
-        cargo publish $ARG
+        if ! is_already_published "$CRATE_NAME" "$CRATE_VERSION"; then
+            cargo publish $ARG
+        else
+            echo "Skip: $CRATE_NAME $CRATE_VERSION already published"
+        fi
     )
 done
 
diff --git a/util/remaining-gnu-error.py b/util/remaining-gnu-error.py
index 5fd47300ab2..809665dc950 100755
--- a/util/remaining-gnu-error.py
+++ b/util/remaining-gnu-error.py
@@ -11,10 +11,21 @@
 import sys
 
 base = "../gnu/tests/"
-urllib.request.urlretrieve(
-    "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/gnu-full-result.json",
-    "result.json",
-)
+
+# Try to download the file, use local copy if download fails
+result_json = "result.json"
+try:
+    urllib.request.urlretrieve(
+        "https://raw.githubusercontent.com/uutils/coreutils-tracking/main/aggregated-result.json",
+        result_json,
+    )
+except Exception as e:
+    print(f"Failed to download the file: {e}")
+    if not os.path.exists(result_json):
+        print(f"Local file '{result_json}' not found. Exiting.")
+        sys.exit(1)
+    else:
+        print(f"Using local file '{result_json}'.")
 
 types = ("/*/*.sh", "/*/*.pl", "/*/*.xpl")
 
@@ -28,16 +39,27 @@
 list_of_files = sorted(tests, key=lambda x: os.stat(x).st_size)
 
 
-def show_list(l):
+def show_list(list_test):
     # Remove the factor tests and reverse the list (bigger first)
-    tests = list(filter(lambda k: "factor" not in k, l))
+    tests = list(filter(lambda k: "factor" not in k, list_test))
 
     for f in reversed(tests):
-        print("%s: %s" % (f, os.stat(f).st_size))
+        if contains_require_root(f):
+            print("%s: %s / require_root" % (f, os.stat(f).st_size))
+        else:
+            print("%s: %s" % (f, os.stat(f).st_size))
     print("")
     print("%s tests remaining" % len(tests))
 
 
+def contains_require_root(file_path):
+    try:
+        with open(file_path, "r") as file:
+            return "require_root_" in file.read()
+    except IOError:
+        return False
+
+
 with open("result.json", "r") as json_file:
     data = json.load(json_file)
 
diff --git a/util/run-gnu-test.sh b/util/run-gnu-test.sh
index 55ba8cefc28..7fa52f84ee0 100755
--- a/util/run-gnu-test.sh
+++ b/util/run-gnu-test.sh
@@ -1,13 +1,27 @@
-#!/bin/sh
+#!/usr/bin/env bash
 # `run-gnu-test.bash [TEST]`
 # run GNU test (or all tests if TEST is missing/null)
 
-# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS ; (utils) shellcheck
+# spell-checker:ignore (env/vars) GNULIB SRCDIR SUBDIRS OSTYPE ; (utils) shellcheck gnproc greadlink
 
 # ref: [How the GNU coreutils are tested](https://www.pixelbeat.org/docs/coreutils-testing.html) @@ <https://archive.is/p2ITW>
 # * note: to run a single test => `make check TESTS=PATH/TO/TEST/SCRIPT SUBDIRS=. VERBOSE=yes`
 
-ME_dir="$(dirname -- "$(readlink -fm -- "$0")")"
+# Use GNU version for make, nproc, readlink on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        MAKE="gmake"
+        NPROC="gnproc"
+        READLINK="greadlink"
+        ;;
+    *)
+        MAKE="make"
+        NPROC="nproc"
+        READLINK="readlink"
+        ;;
+esac
+
+ME_dir="$(dirname -- "$("${READLINK}" -fm -- "$0")")"
 REPO_main_dir="$(dirname -- "${ME_dir}")"
 
 echo "ME_dir='${ME_dir}'"
@@ -18,7 +32,7 @@ set -e
 ### * config (from environment with fallback defaults); note: GNU and GNULIB are expected to be sibling repo directories
 
 path_UUTILS=${path_UUTILS:-${REPO_main_dir}}
-path_GNU="$(readlink -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
+path_GNU="$("${READLINK}" -fm -- "${path_GNU:-${path_UUTILS}/../gnu}")"
 
 echo "path_UUTILS='${path_UUTILS}'"
 echo "path_GNU='${path_GNU}'"
@@ -29,15 +43,47 @@ cd "${path_GNU}" && echo "[ pwd:'${PWD}' ]"
 
 export RUST_BACKTRACE=1
 
+# Determine if we have SELinux tests
+has_selinux_tests=false
 if test $# -ge 1; then
-    # if set, run only the tests passed
-    SPECIFIC_TESTS=""
     for t in "$@"; do
-        SPECIFIC_TESTS="$SPECIFIC_TESTS $t"
+        if [[ "$t" == *"selinux"* ]]; then
+                has_selinux_tests=true
+                break
+        fi
     done
-    # trim it
-    SPECIFIC_TESTS=$(echo $SPECIFIC_TESTS | xargs)
-    echo "Running specific tests: $SPECIFIC_TESTS"
+fi
+
+if [[ "$1" == "run-root" && "$has_selinux_tests" == true ]]; then
+    # Handle SELinux root tests separately
+    shift
+    if test -n "$CI"; then
+        echo "Running SELinux tests as root"
+        # Don't use check-root here as the upstream root tests is hardcoded
+        sudo "${MAKE}" -j "$("${NPROC}")" check TESTS="$*" 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
+    exit 0
+elif test "$1" != "run-root"; then
+    if test $# -ge 1; then
+        # if set, run only the tests passed
+        SPECIFIC_TESTS=""
+        for t in "$@"; do
+
+            # Construct the full path
+            full_path="$path_GNU/$t"
+
+            # Check if the file exists with .sh, .pl extension or without any extension in the $path_GNU directory
+            if [ -f "$full_path" ] || [ -f "$full_path.sh" ] || [ -f "$full_path.pl" ]; then
+                SPECIFIC_TESTS="$SPECIFIC_TESTS $t"
+            else
+                echo "Error: Test file $full_path, $full_path.sh, or $full_path.pl does not exist!"
+                exit 1
+            fi
+        done
+        # trim it
+        SPECIFIC_TESTS=$(echo "$SPECIFIC_TESTS" | xargs)
+        echo "Running specific tests: $SPECIFIC_TESTS"
+    fi
 fi
 
 # * timeout used to kill occasionally errant/"stuck" processes (note: 'release' testing takes ~1 hour; 'debug' testing takes ~2.5 hours)
@@ -48,16 +94,21 @@ fi
 if test "$1" != "run-root"; then
     # run the regular tests
     if test $# -ge 1; then
-        timeout -sKILL 4h make -j "$(nproc)" check TESTS="$SPECIFIC_TESTS" SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
+        timeout -sKILL 4h "${MAKE}" -j "$("${NPROC}")" check TESTS="$SPECIFIC_TESTS" SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
     else
-        timeout -sKILL 4h make -j "$(nproc)" check SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
+        timeout -sKILL 4h "${MAKE}" -j "$("${NPROC}")" check SUBDIRS=. RUN_EXPENSIVE_TESTS=yes RUN_VERY_EXPENSIVE_TESTS=yes VERBOSE=no gl_public_submodule_commit="" srcdir="${path_GNU}" || : # Kill after 4 hours in case something gets stuck in make
     fi
 else
     # in case we would like to run tests requiring root
     if test -z "$1" -o "$1" == "run-root"; then
         if test -n "$CI"; then
-            echo "Running check-root to run only root tests"
-            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" || :
+            if test $# -ge 2; then
+                echo "Running check-root to run only root tests"
+                sudo "${MAKE}" -j "$("${NPROC}")" check-root TESTS="$2" 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" || :
+            else
+                echo "Running check-root to run only root tests"
+                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
 fi
diff --git a/util/show-code_coverage.BAT b/util/show-code_coverage.BAT
deleted file mode 100644
index 222fff382c0..00000000000
--- a/util/show-code_coverage.BAT
+++ /dev/null
@@ -1,16 +0,0 @@
-@setLocal
-@echo off
-
-@rem:: # spell-checker:ignore (shell/CMD) COMSPEC ERRORLEVEL
-
-set "ME_dir=%~dp0."
-set "REPO_main_dir=%ME_dir%\.."
-
-set "ERRORLEVEL="
-set "COVERAGE_REPORT_DIR=%REPO_main_dir%\target\debug\coverage-win"
-
-call "%ME_dir%\build-code_coverage.BAT"
-if ERRORLEVEL 1 goto _undefined_ 2>NUL || @for %%G in ("%COMSPEC%") do @title %%nG & @"%COMSPEC%" /d/c exit %ERRORLEVEL%
-
-call start "" "%COVERAGE_REPORT_DIR%"\index.html
-if ERRORLEVEL 1 goto _undefined_ 2>NUL || @for %%G in ("%COMSPEC%") do @title %%nG & @"%COMSPEC%" /d/c exit %ERRORLEVEL%
diff --git a/util/show-code_coverage.sh b/util/show-code_coverage.sh
deleted file mode 100755
index 3f51462c904..00000000000
--- a/util/show-code_coverage.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/sh
-
-# spell-checker:ignore (vars) OSID binfmt
-
-ME="${0}"
-ME_dir="$(dirname -- "$(readlink -fm -- "${ME}")")"
-REPO_main_dir="$(dirname -- "${ME_dir}")"
-
-export COVERAGE_REPORT_DIR="${REPO_main_dir}/target/debug/coverage-nix"
-
-if ! "${ME_dir}/build-code_coverage.sh"; then exit 1; fi
-
-# WSL?
-if [ -z "${OSID_tags}" ]; then
-    if [ -e '/proc/sys/fs/binfmt_misc/WSLInterop' ] && (grep '^enabled$' '/proc/sys/fs/binfmt_misc/WSLInterop' >/dev/null); then
-        __="wsl"
-        case ";${OSID_tags};" in ";;") OSID_tags="$__" ;; *";$__;"*) ;; *) OSID_tags="$__;$OSID_tags" ;; esac
-        unset __
-        # Windows version == <major>.<minor>.<build>.<revision>
-        # Release ID; see [Release ID/Version vs Build](https://winreleaseinfoprod.blob.core.windows.net/winreleaseinfoprod/en-US.html)[`@`](https://archive.is/GOj1g)
-        OSID_wsl_build="$(uname -r | sed 's/^[0-9.][0-9.]*-\([0-9][0-9]*\)-.*$/\1/g')"
-        OSID_wsl_revision="$(uname -v | sed 's/^#\([0-9.][0-9.]*\)-.*$/\1/g')"
-        export OSID_wsl_build OSID_wsl_revision
-    fi
-fi
-
-case ";${OSID_tags};" in
-    *";wsl;"*) powershell.exe -c "$(wslpath -w "${COVERAGE_REPORT_DIR}"/index.html)" ;;
-    *) xdg-open --version >/dev/null 2>&1 && xdg-open "${COVERAGE_REPORT_DIR}"/index.html || echo "report available at '\"${COVERAGE_REPORT_DIR}\"/index.html'" ;;
-esac
diff --git a/util/show-utils.BAT b/util/show-utils.BAT
index 9fa5e2ffae4..f6d9007349c 100644
--- a/util/show-utils.BAT
+++ b/util/show-utils.BAT
@@ -2,7 +2,7 @@
 @echo off
 
 @rem ::# spell-checker:ignore (CMD) ERRORLEVEL
-@rem ::# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath relpath rmdir shuf tsort unexpand
+@rem ::# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath rmdir shuf tsort unexpand
 @rem ::# spell-checker:ignore (jq) deps startswith
 
 set "ME=%~0"
@@ -12,7 +12,7 @@ set "ME_parent_dir=%~dp0.\.."
 @rem refs: <https://forge.rust-lang.org/release/platform-support.html> , <https://docs.rs/platforms/0.2.1/platforms/platform/tier1/index.html>
 
 @rem :: default ("Tier 1" cross-platform) utility list
-set "default_utils=base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath relpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
+set "default_utils=base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
 
 set "project_dir=%ME_parent_dir%"
 cd "%project_dir%"
diff --git a/util/show-utils.sh b/util/show-utils.sh
index b6a0f9856d8..0a41698d930 100755
--- a/util/show-utils.sh
+++ b/util/show-utils.sh
@@ -1,18 +1,28 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
-# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath relpath rmdir shuf tsort unexpand
+# spell-checker:ignore (shell) OSTYPE
+# spell-checker:ignore (utils) cksum coreutils dircolors hashsum mkdir mktemp printenv printf readlink realpath grealpath rmdir shuf tsort unexpand
 # spell-checker:ignore (jq) deps startswith
 
+# Use GNU version for realpath on *BSD
+case "$OSTYPE" in
+    *bsd*)
+        REALPATH="grealpath"
+        ;;
+    *)
+        REALPATH="realpath"
+        ;;
+esac
+
 ME="${0}"
 ME_dir="$(dirname -- "${ME}")"
 ME_parent_dir="$(dirname -- "${ME_dir}")"
-# NOTE: On FreeBSD, `-mP` arguments are not available.
-ME_parent_dir_abs="$(realpath -mP -- "${ME_parent_dir}" || realpath -- "${ME_parent_dir}")"
+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>
 
 # default ("Tier 1" cross-platform) utility list
-default_utils="base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath relpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
+default_utils="base32 base64 basename cat cksum comm cp cut date dircolors dirname echo env expand expr factor false fmt fold hashsum head join link ln ls mkdir mktemp more mv nl od paste printenv printf ptx pwd readlink realpath rm rmdir seq shred shuf sleep sort split sum tac tail tee test tr true truncate tsort unexpand uniq wc yes"
 
 project_main_dir="${ME_parent_dir_abs}"
 # printf 'project_main_dir="%s"\n' "${project_main_dir}"
@@ -23,6 +33,10 @@ 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(\" \")"
+    # Find 'coreutils' id with regex
+    # with cargo v1.76.0, id = "coreutils 0.0.26 (path+file://<coreutils local directory>)"
+    # with cargo >= v1.77.0
+    # - if local path != '<...>/coreutils' id = "path+file://<coreutils local directory>#coreutils@0.0.26"
+    # - if local path == '<...>/coreutils' id = "path+file://<parent directory>/coreutils#0.0.26"
+        cargo metadata "$@" --format-version 1 | jq -r '[.resolve.nodes[] | select(.id|match(".*coreutils[ |@|#]\\d+\\.\\d+\\.\\d+")) | .deps[] | select(.pkg|match("uu_")) | .name | sub("^uu_"; "")] | sort | join(" ")'
     fi
diff --git a/util/size-experiment.py b/util/size-experiment.py
index 8acacf9d108..d383c906e16 100644
--- a/util/size-experiment.py
+++ b/util/size-experiment.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+# spell-checker:ignore debuginfo
 import subprocess
 from itertools import product
 import shutil
@@ -21,9 +23,7 @@ def config(name, val):
 
 sizes = {}
 
-for (strip, panic, opt, lto) in product(
-    STRIP_VALS, PANIC_VALS, OPT_LEVEL_VALS, LTO_VALS
-):
+for strip, panic, opt, lto in product(STRIP_VALS, PANIC_VALS, OPT_LEVEL_VALS, LTO_VALS):
     if RECOMPILE:
         cmd = [
             "cargo",
@@ -75,8 +75,9 @@ def collect_diff(idx, name):
 collect_diff(3, "lto")
 
 
-def analyze(l):
-    return f"MIN: {float(min(l)):.3}, AVG: {float(sum(l)/len(l)):.3}, MAX: {float(max(l)):.3}"
+def analyze(change):
+    return f"""MIN: {float(min(change)):.3},
+        AVG: {float(sum(change) / len(change)):.3}, MAX: {float(max(change)):.3}"""
 
 
 print("Absolute changes")
diff --git a/util/test_compare_test_results.py b/util/test_compare_test_results.py
new file mode 100644
index 00000000000..c3ab4d833a8
--- /dev/null
+++ b/util/test_compare_test_results.py
@@ -0,0 +1,541 @@
+#!/usr/bin/env python3
+"""
+Unit tests for the GNU test results comparison script.
+"""
+
+import unittest
+import json
+import tempfile
+import os
+from unittest.mock import patch
+from io import StringIO
+from util.compare_test_results import (
+    flatten_test_results,
+    load_ignore_list,
+    identify_test_changes,
+    main,
+)
+
+
+class TestFlattenTestResults(unittest.TestCase):
+    """Tests for the flatten_test_results function."""
+
+    def test_basic_flattening(self):
+        """Test basic flattening of nested test results."""
+        test_data = {
+            "ls": {"test1": "PASS", "test2": "FAIL"},
+            "cp": {"test3": "SKIP", "test4": "ERROR"},
+        }
+        expected = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "FAIL",
+            "tests/cp/test3": "SKIP",
+            "tests/cp/test4": "ERROR",
+        }
+        self.assertEqual(flatten_test_results(test_data), expected)
+
+    def test_empty_dict(self):
+        """Test flattening an empty dictionary."""
+        self.assertEqual(flatten_test_results({}), {})
+
+    def test_single_util(self):
+        """Test flattening results with a single utility."""
+        test_data = {"ls": {"test1": "PASS", "test2": "FAIL"}}
+        expected = {"tests/ls/test1": "PASS", "tests/ls/test2": "FAIL"}
+        self.assertEqual(flatten_test_results(test_data), expected)
+
+    def test_empty_tests(self):
+        """Test flattening with a utility that has no tests."""
+        test_data = {"ls": {}, "cp": {"test1": "PASS"}}
+        expected = {"tests/cp/test1": "PASS"}
+        self.assertEqual(flatten_test_results(test_data), expected)
+
+    def test_log_extension_removal(self):
+        """Test that .log extensions are removed."""
+        test_data = {"ls": {"test1.log": "PASS", "test2": "FAIL"}}
+        expected = {"tests/ls/test1": "PASS", "tests/ls/test2": "FAIL"}
+        self.assertEqual(flatten_test_results(test_data), expected)
+
+
+class TestLoadIgnoreList(unittest.TestCase):
+    """Tests for the load_ignore_list function."""
+
+    def test_load_ignores(self):
+        """Test loading ignore list from a file."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp.write(
+                "tests/tail/inotify-dir-recreate\ntests/timeout/timeout\ntests/rm/rm1\n"
+            )
+            tmp_path = tmp.name
+        try:
+            ignore_list = load_ignore_list(tmp_path)
+            self.assertEqual(
+                ignore_list,
+                {
+                    "tests/tail/inotify-dir-recreate",
+                    "tests/timeout/timeout",
+                    "tests/rm/rm1",
+                },
+            )
+        finally:
+            os.unlink(tmp_path)
+
+    def test_empty_file(self):
+        """Test loading an empty ignore file."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            ignore_list = load_ignore_list(tmp_path)
+            self.assertEqual(ignore_list, set())
+        finally:
+            os.unlink(tmp_path)
+
+    def test_with_comments_and_blanks(self):
+        """Test loading ignore file with comments and blank lines."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp.write(
+                "tests/tail/inotify-dir-recreate\n# A comment\n\ntests/timeout/timeout\n#Indented comment\n  tests/rm/rm1  \n"
+            )
+            tmp_path = tmp.name
+        try:
+            ignore_list = load_ignore_list(tmp_path)
+            self.assertEqual(
+                ignore_list,
+                {
+                    "tests/tail/inotify-dir-recreate",
+                    "tests/timeout/timeout",
+                    "tests/rm/rm1",
+                },
+            )
+        finally:
+            os.unlink(tmp_path)
+
+    def test_nonexistent_file(self):
+        """Test behavior with a nonexistent file."""
+        result = load_ignore_list("/nonexistent/file/path")
+        self.assertEqual(result, set())
+
+
+class TestIdentifyTestChanges(unittest.TestCase):
+    """Tests for the identify_test_changes function."""
+
+    def test_regressions(self):
+        """Test identifying regressions."""
+        current = {
+            "tests/ls/test1": "FAIL",
+            "tests/ls/test2": "ERROR",
+            "tests/cp/test3": "PASS",
+            "tests/cp/test4": "SKIP",
+        }
+        reference = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "SKIP",
+            "tests/cp/test3": "PASS",
+            "tests/cp/test4": "FAIL",
+        }
+        regressions, _, _, _ = identify_test_changes(current, reference)
+        self.assertEqual(sorted(regressions), ["tests/ls/test1", "tests/ls/test2"])
+
+    def test_fixes(self):
+        """Test identifying fixes."""
+        current = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "PASS",
+            "tests/cp/test3": "FAIL",
+            "tests/cp/test4": "SKIP",
+        }
+        reference = {
+            "tests/ls/test1": "FAIL",
+            "tests/ls/test2": "ERROR",
+            "tests/cp/test3": "PASS",
+            "tests/cp/test4": "FAIL",
+        }
+        _, fixes, _, _ = identify_test_changes(current, reference)
+        self.assertEqual(sorted(fixes), ["tests/ls/test1", "tests/ls/test2"])
+
+    def test_newly_skipped(self):
+        """Test identifying newly skipped tests."""
+        current = {
+            "tests/ls/test1": "SKIP",
+            "tests/ls/test2": "SKIP",
+            "tests/cp/test3": "PASS",
+        }
+        reference = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "FAIL",
+            "tests/cp/test3": "PASS",
+        }
+        _, _, newly_skipped, _ = identify_test_changes(current, reference)
+        self.assertEqual(newly_skipped, ["tests/ls/test1"])
+
+    def test_newly_passing(self):
+        """Test identifying newly passing tests."""
+        current = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "PASS",
+            "tests/cp/test3": "SKIP",
+        }
+        reference = {
+            "tests/ls/test1": "SKIP",
+            "tests/ls/test2": "FAIL",
+            "tests/cp/test3": "SKIP",
+        }
+        _, _, _, newly_passing = identify_test_changes(current, reference)
+        self.assertEqual(newly_passing, ["tests/ls/test1"])
+
+    def test_all_categories(self):
+        """Test identifying all categories of changes simultaneously."""
+        current = {
+            "tests/ls/test1": "FAIL",  # Regression
+            "tests/ls/test2": "PASS",  # Fix
+            "tests/cp/test3": "SKIP",  # Newly skipped
+            "tests/cp/test4": "PASS",  # Newly passing
+            "tests/rm/test5": "PASS",  # No change
+        }
+        reference = {
+            "tests/ls/test1": "PASS",  # Regression
+            "tests/ls/test2": "FAIL",  # Fix
+            "tests/cp/test3": "PASS",  # Newly skipped
+            "tests/cp/test4": "SKIP",  # Newly passing
+            "tests/rm/test5": "PASS",  # No change
+        }
+        regressions, fixes, newly_skipped, newly_passing = identify_test_changes(
+            current, reference
+        )
+        self.assertEqual(regressions, ["tests/ls/test1"])
+        self.assertEqual(fixes, ["tests/ls/test2"])
+        self.assertEqual(newly_skipped, ["tests/cp/test3"])
+        self.assertEqual(newly_passing, ["tests/cp/test4"])
+
+    def test_new_and_removed_tests(self):
+        """Test handling of tests that are only in one of the datasets."""
+        current = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "FAIL",
+            "tests/cp/new_test": "PASS",
+        }
+        reference = {
+            "tests/ls/test1": "PASS",
+            "tests/ls/test2": "PASS",
+            "tests/rm/old_test": "FAIL",
+        }
+        regressions, fixes, newly_skipped, newly_passing = identify_test_changes(
+            current, reference
+        )
+        self.assertEqual(regressions, ["tests/ls/test2"])
+        self.assertEqual(fixes, [])
+        self.assertEqual(newly_skipped, [])
+        self.assertEqual(newly_passing, [])
+
+
+class TestMainFunction(unittest.TestCase):
+    """Integration tests for the main function."""
+
+    def setUp(self):
+        """Set up test files needed for main function tests."""
+        self.current_data = {
+            "ls": {
+                "test1": "PASS",
+                "test2": "FAIL",
+                "test3": "PASS",
+                "test4": "SKIP",
+                "test5": "PASS",
+            },
+            "cp": {"test1": "PASS", "test2": "PASS"},
+        }
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            json.dump(self.current_data, tmp)
+            self.current_json = tmp.name
+
+        self.reference_data = {
+            "ls": {
+                "test1": "PASS",
+                "test2": "PASS",
+                "test3": "FAIL",
+                "test4": "PASS",
+                "test5": "SKIP",
+            },
+            "cp": {"test1": "FAIL", "test2": "ERROR"},
+        }
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            json.dump(self.reference_data, tmp)
+            self.reference_json = tmp.name
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp.write("tests/ls/test2\ntests/cp/test1\n")
+            self.ignore_file = tmp.name
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            self.output_file = tmp.name
+
+    def tearDown(self):
+        """Clean up test files after tests."""
+        for file_path in [
+            self.current_json,
+            self.reference_json,
+            self.ignore_file,
+            self.output_file,
+        ]:
+            if os.path.exists(file_path):
+                os.unlink(file_path)
+
+    def test_main_exit_code_with_real_regressions(self):
+        """Test main function exit code with real regressions."""
+
+        current_flat = flatten_test_results(self.current_data)
+        reference_flat = flatten_test_results(self.reference_data)
+
+        regressions, _, _, _ = identify_test_changes(current_flat, reference_flat)
+
+        self.assertIn("tests/ls/test2", regressions)
+
+        ignore_list = load_ignore_list(self.ignore_file)
+
+        real_regressions = [r for r in regressions if r not in ignore_list]
+
+        self.assertNotIn("tests/ls/test2", real_regressions)
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp.write(
+                "tests/cp/test1\n"
+            )  # only ignore tests/cp/test1, not tests/ls/test2
+            new_ignore_file = tmp.name
+
+        try:
+            new_ignore_list = load_ignore_list(new_ignore_file)
+
+            new_real_regressions = [r for r in regressions if r not in new_ignore_list]
+
+            # tests/ls/test2 should now be in real_regressions
+            self.assertIn("tests/ls/test2", new_real_regressions)
+
+            # In main(), this would cause a non-zero exit code
+            would_exit_with_error = len(new_real_regressions) > 0
+            self.assertTrue(would_exit_with_error)
+        finally:
+            os.unlink(new_ignore_file)
+
+    def test_filter_intermittent_fixes(self):
+        """Test that fixes in the ignore list are filtered properly."""
+        current_flat = flatten_test_results(self.current_data)
+        reference_flat = flatten_test_results(self.reference_data)
+
+        _, fixes, _, _ = identify_test_changes(current_flat, reference_flat)
+
+        # tests/cp/test1 and tests/cp/test2 should be fixed but tests/cp/test1 is in ignore list
+        self.assertIn("tests/cp/test1", fixes)
+        self.assertIn("tests/cp/test2", fixes)
+
+        ignore_list = load_ignore_list(self.ignore_file)
+        real_fixes = [f for f in fixes if f not in ignore_list]
+        intermittent_fixes = [f for f in fixes if f in ignore_list]
+
+        # tests/cp/test1 should be identified as intermittent
+        self.assertIn("tests/cp/test1", intermittent_fixes)
+        # tests/cp/test2 should be identified as a real fix
+        self.assertIn("tests/cp/test2", real_fixes)
+
+
+class TestOutputFunctionality(unittest.TestCase):
+    """Tests focused on the output generation of the script."""
+
+    def setUp(self):
+        """Set up test files needed for output tests."""
+        self.current_data = {
+            "ls": {
+                "test1": "PASS",
+                "test2": "FAIL",  # Regression but in ignore list
+                "test3": "PASS",  # Fix
+            },
+            "cp": {
+                "test1": "PASS",  # Fix but in ignore list
+                "test2": "SKIP",  # Newly skipped
+                "test4": "PASS",  # Newly passing
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            json.dump(self.current_data, tmp)
+            self.current_json = tmp.name
+
+        self.reference_data = {
+            "ls": {
+                "test1": "PASS",  # No change
+                "test2": "PASS",  # Regression but in ignore list
+                "test3": "FAIL",  # Fix
+            },
+            "cp": {
+                "test1": "FAIL",  # Fix but in ignore list
+                "test2": "PASS",  # Newly skipped
+                "test4": "SKIP",  # Newly passing
+            },
+        }
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            json.dump(self.reference_data, tmp)
+            self.reference_json = tmp.name
+
+        # Create an ignore file
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp.write("tests/ls/test2\ntests/cp/test1\n")
+            self.ignore_file = tmp.name
+
+    def tearDown(self):
+        """Clean up test files after tests."""
+        for file_path in [self.current_json, self.reference_json, self.ignore_file]:
+            if os.path.exists(file_path):
+                os.unlink(file_path)
+
+        if hasattr(self, "output_file") and os.path.exists(self.output_file):
+            os.unlink(self.output_file)
+
+    @patch("sys.stdout", new_callable=StringIO)
+    @patch("sys.stderr", new_callable=StringIO)
+    def test_console_output_formatting(self, mock_stderr, mock_stdout):
+        """Test the formatting of console output."""
+        with patch(
+            "sys.argv",
+            [
+                "compare_test_results.py",
+                self.current_json,
+                self.reference_json,
+                "--ignore-file",
+                self.ignore_file,
+            ],
+        ):
+            try:
+                main()
+            except SystemExit:
+                pass  # Expected to exit with a status code
+
+        stdout_content = mock_stdout.getvalue()
+        self.assertIn("Total tests in current run:", stdout_content)
+        self.assertIn("New regressions: 0", stdout_content)
+        self.assertIn("Intermittent regressions: 1", stdout_content)
+        self.assertIn("Fixed tests: 1", stdout_content)
+        self.assertIn("Intermittent fixes: 1", stdout_content)
+        self.assertIn("Newly skipped tests: 1", stdout_content)
+        self.assertIn("Newly passing tests (previously skipped): 1", stdout_content)
+
+        stderr_content = mock_stderr.getvalue()
+        self.assertIn("INTERMITTENT ISSUES (ignored regressions):", stderr_content)
+        self.assertIn("Skip an intermittent issue tests/ls/test2", stderr_content)
+        self.assertIn("INTERMITTENT ISSUES (ignored fixes):", stderr_content)
+        self.assertIn("Skipping an intermittent issue tests/cp/test1", stderr_content)
+        self.assertIn("FIXED TESTS:", stderr_content)
+        self.assertIn(
+            "Congrats! The gnu test tests/ls/test3 is no longer failing!",
+            stderr_content,
+        )
+        self.assertIn("NEWLY SKIPPED TESTS:", stderr_content)
+        self.assertIn("Note: The gnu test tests/cp/test2", stderr_content)
+        self.assertIn("NEWLY PASSING TESTS (previously skipped):", stderr_content)
+        self.assertIn(
+            "Congrats! The gnu test tests/cp/test4 is now passing!", stderr_content
+        )
+
+    def test_file_output_generation(self):
+        """Test that the output file is generated correctly."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            self.output_file = tmp.name
+
+        with patch(
+            "sys.argv",
+            [
+                "compare_test_results.py",
+                self.current_json,
+                self.reference_json,
+                "--ignore-file",
+                self.ignore_file,
+                "--output",
+                self.output_file,
+            ],
+        ):
+            try:
+                main()
+            except SystemExit:
+                pass  # Expected to exit with a status code
+
+        self.assertTrue(os.path.exists(self.output_file))
+
+        with open(self.output_file, "r") as f:
+            output_content = f.read()
+
+        self.assertIn("Skip an intermittent issue tests/ls/test2", output_content)
+        self.assertIn("Skipping an intermittent issue tests/cp/test1", output_content)
+        self.assertIn(
+            "Congrats! The gnu test tests/ls/test3 is no longer failing!",
+            output_content,
+        )
+        self.assertIn("Note: The gnu test tests/cp/test2", output_content)
+        self.assertIn(
+            "Congrats! The gnu test tests/cp/test4 is now passing!", output_content
+        )
+
+    def test_exit_code_with_no_regressions(self):
+        """Test that the script exits with code 0 when there are no regressions."""
+        with patch(
+            "sys.argv",
+            [
+                "compare_test_results.py",
+                self.current_json,
+                self.reference_json,
+                "--ignore-file",
+                self.ignore_file,
+            ],
+        ):
+            # Instead of assertRaises, just call main() and check its return value
+            exit_code = main()
+            # Since all regressions are in the ignore list, should exit with 0
+            self.assertEqual(exit_code, 0)
+
+    def test_exit_code_with_regressions(self):
+        """Test that the script exits with code 1 when there are real regressions."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as tmp:
+            tmp.write("tests/cp/test1\n")  # Only ignore cp/test1
+            new_ignore_file = tmp.name
+
+        try:
+            with patch(
+                "sys.argv",
+                [
+                    "compare_test_results.py",
+                    self.current_json,
+                    self.reference_json,
+                    "--ignore-file",
+                    new_ignore_file,
+                ],
+            ):
+                # Just call main() and check its return value
+                exit_code = main()
+                # Since ls/test2 is now a real regression, should exit with 1
+                self.assertEqual(exit_code, 1)
+        finally:
+            os.unlink(new_ignore_file)
+
+    def test_github_actions_formatting(self):
+        """Test that the output is formatted for GitHub Actions."""
+        with patch("sys.stderr", new_callable=StringIO) as mock_stderr:
+            with patch(
+                "sys.argv",
+                [
+                    "compare_test_results.py",
+                    self.current_json,
+                    self.reference_json,
+                    "--ignore-file",
+                    self.ignore_file,
+                ],
+            ):
+                try:
+                    main()
+                except SystemExit:
+                    pass  # Expected to exit with a status code
+
+            stderr_content = mock_stderr.getvalue()
+
+            self.assertIn(
+                "::notice ::", stderr_content
+            )  # For fixes and informational messages
+            self.assertIn("::warning ::", stderr_content)  # For newly skipped tests
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/util/update-version.sh b/util/update-version.sh
index 6738f19b66d..5ee4201031d 100755
--- a/util/update-version.sh
+++ b/util/update-version.sh
@@ -9,15 +9,18 @@
 # 2) run it: sh util/update-version.sh
 # 3) Do a spot check with "git diff"
 # 4) cargo test --release --features unix
-# 5) git commit -m "New release"
+# 5) git commit -m "New release" (make sure it includes Cargo.lock)
 # 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
+# 9) Tag the release - "git tag 0.0.X && git push --tags"
+# 10) Create the release on github https://github.com/uutils/coreutils/releases/new
+# 11) Make sure we have good release notes
 
-FROM="0.0.20"
-TO="0.0.21"
+FROM="0.0.30"
+TO="0.1.0"
 
-PROGS=$(ls -1d src/uu/*/Cargo.toml src/uu/stdbuf/src/libstdbuf/Cargo.toml src/uucore/Cargo.toml Cargo.toml)
+PROGS=$(ls -1d src/uu/*/Cargo.toml src/uu/stdbuf/src/libstdbuf/Cargo.toml src/uucore/Cargo.toml Cargo.toml fuzz/uufuzz/Cargo.toml)
 
 # update the version of all programs
 #shellcheck disable=SC2086
diff --git a/util/why-error.md b/util/why-error.md
new file mode 100644
index 00000000000..c4c371d070f
--- /dev/null
+++ b/util/why-error.md
@@ -0,0 +1,70 @@
+This file documents why some tests are failing:
+
+* gnu/tests/cp/preserve-gid.sh
+* gnu/tests/csplit/csplit-suppress-matched.pl
+* gnu/tests/date/date-debug.sh
+* gnu/tests/date/date-next-dow.pl
+* gnu/tests/date/date-tz.sh
+* gnu/tests/date/date.pl
+* gnu/tests/dd/direct.sh
+* gnu/tests/dd/no-allocate.sh
+* gnu/tests/dd/nocache_eof.sh
+* gnu/tests/dd/skip-seek-past-file.sh - https://github.com/uutils/coreutils/issues/7216
+* gnu/tests/dd/stderr.sh
+* gnu/tests/du/long-from-unreadable.sh - https://github.com/uutils/coreutils/issues/7217
+* gnu/tests/du/move-dir-while-traversing.sh
+* gnu/tests/expr/expr-multibyte.pl
+* gnu/tests/fmt/goal-option.sh
+* gnu/tests/fmt/non-space.sh
+* gnu/tests/head/head-elide-tail.pl
+* gnu/tests/head/head-pos.sh
+* gnu/tests/help/help-version-getopt.sh
+* gnu/tests/help/help-version.sh
+* gnu/tests/install/install-C.sh - https://github.com/uutils/coreutils/pull/7215
+* gnu/tests/ls/ls-misc.pl
+* gnu/tests/ls/stat-free-symlinks.sh
+* gnu/tests/misc/close-stdout.sh
+* gnu/tests/misc/comm.pl
+* gnu/tests/misc/nohup.sh
+* gnu/tests/misc/numfmt.pl - https://github.com/uutils/coreutils/issues/7219 / https://github.com/uutils/coreutils/issues/7221
+* gnu/tests/misc/stdbuf.sh - https://github.com/uutils/coreutils/issues/7072
+* gnu/tests/misc/tee.sh - https://github.com/uutils/coreutils/issues/7073
+* gnu/tests/misc/time-style.sh
+* gnu/tests/misc/tsort.pl - https://github.com/uutils/coreutils/issues/7074
+* gnu/tests/misc/write-errors.sh
+* gnu/tests/mv/hard-link-1.sh
+* gnu/tests/mv/mv-special-1.sh - https://github.com/uutils/coreutils/issues/7076
+* gnu/tests/mv/part-fail.sh
+* gnu/tests/mv/part-hardlink.sh
+* gnu/tests/od/od-N.sh
+* gnu/tests/od/od-float.sh
+* gnu/tests/printf/printf-cov.pl
+* gnu/tests/printf/printf-indexed.sh
+* gnu/tests/printf/printf-mb.sh
+* gnu/tests/printf/printf-quote.sh
+* gnu/tests/printf/printf.sh
+* gnu/tests/ptx/ptx-overrun.sh
+* gnu/tests/ptx/ptx.pl
+* gnu/tests/rm/empty-inacc.sh - https://github.com/uutils/coreutils/issues/7033
+* gnu/tests/rm/ir-1.sh
+* gnu/tests/rm/one-file-system.sh - https://github.com/uutils/coreutils/issues/7011
+* gnu/tests/rm/rm1.sh
+* gnu/tests/rm/rm2.sh
+* gnu/tests/shred/shred-passes.sh
+* gnu/tests/sort/sort-continue.sh
+* gnu/tests/sort/sort-debug-keys.sh
+* gnu/tests/sort/sort-debug-warn.sh
+* gnu/tests/sort/sort-files0-from.pl
+* gnu/tests/sort/sort-float.sh
+* gnu/tests/sort/sort-h-thousands-sep.sh
+* gnu/tests/sort/sort-merge-fdlimit.sh
+* gnu/tests/sort/sort-month.sh
+* gnu/tests/sort/sort.pl
+* gnu/tests/stat/stat-nanoseconds.sh
+* gnu/tests/tac/tac-2-nonseekable.sh
+* gnu/tests/tail/end-of-device.sh
+* gnu/tests/tail/follow-stdin.sh
+* gnu/tests/tail/inotify-rotate-resources.sh
+* gnu/tests/tail/symlink.sh
+* gnu/tests/touch/obsolescent.sh
+* gnu/tests/tty/tty-eof.pl
diff --git a/util/why-skip.md b/util/why-skip.md
new file mode 100644
index 00000000000..a3ecdfbeae9
--- /dev/null
+++ b/util/why-skip.md
@@ -0,0 +1,94 @@
+# 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
+
+= 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
diff --git a/util/why-skip.txt b/util/why-skip.txt
deleted file mode 100644
index c790311c13d..00000000000
--- a/util/why-skip.txt
+++ /dev/null
@@ -1,98 +0,0 @@
-# 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