starting new job...
→ running command: dir='/etc/byggsteg/job-clone//sift/trunk'
branch='trunk'
if ! command -v git >/dev/null 2>&1; then
echo 'byggsteg: git is not on this deployment PATH, so the clone cannot be updated' >&2
exit 1
fi
if ! cd "$dir"; then
echo "byggsteg: cannot enter the clone $dir" >&2
exit 1
fi
root=$(git rev-parse --show-toplevel 2>/dev/null)
if [ "$root" != "$(pwd -P)" ]; then
echo "byggsteg: $dir is not a git checkout; remove it and the next run clones it again" >&2
exit 1
fi
if ! origin=$(git remote get-url origin 2>/dev/null); then
echo "byggsteg: $dir has no origin remote to fetch $branch from" >&2
exit 1
fi
before=$(git rev-parse --short HEAD 2>/dev/null) || before=none
attempt=1
while :; do
if GIT_TERMINAL_PROMPT=0 git fetch --quiet origin "+refs/heads/$branch:refs/remotes/origin/$branch"; then
break
fi
if [ "$attempt" -ge 3 ]; then
echo "byggsteg: could not fetch $branch from $origin after 3 attempts; is the branch still there, and is the remote reachable?" >&2
exit 1
fi
echo "byggsteg: fetching $branch from $origin failed; retrying in $((attempt * 2))s" >&2
sleep $((attempt * 2))
attempt=$((attempt + 1))
done
if ! git checkout --quiet --force -B "$branch" FETCH_HEAD; then
echo "byggsteg: fetched $branch from $origin but could not check it out" >&2
exit 1
fi
after=$(git rev-parse --short HEAD)
if [ "$before" = "$after" ]; then
echo "byggsteg: $branch was already at $after"
else
echo "byggsteg: $branch moved from $before to $after"
fi
byggsteg: trunk moved from c556861 to 30aef81
→ running command: cd /etc/byggsteg/job-clone/sift/trunk && uname -a
Linux wolk-jjba 7.2.11-gnu #1 SMP PREEMPT_DYNAMIC 1 x86_64 GNU/Linux
→ running command: cd /etc/byggsteg/job-clone/sift/trunk && git log --name-status HEAD^..HEAD
commit 30aef812a3233f5ee66bd4e3454e8bf2218c7887
Author: Josep Bigorra <jjbigorra@gmail.com>
Date: Sun Nov 1 22:17:32 2026 +0100
feat: Improve reproducibility with channels and time machine
M maak.scm
→ running command: cd /etc/byggsteg/job-clone/sift/trunk && maak test
channels.scm:17:6: warning: channel 'jointhefreeworld' is not trusted
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 100.0%
substitute:
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 0.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 50.0%
0.3 MB will be downloaded
.
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 100.0%
substitute:
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 0.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 1.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 1.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 2.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 3.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 4.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 5.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 6.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 7.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 8.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 9.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 10.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 11.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 12.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 13.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 14.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 15.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 16.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 17.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 18.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 19.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 20.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 21.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 22.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 23.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 24.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 25.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 26.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 27.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 28.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 29.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 30.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 31.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 32.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 33.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 34.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 35.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 35.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 36.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 37.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 38.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 39.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 40.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 41.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 42.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 43.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 44.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 45.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 46.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 47.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 48.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 49.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 50.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 51.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 52.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 53.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 54.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 55.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 56.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 57.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 58.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 59.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 60.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 61.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 62.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 63.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 64.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 65.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 66.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 67.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 68.0%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 68.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 69.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 70.9%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 71.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 72.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 73.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 74.8%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 75.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 76.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 77.7%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 78.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 79.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 80.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 81.6%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 82.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 83.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 84.5%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 85.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 86.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 87.4%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 88.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 89.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 90.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 91.3%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 92.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 93.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 94.2%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 95.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 96.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 97.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 98.1%
substitute: looking for substitutes on 'https://bordeaux.guix.gnu.org'... 99.0%
The following derivation will be built:
/gnu/store/j2xfbccpvygnrk2vl367zi8rka8l5sdh-profile.drv
39.0 MB will be downloaded
...
building CA certificate bundle...
listing Emacs sub-directories...
building fonts directory...
building directory of Info manuals...
building profile with 6 packages...
;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;; or pass the --no-auto-compile argument to disable.
;;; compiling ./tests/run.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/run.scm.go
loading tests/catalogue.scm
;;; compiling ./tests/catalogue.scm
;;; compiling ./src/sift/records.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/records.scm.go
;;; compiling ./src/sift/lint.scm
;;; compiling ./src/sift/reader.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/reader.scm.go
;;; compiling ./src/sift/pool.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/pool.scm.go
;;; compiling ./src/sift/check/base.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/check/base.scm.go
;;; compiling ./src/sift/checkers/whitespace.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/whitespace.scm.go
;;; compiling ./src/sift/checkers/comments.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/comments.scm.go
;;; compiling ./src/sift/checkers/parens.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/parens.scm.go
;;; compiling ./src/sift/checkers/bodies.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/bodies.scm.go
;;; compiling ./src/sift/checkers/scheme.scm
;;; compiling ./src/sift/format.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/format.scm.go
;;; compiling ./src/sift/imports.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/imports.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/scheme.scm.go
;;; compiling ./src/sift/checkers/elisp.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/elisp.scm.go
;;; compiling ./src/sift/checkers/cl.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/cl.scm.go
;;; compiling ./src/sift/checkers/ergonomics.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/ergonomics.scm.go
;;; compiling ./src/sift/checkers/naming.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/naming.scm.go
;;; compiling ./src/sift/checkers/simplify.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/simplify.scm.go
;;; compiling ./src/sift/checkers/sxml.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/sxml.scm.go
;;; compiling ./src/sift/checkers/practices.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/checkers/practices.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/lint.scm.go
;;; compiling ./src/sift/catalogue.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/catalogue.scm.go
;;; compiling ./tests/helpers.scm
;;; compiling ./src/sift/config.scm
;;; compiling ./src/sift/yaml.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/yaml.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/config.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/helpers.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/catalogue.scm.go
loading tests/check-base.scm
;;; compiling ./tests/check-base.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/check-base.scm.go
loading tests/checkers/beta-reduction.scm
;;; compiling ./tests/checkers/beta-reduction.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/beta-reduction.scm.go
loading tests/checkers/blank-line-in-body.scm
;;; compiling ./tests/checkers/blank-line-in-body.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/blank-line-in-body.scm.go
loading tests/checkers/checkdoc-style-verb.scm
;;; compiling ./tests/checkers/checkdoc-style-verb.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/checkdoc-style-verb.scm.go
loading tests/checkers/clause-brackets.scm
;;; compiling ./tests/checkers/clause-brackets.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/clause-brackets.scm.go
loading tests/checkers/comment-semicolons.scm
;;; compiling ./tests/checkers/comment-semicolons.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/comment-semicolons.scm.go
loading tests/checkers/composition.scm
;;; compiling ./tests/checkers/composition.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/composition.scm.go
loading tests/checkers/dangling-paren.scm
;;; compiling ./tests/checkers/dangling-paren.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/dangling-paren.scm.go
loading tests/checkers/declare-indent.scm
;;; compiling ./tests/checkers/declare-indent.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/declare-indent.scm.go
loading tests/checkers/defun-no-docstring.scm
;;; compiling ./tests/checkers/defun-no-docstring.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/defun-no-docstring.scm.go
loading tests/checkers/docstring-arguments.scm
;;; compiling ./tests/checkers/docstring-arguments.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/docstring-arguments.scm.go
loading tests/checkers/docstring-first-line.scm
;;; compiling ./tests/checkers/docstring-first-line.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/docstring-first-line.scm.go
loading tests/checkers/docstring-indent.scm
;;; compiling ./tests/checkers/docstring-indent.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/docstring-indent.scm.go
loading tests/checkers/docstring-missing.scm
;;; compiling ./tests/checkers/docstring-missing.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/docstring-missing.scm.go
loading tests/checkers/docstring-texinfo.scm
;;; compiling ./tests/checkers/docstring-texinfo.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/docstring-texinfo.scm.go
loading tests/checkers/double-colon.scm
;;; compiling ./tests/checkers/double-colon.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/double-colon.scm.go
loading tests/checkers/empty-body.scm
;;; compiling ./tests/checkers/empty-body.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/empty-body.scm.go
loading tests/checkers/empty-form.scm
;;; compiling ./tests/checkers/empty-form.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/empty-form.scm.go
loading tests/checkers/eta-reduction.scm
;;; compiling ./tests/checkers/eta-reduction.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/eta-reduction.scm.go
loading tests/checkers/if-without-else.scm
;;; compiling ./tests/checkers/if-without-else.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/if-without-else.scm.go
loading tests/checkers/interactive-without-docstring.scm
;;; compiling ./tests/checkers/interactive-without-docstring.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/interactive-without-docstring.scm.go
loading tests/checkers/internal-define.scm
;;; compiling ./tests/checkers/internal-define.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/internal-define.scm.go
loading tests/checkers/keyword-arguments.scm
;;; compiling ./tests/checkers/keyword-arguments.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/keyword-arguments.scm.go
loading tests/checkers/let-simplification.scm
;;; compiling ./tests/checkers/let-simplification.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/let-simplification.scm.go
loading tests/checkers/letrec-single-binding.scm
;;; compiling ./tests/checkers/letrec-single-binding.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/letrec-single-binding.scm.go
loading tests/checkers/lexical-binding-missing.scm
;;; compiling ./tests/checkers/lexical-binding-missing.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/lexical-binding-missing.scm.go
loading tests/checkers/library-not-found.scm
;;; compiling ./tests/checkers/library-not-found.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/library-not-found.scm.go
loading tests/checkers/line-length.scm
;;; compiling ./tests/checkers/line-length.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/line-length.scm.go
loading tests/checkers/loop-keyword-style.scm
;;; compiling ./tests/checkers/loop-keyword-style.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/loop-keyword-style.scm.go
loading tests/checkers/naming-convention.scm
;;; compiling ./tests/checkers/naming-convention.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/naming-convention.scm.go
loading tests/checkers/negated-if.scm
;;; compiling ./tests/checkers/negated-if.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/negated-if.scm.go
loading tests/checkers/nesting-depth.scm
;;; compiling ./tests/checkers/nesting-depth.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/nesting-depth.scm.go
loading tests/checkers/package-prefix.scm
;;; compiling ./tests/checkers/package-prefix.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/package-prefix.scm.go
loading tests/checkers/practices.scm
;;; compiling ./tests/checkers/practices.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/practices.scm.go
loading tests/checkers/predicate-name.scm
;;; compiling ./tests/checkers/predicate-name.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/predicate-name.scm.go
loading tests/checkers/provide-missing.scm
;;; compiling ./tests/checkers/provide-missing.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/provide-missing.scm.go
loading tests/checkers/quasiquote-unquote-constant.scm
;;; compiling ./tests/checkers/quasiquote-unquote-constant.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/quasiquote-unquote-constant.scm.go
loading tests/checkers/reader-prefix-break.scm
;;; compiling ./tests/checkers/reader-prefix-break.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/reader-prefix-break.scm.go
loading tests/checkers/redundant-identity.scm
;;; compiling ./tests/checkers/redundant-identity.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/redundant-identity.scm.go
loading tests/checkers/redundant-progn.scm
;;; compiling ./tests/checkers/redundant-progn.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/redundant-progn.scm.go
loading tests/checkers/single-letter-name.scm
;;; compiling ./tests/checkers/single-letter-name.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/single-letter-name.scm.go
loading tests/checkers/special-variable-name.scm
;;; compiling ./tests/checkers/special-variable-name.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/special-variable-name.scm.go
loading tests/checkers/sxml-attributes.scm
;;; compiling ./tests/checkers/sxml-attributes.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/sxml-attributes.scm.go
loading tests/checkers/sxml-child.scm
;;; compiling ./tests/checkers/sxml-child.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/sxml-child.scm.go
loading tests/checkers/tabs.scm
;;; compiling ./tests/checkers/tabs.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/tabs.scm.go
loading tests/checkers/trailing-blank-lines.scm
;;; compiling ./tests/checkers/trailing-blank-lines.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/trailing-blank-lines.scm.go
loading tests/checkers/trailing-whitespace.scm
;;; compiling ./tests/checkers/trailing-whitespace.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/trailing-whitespace.scm.go
loading tests/checkers/unless-without-body.scm
;;; compiling ./tests/checkers/unless-without-body.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/unless-without-body.scm.go
loading tests/checkers/unmatched-parens.scm
;;; compiling ./tests/checkers/unmatched-parens.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/unmatched-parens.scm.go
loading tests/checkers/unused-argument.scm
;;; compiling ./tests/checkers/unused-argument.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/unused-argument.scm.go
loading tests/checkers/unused-definition.scm
;;; compiling ./tests/checkers/unused-definition.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/unused-definition.scm.go
loading tests/checkers/unused-import.scm
;;; compiling ./tests/checkers/unused-import.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/unused-import.scm.go
loading tests/checkers/when-without-body.scm
;;; compiling ./tests/checkers/when-without-body.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/when-without-body.scm.go
loading tests/checkers/wrap-in-let.scm
;;; compiling ./tests/checkers/wrap-in-let.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/checkers/wrap-in-let.scm.go
loading tests/cli.scm
;;; compiling ./tests/cli.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/cli.scm.go
loading tests/declarations.scm
;;; compiling ./tests/declarations.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/declarations.scm.go
loading tests/definitions.scm
;;; compiling ./tests/definitions.scm
;;; compiling ./src/sift/definitions.scm
;;; compiled
+----------------------------------------------+
[📑 suite] catalogue
[🧪 test] no two rules share a code✅ got: 62
[🧪 test] the summary table has a row per rule✅ got: 62
[🧪 test] doc/rules.org is what the rules produce
[⚙️ assert] doc/rules.org is up to date✅ got: #t
[🧪 test] every rule has an example and a sentence about its fix✅ got: ()
[🧪 test] every code looks like one✅ got: ()
[🧪 test] every rule has a code✅ got: ()
[🧪 test] the document names every rule by name and code✅ got: ** SIFT046 beta-reduction✅ got: ** SIFT052 blank-line-in-body✅ got: ** SIFT022 checkdoc-style-verb✅ got: ** SIFT036 clause-brackets✅ got: ** SIFT051 comment-semicolons✅ got: ** SIFT047 composition✅ got: ** SIFT056 cond-else-not-last✅ got: ** SIFT027 dangling-paren✅ got: ** SIFT024 declare-indent✅ got: ** SIFT059 defcustom-without-type✅ got: ** SIFT028 defun-no-docstring✅ got: ** SIFT034 docstring-arguments✅ got: ** SIFT038 docstring-before-interactive✅ got: ** SIFT018 docstring-first-line✅ got: ** SIFT019 docstring-indent✅ got: ** SIFT017 docstring-missing✅ got: ** SIFT035 docstring-texinfo✅ got: ** SIFT026 double-colon✅ got: ** SIFT037 duplicate-binding✅ got: ** SIFT057 duplicate-case-datum✅ got: ** SIFT009 duplicate-keyword✅ got: ** SIFT005 empty-body✅ got: ** SIFT008 empty-form✅ got: ** SIFT055 eq-on-literal✅ got: ** SIFT045 eta-reduction✅ got: ** SIFT012 if-without-else✅ got: ** SIFT021 interactive-without-docstring✅ got: ** SIFT011 internal-define✅ got: ** SIFT032 keyword-arguments✅ got: ** SIFT048 let-simplification✅ got: ** SIFT015 letrec-single-binding✅ got: ** SIFT020 lexical-binding-missing✅ got: ** SIFT061 library-not-found✅ got: ** SIFT003 line-length✅ got: ** SIFT029 loop-keyword-style✅ got: ** SIFT040 naming-convention✅ got: ** SIFT033 negated-if✅ got: ** SIFT044 nesting-depth✅ got: ** SIFT025 package-prefix✅ got: ** SIFT041 predicate-name✅ got: ** SIFT023 provide-missing✅ got: ** SIFT016 quasiquote-unquote-constant✅ got: ** SIFT054 quote-of-constant✅ got: ** SIFT007 reader-prefix-break✅ got: ** SIFT030 redundant-identity✅ got: ** SIFT006 redundant-progn✅ got: ** SIFT053 single-letter-name✅ got: ** SIFT042 special-variable-name✅ got: ** SIFT049 sxml-attributes✅ got: ** SIFT050 sxml-child✅ got: ** SIFT002 tabs✅ got: ** SIFT058 too-many-arguments✅ got: ** SIFT010 trailing-blank-lines✅ got: ** SIFT001 trailing-whitespace✅ got: ** SIFT014 unless-without-body✅ got: ** SIFT004 unmatched-parens✅ got: ** SIFT043 unused-argument✅ got: ** SIFT039 unused-binding✅ got: ** SIFT062 unused-definition✅ got: ** SIFT060 unused-import✅ got: ** SIFT013 when-without-body✅ got: ** SIFT031 wrap-in-let
+----------------------------------------------+
[📑 suite] walk: where code is evaluated
[🧪 test] `walk-forms' and `code-position?' agree on every ambiguous source
[⚙️ assert] "(quote (if a b))\n" agrees✅ got: #t
[⚙️ assert] "'(if a b)\n" agrees✅ got: #t
[⚙️ assert] "`(a ,(if b c) d)\n" agrees✅ got: #t
[⚙️ assert] "`(a ,@(if b (list c)) d)\n" agrees✅ got: #t
[⚙️ assert] "(case x\n ((if a b) 1)\n (else (if a b)))\n" agrees✅ got: #t
[⚙️ assert] "(define (f (if #f)) (if a b))\n" agrees✅ got: #t
[⚙️ assert] "(lambda (x) (lambda (y) y))\n" agrees✅ got: #t
[⚙️ assert] "#(if a b)\n" agrees✅ got: #t
[⚙️ assert] "#u8(1 2 3)\n" agrees✅ got: #t
[⚙️ assert] "(define x #(1 #(2 (if a b))))\n" agrees✅ got: #t
[⚙️ assert] "(let loop ((i 0)) (when (< i 1) (loop (+ i 1))))\n" agrees✅ got: #t
[⚙️ assert] "(define-syntax m (syntax-rules () ((_ a) a)))\n" agrees✅ got: #t
[⚙️ assert] "#'(a b)\n" agrees✅ got: #t
[⚙️ assert] "(syntax-case stx ()\n ((_ a) #'a))\n" agrees✅ got: #t
[⚙️ assert] "(case x\n ((a b) 1)\n (else 2))\n" agrees✅ got: #t
[⚙️ assert] "(defun f (x) \"doc\" (if x y z))\n" agrees✅ got: #t
[⚙️ assert] "(defmacro m (a) `(list ,a))\n" agrees✅ got: #t
[⚙️ assert] "#+foo (if a b)\n" agrees✅ got: #t
[⚙️ assert] "(quasiquote (a (unquote (if x y))))\n" agrees✅ got: #t
[⚙️ assert] "; a comment\n(if a b)\n" agrees✅ got: #t
[🧪 test] nothing inside a vector literal is code
[⚙️ assert] the two calls, and neither literal✅ got: (begin f)
[🧪 test] a parameter list holds parameters, not forms
[⚙️ assert] the definition and the call, not the default's `g`✅ got: (define g)
[🧪 test] a `case` datum is data, and its clauses are code
[⚙️ assert] the `case`, and the calls in the clause bodies✅ got: (case f else g)
[🧪 test] an unquote is code again
[⚙️ assert] the two forms inside unquotes, and nothing else✅ got: (if list)
[🧪 test] a quoted form holds data, not code
[⚙️ assert] only the call is a form✅ got: (#t #f #f)
[⚙️ assert] the call, `car`, and the quote mark✅ got: 3
+----------------------------------------------+
[📑 suite] checker: beta-reduction
[🧪 test] the fix writes the let
[⚙️ assert] the fix produces the expected text✅ got: (let ((x (g))) (f x))
[🧪 test] a multi-form body becomes a multi-form let
[⚙️ assert] the fix produces the expected text✅ got: (let ((x (h))) (f x) (g x))
[🧪 test] accepts a lambda with no body
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a Common Lisp lambda applied in place is a let too
[⚙️ assert] the fix produces the expected text✅ got: (let ((x (g))) (f x))
[🧪 test] reports a lambda applied in place
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a lambda applied to two arguments
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] accepts a call to something that is not a lambda
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: blank-line-in-body
[🧪 test] reports a blank line between two body forms of a definition
[⚙️ assert] the findings are where they should be✅ got: ((4 3))
[🧪 test] reports a blank line between the forms of an Emacs Lisp defun
[⚙️ assert] the findings are where they should be✅ got: ((4 3))
[🧪 test] reports a blank line in a `lambda' body
[⚙️ assert] the findings are where they should be✅ got: ((4 3))
[🧪 test] accepts a blank line between two internal definitions
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a blank line between top-level forms
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a blank line in a `let' body
[⚙️ assert] the findings are where they should be✅ got: ((4 3))
[🧪 test] reports a run of blank lines as one finding
[⚙️ assert] the findings are where they should be✅ got: ((5 3))
[🧪 test] accepts a blank line between the bindings of a `let'
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a body whose forms are adjacent
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: checkdoc-style-verb
[🧪 test] accepts the imperative
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a third-person opening
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
+----------------------------------------------+
[📑 suite] checker: clause-brackets
[🧪 test] the fix rewrites the delimiters
[⚙️ assert] the fix produces the expected text✅ got: (cond [(= x 1) 'one] [else 'other])
[🧪 test] reports a cond clause written with parentheses
[⚙️ assert] the findings are where they should be✅ got: ((1 7) (2 7))
[🧪 test] accepts a cond clause written with square brackets
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] says nothing when the project preserves what was written
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a case clause written with parentheses
[⚙️ assert] the findings are where they should be✅ got: ((1 9) (2 3))
[🧪 test] the default for Scheme is square✅ got: square
[🧪 test] the default for the other dialects is to preserve✅ got: preserve✅ got: preserve
[🧪 test] follows a project that writes parentheses
[⚙️ assert] the findings are where they should be✅ got: ((1 7))
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
+----------------------------------------------+
[📑 suite] checker: comment-semicolons
[🧪 test] the fix leaves a heading at four semicolons
[⚙️ assert] the fix produces the expected text✅ got: ;;;; Frob Grovel(define x 1)
[🧪 test] the fix lowers a comment inside a form to two semicolons
[⚙️ assert] the fix produces the expected text✅ got: (define (f x) ;; a heading in a body x)
[🧪 test] reports a comment with no space after its semicolons
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] the fix adds the space after the semicolons and nothing else
[⚙️ assert] the fix produces the expected text✅ got: ;;; tight(define x 1)
[🧪 test] accepts a heading, which has four
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix leaves the sentence of the comment exactly as it was
[⚙️ assert] the fix produces the expected text✅ got: ;;; spaced out (define x 1)
[🧪 test] reports a top-level comment with two semicolons
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] one pass fixes every comment in the buffer
[⚙️ assert] the fix produces the expected text✅ got: ;;; first(define (f x) ;; second x);;; third
[🧪 test] accepts a margin comment written without a space
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a margin comment with one semicolon
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] says nothing about a block comment, which has no semicolons
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts two semicolons inside a form
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a one-semicolon comment inside a form
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] the fix leaves a margin comment alone
[⚙️ assert] the fix produces the expected text✅ got: (a b) ;Zibblefrotz.
[🧪 test] accepts a top-level comment with three semicolons
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fixed buffer is clean, so a second run has nothing to do
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] the fix raises a top-level comment to three semicolons
[⚙️ assert] the fix produces the expected text✅ got: ;;; about the program(define x 1)
[🧪 test] reports a heading inside a form, where two is the level
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
+----------------------------------------------+
[📑 suite] checker: composition
[🧪 test] reports a lambda whose body is one call around another
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a body that is not a nested call
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] does not suggest Guile's compose to Common Lisp
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a lambda that takes two arguments
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts an inner call that takes more than the argument
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] the fix names the composition
[⚙️ assert] the fix produces the expected text✅ got: (compose f g)
+----------------------------------------------+
[📑 suite] checker: dangling-paren
[🧪 test] the fix pulls the closer onto the previous line
[⚙️ assert] the fix produces the expected text✅ got: (defun f (x) x)
[🧪 test] accepts a closer that trails the last element
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a closer that starts a line
[⚙️ assert] the findings are where they should be✅ got: ((3 3))
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
+----------------------------------------------+
[📑 suite] checker: declare-indent
[🧪 test] reports a declare indented too far
[⚙️ assert] the findings are where they should be✅ got: ((2 5))
[🧪 test] the fix re-indents the declare
[⚙️ assert] the fix produces the expected text✅ got: (defun f (x) (declare (indent 1)) x)
[🧪 test] accepts a declare two columns in
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: defun-no-docstring
[🧪 test] reports a defun with no docstring
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a documented defun
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: docstring-arguments
[🧪 test] says nothing about a defun with no docstring
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports each argument the docstring does not mention
[⚙️ assert] the findings are where they should be✅ got: ((2 3) (2 3))
[🧪 test] accepts any spelling of the name
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a docstring that names its arguments
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] looks through optional and rest arguments
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
+----------------------------------------------+
[📑 suite] checker: docstring-first-line
[🧪 test] reports a first line with no full stop
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] reports a first line that starts lowercase
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] accepts a capitalised sentence with a period
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a first line that is too long for apropos
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
+----------------------------------------------+
[📑 suite] checker: docstring-indent
[🧪 test] reports an indented continuation line
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] accepts continuation lines that start at column zero
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: docstring-missing
[🧪 test] a defun with no body is a finding, not a crash
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] reports a defun with no docstring
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] reports a defvar with no docstring
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a bare defvar declaration
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a defcustom with no docstring
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a documented defun
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: docstring-texinfo
[🧪 test] reports each undocumented parameter
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] says nothing about a definition with no docstring
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] says nothing about a procedure with no parameters
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a docstring that documents every parameter
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a parameter the docstring does not document
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
+----------------------------------------------+
[📑 suite] checker: double-colon
[🧪 test] accepts a single-colon reference
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a double-colon reference
[⚙️ assert] the findings are where they should be✅ got: ((1 2))
[🧪 test] accepts an ordinary symbol
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: empty-body
[🧪 test] accepts a form with a body
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a cond clause with no body
[⚙️ assert] the findings are where they should be✅ got: ((1 7))
[🧪 test] reports a cond with no clauses
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] reports a let with no body
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] reports a lambda with no body
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] covers when and unless in Emacs Lisp
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] a case datum is data, not a form
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: empty-form
[🧪 test] accepts an empty binding list
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a quoted empty list
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts the literals list of a syntax-rules transformer
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts an empty parameter list
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts the literals list of a syntax-case transformer
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports the empty list in an argument position
[⚙️ assert] the findings are where they should be✅ got: ((1 7))
+----------------------------------------------+
[📑 suite] checker: eta-reduction
[🧪 test] reports a lambda that only passes its argument on
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a call that passes more than the argument
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a body that is more than the call
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] never rewrites a special form into a value
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a call that passes something else
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a rest argument
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a lambda with two formals
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix names the procedure itself
[⚙️ assert] the fix produces the expected text✅ got: f
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] an Emacs Lisp lambda is not a Scheme function designator
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: if-without-else
[🧪 test] a vector literal is data, not a form
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] what an unquote puts back is code again
[⚙️ assert] the findings are where they should be✅ got: ((1 17))
[⚙️ assert] the findings are where they should be✅ got: ((1 22))
[⚙️ assert] the findings are where they should be✅ got: ((1 18))
[🧪 test] a quasiquoted or quasisyntaxed template is data
[⚙️ assert] the findings are where they should be✅ got: ()
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] accepts an if with an else branch
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix rewrites it as when
[⚙️ assert] the fix produces the expected text✅ got: (when a b)
[🧪 test] reports an if with two arguments
[⚙️ assert] the findings are where they should be✅ got: ((1 2))
+----------------------------------------------+
[📑 suite] checker: interactive-without-docstring
[🧪 test] accepts a documented command
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports an interactive command with no docstring
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
+----------------------------------------------+
[📑 suite] checker: internal-define
[🧪 test] accepts a definition under a let
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts top-level definitions
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a define inside a lambda, after an expression
[⚙️ assert] the findings are where they should be✅ got: ((3 3))
[🧪 test] reports a define that comes after the first expression
[⚙️ assert] the findings are where they should be✅ got: ((3 3))
[🧪 test] accepts definitions at the head of a body
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: keyword-arguments
[🧪 test] accepts a special form
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a Common Lisp package definition is a declaration
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] require and provide are declarations
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a call with too many positional arguments
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] a parameter list is not a call
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts the calls that are meant to be variadic
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a call with a readable number of arguments
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the limit is configuration
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] the export list of a define-module is data
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts arguments that are already keywords
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a use-modules form is a declaration, not a call
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: let-simplification
[🧪 test] accepts a let with two bindings
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a let with a named let
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix is the value
[⚙️ assert] the fix produces the expected text✅ got: (f)
[🧪 test] accepts a binding that is used in the body
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fixed files have nothing left to report
[⚙️ assert] "(let ((x (f))) x)\n" is clean after its fix✅ got: ()
[⚙️ assert] "(let () (f))\n" is clean after its fix✅ got: ()
[⚙️ assert] "(let* ((x (f))) (g x))\n" is clean after its fix✅ got: ()
[🧪 test] reports a let* that binds once
[⚙️ assert] the findings are where they should be✅ got: ((1 2))
[🧪 test] reports a let with no bindings
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] the fix says let
[⚙️ assert] the fix produces the expected text✅ got: (let ((x (f))) (g x))
[🧪 test] an Emacs Lisp let is the same let
[⚙️ assert] the fix produces the expected text✅ got: (f)
[🧪 test] accepts a let* with two bindings
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix is the body
[⚙️ assert] the fix produces the expected text✅ got: (f)
[🧪 test] reports a binding that exists to be returned
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
+----------------------------------------------+
[📑 suite] checker: letrec-single-binding
[🧪 test] reports a letrec with one non-recursive binding
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts two bindings
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a binding that refers to itself
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: lexical-binding-missing
[🧪 test] the fix inserts the header
[⚙️ assert] the fix produces the expected text✅ got: ;;; -*- lexical-binding: t; -*-;;; f.el --- a package
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] reports a file with no header
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a header on the second line
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a header on the first line
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: library-not-found
[🧪 test] a library imported where nothing it exports is used is reported✅ got: ((1 23))
[🧪 test] a project that declares no library is not judged✅ got: ()
[🧪 test] a standard library is never reported missing✅ got: ()
[🧪 test] an import of a library no file declares is reported✅ got: ((1 23))
[🧪 test] a library the project declares is found✅ got: ()
[🧪 test] a library the file declares itself is found✅ got: ()
+----------------------------------------------+
[📑 suite] checker: line-length
[🧪 test] accepts a short line
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a line over the Scheme limit
[⚙️ assert] the findings are where they should be✅ got: ((1 97))
[🧪 test] reports a line over the Emacs Lisp limit, which is 80
[⚙️ assert] the findings are where they should be✅ got: ((1 81))
[🧪 test] the limit can be configured
[⚙️ assert] the findings are where they should be✅ got: ((1 6))
+----------------------------------------------+
[📑 suite] checker: loop-keyword-style
[🧪 test] reports symbolic keywords when the style asks for literal ones
[⚙️ assert] the findings are where they should be✅ got: ((1 7) (1 13) (1 19))
[🧪 test] says nothing when both spellings are accepted
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix rewrites the keywords
[⚙️ assert] the fix produces the expected text✅ got: (loop :for x :in xs :do (print x))
+----------------------------------------------+
[📑 suite] checker: naming-convention
[🧪 test] reports a variable definition too
[⚙️ assert] the findings are where they should be✅ got: ((1 9))
[🧪 test] reports a Common Lisp defparameter
[⚙️ assert] the findings are where they should be✅ got: ((1 15))
[🧪 test] reports an Emacs Lisp defun
[⚙️ assert] the findings are where they should be✅ got: ((1 8))
[🧪 test] accepts the usual hyphenated name
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports camelCase in a procedure name
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
[🧪 test] says nothing about a symbol that is not a definition
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a capitalised name
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
[🧪 test] accepts a name that is punctuation
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports an underscore in a procedure name
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
+----------------------------------------------+
[📑 suite] checker: negated-if
[🧪 test] reports an if with a negated test and no else branch
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] the fix rewrites a when as an unless
[⚙️ assert] the fix produces the expected text✅ got: (unless x (go))
[🧪 test] accepts an unless
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a when with a negated test
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] the fix rewrites the if as an unless
[⚙️ assert] the fix produces the expected text✅ got: (unless (ready?) (wait) (go))
[🧪 test] accepts an if whose test is not a negation
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports an if with a negated test
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
+----------------------------------------------+
[📑 suite] checker: nesting-depth
[🧪 test] counts a `when' inside an `if'
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] the limit is configuration
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a chain of conditionals deeper than the limit
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a `let' inside a `cond' inside a `define'
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: package-prefix
[🧪 test] reports an exported symbol used without a prefix
[⚙️ assert] the findings are where they should be✅ got: ((3 2))
[🧪 test] accepts a file with no export list
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a prefixed use
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: practices
[🧪 test] six parameters are reported and five are not
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the findings are where they should be✅ got: ()
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a quote around a symbol is left alone
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] eq? on a number and on a string are reported
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the number of findings is right✅ got: 1
[🧪 test] eq? on two variables and eqv? on a number are silent
[⚙️ assert] the findings are where they should be✅ got: ()
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a cond with clauses after else is reported
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] only the required positional parameters are counted
[⚙️ assert] the findings are where they should be✅ got: ()
[⚙️ assert] the findings are where they should be✅ got: ()
[⚙️ assert] the findings are where they should be✅ got: ()
[⚙️ assert] the number of findings is right✅ got: 0
[🧪 test] a quoted number is reported and the quote is removable
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the fix produces the expected text✅ got: 5
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] a defcustom without :type is reported in Emacs Lisp
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a case datum listed twice is reported
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a defun's parameters are all of them, not all but the first
[⚙️ assert] the number of findings is right✅ got: 1
[🧪 test] a quoted string, character and list are told apart
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the number of findings is right✅ got: 1
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: predicate-name
[🧪 test] reports a procedure that returns a comparison
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
[🧪 test] accepts a name that ends in a question mark
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a procedure whose last form is another predicate
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
[🧪 test] Emacs Lisp accepts the -p suffix
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a procedure that returns something else
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] Emacs Lisp reports a name with neither suffix
[⚙️ assert] the findings are where they should be✅ got: ((1 8))
[🧪 test] a docstring is not the returned value
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
+----------------------------------------------+
[📑 suite] checker: provide-missing
[🧪 test] accepts a file that defines nothing
[⚙️ assert] the number of findings is right✅ got: 0
[🧪 test] reports a file that defines but never provides
[⚙️ assert] the number of findings is right✅ got: 1
[🧪 test] accepts a file that provides its feature
[⚙️ assert] the number of findings is right✅ got: 0
+----------------------------------------------+
[📑 suite] checker: quasiquote-unquote-constant
[🧪 test] reports the long-hand form too
[⚙️ assert] the findings are where they should be✅ got: ((1 13))
[🧪 test] reports an unquoted number inside a quasiquote
[⚙️ assert] the findings are where they should be✅ got: ((1 5))
[🧪 test] accepts an unquoted variable
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: reader-prefix-break
[🧪 test] reports a quote separated from its datum
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] a function quote is covered too
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a quote attached to its datum
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix joins the prefix to the datum
[⚙️ assert] the fix produces the expected text✅ got: '(a)
+----------------------------------------------+
[📑 suite] checker: redundant-identity
[🧪 test] reports an identity call
[⚙️ assert] the findings are where they should be✅ got: ((1 21))
[🧪 test] reports a funcall of a function name
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a plain call
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: redundant-progn
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] reports a progn that is the only body form
[⚙️ assert] the findings are where they should be✅ got: ((1 13))
[🧪 test] reports one in a defun
[⚙️ assert] the findings are where they should be✅ got: ((1 13))
[🧪 test] a vector whose first element is progn is a literal, not a body
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a progn with company
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix splices the body
[⚙️ assert] the fix produces the expected text✅ got: (define (f) (a) (b))
+----------------------------------------------+
[📑 suite] checker: single-letter-name
[🧪 test] reports a parameter of a `lambda'
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
[🧪 test] accepts an ignored parameter
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] says nothing about a definition that names a program
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts an index variable, which is what the setting is for
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the accepted names are a setting
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports the binding of a `let'
[⚙️ assert] the findings are where they should be✅ got: ((1 8))
[🧪 test] reports each single-letter parameter of a definition
[⚙️ assert] the findings are where they should be✅ got: ((1 15) (1 17))
[🧪 test] reports a parameter of a Common Lisp defun
[⚙️ assert] the findings are where they should be✅ got: ((1 11))
[🧪 test] reports a parameter of an Emacs Lisp defun
[⚙️ assert] the findings are where they should be✅ got: ((1 11))
[🧪 test] accepts names made of words
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a setting replaces the default list rather than extending it
[⚙️ assert] the findings are where they should be✅ got: ((1 10))
+----------------------------------------------+
[📑 suite] checker: special-variable-name
[🧪 test] accepts a constant written with plus signs
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts an earmuffed one
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports earmuffs in Emacs Lisp
[⚙️ assert] the findings are where they should be✅ got: ((1 9))
[🧪 test] reports a Common Lisp constant without plus signs
[⚙️ assert] the findings are where they should be✅ got: ((1 14))
[🧪 test] accepts a plain Emacs Lisp variable
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a Common Lisp special variable without earmuffs
[⚙️ assert] the findings are where they should be✅ got: ((1 15))
+----------------------------------------------+
[📑 suite] checker: sxml-attributes
[🧪 test] reports a second attribute list
[⚙️ assert] the findings are where they should be✅ got: ((1 22))
[🧪 test] reports an empty attribute list
[⚙️ assert] the findings are where they should be✅ got: ((1 6))
[🧪 test] accepts an element with no attributes at all
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports attributes that come after a child
[⚙️ assert] the findings are where they should be✅ got: ((1 14))
[🧪 test] accepts a document of nested elements
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts an element whose attributes come first
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: sxml-child
[🧪 test] accepts elements, strings and numbers as children
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] an element with no attributes is not judged
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts the same list without the extra level
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a list of elements where elements belong
[⚙️ assert] the findings are where they should be✅ got: ((1 18))
+----------------------------------------------+
[📑 suite] checker: tabs
[🧪 test] accepts indentation made of spaces
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix replaces the tab with spaces
[⚙️ assert] the fix produces the expected text✅ got: (a b)
[🧪 test] a tab inside a string is data, not indentation
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] reports a tab used for indentation
[⚙️ assert] the findings are where they should be✅ got: ((2 1))
+----------------------------------------------+
[📑 suite] checker: trailing-blank-lines
[🧪 test] the fix trims the end of the file to one blank line
[⚙️ assert] the fix produces the expected text✅ got: (define x 1)
[🧪 test] reports four blank lines at the end of a file
[⚙️ assert] the number of findings is right✅ got: 1
[🧪 test] accepts a file with one blank line at the end
[⚙️ assert] the number of findings is right✅ got: 0
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] accepts a file with a single trailing newline
[⚙️ assert] the number of findings is right✅ got: 0
+----------------------------------------------+
[📑 suite] checker: trailing-whitespace
[🧪 test] reports a line that ends with a space
[⚙️ assert] the findings are where they should be✅ got: ((1 2))
[🧪 test] the fixed file has nothing left to report
[⚙️ assert] the fixed text is clean✅ got: ()
[🧪 test] reports every line of a file
[⚙️ assert] the findings are where they should be✅ got: ((1 2) (2 2))
[🧪 test] the fix strips the whitespace
[⚙️ assert] the fix produces the expected text✅ got: xy
[🧪 test] accepts a file whose lines are clean
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a line that ends with a tab
[⚙️ assert] the findings are where they should be✅ got: ((1 2))
+----------------------------------------------+
[📑 suite] checker: unless-without-body
[🧪 test] reports one in Common Lisp too
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts an unless with a body
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports an unless with no body
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
+----------------------------------------------+
[📑 suite] checker: unmatched-parens
[🧪 test] reports a stray closing parenthesis
[⚙️ assert] the findings are where they should be✅ got: ((1 2))
[🧪 test] reports an unmatched opening parenthesis at the opener
[⚙️ assert] the findings are where they should be✅ got: ((1 1) (1 4))
[🧪 test] accepts a balanced file
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: unused-argument
[🧪 test] reports a parameter the body never uses
[⚙️ assert] the findings are where they should be✅ got: ((1 14))
[🧪 test] accepts a parameter named with an underscore
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] accepts a parameter that is used
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reads a parameter with a default
[⚙️ assert] the findings are where they should be✅ got: ((1 25))
[🧪 test] accepts a lambda that uses its parameter
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reads a specialized Common Lisp parameter
[⚙️ assert] the findings are where they should be✅ got: ((1 19))
[🧪 test] reads the parameters of a defun
[⚙️ assert] the findings are where they should be✅ got: ((1 13))
+----------------------------------------------+
[📑 suite] checker: unused-definition
[🧪 test] a file with no define-module is not judged
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a definition another one uses is not dead
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a module with no #:export clause is not judged
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a name mentioned under a quote counts as mentioned
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a definition nothing uses and the module does not export
[⚙️ assert] the findings are where they should be✅ got: ((4 10))
[🧪 test] the name in the export list is the name that counts
[⚙️ assert] the findings are where they should be✅ got: ((3 10))
[🧪 test] an exported definition is the module's surface
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a module that says it exports nothing is judged
[⚙️ assert] the findings are where they should be✅ got: ((3 10))
+----------------------------------------------+
[📑 suite] checker: unused-import
[🧪 test] a name used only inside a quote does not count as used
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] a plain import of a library sift cannot read is left alone
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] a `#:use-module` clause whose names are used is silent
[⚙️ assert] the name the clause brings in is used✅ got: 0
[🧪 test] the fix deletes the name and the space before it
[⚙️ assert] the fix produces the expected text✅ got: (import (only (srfi 1) fold))(display (fold + 0 (list 1 2)))
[🧪 test] an import used inside a library body is read
[⚙️ assert] the findings are where they should be✅ got: ((3 25))
[🧪 test] reports a renamed import nothing uses, by its new name
[⚙️ assert] the fix produces the expected text✅ got: (import (rename (srfi 1) (fold foldl)))(display (foldl + 0 (list 1)))
[🧪 test] every name in an `only` clause used is silent
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] the fix removes the whole import when it is the only thing on its line
[⚙️ assert] the fix produces the expected text✅ got: (display 1)
[🧪 test] a `#:use-module` clause nothing uses is reported, keyword and all
[⚙️ assert] one finding, on the clause✅ got: 1
[⚙️ assert] the fix removes the clause and the line it was on✅ got: (define-module (proj client) #:export (f))(define (f x) x)
[🧪 test] a name used inside a quasiquote counts as used
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] one unused spec of two is deleted, and the form stays
[⚙️ assert] the fix produces the expected text✅ got: (import (scheme base))(display 1)
[🧪 test] an `only` clause with nothing used is one finding, on the form
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] reports the name of an `only` clause nothing uses
[⚙️ assert] the findings are where they should be✅ got: ((1 29))
[🧪 test] a name used inside a template that spells unquote counts as used
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] checker: when-without-body
[🧪 test] reports a when with no body in Common Lisp
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
[🧪 test] accepts a when with a body
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a when with no body
[⚙️ assert] the findings are where they should be✅ got: ((1 1))
+----------------------------------------------+
[📑 suite] checker: wrap-in-let
[🧪 test] reports a body form that nests too deeply
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] the depth limit is configuration
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] reports a body form with too many elements
[⚙️ assert] the findings are where they should be✅ got: ((2 3))
[🧪 test] accepts a body form that is already split up
[⚙️ assert] the findings are where they should be✅ got: ()
[🧪 test] there is no automatic fix✅ got: #f
[🧪 test] the element limit is configuration
[⚙️ assert] the findings are where they should be✅ got: ()
+----------------------------------------------+
[📑 suite] cli
[🧪 test] lint reports findings with status 1
[⚙️ assert] the exit status is right✅ got: 1✅ got: [trailing-whitespace]
[🧪 test] lint --format=github writes workflow commands
[⚙️ assert] the exit status is right✅ got: 1✅ got: ::warning file=✅ got: title=SIFT001 [trailing-whitespace]
[🧪 test] --stdin and --stdout work as a filter
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (define (f x) (+ x 1))
[🧪 test] a document format writes one document for the whole run
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] there is one document✅ got: 1
[⚙️ assert] both files are artifacts✅ got: 2✅ got: "ruleId":"format"✅ got: "ruleId":"SIFT001"
[🧪 test] lint --quiet keeps the findings and drops the summary
[⚙️ assert] the exit status is right✅ got: 1✅ got: [trailing-whitespace]✅ got: file checked
[🧪 test] install-hooks leaves an existing hook alone
[⚙️ assert] the exit status is right✅ got: 2✅ got: already exists
[🧪 test] an unknown bracket style is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: unknown bracket style
[🧪 test] version prints the version and succeeds
[⚙️ assert] the exit status is right✅ got: 0✅ got: sift
[🧪 test] lint --format=json emits one array for the run
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] it starts with an array✅ got: #t✅ got: "severity"✅ got: "checker"✅ got: "line"
[🧪 test] lint --format=json carries the rule code✅ got: "code"✅ got: SIFT001
[🧪 test] ci fails when the linter has something to say
[⚙️ assert] the exit status is right✅ got: 1✅ got: [trailing-whitespace]
[🧪 test] lint on a clean file succeeds and prints a summary
[⚙️ assert] the exit status is right✅ got: 0✅ got: 1 file checked
[🧪 test] --version prints the version without a subcommand
[⚙️ assert] the exit status is right✅ got: 0✅ got: sift
[🧪 test] a document format answers a run of several files once
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] it is one array✅ got: #t
[⚙️ assert] one array holds them all✅ got: 1
[🧪 test] list-checkers --dialect filters to the dialect
[⚙️ assert] the exit status is right✅ got: 0✅ got: docstring-missing✅ got: internal-define
[🧪 test] a parse error is a refusal, with status 2
[⚙️ assert] the exit status is right✅ got: 2✅ got: parse error
[🧪 test] lint --exclude-checker skips the checker it names✅ got: trailing-whitespace
[🧪 test] config show prints the effective configuration
[⚙️ assert] the exit status is right✅ got: 0✅ got: line-length✅ got: style
[🧪 test] lint --format=sarif describes the rules, the artifacts and the run
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] the document carries "fullDescription":✅ got: "fullDescription":
[⚙️ assert] the document carries "help":{"text":✅ got: "help":{"text":
[⚙️ assert] the document carries "helpUri":✅ got: "helpUri":
[⚙️ assert] the document carries "shortDescription":✅ got: "shortDescription":
[⚙️ assert] the document carries "invocations":[{"executionSuccessful":true}]✅ got: "invocations":[{"executionSuccessful":true}]
[⚙️ assert] the document carries "artifacts":[{"location":{"uri":"tests/fixtures/lint/dirty.scm"}✅ got: "artifacts":[{"location":{"uri":"tests/fixtures/lint/dirty.scm"}
[⚙️ assert] the document carries "roles":["analysisTarget"]✅ got: "roles":["analysisTarget"]
[⚙️ assert] the document carries "index":0✅ got: "index":0
[⚙️ assert] the document carries "columnKind":"unicodeCodePoints"✅ got: "columnKind":"unicodeCodePoints"
[⚙️ assert] the document carries "partialFingerprints":{"siftFingerprint/v1":✅ got: "partialFingerprints":{"siftFingerprint/v1":
[⚙️ assert] the document carries "charOffset":✅ got: "charOffset":
[⚙️ assert] the document carries "charLength":✅ got: "charLength":
[⚙️ assert] the document carries "ruleIndex":0✅ got: "ruleIndex":0
[⚙️ assert] the rule is named by its code✅ got: "ruleId":"SIFT001"
[🧪 test] --brackets=parens overrides the Scheme default
[⚙️ assert] the exit status is right✅ got: 0✅ got: (cond ((< n 0) 1)
[🧪 test] lint --fix rewrites the file and reports what is left
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (when (ready?) (go))
[🧪 test] lint --fix --stdin prints the fixed source to stdout
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (when (ready?) (go))
[🧪 test] format writes the formatted source to stdout
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (define (square x) (* x x))(define (classify n) (cond [(< n 0) 'negative] [(= n 0) 'zero] [else 'positive]))(let ((a 1) (b 2)) (+ a b (* a b)))
[🧪 test] format --diff on a formatted file prints nothing and exits 0
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got:
[🧪 test] fix --stdin refuses a buffer that does not parse
[⚙️ assert] the exit status is right✅ got: 2
[⚙️ assert] no text is written to standard output✅ got:
[🧪 test] explain leads with the rule's code✅ got: SIFT012
[🧪 test] explain documents a checker
[⚙️ assert] the exit status is right✅ got: 0✅ got: DESCRIPTION✅ got: DIALECTS
[🧪 test] an unreadable file says why, in words
[⚙️ assert] the exit status is right✅ got: 2✅ got: no-such-file.scm✅ got: ~A
[🧪 test] ci fails when a file is not formatted
[⚙️ assert] the exit status is right✅ got: 1✅ got: @@
[🧪 test] format --write rewrites the file in place
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (define (f x) (+ x 1))
[🧪 test] fix refuses a file that does not parse, and says why
[⚙️ assert] the exit status is right✅ got: 2✅ got: parse error
[⚙️ assert] the file is left exactly as it was✅ got: (define (f x) (a b
[🧪 test] check reports a difference with status 1
[⚙️ assert] the exit status is right✅ got: 1✅ got: @@
[🧪 test] install-hooks writes a pre-commit hook
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the hook was written✅ got: #t✅ got: sift
[🧪 test] every option that takes a value accepts both spellings
[⚙️ assert] --dialect value is accepted✅ got: 0
[⚙️ assert] --dialect spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --severity value is accepted✅ got: 0
[⚙️ assert] --severity spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --format value is accepted✅ got: 0
[⚙️ assert] --format spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --style value is accepted✅ got: 0
[⚙️ assert] --style spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --line-length value is accepted✅ got: 0
[⚙️ assert] --line-length spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --indent value is accepted✅ got: 0
[⚙️ assert] --indent spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --brackets value is accepted✅ got: 0
[⚙️ assert] --brackets spells the same both ways✅ got: (define (f x) (+ x 1))
[⚙️ assert] --label value is accepted✅ got: 0
[⚙️ assert] --label spells the same both ways✅ got: (define (f x) (+ x 1))
[🧪 test] format --diff prints a patch and exits 1
[⚙️ assert] the exit status is right✅ got: 1✅ got: @@ ✅ got: -
[🧪 test] ci passes on a clean file
[⚙️ assert] the exit status is right✅ got: 0
[🧪 test] ci --format=github turns formatting differences into annotations
[⚙️ assert] the exit status is right✅ got: 1✅ got: ::error file=
[🧪 test] fix --force fixes what it can read
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] the trailing whitespace is gone✅ got: (define (f x)
[🧪 test] check on an already formatted file succeeds
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got:
[🧪 test] an unknown dialect is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: unknown dialect
[🧪 test] ci does not write the file it is judging
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] the text matches✅ got: (define (f x) (+ x 1))
[🧪 test] an unreadable file is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: cannot read
[🧪 test] list-checkers prints a table
[⚙️ assert] the exit status is right✅ got: 0✅ got: trailing-whitespace✅ got: SEVERITY
[🧪 test] --label names the source in diagnostics
[⚙️ assert] the exit status is right✅ got: 1✅ got: my-buffer.scm
[🧪 test] explain answers 2 for a checker it does not know
[⚙️ assert] the exit status is right✅ got: 2✅ got: unknown checker
[🧪 test] ci refuses to fix
[⚙️ assert] the exit status is right✅ got: 2✅ got: never fixes
[🧪 test] --stdin with more than one file is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: at most one file
[🧪 test] lint --format=sarif writes a SARIF document
[⚙️ assert] the exit status is right✅ got: 1✅ got: "version":"2.1.0"✅ got: "rules":✅ got: "ruleId":"SIFT001"✅ got: "artifactLocation"
[🧪 test] doctor says what ran and what it decided
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] doctor starts with the version✅ got: sift ✅ got: rules✅ got: sift.yaml
[🧪 test] --stdin with one file is the label, and is not a usage error
[⚙️ assert] the exit status is right✅ got: 0
[🧪 test] --write with --stdout is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: cannot be used together
[🧪 test] config explain documents a key
[⚙️ assert] the exit status is right✅ got: 0✅ got: --line-length
[🧪 test] doctor names the library without a `..' in it
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the library line is a directory under the checkout✅ got: /src✅ got: ..
[🧪 test] a directory operand skips entries it cannot ask about
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] the file that could be read was read✅ got: real.scm
[🧪 test] fix is lint --fix
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (when (ready?) (go))
[🧪 test] an unknown command is a usage error, with status 2
[⚙️ assert] the exit status is right✅ got: 2✅ got: Usage:
[🧪 test] lint --checker runs only the checker it names
[⚙️ assert] the exit status is right✅ got: 0✅ got: trailing-whitespace
[🧪 test] an unknown checker is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: unknown checker
[🧪 test] install-hooks outside a repository is a usage error
[⚙️ assert] the exit status is right✅ got: 2✅ got: no git repository
[🧪 test] --force formats what can be read
[⚙️ assert] the exit status is right✅ got: 0
[🧪 test] install-hooks --force replaces one
[⚙️ assert] the exit status is right✅ got: 0✅ got: sift
[🧪 test] list-checkers prints each rule's code✅ got: SIFT001✅ got: CODE
[🧪 test] lint --format=null says nothing at all
[⚙️ assert] the exit status is right✅ got: 1
[⚙️ assert] the text matches✅ got:
+----------------------------------------------+
[📑 suite] project configuration
[🧪 test] indent-rules written as a YAML sequence indents the macro
[⚙️ assert] the exit status is right✅ got: 0
[⚙️ assert] the text matches✅ got: (with-my-thing (a) (b))
[🧪 test] an empty flow sequence is an empty list of names
[⚙️ assert] the exit status is right✅ got: 0✅ got: exclude-checkers: []
+----------------------------------------------+
[📑 suite] declarations: a declaration is not a call
[🧪 test] a parameter list with too many required parameters is still reported✅ got: 1
[🧪 test] a parameter list of keywords and optionals is not a call✅ got: ()
[🧪 test] no rule about calls reports a declaration
[⚙️ assert] scheme declaration: (define-module (demo thing)✅ got: ()
[⚙️ assert] scheme declaration: (use-modules (srfi srfi-1)✅ got: ()
[⚙️ assert] scheme declaration: (import (scheme base)✅ got: ()
[⚙️ assert] scheme declaration: (export one✅ got: ()
[⚙️ assert] scheme declaration: (define-library (demo lib)✅ got: ()
[⚙️ assert] scheme declaration: (library (demo r6rs)✅ got: ()
[⚙️ assert] scheme declaration: (declare (pure? #t) (blocked #:all) (names one two three four five six))✅ got: ()
[⚙️ assert] elisp declaration: (require 'cl-lib)✅ got: ()
[⚙️ assert] elisp declaration: (use-package flymake✅ got: ()
[⚙️ assert] elisp declaration: (declare-function sift-mode "sift" (&optional arg))✅ got: ()
[⚙️ assert] elisp declaration: (eval-when-compile (require 'cl-lib))✅ got: ()
[⚙️ assert] elisp declaration: (setq one 1 two 2 three 3 four 4 five 5 six 6)✅ got: ()
[⚙️ assert] cl declaration: (defpackage :demo✅ got: ()
[⚙️ assert] cl declaration: (in-package :demo)✅ got: ()
[⚙️ assert] cl declaration: (declaim (optimize (speed 3) (safety 0) (debug 0) (space 0) (compilation-speed 0)))✅ got: ()
[⚙️ assert] cl declaration: (proclaim '(ftype (function (fixnum fixnum) fixnum) add))✅ got: ()
[⚙️ assert] cl declaration: (defmethod area ((shape circle) &key (scale 1) &allow-other-keys)✅ got: ()
[⚙️ assert] cl declaration: (defun add (a b &optional (c 1) &key (d 2) &allow-other-keys)✅ got: ()
[🧪 test] a call with too many positional arguments is still reported✅ got: 1
[🧪 test] a definition's body is still read as code✅ got: 1
[🧪 test] a parameter list is not a call, however long it is
[⚙️ assert] elisp parameter list: (defun demo-f (a b c d e f g)✅ got: ()
[⚙️ assert] elisp parameter list: (lambda (a b c d e f g) (list a b c d e f g))✅ got: ()
[⚙️ assert] scheme parameter list: (define (demo-f a b c d e f g)✅ got: ()
[⚙️ assert] scheme parameter list: (define* (demo-g a b #:key c d e f g h)✅ got: ()
[⚙️ assert] cl parameter list: (defmethod area ((shape circle) &key (scale 1) &allow-other-keys)✅ got: ()
+----------------------------------------------+
[📑 suite] definitions: scope and bindings
[🧪 test] let-syntax binds its keyword over the body✅ got: (with-two 1 15)
[🧪 test] a syntax-case clause binds its pattern variables✅ got: (a 3 7)
[🧪 test] a binding inside a template still wins over the pattern✅ got: (tmp 4 13)
[🧪 test] the ellipsis binds nothing✅ got: #f
[🧪 test] a pattern variable is not a definition of the file✅ got: 1
[🧪 test] a define-syntax is a macro in the outline✅ got: ((swap! macro))
[🧪 test] the name of a definition is a definition of itself✅ got: (f 1 10)
[🧪 test] a literal in the pattern binds nothing✅ got: #f
[🧪 test] a parameter is nearer than the definition of the same name✅ got: (x 1 12)
[🧪 test] a renamed ellipsis binds nothing either✅ got: #f
[🧪 test] an internal definition is a definition of the body it sits in✅ got: (g 2 12)
[🧪 test] a template variable is defined by its pattern✅ got: (a 3 9)
[🧪 test] a pattern variable inside a nested list is still a variable✅ got: (a 3 10)
[🧪 test] an underscore binds nothing✅ got: #f
[🧪 test] a let binding wins over the definition it shadows✅ got: (x 2 10)
[🧪 test] a named let binds its own name over the body✅ got: (loop 2 8)
[🧪 test] letrec-syntax binds its keyword over the body too✅ got: (with-two 1 18)
+----------------------------------------------+
[📑 suite] files: extensions and filters
[🧪 test] a filter replaces the extensions✅ got: #t✅ got: #f
[🧪 test] a file sift has no extension for is not one of its files✅ got: #f
[🧪 test] no filter falls back to the extensions✅ got: #t✅ got: #f
[🧪 test] a dot in a pattern is a dot, not any character✅ got: #f
[🧪 test] * stops at a separator✅ got: #f✅ got: #t
[🧪 test] the Scheme extensions sift reads include the library and program ones
[⚙️ assert] .scm is a Lisp file✅ got: #t
[⚙️ assert] .ss is a Lisp file✅ got: #t
[⚙️ assert] .sld is a Lisp file✅ got: #t
[⚙️ assert] .sls is a Lisp file✅ got: #t
[⚙️ assert] .sps is a Lisp file✅ got: #t
[⚙️ assert] .el is a Lisp file✅ got: #t
[⚙️ assert] .lisp is a Lisp file✅ got: #t
[⚙️ assert] .cl is a Lisp file✅ got: #t
[⚙️ assert] .asd is a Lisp file✅ got: #t
[🧪 test] a single pattern is a filter with one rule✅ got: (*.scm)
[🧪 test] a pattern with no separator is matched against the file's own name✅ got: #t
[🧪 test] the last pattern that matches decides✅ got: #t
[🧪 test] ** crosses a separator✅ got: #t
[🧪 test] a pattern is read relative to the root of the walk✅ got: #t
[🧪 test] a list of patterns is read as it is written✅ got: (src/** !gen/**)
[🧪 test] a negated pattern takes a file back out✅ got: #f✅ got: #t
[🧪 test] no filter in the file is no filter at all✅ got: #f
+----------------------------------------------+
[📑 suite] format: Common Lisp
[🧪 test] a read macro keeps the datum it applies to glued to it
[⚙️ assert] the text matches✅ got: (defparameter *a* #2A((1 2)))
[⚙️ assert] the text matches✅ got: (defparameter *c* #c(1 2))
[⚙️ assert] the text matches✅ got: (probe-file #P"/tmp/x")
[🧪 test] feature conditionals keep both halves on one line
[⚙️ assert] the text matches✅ got: #+sbcl (defun f ())#-sbcl (defun f ())
[🧪 test] handler-case clauses align under each other
[⚙️ assert] the text matches✅ got: (handler-case (foo) (error (e) (print e)))
[🧪 test] every expected file is a fixed point of formatting
[⚙️ assert] package.lisp is already formatted✅ got: (defpackage :demo (:use :cl) (:export #:run))(in-package :demo)(defun run (n) (loop :for i :below n :do (print i)))
[⚙️ assert] reader-macros.lisp is already formatted✅ got: (in-package :demo)(defparameter *grid* #2A((1 2) (3 4)))(defparameter *z* #c(1 2))(defparameter *cycle* #1=(a . #1#))(probe-file #P"/tmp/x")
[🧪 test] a LOOP keeps its keyword atoms and indents them two in
[⚙️ assert] the text matches✅ got: (loop :for x :in xs :do (print x))
[🧪 test] formatting Common Lisp is idempotent
[⚙️ assert] formatting is a fixed point✅ got: (defun f (x) "Doc." (list x))
[🧪 test] line endings are normalised to LF
[⚙️ assert] the text matches✅ got: (a b)
[🧪 test] a defpackage indents its clauses two columns in
[⚙️ assert] the text matches✅ got: (defpackage :demo (:use :cl) (:export #:run))
[🧪 test] a defclass indents its slots two columns in
[⚙️ assert] the text matches✅ got: (defclass point () ((x :initarg :x) (y :initarg :y)))
[🧪 test] every fixture formats to its expected file
[⚙️ assert] package.lisp formats to its expected file✅ got: (defpackage :demo (:use :cl) (:export #:run))(in-package :demo)(defun run (n) (loop :for i :below n :do (print i)))
[⚙️ assert] reader-macros.lisp formats to its expected file✅ got: (in-package :demo)(defparameter *grid* #2A((1 2) (3 4)))(defparameter *z* #c(1 2))(defparameter *cycle* #1=(a . #1#))(probe-file #P"/tmp/x")
+----------------------------------------------+
[📑 suite] format: Emacs Lisp
[🧪 test] formatting Emacs Lisp is idempotent
[⚙️ assert] formatting is a fixed point✅ got: (defun f (x) "Doc." (list x))
[🧪 test] a use-package form puts its keywords and their bodies two columns in
[⚙️ assert] the text matches✅ got: (use-package evil :ensure t :init (setq evil-want-integration t) :config (evil-mode 1))
[🧪 test] every fixture formats to its expected file
[⚙️ assert] buffer.el formats to its expected file✅ got: ;;; buffer.el --- a demo -*- lexical-binding: t; -*-(defun my-greet (name) "Greet NAME." (message "Hello, %s" name))(let ((x 1) (y 2)) (+ x y))(provide 'buffer)
[⚙️ assert] reader-macros.el formats to its expected file✅ got: ;;; reader-macros.el --- the read macros of the dialect -*- lexical-binding: t; -*-(defun my-setup () "Set up the table and the keys." (setq my-table #s(hash-table test equal data ("a" 1))) (setq my-cycle #1=(a . #1#)) (setq my-keys [?\C-x ?\C-c]))(provide 'reader-macros)(setq my-rx (rx (| "a" "b")))
[⚙️ assert] use-package.el formats to its expected file✅ got: ;;; use-package.el --- a demo -*- lexical-binding: t; -*-(use-package evil :ensure t :init (setq evil-want-integration t) :config (evil-mode 1))(use-package magit :ensure t :bind ("C-x g" . magit-status))(use-package foo :ensure t :custom (foo-directory "/tmp/foo") :hook (prog-mode . foo-mode))(provide 'use-package-demo)
[🧪 test] documented forms the table knows are indented from the opener
[⚙️ assert] the text matches✅ got: (with-current-buffer buf (goto-char (point-min)))
[🧪 test] a defun indents its docstring and body two columns in
[⚙️ assert] the text matches✅ got: (defun f (x) "Return X." (when x (message "x")))
[🧪 test] every expected file is a fixed point of formatting
[⚙️ assert] buffer.el is already formatted✅ got: ;;; buffer.el --- a demo -*- lexical-binding: t; -*-(defun my-greet (name) "Greet NAME." (message "Hello, %s" name))(let ((x 1) (y 2)) (+ x y))(provide 'buffer)
[⚙️ assert] reader-macros.el is already formatted✅ got: ;;; reader-macros.el --- the read macros of the dialect -*- lexical-binding: t; -*-(defun my-setup () "Set up the table and the keys." (setq my-table #s(hash-table test equal data ("a" 1))) (setq my-cycle #1=(a . #1#)) (setq my-keys [?\C-x ?\C-c]))(provide 'reader-macros)(setq my-rx (rx (| "a" "b")))
[⚙️ assert] use-package.el is already formatted✅ got: ;;; use-package.el --- a demo -*- lexical-binding: t; -*-(use-package evil :ensure t :init (setq evil-want-integration t) :config (evil-mode 1))(use-package magit :ensure t :bind ("C-x g" . magit-status))(use-package foo :ensure t :custom (foo-directory "/tmp/foo") :hook (prog-mode . foo-mode))(provide 'use-package-demo)
[🧪 test] a read macro keeps the datum it applies to glued to it
[⚙️ assert] the text matches✅ got: (defvar t #s(hash-table test equal data ("a" 1)))
[⚙️ assert] the text matches✅ got: (defvar c #1=(a . #1#))
[🧪 test] the square bracket style does not reach Emacs Lisp
[⚙️ assert] the text matches✅ got: (cond ((null x) 1) (t 2))
[🧪 test] use-package keywords do not line up under the package name
[⚙️ assert] the text matches✅ got: (use-package magit :ensure t :bind ("C-x g" . magit-status))
[🧪 test] a let binds in a data list, lined up under the first binding
[⚙️ assert] the text matches✅ got: (let ((a 1) (b 2)) (+ a b))
[🧪 test] a data list whose head starts a line is not aligned past it
[⚙️ assert] the text matches✅ got: (defcustom x '( insert-tab))
[🧪 test] strings, escapes and characters are preserved
[⚙️ assert] the text matches✅ got: (message "a b\n" ?\C-x)
[🧪 test] condition-case indents its protected form and handlers two in
[⚙️ assert] the text matches✅ got: (condition-case nil (foo) (error (message "no")))
+----------------------------------------------+
[📑 suite] format: Scheme
[🧪 test] a heading comment stays with the form it heads
[⚙️ assert] the text matches✅ got: (a);;; b(b)
[🧪 test] a project that writes parentheses keeps them
[⚙️ assert] the text matches✅ got: (cond ((< n 0) 'negative) (else 'positive))
[🧪 test] a bytevector's numbers line up under the first as well
[⚙️ assert] the text matches✅ got: (define b #u8(1 2 3))
[⚙️ assert] the text matches✅ got: (define b #vu8(1 2 3))
[🧪 test] a data list lines up under its first element
[⚙️ assert] the text matches✅ got: (let ((a 1) (b 2)) (+ a b))
[🧪 test] a cond whose clauses start on their own lines indents them two in
[⚙️ assert] the text matches✅ got: (cond [(< n 0) 1] [else 2])
[🧪 test] a vector's elements line up under its first, symbol or not
[⚙️ assert] the text matches✅ got: (define v #(foo bar baz))
[🧪 test] an unknown operator lines its arguments up under the first
[⚙️ assert] the text matches✅ got: (my-macro a b)
[🧪 test] a read macro keeps the datum it applies to glued to it
[⚙️ assert] the text matches✅ got: (define a #1=(x . #1#))
[⚙️ assert] the text matches✅ got: (display #`(a #,b #,@c))
[🧪 test] one blank line separates adjacent top-level forms when asked
[⚙️ assert] the text matches✅ got: (a)(b)
[🧪 test] a single-line datum comment is untouched
[⚙️ assert] the text matches✅ got: (a #;(b c) d)
[🧪 test] a call without keywords lines up the same way
[⚙️ assert] the text matches✅ got: (make-window title width height)
[🧪 test] comments are aligned when asked
[⚙️ assert] the text matches✅ got: (let ((a 1) ; one (b 22)) ; two (+ a b))
[🧪 test] two forms on one line are separated when asked
[⚙️ assert] the text matches✅ got: (a)(b)
[🧪 test] the dangling style puts each closer on its own line
[⚙️ assert] nested.scm formats to its expected file✅ got: (define (f x) (let ((a 1) (b 2) ) (when (> a b) (display "yes") ) ))
[⚙️ assert] nested.scm is already formatted✅ got: (define (f x) (let ((a 1) (b 2) ) (when (> a b) (display "yes") ) ))
[🧪 test] an unknown operator alone on its line indents one column in
[⚙️ assert] the text matches✅ got: (my-macro a)
[🧪 test] strings are never reflowed or respelled
[⚙️ assert] the text matches✅ got: (display "a b\n")
[🧪 test] formatting is idempotent on this sentence's own source
[⚙️ assert] formatting is a fixed point✅ got: (define (f x) (progn (a) (b)))
[🧪 test] a file without a final newline keeps that shape
[⚙️ assert] the text matches✅ got: (a b)
[🧪 test] preserving brackets leaves each clause as it was written
[⚙️ assert] the text matches✅ got: (cond ((< n 0) 1) [else 2])
[🧪 test] a comment keeps the line it was on
[⚙️ assert] the text matches✅ got: (a ; inline b)
[🧪 test] preserve adds no blank line the author did not write
[⚙️ assert] the text matches✅ got: (a)(b)
[🧪 test] indentation follows the operator's rule
[⚙️ assert] the text matches✅ got: (define (f x) (let ((a 1)) (if x a x)))
[🧪 test] an R6RS library indents its declarations two columns in
[⚙️ assert] the text matches✅ got: #!r6rs(library (demo) (export f) (import (rnrs)))
[⚙️ assert] the text matches✅ got: #!fold-case(define-library (demo lib) (import (scheme base)) (export a))
[🧪 test] an extended symbol is one token, and is never respelled
[⚙️ assert] the text matches✅ got: (define #{foo bar}# 1)
[🧪 test] a vector keeps its own opener whatever the bracket style is
[⚙️ assert] the text matches✅ got: #(1 2 3)
[🧪 test] the one-blank-line style is a fixed point
[⚙️ assert] the text matches✅ got: (a)(b)
[🧪 test] keyword arguments line up under the first argument
[⚙️ assert] the text matches✅ got: (make-window title :width 10 :height 20)
[🧪 test] a multi-line extended symbol keeps the name it was given
[⚙️ assert] the text matches✅ got: (define #{whatever}# 1)
[🧪 test] every fixture formats to its expected file
[⚙️ assert] comments.scm formats to its expected file✅ got: ;;; A file about comments.(define (f x) ; inline ;; standalone x) ; trailing;; a comment after a blank line(display "text")
[⚙️ assert] messy.scm formats to its expected file✅ got: (define (square x) (* x x))(define (classify n) (cond [(< n 0) 'negative] [(= n 0) 'zero] [else 'positive]))(let ((a 1) (b 2)) (+ a b (* a b)))
[⚙️ assert] reader-macros.scm formats to its expected file✅ got: '(a b)`(c ,d ,@e)#(1 2 3) #u8(1 2)#;(ignored form)#| block |##+(or a b) (display "x")(define table #(one two three))(define bytes #vu8(1 2))(define #{odd name}# 'x)(define-syntax (m stx) (syntax-case stx () [(_ x) #`(list #,x ,x)]))(define (f lst' x'') (list lst' x''))
[🧪 test] one blank line is the most a body keeps when asked
[⚙️ assert] the text matches✅ got: (a b)
[🧪 test] a project's own indent rule wins over the table
[⚙️ assert] the text matches✅ got: (with-my-thing x y)
[🧪 test] blank lines between top-level forms are collapsed to one
[⚙️ assert] the text matches✅ got: (a)(b)
[🧪 test] a reader prefix is never separated from its datum
[⚙️ assert] the text matches✅ got: 'a
[🧪 test] a vector is closed with the delimiter it was opened with
[⚙️ assert] the text matches✅ got: (define v #(a b))
[🧪 test] a multi-line datum comment moves with the code around it
[⚙️ assert] the text matches✅ got: (define (f) #;(ignore this) x)
[🧪 test] a project's own indent rule is idempotent
[⚙️ assert] the project rule formats the same way twice✅ got: (with-my-thing x y)
[🧪 test] a blank line inside a form is kept, but a run is collapsed to two
[⚙️ assert] the text matches✅ got: (a b)
[🧪 test] every expected file is a fixed point of formatting
[⚙️ assert] comments.scm is already formatted✅ got: ;;; A file about comments.(define (f x) ; inline ;; standalone x) ; trailing;; a comment after a blank line(display "text")
[⚙️ assert] messy.scm is already formatted✅ got: (define (square x) (* x x))(define (classify n) (cond [(< n 0) 'negative] [(= n 0) 'zero] [else 'positive]))(let ((a 1) (b 2)) (+ a b (* a b)))
[⚙️ assert] reader-macros.scm is already formatted✅ got: '(a b)`(c ,d ,@e)#(1 2 3) #u8(1 2)#;(ignored form)#| block |##+(or a b) (display "x")(define table #(one two three))(define bytes #vu8(1 2))(define #{odd name}# 'x)(define-syntax (m stx) (syntax-case stx () [(_ x) #`(list #,x ,x)]))(define (f lst' x'') (list lst' x''))
[🧪 test] moving a verbatim block is idempotent
[⚙️ assert] the shifted block is the same on the second pass✅ got: (define (f) #;(ignore this) x)
[🧪 test] the body of a clause indents two columns
[⚙️ assert] the text matches✅ got: (cond [else 1])
[🧪 test] a list whose first element starts a line indents one column in
[⚙️ assert] the text matches✅ got: '( insert-tab)
[🧪 test] a datum comment that moves left keeps its internal shape
[⚙️ assert] the text matches✅ got: (let ((a 1)) #;(b c) a)
[🧪 test] cond clauses are written with square brackets
[⚙️ assert] the text matches✅ got: (cond [(< n 0) 'negative] [(= n 0) 'zero] [else 'positive])
+----------------------------------------------+
[📑 suite] JSON
[🧪 test] trailing text after the value is refused
[⚙️ assert] the document is refused: it is refused✅ got: #t
[⚙️ assert] the document is refused: on line 1✅ got: 1
[⚙️ assert] the document is refused: at column 4✅ got: 4
[🧪 test] whitespace between tokens is not part of the value
[⚙️ assert] the document is written back the same✅ got: {"a":[1,2]}
[🧪 test] a lone surrogate does not raise
[⚙️ assert] the text matches✅ got: �x
[🧪 test] a member is found by its name, or a default is answered✅ got: 1✅ got: missing
[⚙️ assert] the text matches✅ got: [1,2]
[🧪 test] an escaped solidus is a solidus
[⚙️ assert] the text matches✅ got: a/b
[🧪 test] a bare word is refused
[⚙️ assert] the document is refused: it is refused✅ got: #t
[⚙️ assert] the document is refused: on line 1✅ got: 1
[⚙️ assert] the document is refused: at column 2✅ got: 2
[🧪 test] an array of mixed values round trips
[⚙️ assert] the document is written back the same✅ got: [1,-2500,true,false,null,"a"]
[🧪 test] numbers are written the way they are read
[⚙️ assert] 0 round trips✅ got: 0
[⚙️ assert] 1 round trips✅ got: 1
[⚙️ assert] -1 round trips✅ got: -1
[⚙️ assert] 2500 round trips✅ got: 2500
[⚙️ assert] -2500 round trips✅ got: -2500
[⚙️ assert] 1.5 round trips✅ got: 1.5
[⚙️ assert] 0.25 round trips✅ got: 0.25
[🧪 test] a \u escape becomes the character it names
[⚙️ assert] the text matches✅ got: é
[🧪 test] a missing comma is refused
[⚙️ assert] the document is refused: it is refused✅ got: #t
[⚙️ assert] the document is refused: on line 1✅ got: 1
[⚙️ assert] the document is refused: at column 4✅ got: 4
[🧪 test] an unterminated string is refused
[⚙️ assert] a malformed member name: it is refused✅ got: #t
[⚙️ assert] a malformed member name: on line 1✅ got: 1
[⚙️ assert] a malformed member name: at column 6✅ got: 6
[🧪 test] an empty object is not an empty array
[⚙️ assert] the document is written back the same✅ got: {}
[⚙️ assert] the document is written back the same✅ got: []
[🧪 test] an object keeps the order it was written in
[⚙️ assert] the document is written back the same✅ got: {"jsonrpc":"2.0","id":1,"method":"initialize"}
[🧪 test] the position of an error counts lines from one
[⚙️ assert] the document is refused: it is refused✅ got: #t
[⚙️ assert] the document is refused: on line 3✅ got: 3
[⚙️ assert] the document is refused: at column 1✅ got: 1
[🧪 test] a string that needs escaping is written escaped
[⚙️ assert] the text matches✅ got: "a\"b\\c\nd"
[🧪 test] a nested document round trips
[⚙️ assert] the document is written back the same✅ got: {"params":{"capabilities":{"textDocument":{"formatting":{}}}}}
[🧪 test] a number that is not finite is written as null
[⚙️ assert] the text matches✅ got: null
[🧪 test] a symbol names a member as well as a string does✅ got: 1
[🧪 test] a control character is written as an escape
[⚙️ assert] the text matches✅ got: "\u0001"
[🧪 test] the escapes JSON requires are read back as characters
[⚙️ assert] the text matches✅ got: a"b\cd e
[🧪 test] a trailing comma is refused
[⚙️ assert] an object with a trailing comma: it is refused✅ got: #t
[⚙️ assert] an object with a trailing comma: on line 1✅ got: 1
[⚙️ assert] an object with a trailing comma: at column 8✅ got: 8
[🧪 test] an object is not an array, and neither is a list✅ got: #t✅ got: #t✅ got: #t✅ got: #t
[🧪 test] a surrogate pair becomes one character
[⚙️ assert] the text matches✅ got: 😀
+----------------------------------------------+
[📑 suite] language server
[🧪 test] a Common Lisp defparameter is a definition✅ got: 0✅ got: 14
[🧪 test] the dialect follows the language identifier the editor sent
[⚙️ assert] the rule that only Emacs Lisp has fired✅ got: #t
[🧪 test] an unknown request is refused, and the server keeps talking
[⚙️ assert] the method is not implemented✅ got: -32601
[⚙️ assert] the next request was still answered✅ got: #t
[🧪 test] the highlights mark the declaration apart from the uses✅ got: 2
[⚙️ assert] the declaration is a write✅ got: 3
[⚙️ assert] the use is a read✅ got: 2
[🧪 test] signature help counts the arguments already written
[⚙️ assert] one argument is finished, so the second is being written✅ got: 1
[🧪 test] a message that is not JSON is answered, and the session goes on
[⚙️ assert] the server exited cleanly✅ got: 0
[⚙️ assert] initialize was answered✅ got: #t
[⚙️ assert] the request after the bad message was answered too✅ got: #t
[🧪 test] the name of a parameter is its own definition
[⚙️ assert] a request on the binding answers with the binding✅ got: 1✅ got: 11
[🧪 test] a reference inside a let jumps to the binding, not the outer name
[⚙️ assert] the `let' binding, on the second line✅ got: 1✅ got: 9
[🧪 test] completion puts the name being typed first
[⚙️ assert] the prefix match is offered first✅ got: alpha-one
[⚙️ assert] and its sort text says why✅ got: alpha-one
[🧪 test] a definition in another buffer is found✅ got: 1
[⚙️ assert] the jump leaves the buffer it started in✅ got: file:///tmp/sift-lsp-test-lib.scm✅ got: 9
[🧪 test] initialize advertises the navigation requests
[⚙️ assert] definitions✅ got: true
[⚙️ assert] references✅ got: true
[⚙️ assert] highlights✅ got: true
[⚙️ assert] an outline✅ got: true
[⚙️ assert] a workspace search✅ got: true
[⚙️ assert] a rename, with a pre-flight check✅ got: true
[🧪 test] organizing imports puts the specs in order✅ got: source.organizeImports
[⚙️ assert] the library that sorts first is written first✅ got: (import (scheme base) (srfi 1))(display 1)
[🧪 test] a symbol with no definition answers with nothing at all
[⚙️ assert] `f' is defined, so this is the definition✅ got: 1
[⚙️ assert] a name nothing defines is an empty answer, not an error✅ got: 0
[🧪 test] organizing imports removes the ones nothing uses
[⚙️ assert] the unused import went, and the file still reads✅ got: (import (scheme base))(display 1)
[🧪 test] a buffer that does not parse has findings, not silence✅ got: 0
[⚙️ assert] the file that never closes is reported as an error✅ got: #t
[⚙️ assert] and the finding is named, not anonymous✅ got: #t
[🧪 test] the hover says what the rule wants✅ got: SIFT012✅ got: if-without-else
[🧪 test] a rename that is not a symbol name is refused, not written✅ got: -32602
[🧪 test] an import that is already organized has no action
[⚙️ assert] nothing to offer, and nothing offered✅ got: 0
[🧪 test] shutdown is answered and exit ends the session✅ got: 0✅ got: null
[🧪 test] signature help answers with the definition's own formal list✅ got: (greet name)
[⚙️ assert] the cursor is in the first argument✅ got: 0
[⚙️ assert] the docstring comes with it✅ got: Greet NAME.
[🧪 test] references list every mention in the project
[⚙️ assert] the definition and the use✅ got: 2
[⚙️ assert] this buffer's mention first, then the other one's✅ got: (file:///tmp/sift-lsp-test.scm file:///tmp/sift-lsp-test-lib.scm)
[🧪 test] a change republishes the findings of the new text✅ got: 0
[⚙️ assert] the clean text has nothing to report✅ got: 0
[🧪 test] prepareRename says what would be renamed, and rename edits every mention✅ got: f✅ got: 1
[⚙️ assert] the definition and the call✅ got: 2✅ got: g
[⚙️ assert] the edit is pinned to the version it was computed from✅ got: 1
[🧪 test] a configuration the server was started with is what it answers with
[⚙️ assert] a warning is below the severity the server was given✅ got: 0
[🧪 test] closing a buffer takes its findings away
[⚙️ assert] the last word about the file is that it has no findings✅ got: 0
[🧪 test] a symbol jumps to the definition that names it
[⚙️ assert] one definition, not every `square' in the file✅ got: 1✅ got: 0✅ got: 9
[🧪 test] a notification that raises does not take the server with it
[⚙️ assert] the editor was told the request was not usable✅ got: #t
[⚙️ assert] and the next request was answered normally✅ got: null
[🧪 test] findings that have not changed are not published again
[⚙️ assert] one buffer, one publication✅ got: 1
[🧪 test] the definition under the cursor can be reformatted on its own✅ got: refactor.rewrite
[⚙️ assert] the body was indented✅ got: (* x x))
[⚙️ assert] the edit starts at the definition✅ got: 0
[⚙️ assert] and ends with it, leaving the next definition alone✅ got: 1
[🧪 test] one action fixes every safe finding in the buffer
[⚙️ assert] one action, not one per finding✅ got: 1✅ got: source.fixAll.sift
[⚙️ assert] the `if' was rewritten✅ got: when
[⚙️ assert] and the trailing whitespace went with it✅ got: #f
[🧪 test] a change sent as a range is applied to the text✅ got: 0
[⚙️ assert] the `if` the range replaced is gone✅ got: ()
[🧪 test] an unknown method is refused and the server keeps its answers✅ got: -32601
[⚙️ assert] shutdown and exit end the server with 0✅ got: 0
[🧪 test] a finding carries the range an editor highlights
[⚙️ assert] the if is on the second line, counted from zero✅ got: 1
[⚙️ assert] at the column the `if` itself is in✅ got: 3
[🧪 test] workspace/symbol searches the buffers the editor has open✅ got: 1✅ got: square
[🧪 test] formatting a buffer that does not parse says why instead of nothing✅ got: 0
[⚙️ assert] no edit is offered, because sift does not guess✅ got: 0
[⚙️ assert] the editor is told that formatting was refused✅ got: #t
[⚙️ assert] as an error✅ got: 1✅ got: cannot format
[🧪 test] a column is counted in the units the protocol counts
[⚙️ assert] the trailing whitespace was found✅ got: #t
[⚙️ assert] the emoji counted as the two units it is✅ got: 13
[🧪 test] a client that asks for quickfixes gets quickfixes and nothing else
[⚙️ assert] something was offered✅ got: #t
[⚙️ assert] no rewrite and no fix-all were mixed in✅ got: (quickfix)
[🧪 test] a request before initialize is refused by the protocol's rule
[⚙️ assert] the server says it has not been initialized✅ got: -32002
[🧪 test] exit without a shutdown ends with the status the protocol asks for✅ got: 1
[🧪 test] an Emacs Lisp defun is a definition✅ got: 0
[⚙️ assert] `greet' behind the `defun'✅ got: 7
[🧪 test] the hover describes the symbol rather than the line✅ got: **square**✅ got: function
[⚙️ assert] the definition's own docstring, not the rule's✅ got: Square X.
[🧪 test] a code action offers the rule's own fix
[⚙️ assert] an action was offered✅ got: #t✅ got: quickfix✅ got: SIFT012
[⚙️ assert] the fix is the one that turns if into when✅ got: when
[🧪 test] opening a buffer publishes its findings✅ got: 0
[⚙️ assert] the if has no else branch✅ got: #t
[⚙️ assert] a warning is a warning✅ got: 2
[🧪 test] completion offers the names the project defines
[⚙️ assert] from this buffer✅ got: #t
[⚙️ assert] from the one next to it✅ got: #t
[🧪 test] initialize names the capabilities sift offers✅ got: 0
[⚙️ assert] a change replaces the whole buffer✅ got: 1
[⚙️ assert] the server formats✅ got: true
[⚙️ assert] the server offers fixes, the one rewrite it can make, and import sorting✅ got: #(quickfix refactor.rewrite source.fixAll source.fixAll.sift source.organizeImports)
[⚙️ assert] the server answers a hover✅ got: true
[🧪 test] the dialect layer still answers about a buffer sift cannot finish✅ got: 0
[⚙️ assert] a code action array came back✅ got: #t
[🧪 test] signature help says nothing about a call sift cannot see
[⚙️ assert] no invented signature✅ got: null
[🧪 test] formatting answers with the text sift would write
[⚙️ assert] one edit came back✅ got: #t
[⚙️ assert] the edit is the buffer, indented✅ got: (if (ready?)
[🧪 test] the outline nests a definition inside the one that holds it✅ got: 1✅ got: f
[⚙️ assert] `g' is inside `f', not beside it✅ got: 1✅ got: g
+----------------------------------------------+
[📑 suite] pool: many files, one order
[🧪 test] one worker answers what many workers answer
[⚙️ assert] the same answers, however they were spread✅ got: (0 0 1 3 6 10 15 21 21 22 24 27 31 36 42 42 43 45 48 52 57 63 63 64 66 69 73 78 84 84 85 87 90 94 99 105 105 106 108 111)
[🧪 test] the empty list is answered without a thread✅ got: ()
[🧪 test] an error reaches the caller instead of vanishing in a thread
[⚙️ assert] the caller sees the error the work raised✅ success catching error: misc-error: (#f no ~S (5) #f)
[🧪 test] the error is the one the work raised, not a summary of it
[⚙️ assert] the key and its arguments arrive unchanged✅ got: (0 1 2)
[🧪 test] the answers are in the order the work was given
[⚙️ assert] the order is the order of the items✅ got: (0 1 4 9 16 25 36 49)
+----------------------------------------------+
[📑 suite] reader: Common Lisp
[🧪 test] a structure literal is a prefix over a list
[⚙️ assert] the text matches✅ got: #s(point :x 1 :y 2)
[🧪 test] a LOOP form is read as ordinary forms
[⚙️ assert] the text matches✅ got: (loop :for x :in xs :do (print x))
[🧪 test] a feature expression may be a list
[⚙️ assert] the text matches✅ got: #+(or sbcl ccl) (defun f ())
[🧪 test] a feature conditional keeps both halves✅ got: ((feature sbcl) (form (defun f ())))
[🧪 test] a keyword is an atom of its own kind✅ got: (keyword)
[🧪 test] block comments nest
[⚙️ assert] the text matches✅ got: #| a #| b |# c |# x
[🧪 test] a bracket and a hash are symbol characters here✅ got: (A[B A#B)
[⚙️ assert] the text matches✅ got: (defun f () A[B)
[🧪 test] a case-sensitive symbol keeps its case
[⚙️ assert] the text matches✅ got: (defun make-Thing () (list :Thing))
[🧪 test] no parse error is reported for Common Lisp syntax✅ got: ()
[🧪 test] a read macro keeps its datum glued to it
[⚙️ assert] the text matches✅ got: #2A((1 2) (3 4))
[⚙️ assert] the text matches✅ got: #c(1 2)
[⚙️ assert] the text matches✅ got: #1=(a . #1#)
[⚙️ assert] the text matches✅ got: #*1011
[🧪 test] a Common Lisp file round-trips byte for byte
[⚙️ assert] the text matches✅ got: (defpackage :demo (:use :cl) (:export #:run))(in-package :demo)(defun run () "Run it." (format t "~a~%" 1))
[🧪 test] radix and exactness prefixes are kept
[⚙️ assert] the text matches✅ got: (list #x1F #o17 #b1010 #e1.0)
[🧪 test] a pathname is a prefix over a string
[⚙️ assert] the text matches✅ got: (probe-file #p"/tmp/x")
[🧪 test] package markers are kept apart✅ got: ((foo:bar . foo:) (foo::baz . foo::) (:key . #f) (#:uninterned . #:))
[🧪 test] read-time evaluation is copied and not evaluated
[⚙️ assert] the text matches✅ got: #.(+ 1 2)✅ got: (#.(+ 1 2))
[🧪 test] a datum comment is Scheme syntax, and is reported here✅ got: ((1 1 the))
[🧪 test] a negated feature conditional is kept
[⚙️ assert] the text matches✅ got: #-(not sbcl) (defun f ())
[🧪 test] a pathname keeps the case of its dispatch character
[⚙️ assert] the text matches✅ got: (probe-file #P"/tmp/x")✅ got: ()
[🧪 test] an unreadable object is copied verbatim
[⚙️ assert] the text matches✅ got: #<buffer foo>
[⚙️ assert] the text matches✅ got: (describe #<window 1 on foo>)
[🧪 test] a datum comment holds one datum
[⚙️ assert] the text matches✅ got: #;foo bar
[🧪 test] a quote ends a symbol here✅ got: (a)
+----------------------------------------------+
[📑 suite] reader: Emacs Lisp
[🧪 test] a defun keeps its name, argument list, docstring and body✅ got: ((defun add (a b) "Add A and B." (+ a b)))
[🧪 test] character literals keep their spelling✅ got: (?a ?\n ?\C-x ?\M-x ?\s ?\()
[🧪 test] an Emacs Lisp file round-trips byte for byte
[⚙️ assert] the text matches✅ got: ;;; demo.el --- a demo -*- lexical-binding: t; -*-(defun demo (x) "Return X." (message "%s" x))(provide 'demo)
[🧪 test] docstrings with escapes are not respelled
[⚙️ assert] the text matches✅ got: (defun f () "Say \"hi\"." nil)
[🧪 test] the dialect is detected from a lexical-binding marker✅ got: elisp
[🧪 test] a dotted pair keeps its dot
[⚙️ assert] the text matches✅ got: (a . b)
[🧪 test] a character literal with a meta and a control modifier is one atom✅ got: (?\M-\C-x)
[🧪 test] the dialect is detected from the extension✅ got: elisp
[🧪 test] a hash-table literal is a read macro over a list
[⚙️ assert] the text matches✅ got: (defvar t #s(hash-table test equal data ("a" 1)))
[🧪 test] a bar is an ordinary symbol character, not an escape✅ got: ()✅ got: (| a b)
[🧪 test] a brace is a symbol character, not a bracket✅ got: ({ _ })
[🧪 test] a shebang line is kept
[⚙️ assert] the text matches✅ got: #!/usr/bin/env emacs --script(message "hi")
[🧪 test] a backslash quotes the next character of a symbol✅ got: ()✅ got: (\( \) a\#b)
[🧪 test] a read-circle label is a prefix over its datum
[⚙️ assert] the text matches✅ got: #1=(a . #1#)
[🧪 test] a function quote is a prefix, like a quote✅ got: ((function foo) (quote bar))
[🧪 test] a Scheme character literal is reported, and still kept✅ got: ((1 1 character))
[⚙️ assert] the text matches✅ got: #\a
[🧪 test] the lexical-binding header is an ordinary comment
[⚙️ assert] the text matches✅ got: ;;; foo.el --- a package -*- lexical-binding: t; -*-
[🧪 test] a block comment is reported, and still kept✅ got: ((1 1 block))
[⚙️ assert] the text matches✅ got: #| not elisp |# x
[🧪 test] a datum comment is reported, and still kept✅ got: ((1 1 the))
[⚙️ assert] the text matches✅ got: #;foo bar
[🧪 test] vectors are read as vectors✅ got: (#(1 2 3))
+----------------------------------------------+
[📑 suite] reader: Scheme
[🧪 test] a whole file of trivia round-trips byte for byte
[⚙️ assert] the text matches✅ got: ;; a comment;; another
[🧪 test] a list is a list of its elements✅ got: ((a b (c d)))
[🧪 test] a read macro over a glued datum is one node✅ got: ()✅ got: prefix✅ got: #1=
[⚙️ assert] the text matches✅ got: #S(point :x 1)
[🧪 test] an inline comment knows it follows code✅ got: (#f #t)
[🧪 test] a syntax-case prefix is a prefix, and its datum is glued to it✅ got: ()✅ got: #`✅ got: a✅ got: #,✅ got: #,@
[⚙️ assert] the text matches✅ got: (display #`(a #,b #,@c))
[🧪 test] an extended symbol is a symbol even when it looks like a number✅ got: (#{}# #{4242}#)✅ got: (symbol symbol)
[🧪 test] a Guile extended symbol is one atom, spaces and all✅ got: ()✅ got: symbol✅ got: #{foo bar}#
[🧪 test] character literals keep their spelling✅ got: (#\a #\space #\newline #\x41)
[🧪 test] an unterminated extended symbol is reported at its opener✅ got: ((1 1 unterminated))
[🧪 test] string escapes are kept exactly as they were written
[⚙️ assert] the text matches✅ got: (display "a \" b\n\t\x41;")
[🧪 test] vectors and bytevectors are read with their own opener✅ got: (#(1 2 3))✅ got: #u8(1 2)
[🧪 test] a shebang names which Scheme is running the file✅ got: scheme✅ got: scheme✅ got: scheme
[🧪 test] the reader marks everything inside a datum comment
[⚙️ assert] the datum itself✅ got: #t
[⚙️ assert] its children✅ got: #t
[🧪 test] a backslash-newline inside a string is kept
[⚙️ assert] the text matches✅ got: "one \two"
[🧪 test] an unterminated string is reported at its quote✅ got: ((1 4 unterminated) (1 1 unterminated))
[🧪 test] an unmatched closer is reported, and the rest of the file is read✅ got: ((1 2 unmatched))✅ got: (a ) b)
[🧪 test] a datum comment holds exactly one datum✅ got: (a b)
[⚙️ assert] the text matches✅ got: #;foo a
[🧪 test] locations count characters, not bytes✅ got: 1✅ got: 4✅ got: 4
[🧪 test] comments are kept, every one of them✅ got: (;; one ;; two ; not three ;; three)
[🧪 test] an unterminated form is reported at its opener✅ got: ((1 1 unterminated))✅ got: ((a (b c)))
[🧪 test] top-level atoms keep their kind✅ got: (symbol keyword number number string character)
[🧪 test] a quote or a comma inside a symbol belongs to it✅ got: (define x' 1)✅ got: (list lst'' a,b)
[⚙️ assert] the text matches✅ got: (define x' 1)
[🧪 test] both spellings of a bytevector are the same datum
[⚙️ assert] the text matches✅ got: (vector-ref #vu8(1 2) 0)
[⚙️ assert] `#vu8(' is a bytevector✅ got: #t
[🧪 test] nested prefixes stay on the datum they belong to✅ got: ((quote #(1 2)))✅ got: ((quote (quasiquote (a (unquote b)))))
[🧪 test] a brace is a symbol character, not a bracket✅ got: ()✅ got: ({a b})
[⚙️ assert] the text matches✅ got: {ab}
[🧪 test] the datum comment may hold a datum with a datum comment
[⚙️ assert] the text matches✅ got: #;#;a b c
[🧪 test] read-time evaluation is Common Lisp syntax, and is reported✅ got: ((1 1 read-time))
[⚙️ assert] the text matches✅ got: #.(+ 1 2)
[🧪 test] an extended symbol round-trips, newline and escape included
[⚙️ assert] the text matches✅ got: (define #{whatever}# 1)
[⚙️ assert] the text matches✅ got: '#{a\}b}#
[🧪 test] CRLF is read as one newline per line
[⚙️ assert] the text matches✅ got: (a b)
[🧪 test] a datum comment inside a list comments out one element✅ got: ((a c))
[🧪 test] every reader prefix applies to one datum✅ got: ((quote a) (quasiquote (b (unquote c) (unquote-splicing d))) (function e))
[🧪 test] a Chez directive inside a form is an atom✅ got: ()
[⚙️ assert] the text matches✅ got: (lambda (x #!optional y) x)
[🧪 test] a prefix separated from its datum still reads✅ got: ((quote a))
[🧪 test] blank lines are nodes, so they survive a round trip
[⚙️ assert] the text matches✅ got: (a)(b)
[🧪 test] a vector node knows it is a vector, and a bracket is one only in Elisp
[⚙️ assert] a `#(' literal✅ got: #t✅ got: #(
[⚙️ assert] a Scheme clause written with a bracket✅ got: #f
[⚙️ assert] an Emacs Lisp vector✅ got: #t
[🧪 test] a vector keeps the comments written inside it
[⚙️ assert] the text matches✅ got: #(a #| note |# b)
[🧪 test] a reader directive is a token, not a shebang✅ got: ()✅ got: atom✅ got: #!r6rs
[⚙️ assert] the text matches✅ got: #!fold-case(a)
[🧪 test] a file that is already formatted round-trips byte for byte
[⚙️ assert] the text matches✅ got: (define (square x) (* x x));; done
[🧪 test] a shebang is a node, not a reader directive
[⚙️ assert] the text matches✅ got: #!/usr/bin/env guile(foo)
[🧪 test] a dotted pair keeps its dot as an atom
[⚙️ assert] the text matches✅ got: (a . b)✅ got: (a . b)
[🧪 test] a block comment between two elements is preserved
[⚙️ assert] the text matches✅ got: (a #| note |# b)
[🧪 test] numbers are not normalised✅ got: (16 5 1 1/3 1.0e10)
[🧪 test] extended symbols are Guile syntax, and say so elsewhere✅ got: ((1 1 extended))
[🧪 test] block comments nest, and none of them is lost
[⚙️ assert] the text matches✅ got: #| a #| b |# c |# x
+----------------------------------------------+
[📑 suite] robustness
[🧪 test] every odd source is read, linted and formatted without raising
[⚙️ assert] scheme: ""✅ got: #t
[⚙️ assert] scheme: ""✅ got: #t
[⚙️ assert] scheme: ""✅ got: #t
[⚙️ assert] scheme: " "✅ got: #t
[⚙️ assert] scheme: " "✅ got: #t
[⚙️ assert] scheme: " "✅ got: #t
[⚙️ assert] scheme: "\n\n\n"✅ got: #t
[⚙️ assert] scheme: "\n\n\n"✅ got: #t
[⚙️ assert] scheme: "\n\n\n"✅ got: #t
[⚙️ assert] scheme: "("✅ got: #t
[⚙️ assert] scheme: "("✅ got: #t
[⚙️ assert] scheme: "("✅ got: #t
[⚙️ assert] scheme: ")"✅ got: #t
[⚙️ assert] scheme: ")"✅ got: #t
[⚙️ assert] scheme: ")"✅ got: #t
[⚙️ assert] scheme: "())"✅ got: #t
[⚙️ assert] scheme: "())"✅ got: #t
[⚙️ assert] scheme: "())"✅ got: #t
[⚙️ assert] scheme: "(defun)"✅ got: #t
[⚙️ assert] scheme: "(defun)"✅ got: #t
[⚙️ assert] scheme: "(defun)"✅ got: #t
[⚙️ assert] scheme: "(defun defmacro)"✅ got: #t
[⚙️ assert] scheme: "(defun defmacro)"✅ got: #t
[⚙️ assert] scheme: "(defun defmacro)"✅ got: #t
[⚙️ assert] scheme: "(defun f)"✅ got: #t
[⚙️ assert] scheme: "(defun f)"✅ got: #t
[⚙️ assert] scheme: "(defun f)"✅ got: #t
[⚙️ assert] scheme: "(defun f ()"✅ got: #t
[⚙️ assert] scheme: "(defun f ()"✅ got: #t
[⚙️ assert] scheme: "(defun f ()"✅ got: #t
[⚙️ assert] scheme: "(defmacro)"✅ got: #t
[⚙️ assert] scheme: "(defmacro)"✅ got: #t
[⚙️ assert] scheme: "(defmacro)"✅ got: #t
[⚙️ assert] scheme: "(let)"✅ got: #t
[⚙️ assert] scheme: "(let)"✅ got: #t
[⚙️ assert] scheme: "(let)"✅ got: #t
[⚙️ assert] scheme: "(let ())"✅ got: #t
[⚙️ assert] scheme: "(let ())"✅ got: #t
[⚙️ assert] scheme: "(let ())"✅ got: #t
[⚙️ assert] scheme: "(case)"✅ got: #t
[⚙️ assert] scheme: "(case)"✅ got: #t
[⚙️ assert] scheme: "(case)"✅ got: #t
[⚙️ assert] scheme: "(case x)"✅ got: #t
[⚙️ assert] scheme: "(case x)"✅ got: #t
[⚙️ assert] scheme: "(case x)"✅ got: #t
[⚙️ assert] scheme: "(case x ())"✅ got: #t
[⚙️ assert] scheme: "(case x ())"✅ got: #t
[⚙️ assert] scheme: "(case x ())"✅ got: #t
[⚙️ assert] scheme: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] scheme: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] scheme: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] scheme: "(cond)"✅ got: #t
[⚙️ assert] scheme: "(cond)"✅ got: #t
[⚙️ assert] scheme: "(cond)"✅ got: #t
[⚙️ assert] scheme: "(cond ())"✅ got: #t
[⚙️ assert] scheme: "(cond ())"✅ got: #t
[⚙️ assert] scheme: "(cond ())"✅ got: #t
[⚙️ assert] scheme: "(lambda)"✅ got: #t
[⚙️ assert] scheme: "(lambda)"✅ got: #t
[⚙️ assert] scheme: "(lambda)"✅ got: #t
[⚙️ assert] scheme: "(lambda ())"✅ got: #t
[⚙️ assert] scheme: "(lambda ())"✅ got: #t
[⚙️ assert] scheme: "(lambda ())"✅ got: #t
[⚙️ assert] scheme: "(define)"✅ got: #t
[⚙️ assert] scheme: "(define)"✅ got: #t
[⚙️ assert] scheme: "(define)"✅ got: #t
[⚙️ assert] scheme: "(define ())"✅ got: #t
[⚙️ assert] scheme: "(define ())"✅ got: #t
[⚙️ assert] scheme: "(define ())"✅ got: #t
[⚙️ assert] scheme: "(quote)"✅ got: #t
[⚙️ assert] scheme: "(quote)"✅ got: #t
[⚙️ assert] scheme: "(quote)"✅ got: #t
[⚙️ assert] scheme: "'"✅ got: #t
[⚙️ assert] scheme: "'"✅ got: #t
[⚙️ assert] scheme: "'"✅ got: #t
[⚙️ assert] scheme: "#"✅ got: #t
[⚙️ assert] scheme: "#"✅ got: #t
[⚙️ assert] scheme: "#"✅ got: #t
[⚙️ assert] scheme: "#;"✅ got: #t
[⚙️ assert] scheme: "#;"✅ got: #t
[⚙️ assert] scheme: "#;"✅ got: #t
[⚙️ assert] scheme: "#|"✅ got: #t
[⚙️ assert] scheme: "#|"✅ got: #t
[⚙️ assert] scheme: "#|"✅ got: #t
[⚙️ assert] scheme: "#\\"✅ got: #t
[⚙️ assert] scheme: "#\\"✅ got: #t
[⚙️ assert] scheme: "#\\"✅ got: #t
[⚙️ assert] scheme: "?\\"✅ got: #t
[⚙️ assert] scheme: "?\\"✅ got: #t
[⚙️ assert] scheme: "?\\"✅ got: #t
[⚙️ assert] scheme: "(a . )"✅ got: #t
[⚙️ assert] scheme: "(a . )"✅ got: #t
[⚙️ assert] scheme: "(a . )"✅ got: #t
[⚙️ assert] scheme: "(a . b . c)"✅ got: #t
[⚙️ assert] scheme: "(a . b . c)"✅ got: #t
[⚙️ assert] scheme: "(a . b . c)"✅ got: #t
[⚙️ assert] scheme: "(#)"✅ got: #t
[⚙️ assert] scheme: "(#)"✅ got: #t
[⚙️ assert] scheme: "(#)"✅ got: #t
[⚙️ assert] scheme: "(list #;)"✅ got: #t
[⚙️ assert] scheme: "(list #;)"✅ got: #t
[⚙️ assert] scheme: "(list #;)"✅ got: #t
[⚙️ assert] scheme: "(list #|x|#)"✅ got: #t
[⚙️ assert] scheme: "(list #|x|#)"✅ got: #t
[⚙️ assert] scheme: "(list #|x|#)"✅ got: #t
[⚙️ assert] scheme: "(((("✅ got: #t
[⚙️ assert] scheme: "(((("✅ got: #t
[⚙️ assert] scheme: "(((("✅ got: #t
[⚙️ assert] scheme: "))))"✅ got: #t
[⚙️ assert] scheme: "))))"✅ got: #t
[⚙️ assert] scheme: "))))"✅ got: #t
[⚙️ assert] scheme: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] scheme: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] scheme: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] scheme: "(f \"unterminated"✅ got: #t
[⚙️ assert] scheme: "(f \"unterminated"✅ got: #t
[⚙️ assert] scheme: "(f \"unterminated"✅ got: #t
[⚙️ assert] scheme: "(f #<garbage)"✅ got: #t
[⚙️ assert] scheme: "(f #<garbage)"✅ got: #t
[⚙️ assert] scheme: "(f #<garbage)"✅ got: #t
[⚙️ assert] scheme: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] scheme: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] scheme: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] scheme: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] scheme: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] scheme: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] scheme: "(when)"✅ got: #t
[⚙️ assert] scheme: "(when)"✅ got: #t
[⚙️ assert] scheme: "(when)"✅ got: #t
[⚙️ assert] scheme: "(unless)"✅ got: #t
[⚙️ assert] scheme: "(unless)"✅ got: #t
[⚙️ assert] scheme: "(unless)"✅ got: #t
[⚙️ assert] scheme: "(if)"✅ got: #t
[⚙️ assert] scheme: "(if)"✅ got: #t
[⚙️ assert] scheme: "(if)"✅ got: #t
[⚙️ assert] scheme: "(do)"✅ got: #t
[⚙️ assert] scheme: "(do)"✅ got: #t
[⚙️ assert] scheme: "(do)"✅ got: #t
[⚙️ assert] scheme: "(λ (x) x)"✅ got: #t
[⚙️ assert] scheme: "(λ (x) x)"✅ got: #t
[⚙️ assert] scheme: "(λ (x) x)"✅ got: #t
[⚙️ assert] elisp: ""✅ got: #t
[⚙️ assert] elisp: ""✅ got: #t
[⚙️ assert] elisp: ""✅ got: #t
[⚙️ assert] elisp: " "✅ got: #t
[⚙️ assert] elisp: " "✅ got: #t
[⚙️ assert] elisp: " "✅ got: #t
[⚙️ assert] elisp: "\n\n\n"✅ got: #t
[⚙️ assert] elisp: "\n\n\n"✅ got: #t
[⚙️ assert] elisp: "\n\n\n"✅ got: #t
[⚙️ assert] elisp: "("✅ got: #t
[⚙️ assert] elisp: "("✅ got: #t
[⚙️ assert] elisp: "("✅ got: #t
[⚙️ assert] elisp: ")"✅ got: #t
[⚙️ assert] elisp: ")"✅ got: #t
[⚙️ assert] elisp: ")"✅ got: #t
[⚙️ assert] elisp: "())"✅ got: #t
[⚙️ assert] elisp: "())"✅ got: #t
[⚙️ assert] elisp: "())"✅ got: #t
[⚙️ assert] elisp: "(defun)"✅ got: #t
[⚙️ assert] elisp: "(defun)"✅ got: #t
[⚙️ assert] elisp: "(defun)"✅ got: #t
[⚙️ assert] elisp: "(defun defmacro)"✅ got: #t
[⚙️ assert] elisp: "(defun defmacro)"✅ got: #t
[⚙️ assert] elisp: "(defun defmacro)"✅ got: #t
[⚙️ assert] elisp: "(defun f)"✅ got: #t
[⚙️ assert] elisp: "(defun f)"✅ got: #t
[⚙️ assert] elisp: "(defun f)"✅ got: #t
[⚙️ assert] elisp: "(defun f ()"✅ got: #t
[⚙️ assert] elisp: "(defun f ()"✅ got: #t
[⚙️ assert] elisp: "(defun f ()"✅ got: #t
[⚙️ assert] elisp: "(defmacro)"✅ got: #t
[⚙️ assert] elisp: "(defmacro)"✅ got: #t
[⚙️ assert] elisp: "(defmacro)"✅ got: #t
[⚙️ assert] elisp: "(let)"✅ got: #t
[⚙️ assert] elisp: "(let)"✅ got: #t
[⚙️ assert] elisp: "(let)"✅ got: #t
[⚙️ assert] elisp: "(let ())"✅ got: #t
[⚙️ assert] elisp: "(let ())"✅ got: #t
[⚙️ assert] elisp: "(let ())"✅ got: #t
[⚙️ assert] elisp: "(case)"✅ got: #t
[⚙️ assert] elisp: "(case)"✅ got: #t
[⚙️ assert] elisp: "(case)"✅ got: #t
[⚙️ assert] elisp: "(case x)"✅ got: #t
[⚙️ assert] elisp: "(case x)"✅ got: #t
[⚙️ assert] elisp: "(case x)"✅ got: #t
[⚙️ assert] elisp: "(case x ())"✅ got: #t
[⚙️ assert] elisp: "(case x ())"✅ got: #t
[⚙️ assert] elisp: "(case x ())"✅ got: #t
[⚙️ assert] elisp: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] elisp: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] elisp: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] elisp: "(cond)"✅ got: #t
[⚙️ assert] elisp: "(cond)"✅ got: #t
[⚙️ assert] elisp: "(cond)"✅ got: #t
[⚙️ assert] elisp: "(cond ())"✅ got: #t
[⚙️ assert] elisp: "(cond ())"✅ got: #t
[⚙️ assert] elisp: "(cond ())"✅ got: #t
[⚙️ assert] elisp: "(lambda)"✅ got: #t
[⚙️ assert] elisp: "(lambda)"✅ got: #t
[⚙️ assert] elisp: "(lambda)"✅ got: #t
[⚙️ assert] elisp: "(lambda ())"✅ got: #t
[⚙️ assert] elisp: "(lambda ())"✅ got: #t
[⚙️ assert] elisp: "(lambda ())"✅ got: #t
[⚙️ assert] elisp: "(define)"✅ got: #t
[⚙️ assert] elisp: "(define)"✅ got: #t
[⚙️ assert] elisp: "(define)"✅ got: #t
[⚙️ assert] elisp: "(define ())"✅ got: #t
[⚙️ assert] elisp: "(define ())"✅ got: #t
[⚙️ assert] elisp: "(define ())"✅ got: #t
[⚙️ assert] elisp: "(quote)"✅ got: #t
[⚙️ assert] elisp: "(quote)"✅ got: #t
[⚙️ assert] elisp: "(quote)"✅ got: #t
[⚙️ assert] elisp: "'"✅ got: #t
[⚙️ assert] elisp: "'"✅ got: #t
[⚙️ assert] elisp: "'"✅ got: #t
[⚙️ assert] elisp: "#"✅ got: #t
[⚙️ assert] elisp: "#"✅ got: #t
[⚙️ assert] elisp: "#"✅ got: #t
[⚙️ assert] elisp: "#;"✅ got: #t
[⚙️ assert] elisp: "#;"✅ got: #t
[⚙️ assert] elisp: "#;"✅ got: #t
[⚙️ assert] elisp: "#|"✅ got: #t
[⚙️ assert] elisp: "#|"✅ got: #t
[⚙️ assert] elisp: "#|"✅ got: #t
[⚙️ assert] elisp: "#\\"✅ got: #t
[⚙️ assert] elisp: "#\\"✅ got: #t
[⚙️ assert] elisp: "#\\"✅ got: #t
[⚙️ assert] elisp: "?\\"✅ got: #t
[⚙️ assert] elisp: "?\\"✅ got: #t
[⚙️ assert] elisp: "?\\"✅ got: #t
[⚙️ assert] elisp: "(a . )"✅ got: #t
[⚙️ assert] elisp: "(a . )"✅ got: #t
[⚙️ assert] elisp: "(a . )"✅ got: #t
[⚙️ assert] elisp: "(a . b . c)"✅ got: #t
[⚙️ assert] elisp: "(a . b . c)"✅ got: #t
[⚙️ assert] elisp: "(a . b . c)"✅ got: #t
[⚙️ assert] elisp: "(#)"✅ got: #t
[⚙️ assert] elisp: "(#)"✅ got: #t
[⚙️ assert] elisp: "(#)"✅ got: #t
[⚙️ assert] elisp: "(list #;)"✅ got: #t
[⚙️ assert] elisp: "(list #;)"✅ got: #t
[⚙️ assert] elisp: "(list #;)"✅ got: #t
[⚙️ assert] elisp: "(list #|x|#)"✅ got: #t
[⚙️ assert] elisp: "(list #|x|#)"✅ got: #t
[⚙️ assert] elisp: "(list #|x|#)"✅ got: #t
[⚙️ assert] elisp: "(((("✅ got: #t
[⚙️ assert] elisp: "(((("✅ got: #t
[⚙️ assert] elisp: "(((("✅ got: #t
[⚙️ assert] elisp: "))))"✅ got: #t
[⚙️ assert] elisp: "))))"✅ got: #t
[⚙️ assert] elisp: "))))"✅ got: #t
[⚙️ assert] elisp: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] elisp: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] elisp: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] elisp: "(f \"unterminated"✅ got: #t
[⚙️ assert] elisp: "(f \"unterminated"✅ got: #t
[⚙️ assert] elisp: "(f \"unterminated"✅ got: #t
[⚙️ assert] elisp: "(f #<garbage)"✅ got: #t
[⚙️ assert] elisp: "(f #<garbage)"✅ got: #t
[⚙️ assert] elisp: "(f #<garbage)"✅ got: #t
[⚙️ assert] elisp: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] elisp: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] elisp: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] elisp: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] elisp: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] elisp: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] elisp: "(when)"✅ got: #t
[⚙️ assert] elisp: "(when)"✅ got: #t
[⚙️ assert] elisp: "(when)"✅ got: #t
[⚙️ assert] elisp: "(unless)"✅ got: #t
[⚙️ assert] elisp: "(unless)"✅ got: #t
[⚙️ assert] elisp: "(unless)"✅ got: #t
[⚙️ assert] elisp: "(if)"✅ got: #t
[⚙️ assert] elisp: "(if)"✅ got: #t
[⚙️ assert] elisp: "(if)"✅ got: #t
[⚙️ assert] elisp: "(do)"✅ got: #t
[⚙️ assert] elisp: "(do)"✅ got: #t
[⚙️ assert] elisp: "(do)"✅ got: #t
[⚙️ assert] elisp: "(λ (x) x)"✅ got: #t
[⚙️ assert] elisp: "(λ (x) x)"✅ got: #t
[⚙️ assert] elisp: "(λ (x) x)"✅ got: #t
[⚙️ assert] cl: ""✅ got: #t
[⚙️ assert] cl: ""✅ got: #t
[⚙️ assert] cl: ""✅ got: #t
[⚙️ assert] cl: " "✅ got: #t
[⚙️ assert] cl: " "✅ got: #t
[⚙️ assert] cl: " "✅ got: #t
[⚙️ assert] cl: "\n\n\n"✅ got: #t
[⚙️ assert] cl: "\n\n\n"✅ got: #t
[⚙️ assert] cl: "\n\n\n"✅ got: #t
[⚙️ assert] cl: "("✅ got: #t
[⚙️ assert] cl: "("✅ got: #t
[⚙️ assert] cl: "("✅ got: #t
[⚙️ assert] cl: ")"✅ got: #t
[⚙️ assert] cl: ")"✅ got: #t
[⚙️ assert] cl: ")"✅ got: #t
[⚙️ assert] cl: "())"✅ got: #t
[⚙️ assert] cl: "())"✅ got: #t
[⚙️ assert] cl: "())"✅ got: #t
[⚙️ assert] cl: "(defun)"✅ got: #t
[⚙️ assert] cl: "(defun)"✅ got: #t
[⚙️ assert] cl: "(defun)"✅ got: #t
[⚙️ assert] cl: "(defun defmacro)"✅ got: #t
[⚙️ assert] cl: "(defun defmacro)"✅ got: #t
[⚙️ assert] cl: "(defun defmacro)"✅ got: #t
[⚙️ assert] cl: "(defun f)"✅ got: #t
[⚙️ assert] cl: "(defun f)"✅ got: #t
[⚙️ assert] cl: "(defun f)"✅ got: #t
[⚙️ assert] cl: "(defun f ()"✅ got: #t
[⚙️ assert] cl: "(defun f ()"✅ got: #t
[⚙️ assert] cl: "(defun f ()"✅ got: #t
[⚙️ assert] cl: "(defmacro)"✅ got: #t
[⚙️ assert] cl: "(defmacro)"✅ got: #t
[⚙️ assert] cl: "(defmacro)"✅ got: #t
[⚙️ assert] cl: "(let)"✅ got: #t
[⚙️ assert] cl: "(let)"✅ got: #t
[⚙️ assert] cl: "(let)"✅ got: #t
[⚙️ assert] cl: "(let ())"✅ got: #t
[⚙️ assert] cl: "(let ())"✅ got: #t
[⚙️ assert] cl: "(let ())"✅ got: #t
[⚙️ assert] cl: "(case)"✅ got: #t
[⚙️ assert] cl: "(case)"✅ got: #t
[⚙️ assert] cl: "(case)"✅ got: #t
[⚙️ assert] cl: "(case x)"✅ got: #t
[⚙️ assert] cl: "(case x)"✅ got: #t
[⚙️ assert] cl: "(case x)"✅ got: #t
[⚙️ assert] cl: "(case x ())"✅ got: #t
[⚙️ assert] cl: "(case x ())"✅ got: #t
[⚙️ assert] cl: "(case x ())"✅ got: #t
[⚙️ assert] cl: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] cl: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] cl: "(case x ((cond) 1))"✅ got: #t
[⚙️ assert] cl: "(cond)"✅ got: #t
[⚙️ assert] cl: "(cond)"✅ got: #t
[⚙️ assert] cl: "(cond)"✅ got: #t
[⚙️ assert] cl: "(cond ())"✅ got: #t
[⚙️ assert] cl: "(cond ())"✅ got: #t
[⚙️ assert] cl: "(cond ())"✅ got: #t
[⚙️ assert] cl: "(lambda)"✅ got: #t
[⚙️ assert] cl: "(lambda)"✅ got: #t
[⚙️ assert] cl: "(lambda)"✅ got: #t
[⚙️ assert] cl: "(lambda ())"✅ got: #t
[⚙️ assert] cl: "(lambda ())"✅ got: #t
[⚙️ assert] cl: "(lambda ())"✅ got: #t
[⚙️ assert] cl: "(define)"✅ got: #t
[⚙️ assert] cl: "(define)"✅ got: #t
[⚙️ assert] cl: "(define)"✅ got: #t
[⚙️ assert] cl: "(define ())"✅ got: #t
[⚙️ assert] cl: "(define ())"✅ got: #t
[⚙️ assert] cl: "(define ())"✅ got: #t
[⚙️ assert] cl: "(quote)"✅ got: #t
[⚙️ assert] cl: "(quote)"✅ got: #t
[⚙️ assert] cl: "(quote)"✅ got: #t
[⚙️ assert] cl: "'"✅ got: #t
[⚙️ assert] cl: "'"✅ got: #t
[⚙️ assert] cl: "'"✅ got: #t
[⚙️ assert] cl: "#"✅ got: #t
[⚙️ assert] cl: "#"✅ got: #t
[⚙️ assert] cl: "#"✅ got: #t
[⚙️ assert] cl: "#;"✅ got: #t
[⚙️ assert] cl: "#;"✅ got: #t
[⚙️ assert] cl: "#;"✅ got: #t
[⚙️ assert] cl: "#|"✅ got: #t
[⚙️ assert] cl: "#|"✅ got: #t
[⚙️ assert] cl: "#|"✅ got: #t
[⚙️ assert] cl: "#\\"✅ got: #t
[⚙️ assert] cl: "#\\"✅ got: #t
[⚙️ assert] cl: "#\\"✅ got: #t
[⚙️ assert] cl: "?\\"✅ got: #t
[⚙️ assert] cl: "?\\"✅ got: #t
[⚙️ assert] cl: "?\\"✅ got: #t
[⚙️ assert] cl: "(a . )"✅ got: #t
[⚙️ assert] cl: "(a . )"✅ got: #t
[⚙️ assert] cl: "(a . )"✅ got: #t
[⚙️ assert] cl: "(a . b . c)"✅ got: #t
[⚙️ assert] cl: "(a . b . c)"✅ got: #t
[⚙️ assert] cl: "(a . b . c)"✅ got: #t
[⚙️ assert] cl: "(#)"✅ got: #t
[⚙️ assert] cl: "(#)"✅ got: #t
[⚙️ assert] cl: "(#)"✅ got: #t
[⚙️ assert] cl: "(list #;)"✅ got: #t
[⚙️ assert] cl: "(list #;)"✅ got: #t
[⚙️ assert] cl: "(list #;)"✅ got: #t
[⚙️ assert] cl: "(list #|x|#)"✅ got: #t
[⚙️ assert] cl: "(list #|x|#)"✅ got: #t
[⚙️ assert] cl: "(list #|x|#)"✅ got: #t
[⚙️ assert] cl: "(((("✅ got: #t
[⚙️ assert] cl: "(((("✅ got: #t
[⚙️ assert] cl: "(((("✅ got: #t
[⚙️ assert] cl: "))))"✅ got: #t
[⚙️ assert] cl: "))))"✅ got: #t
[⚙️ assert] cl: "))))"✅ got: #t
[⚙️ assert] cl: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] cl: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] cl: "(f :a 1 :a 2)"✅ got: #t
[⚙️ assert] cl: "(f \"unterminated"✅ got: #t
[⚙️ assert] cl: "(f \"unterminated"✅ got: #t
[⚙️ assert] cl: "(f \"unterminated"✅ got: #t
[⚙️ assert] cl: "(f #<garbage)"✅ got: #t
[⚙️ assert] cl: "(f #<garbage)"✅ got: #t
[⚙️ assert] cl: "(f #<garbage)"✅ got: #t
[⚙️ assert] cl: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] cl: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] cl: "(f #.(+ 1 2))"✅ got: #t
[⚙️ assert] cl: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] cl: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] cl: "(let ((x 1) (x 2)) x)"✅ got: #t
[⚙️ assert] cl: "(when)"✅ got: #t
[⚙️ assert] cl: "(when)"✅ got: #t
[⚙️ assert] cl: "(when)"✅ got: #t
[⚙️ assert] cl: "(unless)"✅ got: #t
[⚙️ assert] cl: "(unless)"✅ got: #t
[⚙️ assert] cl: "(unless)"✅ got: #t
[⚙️ assert] cl: "(if)"✅ got: #t
[⚙️ assert] cl: "(if)"✅ got: #t
[⚙️ assert] cl: "(if)"✅ got: #t
[⚙️ assert] cl: "(do)"✅ got: #t
[⚙️ assert] cl: "(do)"✅ got: #t
[⚙️ assert] cl: "(do)"✅ got: #t
[⚙️ assert] cl: "(λ (x) x)"✅ got: #t
[⚙️ assert] cl: "(λ (x) x)"✅ got: #t
[⚙️ assert] cl: "(λ (x) x)"✅ got: #t
[🧪 test] a case clause whose datum is a list of symbols is not a form✅ got: ()
[🧪 test] formatting an odd source twice changes nothing
[⚙️ assert] idempotent: ""✅ got:
[⚙️ assert] idempotent: " "✅ got:
[⚙️ assert] idempotent: "\n\n\n"✅ got:
[⚙️ assert] idempotent: "("✅ got: (
[⚙️ assert] idempotent: ")"✅ got: )
[⚙️ assert] idempotent: "())"✅ got: ())
[⚙️ assert] idempotent: "(defun)"✅ got: (defun)
[⚙️ assert] idempotent: "(defun defmacro)"✅ got: (defun defmacro)
[⚙️ assert] idempotent: "(defun f)"✅ got: (defun f)
[⚙️ assert] idempotent: "(defun f ()"✅ got: (defun f ()
[⚙️ assert] idempotent: "(defmacro)"✅ got: (defmacro)
[⚙️ assert] idempotent: "(let)"✅ got: (let)
[⚙️ assert] idempotent: "(let ())"✅ got: (let ())
[⚙️ assert] idempotent: "(case)"✅ got: (case)
[⚙️ assert] idempotent: "(case x)"✅ got: (case x)
[⚙️ assert] idempotent: "(case x ())"✅ got: (case x [])
[⚙️ assert] idempotent: "(case x ((cond) 1))"✅ got: (case x [(cond) 1])
[⚙️ assert] idempotent: "(cond)"✅ got: (cond)
[⚙️ assert] idempotent: "(cond ())"✅ got: (cond [])
[⚙️ assert] idempotent: "(lambda)"✅ got: (lambda)
[⚙️ assert] idempotent: "(lambda ())"✅ got: (lambda ())
[⚙️ assert] idempotent: "(define)"✅ got: (define)
[⚙️ assert] idempotent: "(define ())"✅ got: (define ())
[⚙️ assert] idempotent: "(quote)"✅ got: (quote)
[⚙️ assert] idempotent: "'"✅ got: '
[⚙️ assert] idempotent: "#"✅ got: #
[⚙️ assert] idempotent: "#;"✅ got: #;
[⚙️ assert] idempotent: "#|"✅ got: #|
[⚙️ assert] idempotent: "#\\"✅ got: #\
[⚙️ assert] idempotent: "?\\"✅ got: ?\
[⚙️ assert] idempotent: "(a . )"✅ got: (a .)
[⚙️ assert] idempotent: "(a . b . c)"✅ got: (a . b . c)
[⚙️ assert] idempotent: "(#)"✅ got: (#)
[⚙️ assert] idempotent: "(list #;)"✅ got: (list #;)
[⚙️ assert] idempotent: "(list #|x|#)"✅ got: (list #|x|#)
[⚙️ assert] idempotent: "(((("✅ got: ((((
[⚙️ assert] idempotent: "))))"✅ got: ))))
[⚙️ assert] idempotent: "(f :a 1 :a 2)"✅ got: (f :a 1 :a 2)
[⚙️ assert] idempotent: "(f \"unterminated"✅ got: (f "unterminated
[⚙️ assert] idempotent: "(f #<garbage)"✅ got: (f #<garbage)
[⚙️ assert] idempotent: "(f #.(+ 1 2))"✅ got: (f #.(+ 1 2))
[⚙️ assert] idempotent: "(let ((x 1) (x 2)) x)"✅ got: (let ((x 1) (x 2)) x)
[⚙️ assert] idempotent: "(when)"✅ got: (when)
[⚙️ assert] idempotent: "(unless)"✅ got: (unless)
[⚙️ assert] idempotent: "(if)"✅ got: (if)
[⚙️ assert] idempotent: "(do)"✅ got: (do)
[⚙️ assert] idempotent: "(λ (x) x)"✅ got: (λ (x) x)
[🧪 test] an empty body is reported rather than raising✅ got: 1ℹ️ info - ran 70 tasks in: 15 seconds, -162708 microseconds/root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/definitions.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/definitions.scm.go
loading tests/files.scm
;;; compiling ./tests/files.scm
;;; compiling ./src/sift/files.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/files.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/files.scm.go
loading tests/format-cl.scm
;;; compiling ./tests/format-cl.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/format-cl.scm.go
loading tests/format-elisp.scm
;;; compiling ./tests/format-elisp.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/format-elisp.scm.go
loading tests/format-scheme.scm
;;; compiling ./tests/format-scheme.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/format-scheme.scm.go
loading tests/json.scm
;;; compiling ./tests/json.scm
;;; compiling ./src/sift/json.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/src/sift/json.scm.go
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/json.scm.go
loading tests/lsp.scm
;;; compiling ./tests/lsp.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/lsp.scm.go
loading tests/pool.scm
;;; compiling ./tests/pool.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/pool.scm.go
loading tests/reader-cl.scm
;;; compiling ./tests/reader-cl.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/reader-cl.scm.go
loading tests/reader-elisp.scm
;;; compiling ./tests/reader-elisp.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/reader-elisp.scm.go
loading tests/reader-scheme.scm
;;; compiling ./tests/reader-scheme.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/reader-scheme.scm.go
loading tests/robustness.scm
;;; compiling ./tests/robustness.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/tests/robustness.scm.go
;;; note: source file /etc/byggsteg/job-clone/sift/trunk/maak.scm
;;; newer than compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/maak.scm.go
;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;; or pass the --no-auto-compile argument to disable.
;;; compiling /etc/byggsteg/job-clone/sift/trunk/maak.scm
;;; compiled /root/.cache/guile/ccache/3.0-LE-8-4.6/etc/byggsteg/job-clone/sift/trunk/maak.scm.go
--------------------------------------------------------------
Maak 0.14.0: the infinitely extensible command runner
Loading tasks from Maak file: /etc/byggsteg/job-clone/sift/trunk/maak.scm
Executing Maak tasks: test
--------------------------------------------------------------
=> Running Maak task: test
Run the whole Veritas suite.
Veritas is the only test framework this project uses; it is loaded from
VERITAS_DIR (~/Hacking/veritas by default) so that the checkout under test is
the checkout that is being developed, and the load path is passed here rather
than exported by the caller, so `maak test' works from a clean checkout.
Execute command:
guix time-machine --channels=channels.scm -- shell -m manifest.scm -- guile -L ./src -L . -c '(begin (use-modules (tests run)) (exit (run-all!)))'
Executing: guix time-machine --channels=channels.scm -- shell -m manifest.scm -- guile -L ./src -L . -c '(begin (use-modules (tests run)) (exit (run-all!)))'
→ running command: cd /etc/byggsteg/job-clone/sift/trunk && maak emacs-test
channels.scm:17:6: warning: channel 'jointhefreeworld' is not trusted
Running 31 tests (2026-11-01 22:18:34+0100, selector ‘t’)
passed 1/31 sift-test-check-buffer (0.000521 sec)
passed 2/31 sift-test-ci-command (0.000099 sec)
passed 3/31 sift-test-code-actions-need-a-server (0.000055 sec)
passed 4/31 sift-test-diagnostics-empty (0.000033 sec)
passed 5/31 sift-test-diagnostics-shape (0.000056 sec)
passed 6/31 sift-test-dialect-from-major-mode (0.000046 sec)
passed 7/31 sift-test-eglot-contact-runs-the-server (0.000037 sec)
passed 8/31 sift-test-eglot-contact-says-when-sift-is-missing (0.000055 sec)
passed 9/31 sift-test-eglot-leaves-formatting-to-the-server (0.084535 sec)
passed 10/31 sift-test-eglot-setup-leaves-the-flymake-backend-alone (0.000101 sec)
passed 11/31 sift-test-eglot-setup-registers-the-modes (0.000065 sec)
passed 12/31 sift-test-eglot-silences-the-flymake-backend (0.000047 sec)
passed 13/31 sift-test-error-regexp (0.000055 sec)
sift: this buffer would be reformatted (M-x sift-format-buffer)
passed 14/31 sift-test-explain (0.115015 sec)
sift: fixed
passed 15/31 sift-test-fix-buffer (0.059259 sec)
passed 16/31 sift-test-fix-buffer-refuses-a-parse-error (0.067086 sec)
passed 17/31 sift-test-fix-string-filters-by-checker (0.096862 sec)
passed 18/31 sift-test-flymake-backend (0.098594 sec)
passed 19/31 sift-test-flymake-backend-reports-a-parse-error (0.099035 sec)
passed 20/31 sift-test-flymake-backend-unknown-mode (0.000102 sec)
passed 21/31 sift-test-flymake-cancels-the-run-it-replaces (0.001105 sec)
passed 22/31 sift-test-format-broken-source-says-why (0.086030 sec)
sift: formatted
passed 23/31 sift-test-format-buffer (0.055729 sec)
sift: formatted
sift: already formatted
passed 24/31 sift-test-format-buffer-is-idempotent (0.070520 sec)
passed 25/31 sift-test-format-buffer-refuses-a-parse-error (0.034481 sec)
sift: formatted
passed 26/31 sift-test-format-elisp (0.038009 sec)
sift: formatted the region
passed 27/31 sift-test-format-region (0.055066 sec)
passed 28/31 sift-test-rule-at-point-from-compilation-line (0.000059 sec)
passed 29/31 sift-test-rule-names (0.048581 sec)
passed 30/31 sift-test-severity-is-said-only-when-it-is-set (0.000042 sec)
passed 31/31 sift-test-version (0.048394 sec)
Ran 31 tests, 31 results as expected, 0 unexpected (2026-11-01 22:18:36+0100, 1.065216 sec)
--------------------------------------------------------------
Maak 0.14.0: the infinitely extensible command runner
Loading tasks from Maak file: /etc/byggsteg/job-clone/sift/trunk/maak.scm
Executing Maak tasks: emacs-test
--------------------------------------------------------------
=> Running Maak task: emacs-test
Run the Emacs package's ERT suite.
ERT is the test framework Emacs ships, and it is the right one here: the
package is a thin wrapper around the executable, so the tests run the
executable and read what came back, the way a user would. The Guile suite is
Veritas; this one never runs the two together.
Execute command:
guix time-machine --channels=channels.scm -- shell -m manifest.scm -- emacs -Q --batch -L emacs -l ert -l emacs/sift-test.el -f ert-run-tests-batch-and-exit
Executing: guix time-machine --channels=channels.scm -- shell -m manifest.scm -- emacs -Q --batch -L emacs -l ert -l emacs/sift-test.el -f ert-run-tests-batch-and-exit