Bug#1019392: toybox: autopkgtest regression on ppc64el: exited with signal (or returned 255)

[Antoni Villalonga]

Hi Paul,

Thanks for reporting the issue.

I've tested the package on a virtual ppc64el Debian/Sid fresh installation.

Testing the coreutils seq takes around 0.8 seconds:
 $ echo -ne '' | timeout 10 seq 10000000 > /dev/null

Testing the toybox seq takes around 1.4 seconds:
 $ echo -ne '' | timeout 10 toybox seq 10000000 > /dev/null

In that case, Coreutils seems to perform twice faster than Toybox. In any case
both have taken lot less than 10 seconds specified for the test.


After looking at your qa profile I've noticed you are the autopkgtest
maintainer. May be you can give me some hints on how to reproduce the issue or
how long it takes on "autopkgtest boxes" to adapt the "timeout" :)

If it's not possible, I'll try to contact with ppc64el debian team for help.


Thanks for yout time!
Best regards,

On Thu, Sep 08, 2022 at 04:03:36PM +0200, Paul Gevers wrote:
> Source: toybox
> Version: 0.8.8+dfsg-1
> Severity: serious
> User: debian...@lists.debian.org
> Usertags: regression
> 
> Dear maintainer(s),
> 
> With a recent upload of toybox the autopkgtest of toybox fails in testing
> when that autopkgtest is run with the binary packages of toybox from
> unstable. It passes when run with only packages from testing. In tabular
> form:
> 
>                        pass            fail
> toybox                 from testing    0.8.8+dfsg-1
> all others             from testing    from testing
> 
> I copied some of the output at the bottom of this report.
> 
> Currently this regression is blocking the migration to testing [1]. Can you
> please investigate the situation and fix it?
> 
> More information about this bug and the reason for filing it can be found on
> https://wiki.debian.org/ContinuousIntegration/RegressionEmailInformation
> 
> Paul
> 
> [1] https://qa.debian.org/excuses.php?package=toybox
> 
> https://ci.debian.net/data/autopkgtest/testing/ppc64el/t/toybox/25825642/log.gz
> 
> # README:
> # The maximum sane configuration is "make defconfig": allyesconfig isn't
> CFLAGS="-g -O2
> -ffile-prefix-map=/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src=.
> -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time
> -D_FORTIFY_SOURCE=2 -Wl,-z,relro -Wl,-z,now" make defconfig
> make[1]: Entering directory
> '/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src'
> cc -g -O2
> -ffile-prefix-map=/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src=.
> -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time
> -D_FORTIFY_SOURCE=2 -Wl,-z,relro -Wl,-z,now -o kconfig/conf kconfig/conf.c
> kconfig/zconf.tab.c -DKBUILD_NO_NLS=1 \
>       -DPROJECT_NAME=\"ToyBox\"
> kconfig/conf.c: In function ‘conf_askvalue’:
> kconfig/conf.c:104:17: warning: ignoring return value of ‘fgets’ declared
> with attribute ‘warn_unused_result’ [-Wunused-result]
>   104 |                 fgets(line, 128, stdin);
>       |                 ^~~~~~~~~~~~~~~~~~~~~~~
> kconfig/conf.c: In function ‘conf_choice’:
> kconfig/conf.c:359:25: warning: ignoring return value of ‘fgets’ declared
> with attribute ‘warn_unused_result’ [-Wunused-result]
>   359 |                         fgets(line, 128, stdin);
>       |                         ^~~~~~~~~~~~~~~~~~~~~~~
> scripts/genconfig.sh
> kconfig/conf -D /dev/null Config.in > /dev/null
> make[1]: Leaving directory
> '/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src'
> # Go for insanely overpowered toys!
> # allyesconfig add build-depends: libssl-dev zlib1g-dev
> #CFLAGS="-g -O2
> -ffile-prefix-map=/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src=.
> -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time
> -D_FORTIFY_SOURCE=2 -Wl,-z,relro -Wl,-z,now" make allyesconfig
> # Hardening and such FLAGS
> echo -g -O2
> -ffile-prefix-map=/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src=.
> -fstack-protector-strong -Wformat -Werror=format-security > generated/cflags
> echo -Wdate-time -D_FORTIFY_SOURCE=2 >> generated/cflags
> scripts/test.sh
> make[1]: Entering directory
> '/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src'
> scripts/install.sh --symlink --force
> Compile instlist...
> Library probe
> generated/{Config.in,newtoys.h,flags.h,globals.h,tags.h,help.h}
> Install commands...
> make[1]: Leaving directory
> '/tmp/autopkgtest-lxc.ftn7u0vb/downtmp/build.Qwz/src'
> PASS: base32 simple
> PASS: base32 file
> PASS: base32 simple -d
> PASS: base32 file -d
> PASS: base32 default wrap
> PASS: base32 multiline -d PASS: base32 -w
> PASS: base32 -w0
> PASS: base64 simple
> PASS: base64 file
> PASS: base64 simple -d
> PASS: base64 simple -d
> PASS: base64 default wrap
> PASS: base64 multiline -d PASS: base64 -w
> PASS: base64 -w0
> PASS: basename /-only
> PASS: basename trailing /
> PASS: basename combined
> PASS: basename suffix
> PASS: basename suffix=result
> PASS: basename reappearing suffix 1
> PASS: basename reappearing suffix 2
> PASS: basename invalid suffix
> PASS: basename zero-length suffix
> PASS: basename -s
> PASS: basename -s implies -a
> PASS: basename -a
> PASS: blkid cramfs
> PASS: blkid ext2
> PASS: blkid ext3
> PASS: blkid ext4
> PASS: blkid f2fs
> PASS: blkid msdos
> PASS: blkid ntfs
> PASS: blkid reiserfs
> PASS: blkid squashfs
> PASS: blkid vfat
> PASS: blkid xfs
> PASS: blkid stdin
> PASS: blkid -o value -s
> PASS: blkid -o export
> PASS: bzcat 2 known files
> PASS: bzcat overflow
> PASS: bzcat badcrc
> PASS: cat cat
> PASS: cat -
> PASS: cat file1 file2
> PASS: cat - file
> PASS: cat file -
> PASS: cat file1 notfound file2
> PASS: cat binary
> PASS: cat - file1
> PASS: cat > /dev/full
> SKIP: chattr (not root)
> SKIP: chgrp (not root)
> PASS: chmod 000 dir
> PASS: chmod 000 file
> PASS: chmod 007 dir
> PASS: chmod 007 file
> PASS: chmod 030 dir
> PASS: chmod 030 file
> PASS: chmod 037 dir
> PASS: chmod 037 file
> PASS: chmod 060 dir
> PASS: chmod 060 file
> PASS: chmod 067 dir
> PASS: chmod 067 file
> PASS: chmod 100 dir
> PASS: chmod 100 file
> PASS: chmod 107 dir
> PASS: chmod 107 file
> PASS: chmod 130 dir
> PASS: chmod 130 file
> PASS: chmod 137 dir
> PASS: chmod 137 file
> PASS: chmod 160 dir
> PASS: chmod 160 file
> PASS: chmod 167 dir
> PASS: chmod 167 file
> PASS: chmod 200 dir
> PASS: chmod 200 file
> PASS: chmod 207 dir
> PASS: chmod 207 file
> PASS: chmod 230 dir
> PASS: chmod 230 file
> PASS: chmod 237 dir
> PASS: chmod 237 file
> PASS: chmod 260 dir
> PASS: chmod 260 file
> PASS: chmod 267 dir
> PASS: chmod 267 file
> PASS: chmod 300 dir
> PASS: chmod 300 file
> PASS: chmod 307 dir
> PASS: chmod 307 file
> PASS: chmod 330 dir
> PASS: chmod 330 file
> PASS: chmod 337 dir
> PASS: chmod 337 file
> PASS: chmod 360 dir
> PASS: chmod 360 file
> PASS: chmod 367 dir
> PASS: chmod 367 file
> PASS: chmod 400 dir
> PASS: chmod 400 file
> PASS: chmod 407 dir
> PASS: chmod 407 file
> PASS: chmod 430 dir
> PASS: chmod 430 file
> PASS: chmod 437 dir
> PASS: chmod 437 file
> PASS: chmod 460 dir
> PASS: chmod 460 file
> PASS: chmod 467 dir
> PASS: chmod 467 file
> PASS: chmod 500 dir
> PASS: chmod 500 file
> PASS: chmod 507 dir
> PASS: chmod 507 file
> PASS: chmod 530 dir
> PASS: chmod 530 file
> PASS: chmod 537 dir
> PASS: chmod 537 file
> PASS: chmod 560 dir
> PASS: chmod 560 file
> PASS: chmod 567 dir
> PASS: chmod 567 file
> PASS: chmod 600 dir
> PASS: chmod 600 file
> PASS: chmod 607 dir
> PASS: chmod 607 file
> PASS: chmod 630 dir
> PASS: chmod 630 file
> PASS: chmod 637 dir
> PASS: chmod 637 file
> PASS: chmod 660 dir
> PASS: chmod 660 file
> PASS: chmod 667 dir
> PASS: chmod 667 file
> PASS: chmod 700 dir
> PASS: chmod 700 file
> PASS: chmod 707 dir
> PASS: chmod 707 file
> PASS: chmod 730 dir
> PASS: chmod 730 file
> PASS: chmod 737 dir
> PASS: chmod 737 file
> PASS: chmod 760 dir
> PASS: chmod 760 file
> PASS: chmod 767 dir
> PASS: chmod 767 file
> PASS: chmod 750 dir 640 file
> PASS: chmod 666 dir file
> PASS: chmod 765 dir file
> PASS: chmod u=r dir file
> PASS: chmod u=w dir file
> PASS: chmod u=x dir file
> PASS: chmod u+r dir file
> PASS: chmod u+w dir file
> PASS: chmod u+x dir file
> PASS: chmod u-r dir file
> PASS: chmod u-w dir file
> PASS: chmod u-x dir file
> PASS: chmod g=r dir file
> PASS: chmod g=w dir file
> PASS: chmod g=x dir file
> PASS: chmod g+r dir file
> PASS: chmod g+w dir file
> PASS: chmod g+x dir file
> PASS: chmod g-r dir file
> PASS: chmod g-w dir file
> PASS: chmod g-x dir file
> PASS: chmod o=r dir file
> PASS: chmod o=w dir file
> PASS: chmod o=x dir file
> PASS: chmod o+r dir file
> PASS: chmod o+w dir file
> PASS: chmod o+x dir file
> PASS: chmod o-r dir file
> PASS: chmod o-w dir file
> PASS: chmod o-x dir file
> PASS: chmod a=r dir file
> PASS: chmod a=w dir file
> PASS: chmod a=x dir file
> PASS: chmod a+r dir file
> PASS: chmod a+w dir file
> PASS: chmod a+x dir file
> PASS: chmod a-r dir file
> PASS: chmod a-w dir file
> PASS: chmod a-x dir file
> PASS: chmod =r dir file
> PASS: chmod =w dir file
> PASS: chmod =x dir file
> PASS: chmod +r dir file
> PASS: chmod +w dir file
> PASS: chmod +x dir file
> PASS: chmod -r dir file
> PASS: chmod -w dir file
> PASS: chmod -x dir file
> PASS: chmod a-w,a+x dir file
> PASS: chmod g+s dir file
> PASS: chmod u+s dir file
> PASS: chmod +s dir file
> PASS: chmod o+s dir file
> PASS: chmod +t dir file
> PASS: chmod a=r+w+x dir file
> PASS: chmod +X
> PASS: chmod -R symlink arg
> PASS: chmod -R symlink recurse
> SKIP: chown (not root)
> PASS: cksum on stdin
> PASS: cksum on file
> PASS: cksum on multiple files
> PASS: cksum on abc including length
> PASS: cksum on abc excluding length
> PASS: cksum on no data post-inversion
> PASS: cksum on no data pre+post-inversion
> PASS: cksum on no data no inversion
> PASS: cksum on no data pre-inversion
> PASS: cmp one argument match
> PASS: cmp one argument diff
> PASS: cmp missing file1 [fail]
> PASS: cmp identical files, stdout
> PASS: cmp identical files, return code
> PASS: cmp EOF, stderr
> PASS: cmp EOF, return code
> PASS: cmp diff, stdout
> PASS: cmp diff, return code
> PASS: cmp -s EOF, return code
> PASS: cmp -s diff, return code
> PASS: cmp -l EOF, stderr
> PASS: cmp -l diff and EOF, stdout and stderr
> PASS: cmp -s not exist
> PASS: cmp stdin and file
> PASS: cmp -n skip1 skip2
> PASS: comm comm
> PASS: cp not enough arguments [fail]
> PASS: cp -missing source [fail]
> PASS: cp file->file
> PASS: cp file->dir
> PASS: cp file->dir/file
> PASS: cp -r dir->missing
> PASS: cp -r dir->file [fail]
> PASS: cp -r dir hits file.
> PASS: cp file->inaccessible [fail]
> PASS: cp -f file->inaccessible
> PASS: cp file->inaccessible_dir [fail]
> PASS: cp file1 file2 missing [fail]
> PASS: cp dir file missing [fail]
> PASS: cp -rf dir file missing [fail]
> PASS: cp file1 file2 file [fail]
> PASS: cp file1 file2 dir
> PASS: cp -r /abspath dest
> PASS: cp -r dir again
> PASS: cp -r dir1/* dir2
> PASS: cp -pr dir/.
> PASS: cp -pr dir/. symlink child
> PASS: cp symlink dest permissions
> PASS: cp duplicated --preserve options
> PASS: cp -T file
> PASS: cp -T dir
> PASS: cp --parents b/c/d/file a/
> PASS: cp -P file
> PASS: cp -P symlink
> PASS: cp follow symlink
> PASS: cp -t one arg
> PASS: cp -Dt
> PASS: cp -u1
> PASS: cp -u2
> PASS: cp -i
> PASS: cpio name padding
> PASS: cpio file padding
> PASS: cpio archive length
> PASS: cpio archive magic
> PASS: cpio name length
> PASS: cpio -t
> PASS: cpio -t --quiet
> PASS: cpio -p
> PASS: cpio -pd
> PASS: cpio archives unreadable empty files
> PASS: cpio -i doesn't create leading directories
> PASS: cpio -id creates leading directories
> PASS: cpio -i keeps existing files
> PASS: cpio -id keeps existing files
> PASS: cpio -iu replaces existing files; no error
> PASS: cpio -idu replaces existing files; no error
> PASS: cpio skip NUL
> PASS: cpio error on empty file
> PASS: cut -b a,a,a
> PASS: cut -b overlaps
> PASS: cut -b encapsulated
> PASS: cut -bO overlaps
> PASS: cut high-low error
> PASS: cut -c a-b
> PASS: cut -c a-
> PASS: cut -c -b
> PASS: cut -c a
> PASS: cut -c a,b-c,d
> PASS: cut -c japan.txt
> PASS: cut -C test1.txt
> PASS: cut -DF
> PASS: cut -DF 2
> PASS: cut empty field
> PASS: cut empty field 2
> PASS: cut -f a-
> PASS: cut show whole line with no delim
> PASS: cut -c (a-b)
> PASS: cut -c (a)
> PASS: cut -c (a,b,c)
> PASS: cut -b (a,b,c)
> PASS: cut -d -f(:) -s
> PASS: cut -d -f( ) -s
> PASS: cut -d -f(a) -s
> PASS: cut -d -f(a) -s -n
> PASS: cut -nb
> PASS: cut -d newline
> demo_number disabled
> PASS: dirname /-only
> PASS: dirname trailing /
> PASS: dirname combined
> PASS: dirname /a/
> PASS: dirname multiple
> PASS: du (no options)
> PASS: du -s
> PASS: du counts symlinks without following
> PASS: du -L follows symlinks
> PASS: du -L avoid endless loop
> PASS: du -HL follows symlinks
> PASS: du -H does not follow unspecified symlinks
> PASS: du -LH does not follow unspecified symlinks
> PASS: du -H follows specified symlinks
> PASS: echo echo
> PASS: echo 1 2 3
> PASS: echo with spaces
> PASS: echo echo -n
> PASS: echo echo -n one
> PASS: echo echo one -n
> PASS: echo -en
> PASS: echo echo --hello
> PASS: echo -e all
> PASS: echo -e all but \c
> PASS: echo -nex hello
> PASS: echo -e octal values
> PASS: echo -e invalid oct
> PASS: echo -e \0040
> PASS: echo -e hexadecimal values
> PASS: echo -e invalid hex 1
> PASS: echo -e invalid hex 2
> PASS: echo -e \e
> PASS: echo -e \p
> PASS: echo -En
> PASS: echo -eE
> PASS: echo echo -e 'a\x123\ufb3bbc' | od -An -tx1
> PASS: echo trailing nul
> PASS: env read
> PASS: env -u
> PASS: env -uu
> PASS: env -i uses old $PATH
> PASS: env -i env
> PASS: env -i =
> PASS: env -0
> PASS: env early fail
> PASS: env why is this allowed
> PASS: env replace
> PASS: env norecurse
> PASS: expand default
> PASS: expand default stdin
> PASS: expand single
> PASS: expand tablist
> PASS: expand backspace
> PASS: expand long tab single
> PASS: expand long tab tablist
> PASS: expand multiline single
> PASS: expand multiline tablist
> PASS: expand long line single
> expr disabled
> PASS: factor -32
> PASS: factor 0
> PASS: factor 1
> PASS: factor 2
> PASS: factor 3
> PASS: factor 4
> PASS: factor 10000000017
> PASS: factor 10000000018
> PASS: factor 10000000019
> PASS: factor 3 6 from stdin
> PASS: factor stdin newline
> PASS: factor -h
> PASS: factor -x
> PASS: file directory
> PASS: file empty
> PASS: file script
> PASS: file script with spaces
> PASS: file env script
> PASS: file ascii
> PASS: file utf-8
> PASS: file mach-o universal
> PASS: file tar file
> PASS: file gzip data
> PASS: file bzip2 data
> PASS: file 7z file
> PASS: file zip file
> PASS: file gif file
> PASS: file Android .dex
> PASS: file broken symlink
> PASS: file symlink
> PASS: file symlink -h
> PASS: file /dev/zero
> PASS: file - </dev/zero
> PASS: file ar
> PASS: file cpio
> PASS: find -type l -a -type d -o -type p
> PASS: find -type l -type d -o -type p
> PASS: find -type l -o -type d -a -type p
> PASS: find -type l -o -type d -type p
> PASS: find -type l ( -type d -o -type l )
> PASS: find extra parentheses
> PASS: find ( -type p -o -type d ) -type p
> PASS: find -type l -o -type d -type p -o -type f
> PASS: find -type l,f
> PASS: find -type f -a -print
> PASS: find -print -o -print
> PASS: find  PASS: find -type f -user -exec
> PASS: find -type l -newer -exec
> PASS: find -exec true \; -print
> PASS: find -exec false \; -print
> PASS: find -perm (exact success)
> PASS: find -perm (exact failure)
> PASS: find -perm (min success)
> PASS: find -perm (min failure)
> PASS: find -perm (any success)
> PASS: find -perm (any failure)
> PASS: find unterminated -exec {}
> PASS: find -exec {} +
> PASS: find -name file
> PASS: find -name FILE
> PASS: find -iname file
> PASS: find -iname FILE
> PASS: find -name (no arguments)
> PASS: find -iname (no arguments)
> PASS: find -lname
> PASS: find -ilname
> PASS: find dir \( -iname file -o -iname missing \) -exec echo {} \;
> PASS: find -path glob
> PASS: find -wholename glob
> PASS: find -ipath glob
> PASS: find -iwholename glob
> PASS: find -printf
> PASS: find -printf .N
> PASS: find -printf escapes
> PASS: find -printf \c escape
> PASS: find -L dangling symlink silent
> PASS: find -L symlink loop noisy
> PASS: find -false
> PASS: find -true
> PASS: find missing root error
> PASS: find -path match root
> PASS: find -name match root
> PASS: find -H broken
> PASS: find -L broken
> PASS: find one slash
> PASS: find empty arg
> PASS: find quit
> PASS: find samefile
> PASS: find newerat
> PASS: find newer nano
> PASS: fmt join
> PASS: fmt split
> PASS: fmt no room
> PASS: fmt blank line
> PASS: fmt ws-only line
> PASS: fmt leading space
> PASS: fmt utf8
> PASS: fmt no newline
> PASS: fmt -w 9
> PASS: fmt -w 10
> PASS: fmt -w 11
> PASS: fmt -w 12
> PASS: fmt matched tab indent
> PASS: fmt matched tab/space
> PASS: fmt matched space/tab
> PASS: fstype file
> PASS: fstype cramfs
> PASS: fstype ext2
> PASS: fstype ext3
> PASS: fstype ext4
> PASS: fstype f2fs
> PASS: fstype ntfs
> PASS: fstype squashfs
> PASS: fstype vfat
> PASS: fstype xfs
> PASS: fstype msdos
> PASS: fstype reiserfs
> getopt disabled
> PASS: grep -c
> PASS: grep -l
> PASS: grep -L
> PASS: grep -q
> PASS: grep -E
> PASS: grep -e
> PASS: grep -e -e
> PASS: grep -F
> PASS: grep -H
> PASS: grep -b
> PASS: grep -i
> PASS: grep -n
> PASS: grep -o
> PASS: grep -s
> PASS: grep -v
> PASS: grep -w
> PASS: grep -x
> PASS: grep -H (standard input)
> PASS: grep -l (standard input)
> PASS: grep -n two inputs
> PASS: grep pattern with newline
> PASS: grep -lH
> PASS: grep -cn
> PASS: grep -cH
> PASS: grep -qs
> PASS: grep -hl
> PASS: grep -b stdin
> PASS: grep -o overlap
> PASS: grep -co
> PASS: grep -nom
> PASS: grep -vo
> PASS: grep no newline
> PASS: grep -e multi
> PASS: grep -hr
> PASS: grep -r file
> PASS: grep -r dir
> PASS: grep -Fx ''
> PASS: grep -F ''
> PASS: grep -F -e blah -e ''
> PASS: grep -Fxv -e subset
> PASS: grep -e blah -e ''
> PASS: grep -w ''
> PASS: grep -w '' 2
> PASS: grep -w \1
> PASS: grep -o ''
> PASS: grep backref
> PASS: grep -A
> PASS: grep -B
> PASS: grep -C
> PASS: grep -HnC
> PASS: grep -HnbB1
> PASS: grep -q match overrides error
> PASS: grep -q not found is 1
> PASS: grep -q missing is 2
> PASS: grep -q missing survives exists but not found
> PASS: grep not found retained past match
> PASS: grep one match good enough for 0
> PASS: grep -o ''
> PASS: grep -o -e '' -e two
> PASS: grep -l overrides -C
> PASS: grep match after NUL byte
> PASS: grep implicit BRE |
> PASS: grep explicit BRE |
> PASS: grep explicit ERE |
> PASS: grep -o -e iss -e ipp
> PASS: grep -o -e gum -e rgu
> PASS: grep early failure
> PASS: grep abc ; echo $?
> PASS: grep abc doesnotexist input 2>/dev/null; echo $?
> PASS: grep -r walrus sub 2>/dev/null; echo $?
> PASS: grep --exclude-dir
> PASS: grep -rh hello sub 2>/dev/null || echo err
> PASS: grep -Rh hello sub
> PASS: grep -F multiple
> PASS: grep -Fi multiple
> PASS: grep -F empty multiple
> PASS: grep -Fx
> PASS: grep -Fix
> PASS: grep -f /dev/null
> PASS: grep -z with \n in pattern
> PASS: grep print zero length match
> PASS: grep -o skip zero length match
> PASS: grep --color highlights all matches
> groupadd disabled
> groupdel disabled
> PASS: head head, stdin
> PASS: head head, stdin via -
> PASS: head head, file
> PASS: head -number
> PASS: head head, default lines
> PASS: head -v file
> PASS: head -v stdin
> PASS: head file and stdin
> PASS: head head, multiple files
> PASS: head -q, multiple files
> PASS: head -c 3
> PASS: head -c bigger than input
> PASS: head -c 3 -n 1
> PASS: head -n 1 -c 3
> hexdump disabled
> PASS: hostname get
> PASS: httpd static file
> PASS: httpd mime type
> PASS: iconv chars | xxd -p
> PASS: iconv -t UTF-16BE
> PASS: iconv -t UTF-16LE
> PASS: iconv -t UTF-32BE
> PASS: iconv -t UTF-32LE
> PASS: id 0
> PASS: id root
> PASS: id -G root
> PASS: id -nG root
> PASS: id -g root
> PASS: id -ng root
> PASS: id -u root
> PASS: id -nu root
> PASS: id no-such-user
> PASS: id 2147483647
> SKIP: ifconfig (not root)
> PASS: install install -D exists
> PASS: install install -D -t creates directory
> PASS: link fails on non-existent file
> PASS: link create_hardlink
> PASS: link preserves_hardlinks
> PASS: link create_hardlink_and_remove_sourcefile
> PASS: ln create_hardlink
> PASS: ln create_softlink
> PASS: ln force_create_hardlink
> PASS: ln force_create_symlink
> PASS: ln preserves_hardlinks
> PASS: ln preserves_symlinks
> PASS: ln multilevel_symbolic_links
> PASS: ln no_dereference
> PASS: ln -T acts like -n
> PASS: ln -T with dir
> PASS: ln -t
> PASS: ln create_multiple_hardlinks
> PASS: ln create_multiple_softlinks
> PASS: ln create_softlink_and_remove_sourcefile
> PASS: ln create_hardlink_and_remove_sourcefile
> PASS: ln ln -r
> SKIP: losetup (not root)
> PASS: ls no argument
> PASS: ls with -C: test column spacing equals 2
> PASS: ls with -x: test column spacing equals 2
> PASS: ls with wild char
> PASS: ls with wild char - long listing
> PASS: ls with -p
> PASS: ls with -a
> PASS: ls with -A
> PASS: ls with -d
> PASS: ls with wild char and -d *
> PASS: ls with -k
> PASS: ls with -m
> PASS: ls with -F
> PASS: ls with -dk *
> PASS: ls with -Z
> PASS: ls with -lZ
> PASS: ls -l symlink
> PASS: ls with -d - broken softlink
> PASS: ls nested recursively
> PASS: ls with -i
> PASS: ls missing
> PASS: ls -w test 1
> PASS: ls -w test 2
> PASS: ls -w test 3
> PASS: ls -w test 4
> PASS: md5sum ''
> PASS: md5sum infile
> PASS: md5sum two files
> PASS: md5sum 4
> PASS: md5sum 5
> PASS: md5sum 6
> PASS: md5sum -c spaces
> PASS: md5sum -c nolines
> PASS: md5sum --status okay
> PASS: md5sum --status fail
> PASS: md5sum -c multiple
> PASS: mkdir mkdir
> PASS: mkdir existing file
> PASS: mkdir existing dir
> PASS: mkdir one two
> PASS: mkdir missing/one
> PASS: mkdir -p
> PASS: mkdir -p existing
> PASS: mkdir (default permissions)
> PASS: mkdir -m 124
> PASS: mkdir -p -m 653
> PASS: mkdir -p one/two/ (trailing slash)
> PASS: mkdir -p -m 777 (022 umask)
> PASS: mkdir -p -m 777 (377 umask)
> PASS: mkdir -vp
> PASS: mkdir -vp exists
> PASS: mkdir continue after fail
> PASS: mkfifo mkfifo
> PASS: mkfifo existing
> PASS: mkfifo one two
> PASS: mkfifo (default permissions)
> PASS: mkfifo -m 124
> PASS: mktemp default template uses $TMPDIR
> PASS: mktemp default creates file
> PASS: mktemp -d creates dir
> PASS: mktemp TEMPLATE does not use $TMPDIR
> PASS: mktemp / in TEMPLATE works but ignores $TMPDIR
> PASS: mktemp / in TEMPLATE with -p DIR is error
> PASS: mktemp -t TEMPLATE uses $TMPDIR
> PASS: mktemp -t and TEMPLATE but no $TMPDIR uses /tmp
> PASS: mktemp -p DIR and TEMPLATE should use DIR
> PASS: mktemp -p DIR and -t: -t wins
> PASS: mktemp -p DIR -t TEMPLATE but no $TMPDIR (DIR wins)
> PASS: mktemp -u doesn't need to be able to write to dir
> PASS: mktemp needs at least XXX in template
> PASS: mktemp -q shouldn't print path
> PASS: mktemp --tmpdir doesn't need argument
> PASS: mktemp --tmpdir can have argument
> PASS: mv file to file
> PASS: mv file to dir
> PASS: mv dir to dir
> PASS: mv multiple files/dirs to a dir
> PASS: mv random file to new file
> PASS: mv symlink to new symlink
> PASS: mv hard link to new hardlink
> PASS: mv file to unreadable file
> PASS: mv file hardlink dir
> PASS: mv dir to new dir
> PASS: mv dir to existing dir
> PASS: mv dir1/dir2 to .
> PASS: mv dir1/dir2/ to .
> PASS: mv dir1/dir2/ to ./
> PASS: mv not/exists/ to ./
> PASS: mv force over unwritable
> PASS: mv no clobber (dest exists)
> PASS: mv no clobber (dest doesn't exist)
> PASS: mv over unwritable file only prompts when stdin is a terminal
> PASS: mv interactive: no stdin
> PASS: mv interactive: answered YES
> PASS: mv interactive: answered NO
> PASS: netcat more than buffer bytes left at end
> PASS: nl nl
> PASS: nl explicit defaults
> PASS: nl -nln
> PASS: nl -nln -w
> PASS: nl -nrz
> PASS: nl -nrz -w
> PASS: nl -b t
> PASS: nl -b n
> PASS: nl -sook -b p
> PASS: nl -v42
> PASS: nl -v-1
> PASS: nl -v0
> PASS: nl -l
> PASS: nl no space
> PASS: nl -E
> PASS: paste one two
> PASS: paste -s one two
> PASS: paste -s three four
> PASS: paste three four
> PASS: paste - - -
> PASS: paste - - - -d ''
> PASS: paste one two one two
> PASS: paste five three two
> PASS: paste -d '私\0̴̗̞̠eq' - - - - - - PASS: patch create file
> PASS: patch insert in middle
> PASS: patch append at end
> PASS: patch insert at start
> PASS: patch delete at end
> PASS: patch delete at start
> PASS: patch filter timestamps
> PASS: patch quoted name
> PASS: patch fuzz
> PASS: printf text
> PASS: printf escapes
> PASS: printf %b escapes
> PASS: printf null
> PASS: printf trailing slash
> PASS: printf octal
> PASS: printf not octal
> PASS: printf hex
> PASS: printf %x
> PASS: printf %d 42
> PASS: printf %d 0x2a
> PASS: printf %d 052
> PASS: printf %d none
> PASS: printf %d null
> PASS: printf %s width precision
> PASS: printf extra args
> PASS: printf '%3c'
> PASS: printf '%-3c'
> PASS: printf '%+d'
> PASS: printf '%5d%4d' 1 21 321 4321 54321
> PASS: printf '%c %c' 78 79
> PASS: printf '%d %d' 78 79
> PASS: printf '%f %f' 78 79
> PASS: printf 'f f' 78 79
> PASS: printf '%i %i' 78 79
> PASS: printf '%o %o' 78 79
> PASS: printf '%u %u' 78 79
> PASS: printf '%u %u' -1 -2
> PASS: printf '%x %X' 78 79
> PASS: printf '%g %G' 78 79
> PASS: printf '%s %s' 78 79
> PASS: printf %.s acts like %.0s
> PASS: printf corner case
> PASS: printf printf posix inconsistency
> PASS: printf printf \x
> PASS: printf printf \c
> PASS: printf printf octal %b
> PASS: printf invalid hex 1
> PASS: printf invalid hex 2
> PASS: printf invalid oct
> PASS: printf %b \e
> PASS: printf \e
> PASS: ps -o pid 10349
> PASS: pwd pwd
> PASS: pwd -P
> PASS: pwd pwd
> PASS: pwd -P
> PASS: pwd (bad PWD)
> PASS: readlink missing
> PASS: readlink file
> PASS: readlink -f dir
> PASS: readlink -f missing
> PASS: readlink link
> PASS: readlink links
> PASS: readlink link->missing
> PASS: readlink stays relative
> PASS: readlink -f link->file
> PASS: readlink -f link->dir
> PASS: readlink link->link (recursive)
> PASS: readlink -f link->link (recursive)
> PASS: readlink -q notlink
> PASS: readlink -q link
> PASS: readlink -q notfound
> PASS: readlink -e found
> PASS: readlink -e notfound
> PASS: readlink -nf .
> PASS: readlink -f multi
> PASS: readlink -f link/missing
> PASS: readlink -f /dev/null/file
> PASS: readlink -m missing/dir
> PASS: readlink -m missing/../elsewhere
> PASS: readlink -m file/dir
> PASS: readlink -f link->/
> PASS: readlink -f /dev/null/..
> PASS: readlink recurse
> PASS: readlink follow recursive2
> PASS: realpath realpath .
> PASS: realpath file
> PASS: realpath dir
> PASS: realpath missing defaults to -m
> PASS: realpath missing -e
> PASS: rev rev
> PASS: rev -
> PASS: rev file1 file2
> PASS: rev - file
> PASS: rev file -
> PASS: rev no trailing newline
> PASS: rev file1 notfound file2
> PASS: rev different input sizes
> PASS: rm text-file
> PASS: rm -i nonexistent
> PASS: rm empty directory
> PASS: rm text file(mode 000)
> PASS: rm -r (multiple files and dirs)
> PASS: rm -rf (present + missing files and dirs)
> PASS: rm -r nested_dir
> PASS: rm -rf 000 dir
> PASS: rm -rv dir
> PASS: rm -v
> PASS: rmdir rmdir
> PASS: rmdir file
> PASS: rmdir one two
> PASS: rmdir one missing two file three
> PASS: rmdir mode 000
> PASS: rmdir non-empty
> PASS: rmdir -p dir/file
> PASS: rmdir -p part of path
> PASS: rmdir -p one/two/three
> PASS: rmdir -p one/two/three/
> PASS: sed as cat
> PASS: sed sed - - twice
> PASS: sed -n
> PASS: sed -n p
> PASS: sed explicit pattern
> PASS: sed -n 1p
> PASS: sed 2p
> PASS: sed -n 2p
> PASS: sed -n $p
> PASS: sed as cat #2
> PASS: sed no input means no last line
> PASS: sed -n $,$p
> PASS: sed -n 1,2p
> PASS: sed -n 2,3p
> PASS: sed -n 2,1p
> PASS: sed $ with 2 inputs
> PASS: sed -n /two/p
> PASS: sed -n 1,/two/p
> PASS: sed -n /one/,2p
> PASS: sed -n 1,/one/p
> PASS: sed -n /one/,1p
> PASS: sed sed -n /two/,$p
> PASS: sed -n 3p
> PASS: sed prodigal newline
> PASS: sed Newline only added if further output
> PASS: sed match \t tab
> PASS: sed match t delim disables \t tab
> PASS: sed match t delim makes \t literal t
> PASS: sed match n delim
> PASS: sed match n delim disables \n newline
> PASS: sed match \n literal n
> PASS: sed end match does not check starting match line
> PASS: sed end match/start match mixing number/letter
> PASS: sed num then regex
> PASS: sed regex then num
> PASS: sed multiple regex address match
> PASS: sed regex address overlap
> PASS: sed getdelim with nested [:blah:]
> PASS: sed [ in [[]
> PASS: sed [[] with ] as delimiter
> PASS: sed [[] with [ as delimiter
> PASS: sed prodigaler newline
> PASS: sed aci
> PASS: sed b loop
> PASS: sed b skip
> PASS: sed b end
> PASS: sed c range
> PASS: sed c {range}
> PASS: sed c multiple continuation
> PASS: sed c empty continuation
> PASS: sed D further processing depends on whether line is blank
> PASS: sed newline staying away
> PASS: sed match empty line
> PASS: sed \1
> PASS: sed \1 p
> PASS: sed \1 no newline
> PASS: sed \1 p no newline
> PASS: sed -n s//\1/p
> PASS: sed -n s//\1/p no newline
> PASS: sed backref error
> PASS: sed empty match after nonempty match
> PASS: sed empty match
> PASS: sed s///#comment
> PASS: sed s///num off end
> PASS: sed N flushes pending a and advances match counter
> PASS: sed delimiter in regex [char range] doesn't count
> PASS: sed delete regex range start line after trigger
> PASS: sed blank pattern repeats last pattern
> PASS: sed -e '1a\' -e 'huh'
> PASS: sed -f input
> PASS: sed -f - input
> PASS: sed '1ahello'
> PASS: sed -e '/x/c\' -e 'y'
> PASS: sed -e 's/a[([]*b/X/'
> PASS: sed 'y/a\bc/de\f/'
> PASS: sed [a-a] (for perl)
> PASS: sed trailing a\ (for debian)
> PASS: sed skip start of range
> PASS: sed range +1
> PASS: sed range +0
> PASS: sed range +3
> PASS: sed not -s
> PASS: sed -s
> PASS: sed bonus backslashes
> PASS: sed end b with }
> PASS: sed -z
> PASS: sed \n with empty capture
> PASS: sed \n too high
> PASS: sed s///x
> PASS: sed megabyte s/x/y/g (20 sec timeout)
> PASS: sed w doesn't blank
> PASS: sed s i and I
> PASS: seq (exit with error)
> PASS: seq (exit with error)
> PASS: seq one argument
> PASS: seq two arguments
> PASS: seq two arguments reversed
> PASS: seq two arguments equal
> PASS: seq two arguments equal, arbitrary negative step
> PASS: seq two arguments equal, arbitrary positive step
> PASS: seq count up by 2
> PASS: seq count down by 2
> PASS: seq count wrong way #1
> PASS: seq count wrong way #2
> PASS: seq count by .3
> PASS: seq count by -.9
> PASS: seq count down by zero
> PASS: seq separator -
> PASS: seq format string
> PASS: seq separator and format string
> PASS: seq padding
> PASS: seq padding
> PASS: seq padding
> PASS: seq filter -f "%f"
> PASS: seq filter -f "%e"
> PASS: seq filter -f "%g"
> PASS: seq filter -f "boo %f yah"
> PASS: seq filter -f "% f"
> PASS: seq filter -f "%-1.2f"
> PASS: seq filter -f "%+-f"
> PASS: seq filter -f "%+ - f"
> PASS: seq filter -f "%.2f"
> PASS: seq filter -f "%3.f"
> PASS: seq filter -f "%'.2f"
> PASS: seq filter -f "%%%f%%"
> PASS: seq filter reject -f '%d'
> PASS: seq filter reject -f '%s'
> PASS: seq filter reject -f ''
> PASS: seq filter reject -f 'boo %f %f yah'
> PASS: seq filter reject -f '%*f'
> PASS: seq filter reject -f '%-1.2.3f'
> PASS: seq filter reject -f '%2$f'
> PASS: seq filter reject -f '%1-f'
> PASS: seq filter reject -f '%1 f'
> PASS: seq filter reject -f '%2..2f'
> PASS: seq filter reject -f '%%%f%%%'
> PASS: seq precision inc
> PASS: seq precision first
> PASS: seq precision int
> PASS: seq precision e
> PASS: seq precision E
> PASS: seq invalid last
> PASS: seq invalid first
> PASS: seq invalid increment
> PASS: seq INT_MIN
> make: *** [Makefile:77: tests] Error 1
> FAIL: seq fast path
> echo -ne '' | timeout 10 seq 10000000 > /dev/null
> --- expected  2022-09-07 20:37:15.139178572 +0000
> +++ actual    2022-09-07 20:37:15.595188871 +0000
> @@ -0,0 +1 @@
> +exited with signal (or returned 255)
> autopkgtest [20:37:15]: test toybox-selftest
> 




-- 
Antoni Villalonga
https://friki.cat/