Diff of the two buildlogs: -- --- b1/build.log 2024-11-07 22:28:04.408263231 +0000 +++ b2/build.log 2024-11-07 23:46:43.811801598 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Thu Nov 7 08:43:15 -12 2024 -I: pbuilder-time-stamp: 1731012195 +I: Current time: Fri Nov 8 12:28:25 +14 2024 +I: pbuilder-time-stamp: 1731018505 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/trixie-reproducible-base.tgz] I: copying local configuration @@ -30,52 +30,84 @@ dpkg-source: info: applying fix-compiler-id I: Not using root during the build. I: Installing the build-deps -I: user script /srv/workspace/pbuilder/17092/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/D01_modify_environment starting +debug: Running on virt64a. +I: Changing host+domainname to test build reproducibility +I: Adding a custom variable just for the fun of it... +I: Changing /bin/sh to bash +'/bin/sh' -> '/bin/bash' +lrwxrwxrwx 1 root root 9 Nov 7 22:28 /bin/sh -> /bin/bash +I: Setting pbuilder2's login shell to /bin/bash +I: Setting pbuilder2's GECOS to second user,second room,second work-phone,second home-phone,second other +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/D02_print_environment starting I: set - BUILDDIR='/build/reproducible-path' - BUILDUSERGECOS='first user,first room,first work-phone,first home-phone,first other' - BUILDUSERNAME='pbuilder1' - BUILD_ARCH='armhf' - DEBIAN_FRONTEND='noninteractive' - DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=3 ' - DISTRIBUTION='trixie' - HOME='/root' - HOST_ARCH='armhf' + BASH=/bin/sh + BASHOPTS=checkwinsize:cmdhist:complete_fullquote:extquote:force_fignore:globasciiranges:globskipdots:hostcomplete:interactive_comments:patsub_replacement:progcomp:promptvars:sourcepath + BASH_ALIASES=() + BASH_ARGC=() + BASH_ARGV=() + BASH_CMDS=() + BASH_LINENO=([0]="12" [1]="0") + BASH_LOADABLES_PATH=/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:. + BASH_SOURCE=([0]="/tmp/hooks/D02_print_environment" [1]="/tmp/hooks/D02_print_environment") + BASH_VERSINFO=([0]="5" [1]="2" [2]="32" [3]="1" [4]="release" [5]="arm-unknown-linux-gnueabihf") + BASH_VERSION='5.2.32(1)-release' + BUILDDIR=/build/reproducible-path + BUILDUSERGECOS='second user,second room,second work-phone,second home-phone,second other' + BUILDUSERNAME=pbuilder2 + BUILD_ARCH=armhf + DEBIAN_FRONTEND=noninteractive + DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=4 ' + DIRSTACK=() + DISTRIBUTION=trixie + EUID=0 + FUNCNAME=([0]="Echo" [1]="main") + GROUPS=() + HOME=/root + HOSTNAME=i-capture-the-hostname + HOSTTYPE=arm + HOST_ARCH=armhf IFS=' ' - INVOCATION_ID='d9e66ddbabc14c1c943c76d78721be05' - LANG='C' - LANGUAGE='en_US:en' - LC_ALL='C' - MAIL='/var/mail/root' - OPTIND='1' - PATH='/usr/sbin:/usr/bin:/sbin:/bin:/usr/games' - PBCURRENTCOMMANDLINEOPERATION='build' - PBUILDER_OPERATION='build' - PBUILDER_PKGDATADIR='/usr/share/pbuilder' - PBUILDER_PKGLIBDIR='/usr/lib/pbuilder' - PBUILDER_SYSCONFDIR='/etc' - PPID='17092' - PS1='# ' - PS2='> ' + INVOCATION_ID=71886b70e1584dc09ce6f720bba1bd39 + LANG=C + LANGUAGE=it_CH:it + LC_ALL=C + MACHTYPE=arm-unknown-linux-gnueabihf + MAIL=/var/mail/root + OPTERR=1 + OPTIND=1 + OSTYPE=linux-gnueabihf + PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path + PBCURRENTCOMMANDLINEOPERATION=build + PBUILDER_OPERATION=build + PBUILDER_PKGDATADIR=/usr/share/pbuilder + PBUILDER_PKGLIBDIR=/usr/lib/pbuilder + PBUILDER_SYSCONFDIR=/etc + PIPESTATUS=([0]="0") + POSIXLY_CORRECT=y + PPID=8797 PS4='+ ' - PWD='/' - SHELL='/bin/bash' - SHLVL='2' - SUDO_COMMAND='/usr/bin/timeout -k 18.1h 18h /usr/bin/ionice -c 3 /usr/bin/nice /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.Q4aqKDeP/pbuilderrc_Xm8f --distribution trixie --hookdir /etc/pbuilder/first-build-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/trixie-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.Q4aqKDeP/b1 --logfile b1/build.log rakudo_2024.09-2.dsc' - SUDO_GID='113' - SUDO_UID='107' - SUDO_USER='jenkins' - TERM='unknown' - TZ='/usr/share/zoneinfo/Etc/GMT+12' - USER='root' - _='/usr/bin/systemd-run' - http_proxy='http://10.0.0.15:3142/' + PWD=/ + SHELL=/bin/bash + SHELLOPTS=braceexpand:errexit:hashall:interactive-comments:posix + SHLVL=3 + SUDO_COMMAND='/usr/bin/timeout -k 24.1h 24h /usr/bin/ionice -c 3 /usr/bin/nice -n 11 /usr/bin/unshare --uts -- /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.Q4aqKDeP/pbuilderrc_r6yr --distribution trixie --hookdir /etc/pbuilder/rebuild-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/trixie-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.Q4aqKDeP/b2 --logfile b2/build.log rakudo_2024.09-2.dsc' + SUDO_GID=114 + SUDO_UID=108 + SUDO_USER=jenkins + TERM=unknown + TZ=/usr/share/zoneinfo/Etc/GMT-14 + UID=0 + USER=root + _='I: set' + http_proxy=http://10.0.0.15:3142/ I: uname -a - Linux wbq0 6.1.0-26-armmp #1 SMP Debian 6.1.112-1 (2024-09-30) armv7l GNU/Linux + Linux i-capture-the-hostname 6.1.0-26-arm64 #1 SMP Debian 6.1.112-1 (2024-09-30) aarch64 GNU/Linux I: ls -l /bin lrwxrwxrwx 1 root root 7 Aug 4 21:30 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/17092/tmp/hooks/D02_print_environment finished +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -160,7 +192,7 @@ Get: 37 http://deb.debian.org/debian trixie/main armhf moarvm-dev armhf 2024.09+dfsg-2 [393 kB] Get: 38 http://deb.debian.org/debian trixie/main armhf nqp-data all 2024.09+dfsg-2 [570 kB] Get: 39 http://deb.debian.org/debian trixie/main armhf nqp armhf 2024.09+dfsg-2 [80.0 kB] -Fetched 21.9 MB in 2s (11.6 MB/s) +Fetched 21.9 MB in 0s (43.8 MB/s) debconf: delaying package configuration, since apt-utils is not installed Selecting previously unselected package sensible-utils. (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 19690 files and directories currently installed.) @@ -331,7 +363,11 @@ Building tag database... -> Finished parsing the build-deps I: Building the package -I: Running cd /build/reproducible-path/rakudo-2024.09/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-genchanges -S > ../rakudo_2024.09-2_source.changes +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for trixie +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/A99_set_merged_usr finished +hostname: Name or service not known +I: Running cd /build/reproducible-path/rakudo-2024.09/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-genchanges -S > ../rakudo_2024.09-2_source.changes dpkg-buildpackage: info: source package rakudo dpkg-buildpackage: info: source version 2024.09-2 dpkg-buildpackage: info: source distribution unstable @@ -360,7 +396,7 @@ debian/rules override_dh_auto_build make[1]: Entering directory '/build/reproducible-path/rakudo-2024.09' dh_auto_build - make -j3 "INSTALL=install --strip-program=true" + make -j4 "INSTALL=install --strip-program=true" make[2]: Entering directory '/build/reproducible-path/rakudo-2024.09' +++ Checking for moar NQP version +++ Generating gen/moar/Grammar.nqp @@ -398,13 +434,13 @@ +++ Compiling blib/Perl6/World.moarvm +++ Compiling blib/Perl6/Actions.moarvm +++ Compiling blib/Raku/Actions.moarvm -+++ Compiling blib/Perl6/Optimizer.moarvm +++ Generating gen/moar/BOOTSTRAP/v6c.nqp +++ Compiling blib/Perl6/BOOTSTRAP/v6d.moarvm +++ Compiling blib/Perl6/BOOTSTRAP/v6e.moarvm ++++ Compiling blib/Perl6/Optimizer.moarvm ++++ Compiling blib/Perl6/BOOTSTRAP/v6c.moarvm +++ Compiling blib/Raku/Grammar.moarvm +++ Compiling blib/Perl6/Compiler.moarvm -+++ Compiling blib/Perl6/BOOTSTRAP/v6c.moarvm +++ Compiling blib/Perl6/Grammar.moarvm +++ Compiling rakudo.moarvm +++ Compiling rakudo-debug.moarvm @@ -416,54 +452,12441 @@ +++ Generating perl6-valgrind-m +++ Compiling blib/CORE.c.setting.moarvm The following step can take a long time, please be patient. -Stage start : 0.003 -Stage parse : 1134.672 -Stage syntaxcheck: 0.002 -Stage ast : 0.001 -Stage optimize : 227.917 -Stage mast : 284.359 -Stage mbc : 50.927 +Stage start : 0.001 +Stage parse : 500.855 +Stage syntaxcheck: 0.000 +Stage ast : 0.000 +Stage optimize : 65.123 +Stage mast : 110.747 +Stage mbc : 53.484 +++ Compiling blib/CORE.d.setting.moarvm The following step can take a long time, please be patient. -Stage start : 0.004 -Stage parse : 8.351 -Stage syntaxcheck: 0.001 -Stage ast : 0.001 -Stage optimize : 0.642 -Stage mast : 0.918 -Stage mbc : 0.134 +Stage start : 0.002 +Stage parse : 6.451 +Stage syntaxcheck: 0.000 +Stage ast : 0.000 +Stage optimize : 0.527 +Stage mast : 0.811 +Stage mbc : 0.177 +++ Compiling blib/CORE.e.setting.moarvm The following step can take a long time, please be patient. -Stage start : 0.005 -Stage parse : 52.775 -Stage syntaxcheck: 0.001 -Stage ast : 0.001 -Stage optimize : 7.177 -Stage mast : 8.673 -Stage mbc : 0.827 +Stage start : 0.001 +Stage parse : 47.071 +Stage syntaxcheck: 0.000 +Stage ast : 0.000 +Stage optimize : 5.024 +Stage mast : 8.787 +Stage mbc : 0.819 +++ Generating rakudo-m make[2]: Leaving directory '/build/reproducible-path/rakudo-2024.09' -echo "Configuration:" -Configuration: -echo -n "NQP source-digest: " -NQP source-digest: nqp --show-config | grep source-digest -nqp::source-digest=c245bc27e150cfdc2b62b1c6fc165c8d07344e93 -echo -n "raku source-digest: " -raku source-digest: ./rakudo-m --show-config | grep source-digest -Raku::source-digest=b084aeda8e16f35b252aab14fffcd4615b1d9b67 -echo -n "raku compiler id: " -raku compiler id: ./rakudo-m -e 'say $*PERL.compiler.id;' -B202134926643267DBA87C686CDAE403DD76376F -pod2man --name=perl6 docs/running.pod debian/perl6.1 -make[1]: Leaving directory '/build/reproducible-path/rakudo-2024.09' - debian/rules override_dh_auto_test -make[1]: Entering directory '/build/reproducible-path/rakudo-2024.09' -rm -f t/08-performance/99-misc.t -echo "Skipping broken test. See https://github.com/rakudo/rakudo/issues/3824" -Skipping broken test. See https://github.com/rakudo/rakudo/issues/3824 -rm -f t/09-moar/01-profilers.t -rm -f t/02-rakudo/repl.t -make test || make test || make test || make test || MVM_SPESH_DISABLE=1 make test +echo "Configuration:" +Configuration: +echo -n "NQP source-digest: " +NQP source-digest: nqp --show-config | grep source-digest +nqp::source-digest=c245bc27e150cfdc2b62b1c6fc165c8d07344e93 +echo -n "raku source-digest: " +raku source-digest: ./rakudo-m --show-config | grep source-digest +Raku::source-digest=b084aeda8e16f35b252aab14fffcd4615b1d9b67 +echo -n "raku compiler id: " +raku compiler id: ./rakudo-m -e 'say $*PERL.compiler.id;' +B202134926643267DBA87C686CDAE403DD76376F +pod2man --name=perl6 docs/running.pod debian/perl6.1 +make[1]: Leaving directory '/build/reproducible-path/rakudo-2024.09' + debian/rules override_dh_auto_test +make[1]: Entering directory '/build/reproducible-path/rakudo-2024.09' +rm -f t/08-performance/99-misc.t +echo "Skipping broken test. See https://github.com/rakudo/rakudo/issues/3824" +Skipping broken test. See https://github.com/rakudo/rakudo/issues/3824 +rm -f t/09-moar/01-profilers.t +rm -f t/02-rakudo/repl.t +make test || make test || make test || make test || MVM_SPESH_DISABLE=1 make test +make[2]: Entering directory '/build/reproducible-path/rakudo-2024.09' +'/usr/bin/perl' -I'/build/reproducible-path/rakudo-2024.09/tools/lib' -I'/build/reproducible-path/rakudo-2024.09/3rdparty/nqp-configure/lib' t/harness5 --moar t/01-sanity t/02-rakudo t/04-nativecall t/05-messages t/06-telemetry t/07-pod-to-text t/08-performance t/10-qast t/09-moar t/12-rakuast +t/01-sanity/01-literals.t ....................................... +1..24 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok 13 +ok 14 +ok 15 +ok 16 +ok 17 +ok 18 +ok 19 +ok 20 +# test multiple escapes in string using diag output: 123 +ok 21 +ok 22 +ok 23 +ok 24 +ok +t/01-sanity/02-op-math.t ........................................ +1..14 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok 13 +ok 14 +ok +t/01-sanity/03-op-logic.t ....................................... +1..16 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok 13 +ok 14 +ok 15 +ok 16 +ok +t/01-sanity/04-op-cmp.t ......................................... +1..24 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok 13 +ok 14 +ok 15 +ok 16 +ok 17 +ok 18 +ok 19 +ok 20 +ok 21 +ok 22 +ok 23 +ok 24 +ok +t/01-sanity/05-var.t ............................................ +1..12 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok +t/01-sanity/06-op-inplace.t ..................................... +1..11 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok +t/01-sanity/07-op-string.t ...................................... +1..18 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok 13 +ok 14 +ok 15 +ok 16 +ok 17 +ok 18 +ok +t/01-sanity/08-var-array.t ...................................... +1..11 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok +t/01-sanity/09-end-blocks.t ..................................... +1..2 +ok 1 +ok 2 +ok +t/01-sanity/10-regex.t .......................................... +1..11 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok +t/01-sanity/11-tap.t ............................................ +1..10 +ok 1 +ok 2 +ok +# comment +ok 4 +ok 5 +ok 6 foo +ok 7 # skip +ok 8 # skip bar +not ok 9 # TODO +not ok 10 # TODO baz +ok +t/01-sanity/12-counter.t ........................................ +1..4 +ok 1 +ok 2 +ok 3 +ok 4 +ok +t/01-sanity/13-equal.t .......................................... +1..4 +ok 1 +ok 2 +ok 3 +ok 4 +ok +t/01-sanity/14-if.t ............................................. +1..9 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok +t/01-sanity/15-sub.t ............................................ +1..4 +ok 1 +ok 2 +ok 3 +ok 4 +ok +t/01-sanity/16-eqv.t ............................................ +1..1 +ok 1 +ok +t/01-sanity/17-isa.t ............................................ +1..3 +ok 1 +ok 2 +ok 3 +ok +t/01-sanity/18-simple-multisubs.t ............................... +1..2 +ok 1 +ok 2 +ok +t/01-sanity/19-say.t ............................................ +1..12 +ok 1 +ok 2 +ok 3 +ok 4 +ok 5 +ok 6 +ok 7 +ok 8 +ok 9 +ok 10 +ok 11 +ok 12 +ok +t/01-sanity/20-defined.t ........................................ +1..3 +ok 1 +ok 2 +ok 3 +ok +t/01-sanity/21-try.t ............................................ +1..4 +ok 1 +ok 2 +ok 3 +ok 4 +ok +t/01-sanity/53-transpose.t ...................................... +1..26 +ok 1 - TRANSPOSE foof,f,a -> aooa +ok 2 - TRANSPOSE foof,f,ab -> abooab +ok 3 - TRANSPOSE foof,f,ff -> ffooff +ok 4 - TRANSPOSE foof,f, -> oo +ok 5 - TRANSPOSE offo,f,a -> oaao +ok 6 - TRANSPOSE offo,f,ab -> oababo +ok 7 - TRANSPOSE offo,f,ff -> offffo +ok 8 - TRANSPOSE offo,f, -> oo +ok 9 - TRANSPOSE foof,fo,a -> aof +ok 10 - TRANSPOSE foof,fo,ab -> abof +ok 11 - TRANSPOSE foof,fo,ff -> ffof +ok 12 - TRANSPOSE foof,fo, -> of +ok 13 - TRANSPOSE offo,fo,a -> ofa +ok 14 - TRANSPOSE offo,fo,ab -> ofab +ok 15 - TRANSPOSE offo,fo,ff -> offf +ok 16 - TRANSPOSE offo,fo, -> of +ok 17 - TRANSPOSE ofof,fo,a -> oaf +ok 18 - TRANSPOSE ofof,fo,ab -> oabf +ok 19 - TRANSPOSE ofof,fo,ff -> offf +ok 20 - TRANSPOSE ofof,fo, -> of +ok 21 - TRANSPOSE oooo,o, -> +ok 22 - TRANSPOSE oooo,o,x -> xxxx +ok 23 - TRANSPOSE oooo,o,xx -> xxxxxxxx +ok 24 - TRANSPOSE oooo,x, -> oooo +ok 25 - TRANSPOSE oooo,x,y -> oooo +ok 26 - TRANSPOSE oooo,x,yy -> oooo +ok +t/01-sanity/55-use-trace.t ...................................... +1..3 +ok 1 - did we get a Proc? +ok 2 - is the program output ok? +ok 3 - is the trace ok? +ok +t/01-sanity/56-use-isms.t ....................................... +1..8 +ok 1 - Can we run p5ish code without it complaining +ok 2 - Did the code with 'use isms' actually run +ok 3 - Can we run p5ish code without it complaining +ok 4 - Did the code with 'use isms ' actually run +ok 5 - Can we run C++ish code without it complaining +ok 6 - Did the code with 'use isms' actually run +ok 7 - Can we run C++ish code without it complaining +ok 8 - Did the code with 'use isms ' actually run +ok +t/01-sanity/99-test-basic.t ..................................... +ok 1 - pass($desc) +ok 2 - ok with description +ok 3 - ok returns True +ok 4 - +ok 5 - ok returns True +not ok 6 - calling ok False # TODO testing failure +# Failed test 'calling ok False' +# at t/01-sanity/99-test-basic.t line 16 +ok 7 - failure returns False +ok 8 - nok with description +ok 9 - nok 0 returns True +ok 10 - +ok 11 - nok 0 returns True +not ok 12 - nok 1 with description # TODO tesing nok True +# Failed test 'nok 1 with description' +# at t/01-sanity/99-test-basic.t line 27 +ok 13 - nok 1 returns False +ok 14 - is with description +ok 15 - is returns True +ok 16 - +not ok 17 - is 1, 0; with description # TODO failing is +# Failed test 'is 1, 0; with description' +# at t/01-sanity/99-test-basic.t line 37 +# expected: '0' +# got: '1' +ok 18 - is 1, 0; returns False +ok 19 - isnt with description +ok 20 - isnt 1, 0; returns True +ok 21 - +not ok 22 - isnt 1,1, with description # TODO testing isnt 1,1 +# Failed test 'isnt 1,1, with description' +# at t/01-sanity/99-test-basic.t line 47 +# expected: anything except '1' +# got: '1' +ok 23 - isnt 1, 1; returns False +not ok 24 - this should fail, to test todo() # TODO testing todo twice +# Failed test 'this should fail, to test todo()' +# at t/01-sanity/99-test-basic.t line 51 +not ok 25 - this should also fail, to test todo() # TODO testing todo twice +# Failed test 'this should also fail, to test todo()' +# at t/01-sanity/99-test-basic.t line 52 +ok 26 - passing test (todo is done) +not ok 27 - todo with no count covers one test # TODO todo with no count +# Failed test 'todo with no count covers one test' +# at t/01-sanity/99-test-basic.t line 56 +ok 28 - passing test (not todo) +ok 29 - # SKIP skip with reason +ok 30 - # SKIP +ok 31 - # SKIP skip with count and reason +ok 32 - # SKIP skip with count and reason +# diag works, FYI +not ok 33 - flunk # TODO testing flunk +# Failed test 'flunk' +# at t/01-sanity/99-test-basic.t line 68 +ok 34 - isa-ok with message +ok 35 - isa-ok returns True +ok 36 - The object is-a 'Int' +not ok 37 - The object is-a 'Int' # TODO failing isa-ok returns False +# Failed test 'The object is-a 'Int'' +# at t/01-sanity/99-test-basic.t line 78 +# Actual type: Str +ok 38 - Failing isa-ok returns False +ok 39 - skip() dies when given the arguments in the wrong order +ok 40 - dies-ok returns True +not ok 41 - dies-ok {1} # TODO failing dies-ok returns False +# Failed test 'dies-ok {1}' +# at t/01-sanity/99-test-basic.t line 88 +ok 42 - dies-ok returns False if code did not die +ok 43 - dies-ok +ok 44 - +ok 45 - lives_ok +ok 46 - lives-ok returns True +ok 47 - +not ok 48 - lives-ok { die } # TODO failing lives-ok returns False +# Failed test 'lives-ok { die }' +# at t/01-sanity/99-test-basic.t line 100 +# Died +ok 49 - failing lives-ok returns False +ok 50 - eval-dies-ok +ok 51 - eavl-dies-ok returns True +ok 52 - +not ok 53 - eval-dies-ok 1 fails # TODO eval-dies-ok 1 returns False +# Failed test 'eval-dies-ok 1 fails' +# at t/01-sanity/99-test-basic.t line 109 +ok 54 - eval-dies-ok 1 returns False +ok 55 - eval-lives-ok +ok 56 - eval-lives-ok 1 returns True +ok 57 - +not ok 58 - lives-ok { die } # TODO failing eval-lives-ok returns False +# Failed test 'lives-ok { die }' +# at t/01-sanity/99-test-basic.t line 118 +# Error: Died +ok 59 - failing eval-lives-ok returns False +ok 60 - is-deeply +ok 61 - is-deeply returns True +ok 62 - +not ok 63 - is-deeply with exta key fails # TODO failing is-deeply returns False +# Failed test 'is-deeply with exta key fails' +# at t/01-sanity/99-test-basic.t line 140 +# expected: ${} +# got: ${:a(1)} +ok 64 - failing is-deeply returns False +ok 65 - Comparing eq Buf +not ok 66 - # TODO Comparing 2 not eq Buf, should not pass +# Failed test at t/01-sanity/99-test-basic.t line 148 +# expected: Buf.new(43) +# got: Buf.new(42) +ok 67 - Comparing neq Buf +1..67 +ok +t/02-rakudo/03-cmp-ok.t ......................................... +1..7 +# Subtest: string comparators + 1..13 + ok 1 - + ok 2 - + ok 3 - "foo" eq "foo" + ok 4 - "a" lt "b" + ok 5 - "b" gt "a" + ok 6 - 1 < 2 + ok 7 - 2 >= 1 + not ok 8 - 2 < 1 # TODO should fail due to requested comparison + # Failed test '2 < 1' + # at t/02-rakudo/03-cmp-ok.t line 14 + # expected: 1 + # matcher: 'infix:«<»' + # got: 2 + ok 9 - should fail due to requested comparison + not ok 10 - "foo" eq "bar" # TODO should fail due to requested comparison + # Failed test '"foo" eq "bar"' + # at t/02-rakudo/03-cmp-ok.t line 14 + # expected: "bar" + # matcher: 'infix:' + # got: "foo" + ok 11 - should fail due to requested comparison + not ok 12 - # TODO should fail due to requested comparison + # Failed test at t/02-rakudo/03-cmp-ok.t line 14 + # Could not use '"non-exisistant-op"' as a comparator. If you are trying to use a meta operator, pass it as a Callable instead of a string: &[non-exisistant-op] + ok 13 - should fail due to requested comparison +ok 1 - string comparators +# Subtest: &[] comparators + 1..11 + ok 1 - + ok 2 - + ok 3 - "foo" eq "foo" + ok 4 - "a" lt "b" + ok 5 - "b" gt "a" + ok 6 - 1 < 2 + ok 7 - 2 >= 1 + not ok 8 - 2 < 1 # TODO should fail due to requested comparison + # Failed test '2 < 1' + # at t/02-rakudo/03-cmp-ok.t line 30 + # expected: 1 + # matcher: 'infix:«<»' + # got: 2 + ok 9 - should fail due to requested comparison + not ok 10 - "foo" eq "bar" # TODO should fail due to requested comparison + # Failed test '"foo" eq "bar"' + # at t/02-rakudo/03-cmp-ok.t line 30 + # expected: "bar" + # matcher: 'infix:' + # got: "foo" + ok 11 - should fail due to requested comparison +ok 2 - &[] comparators +# Subtest: custom operators (in code) + 1..6 + ok 1 - comparing using a fancy operator (Callable version) + ok 2 - comparing using a fancy operator (Str version) + not ok 3 - failing comparison custom op (Callable) # TODO should fail due to requested comparison + # Failed test 'failing comparison custom op (Callable)' + # at t/02-rakudo/03-cmp-ok.t line 45 + # expected: 1 + # matcher: 'infix:<◀>' + # got: 2 + ok 4 - should fail due to requested comparison + not ok 5 - failing comparison custom op (Str) # TODO should fail due to requested comparison + # Failed test 'failing comparison custom op (Str)' + # at t/02-rakudo/03-cmp-ok.t line 45 + # expected: 1 + # matcher: 'infix:<◀>' + # got: 2 + ok 6 - should fail due to requested comparison +ok 3 - custom operators (in code) +# Subtest: custom operators (in nested scope) + 1..6 + ok 1 - passing, Callable + ok 2 - passing, Str + not ok 3 - failing, Callable # TODO should fail due to requested comparison + # Failed test 'failing, Callable' + # at t/02-rakudo/03-cmp-ok.t line 53 + # expected: 1 + # matcher: 'infix:<◀>' + # got: 2 + ok 4 - should fail due to requested comparison + not ok 5 - failing, Str # TODO should fail due to requested comparison + # Failed test 'failing, Str' + # at t/02-rakudo/03-cmp-ok.t line 53 + # expected: 1 + # matcher: 'infix:<◀>' + # got: 2 + ok 6 - should fail due to requested comparison +ok 4 - custom operators (in nested scope) +# Subtest: custom operators (imported) + 1..24 + ok 1 - passing <=! op, Callable + ok 2 - passing <=! op, Str + ok 3 - passing <=» op, Str + ok 4 - passing « op, Callable + ok 5 - passing « op, Str + ok 6 - passing <« op, Str + ok 7 - passing >» op, Str + ok 8 - passing <«>» op, Str + not ok 9 - failing <=! op, Callable # TODO should fail due to requested comparison + # Failed test 'failing <=! op, Callable' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:«<=!»' + # got: 2 + ok 10 - should fail due to requested comparison + not ok 11 - failing <=! op, Str # TODO should fail due to requested comparison + # Failed test 'failing <=! op, Str' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:«<=!»' + # got: 2 + ok 12 - should fail due to requested comparison + not ok 13 - failing <=» op, Str # TODO should fail due to requested comparison + # Failed test 'failing <=» op, Str' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:<\<=»>' + # got: 2 + ok 14 - should fail due to requested comparison + not ok 15 - failing « op, Callable # TODO should fail due to requested comparison + # Failed test 'failing « op, Callable' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:<«>' + # got: 2 + ok 16 - should fail due to requested comparison + not ok 17 - failing « op, Str # TODO should fail due to requested comparison + # Failed test 'failing « op, Str' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:<«>' + # got: 2 + ok 18 - should fail due to requested comparison + not ok 19 - failing <« op, Str # TODO should fail due to requested comparison + # Failed test 'failing <« op, Str' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:<\<«>' + # got: 2 + ok 20 - should fail due to requested comparison + not ok 21 - failing >» op, Str # TODO should fail due to requested comparison + # Failed test 'failing >» op, Str' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:<\>»>' + # got: 2 + ok 22 - should fail due to requested comparison + not ok 23 - failing <«>» op, Str # TODO should fail due to requested comparison + # Failed test 'failing <«>» op, Str' + # at t/02-rakudo/03-cmp-ok.t line 65 + # expected: 1 + # matcher: 'infix:<\<«\>»>' + # got: 2 + ok 24 - should fail due to requested comparison +ok 5 - custom operators (imported) +# Subtest: no EVAL exploit (RT#128283) + 1..2 + not ok 1 - # TODO should fail due to requested comparison + # Failed test at t/02-rakudo/03-cmp-ok.t line 97 + # Could not use '"~~>;exit; ;exit; ' | '⁰/₀' / +ok 9 - 0/0 is not in -Inf^..^Inf range +ok +t/02-rakudo/06-is.t ............................................. +1..6 +not ok 1 - # TODO should fail due to requested comparison +# Failed test at t/02-rakudo/06-is.t line 11 +# expected: 'Mu<89092232>' +# got: (Mu) +ok 2 - should fail due to requested comparison +not ok 3 - # TODO should fail due to requested comparison +# Failed test at t/02-rakudo/06-is.t line 12 +# expected: (Mu) +# got: 'Mu<89092400>' +ok 4 - should fail due to requested comparison +ok 5 - is(Mu:U, Mu:U) passes +ok 6 - is(Mu:D, Mu:D) passes +ok +t/02-rakudo/07-implementation-detail-6.c.t ...................... +1..4 +ok 1 - were any global uppercase CORE:: subs added +ok 2 - were any global uppercase SETTING:: subs added +ok 3 - were any global lowercase CORE:: subs added +ok 4 - were any global lowercase SETTING:: subs added +ok +t/02-rakudo/07-implementation-detail-6.d.t ...................... +1..4 +ok 1 - were any global uppercase CORE:: subs added +ok 2 - were any global uppercase SETTING:: subs added +ok 3 - were any global lowercase CORE:: subs added +ok 4 - were any global lowercase SETTING:: subs added +ok +t/02-rakudo/07-implementation-detail-6.e.t ...................... +1..4 +ok 1 - were any global uppercase CORE:: subs added +ok 2 - were any global uppercase SETTING:: subs added +ok 3 - were any global lowercase CORE:: subs added +ok 4 - were any global lowercase SETTING:: subs added +ok +t/02-rakudo/08-inline-native-arith.t ............................ +1..4 +ok 1 - $i * 2 inlines to mul_i when $i is declared as int +ok 2 - can trialbiand to a sig with slurpy named param +ok 3 - trial bind notices `where` in the capture +ok 4 - trial bind notices `where` in the named slurpy +ok +t/02-rakudo/08-repeat.t ......................................... +1..5 +ok 1 - concatenating strings with `~` that would create a too large result dies +ok 2 - repeating strings with `x` that would create a too large result dies +ok 3 - repeat count equal to the NQP limit works +ok 4 - correct result for count equal to the NQP limit +# Subtest: too large repeat count throws instead of going negative + 1..2 + ok 1 - code dies + ok 2 - right exception type (Exception) +ok 5 - too large repeat count throws instead of going negative +ok +t/02-rakudo/08-slangs.t ......................................... +1..1 +# Subtest: no crash when giving an Actions class to .refine_slang + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 1 - no crash when giving an Actions class to .refine_slang +ok +t/02-rakudo/09-thread-id-after-await.t .......................... +1..1 +# original +ok 1 - Correct dynamic seen after invokving continuation on different thread +ok +t/02-rakudo/10-nqp-ops.t ........................................ +1..2 +ok 1 - p6bindattrinvres with getattr of bigint does not crash +# Subtest: getlexdyn op does not segfault + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 2 - getlexdyn op does not segfault +ok +t/02-rakudo/11-deprecated.t ..................................... +1..2 +# Subtest: no deprecation message with \(v6.d, v6.e, :lang-vers) + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 1 - no deprecation message with \(v6.d, v6.e, :lang-vers) +# Subtest: shows deprecation message with \(v6.d, v6.e, :lang-vers) + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 2 - shows deprecation message with \(v6.d, v6.e, :lang-vers) +ok +t/02-rakudo/12-proto-arity-count.t .............................. +1..346 +ok 1 - `&abs`'s proto's .count and .arity are good +ok 2 - `&acos`'s proto's .count and .arity are good +ok 3 - `&acosec`'s proto's .count and .arity are good +ok 4 - `&acosech`'s proto's .count and .arity are good +ok 5 - `&acosh`'s proto's .count and .arity are good +ok 6 - `&acotan`'s proto's .count and .arity are good +ok 7 - `&acotanh`'s proto's .count and .arity are good +ok 8 - `&all`'s proto's .count and .arity are good +ok 9 - `&any`'s proto's .count and .arity are good +ok 10 - `&append`'s proto's .count and .arity are good +ok 11 - `&asec`'s proto's .count and .arity are good +ok 12 - `&asech`'s proto's .count and .arity are good +ok 13 - `&asin`'s proto's .count and .arity are good +ok 14 - `&asinh`'s proto's .count and .arity are good +ok 15 - `&atan`'s proto's .count and .arity are good +ok 16 - `&atan2`'s proto's .count and .arity are good +ok 17 - `&atanh`'s proto's .count and .arity are good +ok 18 - `&atomic-add-fetch`'s proto's .count and .arity are good +ok 19 - `&atomic-assign`'s proto's .count and .arity are good +ok 20 - `&atomic-dec-fetch`'s proto's .count and .arity are good +ok 21 - `&atomic-fetch`'s proto's .count and .arity are good +ok 22 - `&atomic-fetch-add`'s proto's .count and .arity are good +ok 23 - `&atomic-fetch-dec`'s proto's .count and .arity are good +ok 24 - `&atomic-fetch-inc`'s proto's .count and .arity are good +ok 25 - `&atomic-fetch-sub`'s proto's .count and .arity are good +ok 26 - `&atomic-inc-fetch`'s proto's .count and .arity are good +ok 27 - `&atomic-sub-fetch`'s proto's .count and .arity are good +ok 28 - `&await`'s proto's .count and .arity are good +ok 29 - `&bag`'s proto's .count and .arity are good +ok 30 - `&cache`'s proto's .count and .arity are good +ok 31 - `&cas`'s proto's .count and .arity are good +ok 32 - `&categorize`'s proto's .count and .arity are good +ok 33 - `&ceiling`'s proto's .count and .arity are good +ok 34 - `&chars`'s proto's .count and .arity are good +ok 35 - `&chdir`'s proto's .count and .arity are good +ok 36 - `&chmod`'s proto's .count and .arity are good +ok 37 - `&chomp`'s proto's .count and .arity are good +ok 38 - `&chop`'s proto's .count and .arity are good +ok 39 - `&chr`'s proto's .count and .arity are good +ok 40 - `&chrs`'s proto's .count and .arity are good +ok 41 - `&circumfix:<[ ]>`'s proto's .count and .arity are good +ok 42 - `&circumfix:<{ }>`'s proto's .count and .arity are good +ok 43 - `&cis`'s proto's .count and .arity are good +ok 44 - `&classify`'s proto's .count and .arity are good +ok 45 - `&close`'s proto's .count and .arity are good +ok 46 - `&comb`'s proto's .count and .arity are good +ok 47 - `&combinations`'s proto's .count and .arity are good +ok 48 - `©`'s proto's .count and .arity are good +ok 49 - `&cos`'s proto's .count and .arity are good +ok 50 - `&cosec`'s proto's .count and .arity are good +ok 51 - `&cosech`'s proto's .count and .arity are good +ok 52 - `&cosh`'s proto's .count and .arity are good +ok 53 - `&cotan`'s proto's .count and .arity are good +ok 54 - `&cotanh`'s proto's .count and .arity are good +ok 55 - `&deepmap`'s proto's .count and .arity are good +ok 56 - `&defined`'s proto's .count and .arity are good +ok 57 - `&die`'s proto's .count and .arity are good +ok 58 - `&duckmap`'s proto's .count and .arity are good +ok 59 - `&elems`'s proto's .count and .arity are good +ok 60 - `&end`'s proto's .count and .arity are good +ok 61 - `&EVAL`'s proto's .count and .arity are good +ok 62 - `&EVALFILE`'s proto's .count and .arity are good +ok 63 - `&exit`'s proto's .count and .arity are good +ok 64 - `&exp`'s proto's .count and .arity are good +ok 65 - `&expmod`'s proto's .count and .arity are good +ok 66 - `&fail`'s proto's .count and .arity are good +ok 67 - `&fc`'s proto's .count and .arity are good +ok 68 - `&first`'s proto's .count and .arity are good +ok 69 - `&flat`'s proto's .count and .arity are good +ok 70 - `&flip`'s proto's .count and .arity are good +ok 71 - `&floor`'s proto's .count and .arity are good +ok 72 - `&full-barrier`'s proto's .count and .arity are good +ok 73 - `&get`'s proto's .count and .arity are good +ok 74 - `&getc`'s proto's .count and .arity are good +ok 75 - `&gethostname`'s proto's .count and .arity are good +ok 76 - `&gist`'s proto's .count and .arity are good +ok 77 - `&goto`'s proto's .count and .arity are good +ok 78 - `&grep`'s proto's .count and .arity are good +ok 79 - `&hash`'s proto's .count and .arity are good +ok 80 - `&index`'s proto's .count and .arity are good +ok 81 - `&indices`'s proto's .count and .arity are good +ok 82 - `&indir`'s proto's .count and .arity are good +ok 83 - `&infix:<^^>`'s proto's .count and .arity are good +ok 84 - `&infix:<^>`'s proto's .count and .arity are good +ok 85 - `&infix:<^..^>`'s proto's .count and .arity are good +ok 86 - `&infix:<^..>`'s proto's .count and .arity are good +ok 87 - `&infix:<~^>`'s proto's .count and .arity are good +ok 88 - `&infix:<~~>`'s proto's .count and .arity are good +ok 89 - `&infix:<~>`'s proto's .count and .arity are good +ok 90 - `&infix:<~|>`'s proto's .count and .arity are good +ok 91 - `&infix:<~&>`'s proto's .count and .arity are good +ok 92 - `&infix:«(<=)»`'s proto's .count and .arity are good +ok 93 - `&infix:«(<)»`'s proto's .count and .arity are good +ok 94 - # SKIP `infix:«(<+)»` is not a multi +ok 95 - `&infix:«(>=)»`'s proto's .count and .arity are good +ok 96 - `&infix:«(>)»`'s proto's .count and .arity are good +ok 97 - # SKIP `infix:«(>+)»` is not a multi +ok 98 - `&infix:<=~=>`'s proto's .count and .arity are good +ok 99 - `&infix:<===>`'s proto's .count and .arity are good +ok 100 - `&infix:<==>`'s proto's .count and .arity are good +ok 101 - `&infix:<=:=>`'s proto's .count and .arity are good +ok 102 - `&infix:<|>`'s proto's .count and .arity are good +ok 103 - `&infix:<||>`'s proto's .count and .arity are good +ok 104 - `&infix:<->`'s proto's .count and .arity are good +ok 105 - `&infix:<,>`'s proto's .count and .arity are good +ok 106 - `&infix:`'s proto's .count and .arity are good +ok 107 - `&infix:`'s proto's .count and .arity are good +ok 108 - `&infix:`'s proto's .count and .arity are good +ok 109 - `&infix:`'s proto's .count and .arity are good +ok 110 - `&infix:`'s proto's .count and .arity are good +ok 111 - `&infix:`'s proto's .count and .arity are good +ok 112 - `&infix:`'s proto's .count and .arity are good +ok 113 - `&infix:<..^>`'s proto's .count and .arity are good +ok 114 - `&infix:<..>`'s proto's .count and .arity are good +ok 115 - `&infix:<...^>`'s proto's .count and .arity are good +ok 116 - `&infix:<...>`'s proto's .count and .arity are good +ok 117 - `&infix:<(^)>`'s proto's .count and .arity are good +ok 118 - `&infix:<(|)>`'s proto's .count and .arity are good +ok 119 - `&infix:<(-)>`'s proto's .count and .arity are good +ok 120 - `&infix:<(.)>`'s proto's .count and .arity are good +ok 121 - `&infix:<(&)>`'s proto's .count and .arity are good +ok 122 - `&infix:<(+)>`'s proto's .count and .arity are good +ok 123 - `&infix:<*>`'s proto's .count and .arity are good +ok 124 - `&infix:<**>`'s proto's .count and .arity are good +ok 125 - `&infix:<&>`'s proto's .count and .arity are good +ok 126 - `&infix:<&&>`'s proto's .count and .arity are good +ok 127 - `&infix:<%>`'s proto's .count and .arity are good +ok 128 - `&infix:<%%>`'s proto's .count and .arity are good +ok 129 - `&infix:<+^>`'s proto's .count and .arity are good +ok 130 - `&infix:<+>`'s proto's .count and .arity are good +ok 131 - `&infix:<+|>`'s proto's .count and .arity are good +ok 132 - `&infix:<+&>`'s proto's .count and .arity are good +ok 133 - `&infix:<...^>`'s proto's .count and .arity are good +ok 134 - `&infix:<⚛=>`'s proto's .count and .arity are good +ok 135 - `&infix:<⊄>`'s proto's .count and .arity are good +ok 136 - `&infix:<⊃>`'s proto's .count and .arity are good +ok 137 - `&infix:<⊅>`'s proto's .count and .arity are good +ok 138 - `&infix:<∉>`'s proto's .count and .arity are good +ok 139 - `&infix:<(cont)>`'s proto's .count and .arity are good +ok 140 - `&infix:<∌>`'s proto's .count and .arity are good +ok 141 - `&infix:<...>`'s proto's .count and .arity are good +ok 142 - `&infix:<⊈>`'s proto's .count and .arity are good +ok 143 - `&infix:<⊇>`'s proto's .count and .arity are good +ok 144 - `&infix:<⊉>`'s proto's .count and .arity are good +ok 145 - # SKIP `infix:<≼>` is not a multi +ok 146 - # SKIP `infix:<≽>` is not a multi +ok 147 - `&infix:<⚛-=>`'s proto's .count and .arity are good +ok 148 - `&infix:<⚛+=>`'s proto's .count and .arity are good +ok 149 - `&infix:«<=>»`'s proto's .count and .arity are good +ok 150 - `&infix:«<=»`'s proto's .count and .arity are good +ok 151 - `&infix:«<»`'s proto's .count and .arity are good +ok 152 - `&infix:«=>»`'s proto's .count and .arity are good +ok 153 - `&infix:«>=»`'s proto's .count and .arity are good +ok 154 - `&infix:«>»`'s proto's .count and .arity are good +ok 155 - `&infix:«+<»`'s proto's .count and .arity are good +ok 156 - `&infix:«+>»`'s proto's .count and .arity are good +ok 157 - `&infix:`'s proto's .count and .arity are good +ok 158 - `&infix:`'s proto's .count and .arity are good +ok 159 - `&infix:`'s proto's .count and .arity are good +ok 160 - `&infix:`'s proto's .count and .arity are good +ok 161 - `&infix:`'s proto's .count and .arity are good +ok 162 - `&infix:`'s proto's .count and .arity are good +ok 163 - `&infix:`'s proto's .count and .arity are good +ok 164 - `&infix:<(cont)>`'s proto's .count and .arity are good +ok 165 - `&infix:
`'s proto's .count and .arity are good +ok 166 - `&infix:`'s proto's .count and .arity are good +ok 167 - `&infix:<(elem)>`'s proto's .count and .arity are good +ok 168 - `&infix:`'s proto's .count and .arity are good +ok 169 - `&infix:`'s proto's .count and .arity are good +ok 170 - `&infix:`'s proto's .count and .arity are good +ok 171 - `&infix:`'s proto's .count and .arity are good +ok 172 - `&infix:`'s proto's .count and .arity are good +ok 173 - `&infix:`'s proto's .count and .arity are good +ok 174 - `&infix:`'s proto's .count and .arity are good +ok 175 - `&infix:`'s proto's .count and .arity are good +ok 176 - `&infix:`'s proto's .count and .arity are good +ok 177 - `&infix:`'s proto's .count and .arity are good +ok 178 - `&infix:`'s proto's .count and .arity are good +ok 179 - `&infix:`'s proto's .count and .arity are good +ok 180 - `&infix:`'s proto's .count and .arity are good +ok 181 - `&infix:`'s proto's .count and .arity are good +ok 182 - `&infix:`'s proto's .count and .arity are good +ok 183 - `&infix:`'s proto's .count and .arity are good +ok 184 - `&infix:`'s proto's .count and .arity are good +ok 185 - `&infix:`'s proto's .count and .arity are good +ok 186 - `&infix:`'s proto's .count and .arity are good +ok 187 - `&infix:`'s proto's .count and .arity are good +ok 188 - `&infix:`'s proto's .count and .arity are good +ok 189 - `&infix:`'s proto's .count and .arity are good +ok 190 - `&infix:`'s proto's .count and .arity are good +ok 191 - `&infix:`'s proto's .count and .arity are good +ok 192 - `&is-prime`'s proto's .count and .arity are good +ok 193 - `&item`'s proto's .count and .arity are good +ok 194 - `&join`'s proto's .count and .arity are good +ok 195 - `&keys`'s proto's .count and .arity are good +ok 196 - `&kv`'s proto's .count and .arity are good +ok 197 - `&last`'s proto's .count and .arity are good +ok 198 - `&lc`'s proto's .count and .arity are good +ok 199 - `&lines`'s proto's .count and .arity are good +ok 200 - `&link`'s proto's .count and .arity are good +ok 201 - `&list`'s proto's .count and .arity are good +ok 202 - `&log`'s proto's .count and .arity are good +ok 203 - `&log10`'s proto's .count and .arity are good +ok 204 - `&log2`'s proto's .count and .arity are good +ok 205 - `&lsb`'s proto's .count and .arity are good +ok 206 - # SKIP `make` is not a multi +ok 207 - `&map`'s proto's .count and .arity are good +ok 208 - `&max`'s proto's .count and .arity are good +ok 209 - `&min`'s proto's .count and .arity are good +ok 210 - `&minmax`'s proto's .count and .arity are good +ok 211 - `&mix`'s proto's .count and .arity are good +ok 212 - `&mkdir`'s proto's .count and .arity are good +ok 213 - `&move`'s proto's .count and .arity are good +ok 214 - `&msb`'s proto's .count and .arity are good +ok 215 - `&next`'s proto's .count and .arity are good +ok 216 - `&nodemap`'s proto's .count and .arity are good +ok 217 - `&none`'s proto's .count and .arity are good +ok 218 - `¬`'s proto's .count and .arity are good +ok 219 - `¬e`'s proto's .count and .arity are good +ok 220 - `&one`'s proto's .count and .arity are good +ok 221 - `&open`'s proto's .count and .arity are good +ok 222 - `&ord`'s proto's .count and .arity are good +ok 223 - `&ords`'s proto's .count and .arity are good +ok 224 - `&pair`'s proto's .count and .arity are good +ok 225 - `&pairs`'s proto's .count and .arity are good +ok 226 - `&parse-base`'s proto's .count and .arity are good +ok 227 - `&permutations`'s proto's .count and .arity are good +ok 228 - `&pick`'s proto's .count and .arity are good +ok 229 - `&pop`'s proto's .count and .arity are good +ok 230 - `&postcircumfix:<[ ]>`'s proto's .count and .arity are good +ok 231 - `&postcircumfix:<[; ]>`'s proto's .count and .arity are good +ok 232 - `&postcircumfix:<{ }>`'s proto's .count and .arity are good +ok 233 - `&postcircumfix:<{; }>`'s proto's .count and .arity are good +ok 234 - `&postfix:<-->`'s proto's .count and .arity are good +ok 235 - `&postfix:<++>`'s proto's .count and .arity are good +ok 236 - `&postfix:<ⁿ>`'s proto's .count and .arity are good +ok 237 - `&postfix:<⚛-->`'s proto's .count and .arity are good +ok 238 - `&postfix:<⚛++>`'s proto's .count and .arity are good +ok 239 - `&postfix:`'s proto's .count and .arity are good +ok 240 - `&prefix:<^>`'s proto's .count and .arity are good +ok 241 - `&prefix:<~^>`'s proto's .count and .arity are good +ok 242 - `&prefix:<~>`'s proto's .count and .arity are good +ok 243 - `&prefix:<|>`'s proto's .count and .arity are good +ok 244 - `&prefix:<->`'s proto's .count and .arity are good +ok 245 - `&prefix:<-->`'s proto's .count and .arity are good +ok 246 - `&prefix:<--⚛>`'s proto's .count and .arity are good +ok 247 - `&prefix:`'s proto's .count and .arity are good +ok 248 - `&prefix:`'s proto's .count and .arity are good +ok 249 - `&prefix:`'s proto's .count and .arity are good +ok 250 - `&prefix:<+^>`'s proto's .count and .arity are good +ok 251 - `&prefix:<+>`'s proto's .count and .arity are good +ok 252 - `&prefix:<++>`'s proto's .count and .arity are good +ok 253 - `&prefix:<++⚛>`'s proto's .count and .arity are good +ok 254 - `&prefix:<⚛>`'s proto's .count and .arity are good +ok 255 - `&prefix:`'s proto's .count and .arity are good +ok 256 - `&prefix:`'s proto's .count and .arity are good +ok 257 - `&prepend`'s proto's .count and .arity are good +ok 258 - `&print`'s proto's .count and .arity are good +ok 259 - `&printf`'s proto's .count and .arity are good +ok 260 - `&produce`'s proto's .count and .arity are good +ok 261 - `&prompt`'s proto's .count and .arity are good +ok 262 - `&push`'s proto's .count and .arity are good +ok 263 - `&put`'s proto's .count and .arity are good +ok 264 - `&rand`'s proto's .count and .arity are good +ok 265 - `&redo`'s proto's .count and .arity are good +ok 266 - `&reduce`'s proto's .count and .arity are good +ok 267 - `&rename`'s proto's .count and .arity are good +ok 268 - `&repeated`'s proto's .count and .arity are good +ok 269 - `&return`'s proto's .count and .arity are good +ok 270 - `&return-rw`'s proto's .count and .arity are good +ok 271 - `&reverse`'s proto's .count and .arity are good +ok 272 - `&rindex`'s proto's .count and .arity are good +ok 273 - `&rmdir`'s proto's .count and .arity are good +ok 274 - `&roll`'s proto's .count and .arity are good +ok 275 - `&roots`'s proto's .count and .arity are good +ok 276 - `&rotate`'s proto's .count and .arity are good +ok 277 - `&round`'s proto's .count and .arity are good +ok 278 - `&roundrobin`'s proto's .count and .arity are good +ok 279 - `&run`'s proto's .count and .arity are good +ok 280 - `&samecase`'s proto's .count and .arity are good +ok 281 - `&samemark`'s proto's .count and .arity are good +ok 282 - `&say`'s proto's .count and .arity are good +ok 283 - `&sec`'s proto's .count and .arity are good +ok 284 - `&sech`'s proto's .count and .arity are good +ok 285 - `&set`'s proto's .count and .arity are good +ok 286 - `&shell`'s proto's .count and .arity are good +ok 287 - `&shift`'s proto's .count and .arity are good +ok 288 - `&sign`'s proto's .count and .arity are good +ok 289 - `&signal`'s proto's .count and .arity are good +ok 290 - `&sin`'s proto's .count and .arity are good +ok 291 - `&sinh`'s proto's .count and .arity are good +ok 292 - `&sleep`'s proto's .count and .arity are good +ok 293 - `&sleep-timer`'s proto's .count and .arity are good +ok 294 - `&sleep-until`'s proto's .count and .arity are good +ok 295 - `&slip`'s proto's .count and .arity are good +ok 296 - `&so`'s proto's .count and .arity are good +ok 297 - `&sort`'s proto's .count and .arity are good +ok 298 - `&splice`'s proto's .count and .arity are good +ok 299 - `&split`'s proto's .count and .arity are good +ok 300 - `&sprintf`'s proto's .count and .arity are good +ok 301 - `&sqrt`'s proto's .count and .arity are good +ok 302 - `&squish`'s proto's .count and .arity are good +ok 303 - `&srand`'s proto's .count and .arity are good +ok 304 - `&subbuf-rw`'s proto's .count and .arity are good +ok 305 - `&substr`'s proto's .count and .arity are good +ok 306 - `&substr-rw`'s proto's .count and .arity are good +ok 307 - `&succeed`'s proto's .count and .arity are good +ok 308 - `&sum`'s proto's .count and .arity are good +ok 309 - `&symlink`'s proto's .count and .arity are good +ok 310 - `&take`'s proto's .count and .arity are good +ok 311 - `&take-rw`'s proto's .count and .arity are good +ok 312 - `&tan`'s proto's .count and .arity are good +ok 313 - `&tanh`'s proto's .count and .arity are good +ok 314 - `&tc`'s proto's .count and .arity are good +ok 315 - `&tclc`'s proto's .count and .arity are good +ok 316 - `&trait_mod:`'s proto's .count and .arity are good +ok 317 - `&trait_mod:`'s proto's .count and .arity are good +ok 318 - `&trait_mod:`'s proto's .count and .arity are good +ok 319 - `&trait_mod:`'s proto's .count and .arity are good +ok 320 - `&trait_mod:`'s proto's .count and .arity are good +ok 321 - `&trait_mod:`'s proto's .count and .arity are good +ok 322 - `&trait_mod:`'s proto's .count and .arity are good +ok 323 - `&trait_mod:`'s proto's .count and .arity are good +ok 324 - `&trim`'s proto's .count and .arity are good +ok 325 - `&trim-leading`'s proto's .count and .arity are good +ok 326 - `&trim-trailing`'s proto's .count and .arity are good +ok 327 - `&truncate`'s proto's .count and .arity are good +ok 328 - `&uc`'s proto's .count and .arity are good +ok 329 - `&UNBASE`'s proto's .count and .arity are good +ok 330 - `&undefine`'s proto's .count and .arity are good +ok 331 - `&unimatch`'s proto's .count and .arity are good +ok 332 - `&uniname`'s proto's .count and .arity are good +ok 333 - `&uninames`'s proto's .count and .arity are good +ok 334 - `&uniparse`'s proto's .count and .arity are good +ok 335 - `&uniprop`'s proto's .count and .arity are good +ok 336 - `&uniprops`'s proto's .count and .arity are good +ok 337 - `&unique`'s proto's .count and .arity are good +ok 338 - `&unival`'s proto's .count and .arity are good +ok 339 - `&univals`'s proto's .count and .arity are good +ok 340 - `&unlink`'s proto's .count and .arity are good +ok 341 - `&unpolar`'s proto's .count and .arity are good +ok 342 - `&unshift`'s proto's .count and .arity are good +ok 343 - `&values`'s proto's .count and .arity are good +ok 344 - `&warn`'s proto's .count and .arity are good +ok 345 - `&wordcase`'s proto's .count and .arity are good +ok 346 - `&words`'s proto's .count and .arity are good +ok +t/02-rakudo/13-exceptions.t ..................................... +1..14 +# Subtest: exception isn't lost + 1..3 + ok 1 - 'sub foo ( ::T $val ) { my T $a is default($val); }; foo(42)' died + ok 2 - right exception type (X::Parameter::Default::TypeCheck) + ok 3 - .message matches rx:s/Default value \'\(\w+\)\' will never bind to a variable of type T/ +ok 1 - exception isn't lost +# Subtest: calling multi sub that expects a rw native argument with a literal is caught at compile time + 1..2 + ok 1 - 'multi sub f(int $foo is rw) { }; f(42)' died + ok 2 - right exception type (X::Comp) +ok 2 - calling multi sub that expects a rw native argument with a literal is caught at compile time +# Subtest: calling multi sub that expects a rw non-native argument with a literal is caught at compile time + 1..2 + ok 1 - 'multi sub f(Int $foo is rw) { }; f(42)' died + ok 2 - right exception type (X::Comp) +ok 3 - calling multi sub that expects a rw non-native argument with a literal is caught at compile time +# Subtest: inheriting from uncomposed parent + 1..2 + ok 1 - 'my \parent := Metamodel::ClassHOW.new_type(:name('Parent')); + # my \child := Metamodel::ClassHOW.new_type(:name('Child')); + # child.^add_parent(parent); + # child.^compose; + # ' died + ok 2 - right exception type (X::Inheritance::NotComposed) +ok 4 - inheriting from uncomposed parent +# Subtest: passing an initializer when role cannot accept it + 1..2 + ok 1 - 'role R {}; my $foo = 42 but R(1)' died + ok 2 - right exception type (X::Role::Initialization) +ok 5 - passing an initializer when role cannot accept it +# Subtest: Sigiled variables can be rebound + 1..3 + ok 1 - $-sigiled variable can be rebound + ok 2 - @-sigiled variable can be rebound + ok 3 - %-sigiled variable can be rebound +ok 6 - Sigiled variables can be rebound +# Subtest: Scalars in signatures be rebound if they are 'copy' or 'rw' + 1..2 + ok 1 - Scalars in function signatures can be rebound when they are 'is copy' + ok 2 - Scalars in function signatures can be rebound when they are 'is rw' (and get a writable container) +ok 7 - Scalars in signatures be rebound if they are 'copy' or 'rw' +# Subtest: Scalars in signatures that aren't 'copy' or 'rw' cannot be rebound + 1..4 + # Subtest: Scalars in function signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'$bound-scalar-in-sig'/, /'signature'/) + ok 1 - Scalars in function signatures cannot be rebound + # Subtest: Scalars in function signatures cannot be rebound even if they have a type constraint + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'$bound-scalar-with-type'/, /'signature'/) + ok 2 - Scalars in function signatures cannot be rebound even if they have a type constraint + # Subtest: Scalars in bound signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'$bound-scalar'/, /'signature'/) + ok 3 - Scalars in bound signatures cannot be rebound + # Subtest: Scalars in more complex bound signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'$bound-scalar'/, /'signature'/) + ok 4 - Scalars in more complex bound signatures cannot be rebound +ok 8 - Scalars in signatures that aren't 'copy' or 'rw' cannot be rebound +# Subtest: Positional and Associative variables in signatures can be rebound if they are 'copy' + 1..4 + ok 1 - Positional variables in function signatures can be rebound when they are 'is copy' + ok 2 - Positional variables in bound signatures can be rebound when they are 'is copy' + ok 3 - Associative variables in function signatures can be rebound when they are 'is copy' + ok 4 - Associative variables bound in signatures can be rebound when they are 'is copy' +ok 9 - Positional and Associative variables in signatures can be rebound if they are 'copy' +# Subtest: Positional and Associative variables in signatures that aren't 'copy' cannot be rebound + 1..4 + # Subtest: Positional variables in function signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'@bound-positional-in-sig'/, /'signature'/) + ok 1 - Positional variables in function signatures cannot be rebound + # Subtest: Positional variables in bound signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'@bound-positional'/, /'signature'/) + ok 2 - Positional variables in bound signatures cannot be rebound + # Subtest: Associative variables in function signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'%bound-associative-in-sig'/, /'signature'/) + ok 3 - Associative variables in function signatures cannot be rebound + # Subtest: Associative variables in bound signatures cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'%bound-associative'/, /'signature'/) + ok 4 - Associative variables in bound signatures cannot be rebound +ok 10 - Positional and Associative variables in signatures that aren't 'copy' cannot be rebound +# Subtest: Sigilless "variables" can never be rebound + 1..4 + # Subtest: Sigilless scalar terms cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'sigilless'/, none(/'signature'/)) + ok 1 - Sigilless scalar terms cannot be rebound + # Subtest: Sigilless positional terms cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'sigilless-array'/, none(/'signature'/)) + ok 2 - Sigilless positional terms cannot be rebound + # Subtest: Sigilless associative terms cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'sigilless-hash'/, none(/'signature'/)) + ok 3 - Sigilless associative terms cannot be rebound + # Subtest: Constants cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'con'/, none(/'signature'/)) + ok 4 - Constants cannot be rebound +ok 11 - Sigilless "variables" can never be rebound +# Subtest: Code items can never be rebound + 1..2 + # Subtest: A sub cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'&f'/, none(/'signature'/)) + ok 1 - A sub cannot be rebound + # Subtest: A regex cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'®-exp'/, none(/'signature'/)) + ok 2 - A regex cannot be rebound +ok 12 - Code items can never be rebound +# Subtest: Terms can never be rebound + 1..4 + # Subtest: A class cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'C'/, none(/'signature'/)) + ok 1 - A class cannot be rebound + # Subtest: A role cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'R'/, none(/'signature'/)) + ok 2 - A role cannot be rebound + # Subtest: A grammar cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'G'/, none(/'signature'/)) + ok 3 - A grammar cannot be rebound + # Subtest: Native types cannot be rebound + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Bind::Rebind) + ok 3 - .message matches all(/'int'/, none(/'signature'/)) + ok 4 - Native types cannot be rebound +ok 13 - Terms can never be rebound +# Subtest: Items that were never bound don't throw *re*binding errors + 1..8 + ok 1 - Binding to a native type doesn't throw X::Bind::Rebind + # Subtest: Binding to a native type throws X::Bind::NativeType + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::Bind::NativeType) + ok 2 - Binding to a native type throws X::Bind::NativeType + ok 3 - Binding to a literal doesn't throw X::Bind::Rebind + # Subtest: Binding to a literal throws X::Bind + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::Bind) + ok 4 - Binding to a literal throws X::Bind + ok 5 - Binding to a function call LHS doesn't throw X::Bind::Rebind + # Subtest: Binding to a function call LHS throws X::Bind + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::Bind) + ok 6 - Binding to a function call LHS throws X::Bind + ok 7 - Binding to a pseudo-package LHS doesn't throw X::Bind::Rebind + # Subtest: Binding to a pseudo-package LHS throws X::Bind + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::Bind) + ok 8 - Binding to a pseudo-package LHS throws X::Bind +ok 14 - Items that were never bound don't throw *re*binding errors +ok +t/02-rakudo/14-revisions.t ...................................... +1..3 +# Subtest: CORE.setting Revision + 1..3 + # Subtest: CORE.setting + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - CORE.setting + # Subtest: CORE.d.setting + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - CORE.d.setting + # Subtest: CORE.e.setting + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - CORE.e.setting +ok 1 - CORE.setting Revision +# Subtest: Modifiers + 1..4 + # Subtest: 6.e without PREVIEW dies + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - 6.e without PREVIEW dies + # Subtest: v6.d.TEST loads CORE.d.setting + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - v6.d.TEST loads CORE.d.setting + # Subtest: Deprecated modifier generates a warning + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - Deprecated modifier generates a warning + # Subtest: Unknown modifier dies + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 4 - Unknown modifier dies +ok 2 - Modifiers +# Subtest: Class Version + 1..3 + # Subtest: 6.c class version + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - 6.c class version + # Subtest: 6.c class version on 6.d compiler + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - 6.c class version on 6.d compiler + # Subtest: 6.e class version + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - 6.e class version +ok 3 - Class Version +ok +t/02-rakudo/15-gh_1202.t ........................................ +1..2 +ok 1 - shell output +ok 2 - all runs completed +ok +t/02-rakudo/16-begin-time-eval.t ................................ +ok 1 - Module loaded successfully +1..1 +ok +t/02-rakudo/17-cli.t ............................................ +1..3 +ok 1 - `raku -V` succeeds +ok 2 - `raku -V` prints configuration options +ok 3 - `raku -V` doesn't print to STDERR +ok +t/02-rakudo/18-pseudostash.t .................................... +1..3 +# Subtest: CLIENT:: doesn't fail on NQP packages for 6.c + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 1 - CLIENT:: doesn't fail on NQP packages for 6.c +# Subtest: CLIENT:: doesn't fail on NQP packages for 6.d + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 2 - CLIENT:: doesn't fail on NQP packages for 6.d +# Subtest: CLIENT:: doesn't fail on NQP packages for 6.e.PREVIEW + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 3 - CLIENT:: doesn't fail on NQP packages for 6.e.PREVIEW +ok +t/02-rakudo/19-mkdir.t .......................................... +1..1 +# Subtest: did we fails-like X::IO::Mkdir? + 1..2 + ok 1 - code returned a Failure + # Subtest: Failure threw when sunk + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::IO::Mkdir) + ok 2 - Failure threw when sunk +ok 1 - did we fails-like X::IO::Mkdir? +ok +t/02-rakudo/20-generic-class.rakutest ........................... +1..8 +# Subtest: Before Instantiations + ok 1 - role attribute type name before instantiations + ok 2 - role attribute type archetypes are that of a generic class + ok 3 - role attribute type is-generic method + ok 4 - role attribute type instance archetypes is generic + 1..4 +ok 1 - Before Instantiations +ok 2 - attribute type is the first instantiation +ok 3 - method body resolves generic class into the first instatiation +ok 4 - class instantiated over role's Str:D argument +ok 5 - attribute type is the second instantiation +ok 6 - method body resolves generic class into the second instatiation +ok 7 - class instantiated over role's Int:D arguments +# Subtest: After Instantiations + ok 1 - role attribute type name before instantiations + ok 2 - role attribute type archetypes are that of a generic class + ok 3 - role attribute type is-generic method + ok 4 - role attribute type instance archetypes is generic + 1..4 +ok 8 - After Instantiations +ok +t/02-rakudo/99-misc.t ........................................... +1..10 +# Subtest: IO::Handle.raku.EVAL roundtrips + 1..7 + ok 1 - type object + ok 2 - instance + ok 3 - path + ok 4 - chomp + ok 5 - nl-in + ok 6 - nl-out + ok 7 - encoding +ok 1 - IO::Handle.raku.EVAL roundtrips +# Subtest: profiler does not crash + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 2 - profiler does not crash +ok 3 - no crash when defining multiple routines with tightnes +ok 4 - parametarization of a DefiniteHOW does not complain about complex coercers +# Subtest: postfix-to-prefix-inc-dec opt does not rewrite custom ops + 1..5 + # Subtest: custom classes + 1..2 + ok 1 - postfix increment + ok 2 - postfix decrement + ok 1 - custom classes + # Subtest: core types (Int) + 1..2 + ok 1 - postfix increment + ok 2 - postfix decrement + ok 2 - core types (Int) + # Subtest: core types (Num) + 1..2 + ok 1 - postfix increment + ok 2 - postfix decrement + ok 3 - core types (Num) + # Subtest: core types (native int) + 1..2 + ok 1 - postfix increment + ok 2 - postfix decrement + ok 4 - core types (native int) + # Subtest: core types (native num) + 1..2 + ok 1 - postfix increment + ok 2 - postfix decrement + ok 5 - core types (native num) +ok 5 - postfix-to-prefix-inc-dec opt does not rewrite custom ops +ok 6 - regex blocks update their lexical variables right +# Subtest: collation experiment + 1..2 + # Subtest: $*COLLATION.set no longer requires experimental pragma + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - $*COLLATION.set no longer requires experimental pragma + # Subtest: we can still use the pragma (to support old code) + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - we can still use the pragma (to support old code) +ok 7 - collation experiment +# Subtest: Distribution::Resource can be stringified + ok 1 - Can use .raku +Use of uninitialized value of type Distribution::Resource in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at t/02-rakudo/99-misc.t line 141 + ok 2 - Can use .Str + ok 3 - Can use .gist + 1..3 +ok 8 - Distribution::Resource can be stringified +ok 9 - Subclassing of Parameter works +ok 10 - Parameter takes by-name parameters itself +ok +t/02-rakudo/dd.t ................................................ +1..2 +# Subtest: Failures don't get marked as handled in &dd + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 1 - Failures don't get marked as handled in &dd +# Subtest: Junctions do not crash + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 2 - Junctions do not crash +ok +t/02-rakudo/dump.t .............................................. +1..44 +ok 1 - DUMP(:U) is .raku (Mu) +ok 2 - DUMP(:U) is .raku (Junction) +ok 3 - DUMP(:U) is .raku (Any) +ok 4 - DUMP(:U) is .raku (Bool) +ok 5 - DUMP(:U) is .raku (Cool) +ok 6 - DUMP(:U) is .raku (Str) +ok 7 - DUMP(:U) is .raku (Int) +ok 8 - DUMP(:U) is .raku (Num) +ok 9 - DUMP(:U) is .raku (Rat) +ok 10 - DUMP(:U) is .raku (FatRat) +ok 11 - DUMP(:U) is .raku (Complex) +ok 12 - DUMP(:U) is .raku (Duration) +ok 13 - DUMP(:U) is .raku (Instant) +not ok 14 - DUMP(Bool:D) is .Str (False) # TODO NYI +# Failed test 'DUMP(Bool:D) is .Str (False)' +# at t/02-rakudo/dump.t line 22 +# expected: 'False' +# got: 'Bool::False' +not ok 15 - DUMP(Bool:D) is .Str (True) # TODO NYI +# Failed test 'DUMP(Bool:D) is .Str (True)' +# at t/02-rakudo/dump.t line 23 +# expected: 'True' +# got: 'Bool::True' +ok 16 - DUMP(Int:D) is .raku (0) +ok 17 - DUMP(Int:D) is .raku (1) +ok 18 - DUMP(Int:D) is .raku (-128) +ok 19 - DUMP(Int:D) is .raku (123456789) +ok 20 - DUMP(Int:D) is .raku (1 +< 100) +ok 21 - DUMP(Num:D) is .raku (0e0) +ok 22 - DUMP(Num:D) is .raku (-0e0) +ok 23 - DUMP(Num:D) is .raku (Inf) +ok 24 - DUMP(Num:D) is .raku (-Inf) +ok 25 - DUMP(Num:D) is .raku (NaN) +ok 26 - DUMP(Rat:D) is .raku (0.0) +ok 27 - DUMP(Rat:D) is .raku (-0.0) +ok 28 - DUMP(Rat:D) is .raku (1.1) +ok 29 - DUMP(Rat:D) is .raku (-1.1) +ok 30 - DUMP(Rat:D) is .raku (22/7) +ok 31 - DUMP(Rat:D) is .raku (-22/7) +ok 32 - DUMP(Complex:D) is .raku (0i) +ok 33 - DUMP(Complex:D) is .raku (-0i) +ok 34 - DUMP(Complex:D) is .raku (0+0i) +ok 35 - DUMP(Complex:D) is .raku (0-0i) +ok 36 - DUMP(Complex:D) is .raku (-0+0i) +ok 37 - DUMP(Complex:D) is .raku (-0-0i) +ok 38 - DUMP(Complex:D) is .raku (1+1i) +ok 39 - DUMP(Complex:D) is .raku (1-1i) +ok 40 - DUMP(Complex:D) is .raku (-1+1i) +ok 41 - DUMP(Complex:D) is .raku (-1-1i) +not ok 42 - DUMP(int) dumps as a literal # TODO NYI (can it even?) +# Failed test 'DUMP(int) dumps as a literal' +# at t/02-rakudo/dump.t line 62 +# expected: '42' +# got: '▶42' +not ok 43 - DUMP(num) dumps as a literal # TODO NYI (can it even?) +# Failed test 'DUMP(num) dumps as a literal' +# at t/02-rakudo/dump.t line 63 +# expected: '12345e0' +# got: '▶12345e0' +not ok 44 - DUMP(str) dumps as a literal # TODO NYI (can it even?) +# Failed test 'DUMP(str) dumps as a literal' +# at t/02-rakudo/dump.t line 64 +# expected: '"a string"' +# got: '▶"a string"' +ok +t/02-rakudo/reproducible-builds.t ............................... +ok 1 - Both precompilation runs resulted in the same checksum +1..1 +ok +t/02-rakudo/v6.d-tests/01-deprecations.t ........................ +1..1 +ok 1 - +ok +t/04-nativecall/00-misc.t ....................................... +ok 1 - are all identifiers reachable? +ok 2 - body of a native sub declared in a role body replaced +ok 3 - body of a native sub declared in a BEGIN block replaced +ok 4 - optimizer doesn't inline the native sub's original body +# Subtest: no segfaults when using NC routine after using it during precomp + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 5 - no segfaults when using NC routine after using it during precomp +1..5 +ok +t/04-nativecall/01-argless.t .................................... +1..14 +ok 1 - survived the call +ok 2 - called argless function returning int32 +ok 3 - called argless function returning int32 +ok 4 - called argless function returning char +ok 5 - called argless function returning char +ok 6 - called argless function returning long long +ok 7 - called argless function returning long long +ok 8 - called argless function returning pointer +ok 9 - called argless function returning pointer +ok 10 - called argless function returning string +ok 11 - called argless function returning string +ok 12 - called long_and_complicated_name +ok 13 - called argless closure +ok 14 - called argless closure +ok +t/04-nativecall/02-simple-args.t ................................ +1..21 +ok 1 - passed int 42 +ok 2 - passed two shorts +ok 3 - passed an int32, int16 and int8 +ok 4 - passed a double +ok 5 - passed a NaN (double) +ok 6 - passed a float +ok 7 - passed a NaN (float) +ok 8 - passed a string +ok 9 - defined/undefined works on the same callsite +ok 10 - defined/undefined works on the same callsite +ok 11 - checked previously passed string +ok 12 - wrapped sub +ok 13 - passed int64 0xFFFFFFFFFF +ok 14 - passed uint8 0xFE +ok 15 - # SKIP Cannot test TakeUint16(0xFFFE) with clang without -O0 +ok 16 - passed uint32 0xFFFFFFFE +ok 17 - passed size_t 42 +ok 18 - passed ssize_t -42 +ok 19 - Proxy works +ok 20 - defined/undefined works after Proxy arg +ok 21 - defined/undefined works after Proxy arg +ok +t/04-nativecall/03-simple-returns.t ............................. +1..20 +ok 1 - returning int works +ok 2 - returning int works +ok 3 - returning negative int works +ok 4 - returning negative int works +ok 5 - returning short works +ok 6 - returning short works +ok 7 - returning negative short works +ok 8 - returning negative short works +ok 9 - returning char works +ok 10 - returning char works +ok 11 - returning double works +ok 12 - returning float works +ok 13 - returning string works +ok 14 - returning null string pointer +ok 15 - returning int64 works +ok 16 - returning negative int64 works +ok 17 - returning negative int64 works +ok 18 - returning uint8 works +ok 19 - returning uint16 works +ok 20 - returning uint32 works +ok +t/04-nativecall/04-pointers.t ................................... +1..22 +ok 1 - Got passed back the pointer I returned +ok 2 - Non-NULL pointer is trueish +ok 3 - Calling .Int on non-NULL pointer is trueish +ok 4 - Calling prefix:<+> on non-NULL pointer is trueish +ok 5 - Pointer roundtrips okay using .raku and EVAL +ok 6 - Numerical value of Pointer.new is 0 +ok 7 - Pointer.new(0) has 0 numerical value +ok 8 - Pointer.new(1234) has numerical value 1234 +ok 9 - Pointer.new accepts a native int too +ok 10 - A returned NULL pointer is the Pointer type object itself +ok 11 - typed pointer deref method +ok 12 - typed pointer array dereference +ok 13 - typed pointer increment +ok 14 - .add(-1) +ok 15 - typed pointer incremented (1) +ok 16 - typed pointer incremented (2) +ok 17 - typed pointer decrement +ok 18 - typed pointer incremented (1) +ok 19 - typed pointer incremented (2) +ok 20 - .add(2) +ok 21 - Signature matching with Pointer[int32] works +ok 22 - Signature matching with CArray[Int] works +ok +t/04-nativecall/05-arrays.t ..................................... +1..47 +ok 1 - returning double array (1) +ok 2 - returning double array (2) +ok 3 - returning double array (3) +ok 4 - passing double array +ok 5 - returning string array (1) +ok 6 - returning string array (2) +ok 7 - passing string array +ok 8 - getting last element of managed array +ok 9 - getting uninitialized element in managed array +ok 10 - CArray.elems works (int) +ok 11 - .new with values creates an array containing those values (int) - 1 +ok 12 - .new with values creates an array containing those values (int) - 2 +ok 13 - .new with values creates an array containing those values (int) - 3 +ok 14 - .new with values creates an array containing those values (int) - 4 +ok 15 - CArray.elems works (num) +ok 16 - .new with values creates an array containing those values (num) - 1 +ok 17 - .new with values creates an array containing those values (num) - 2 +ok 18 - .new with values creates an array containing those values (num) - 3 +ok 19 - .new with values creates an array containing those values (num) - 4 +ok 20 - long in struct in element 0 +ok 21 - long in struct in element 1 +ok 22 - long in struct in element 2 +ok 23 - out-of-bounds access on managed array +ok 24 - struct in position 0..2, C-side +ok 25 - Setting a type object in the array passes a NULL to the C side +ok 26 - byte in element 0 +ok 27 - byte in element 1 +ok 28 - byte in element 2 +ok 29 - byte in position 0..2, C-side +ok 30 - byte in position 0..2, C-side +ok 31 - float in element 0 +ok 32 - float in element 1 +ok 33 - float in element 2 +ok 34 - sum of float array +ok 35 - creating CArray with no arguments works +ok 36 - creating CArray with () as argument does not hang +ok 37 - creating CArray with several positionals works +ok 38 - creating CArray with one Positional positional works +ok 39 - unsigned uint8 value +ok 40 - native int as index to CArray does not crash +ok 41 - CArray.^shortname shows sane value +# Subtest: CArray allocation + 1..3 + ok 1 - Allocation works with Int typed CArray + ok 2 - Allocation works with Num typed CArray + ok 3 - Allocation works with miscellaneously typed CArray +ok 42 - CArray allocation +ok 43 - can we build with a CArray attribute +ok 44 - can we create a Buf from a CArray +ok 45 - can we create a Blob from a CArray +ok 46 - Indexing with WhateverStar works on CArray +ok 47 - Make sure optimisation didn't break anything +ok +t/04-nativecall/06-struct.t ..................................... +1..34 +ok 1 - getting long +ok 2 - getting num +ok 3 - getting int8 +ok 4 - getting num32 +ok 5 - getting CArray and element +ok 6 - getting long from C-created struct +ok 7 - getting num from C-created struct +ok 8 - getting int8 from C-created struct +ok 9 - getting num32 from C-created struct +ok 10 - C-created array member, elem 1 +ok 11 - C-created array member, elem 2 +ok 12 - C-created array member, elem 3 +ok 13 - field 1 from struct 1 in struct +ok 14 - field 2 from struct 1 in struct +ok 15 - field 1 from struct 2 in struct +ok 16 - field 2 from struct 2 in struct +ok 17 - CPointer object in struct +ok 18 - first string in struct +ok 19 - second string in struct +ok 20 - C-side values in struct +ok 21 - Setting a CArray struct element to type object passes a NULL to C +ok 22 - C-side values in struct struct +ok 23 - C-side strict values in struct +ok 24 - and the int after is 42 +ok 25 - nested first is 101 +ok 26 - nested second is 77 +ok 27 - struct with inlined structs has correct size +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - 'class EmptyCStructTest is repr { };' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92381976) ... } +ok 28 - did we throws-like Exception? +ok 29 - Can inline fixed sizes array (1) +ok 30 - Can inline fixed sizes array (2) +ok 31 - Can inline fixed sizes array (3) +ok 32 - Can inline fixed sizes array (4) +ok 33 - Can inline fixed sizes array (5) +ok 34 - Can inline fixed sizes array (6) +ok +t/04-nativecall/07-writebarrier.t ............................... +1..7 +ok 1 - pointer in struct before twiddle +ok 2 - pointer in struct after twiddle +ok 3 - array element 1 after twiddle +ok 4 - array element 2 after twiddle +ok 5 - array element 3 after twiddle +ok 6 - ignore NULL arguments +ok 7 - struct value after refresh +ok +t/04-nativecall/08-callbacks.t .................................. +1..13 +ok 1 - simple callback +ok 2 - simple callback +ok 3 - optional callback with Code type object +ok 4 - optional callback with Pointer type object +ok 5 - int callback argument +ok 6 - string callback argument +ok 7 - struct callback string argument +ok 8 - struct callback int argument +ok 9 - callback returned a float to C +ok 10 - callback returned a string to C +ok 11 - callback returned a struct to C +ok 12 - +ok 13 - +ok +t/04-nativecall/09-nativecast.t ................................. +1..9 +ok 1 - casting int * to CArray[uint32] works +ok 2 - casting to CStruct works +ok 3 - casting to int32 works +ok 4 - casting to int16 works +ok 5 - casting to int8 works +ok 6 - casting to num64 works +ok 7 - casting to num32 works +ok 8 - casting to str works +ok 9 - casting null pointer to str +ok +t/04-nativecall/10-cglobals.t ................................... +1..7 +ok 1 - global int works +ok 2 - global short works +ok 3 - global char works +ok 4 - global double works +ok 5 - global float works +ok 6 - global string works +ok 7 - global null string pointer +ok +t/04-nativecall/11-cpp.t ........................................ +1..22 +ok 1 - sizeof(Derived1) +ok 2 - can instantiate C++ class +ok 3 - can instantiate the same C++ class again using « .= » +ok 4 - can read attribute foo +ok 5 - can read attribute bar +ok 6 - can read attribute baz +ok 7 - can read attribute cx +ok 8 - can read attribute cy +ok 9 - can read attribute c +ok 10 - sizeof(Derived2) +ok 11 - can instantiate C++ class with vtable +ok 12 - can read attribute foo +ok 13 - can read attribute bar +ok 14 - can read attribute baz +ok 15 - can read attribute cx +ok 16 - can read attribute cy +ok 17 - can read attribute c +ok 18 - can read typed pointer attribute +ok 19 - can pass arguments to method +ok 20 - name mangling of parameter `const int` +ok 21 - name mangling of parameter `int *` +ok 22 - name mangling of parameter `const int *` +ok +t/04-nativecall/12-sizeof.t ..................................... +1..17 +ok 1 - sizeof(Foo) +ok 2 - sizeof(Bar) +ok 3 - sizeof(Baz) +ok 4 - sizeof(Buz) +ok 5 - sizeof(int) +ok 6 - sizeof(long) +ok 7 - sizeof(Pointer) +ok 8 - sizeof(bool) +ok 9 - sizeof(size_t) +ok 10 - sizeof(foo1) +ok 11 - sizeof(foo2) +ok 12 - sizeof(foo3) +ok 13 - sizeof(foo4) +ok 14 - sizeof(foo5) +ok 15 - sizeof(foo6) +ok 16 - sizeof(foo7) +ok 17 - sizeof(foo8) +ok +t/04-nativecall/13-cpp-mangling.t ............................... +1..26 +ok 1 - void mangling +ok 2 - bool mangling +ok 3 - char mangling +ok 4 - short mangling +ok 5 - int mangling +ok 6 - long mangling +ok 7 - long long mangling +ok 8 - float mangling +ok 9 - double mangling +ok 10 - string mangling +ok 11 - CArray mangling +ok 12 - Pointer mangling +ok 13 - bool* mangling +ok 14 - char* mangling +ok 15 - short* mangling +ok 16 - int* mangling +ok 17 - long* mangling +ok 18 - long long* mangling +ok 19 - float* mangling +ok 20 - double* mangling +ok 21 - uint mangling +ok 22 - ushort mangling +ok 23 - uchar mangling +ok 24 - int64 mangling +ok 25 - unsigned long long mangling +ok 26 - uint64 mangling +ok +t/04-nativecall/13-union.t ...................................... +1..28 +ok 1 - sizeof union is sizeof biggest member +ok 2 - sizeof(MyStruct) +ok 3 - getting long +ok 4 - getting num +ok 5 - getting int8 +ok 6 - getting num32 +ok 7 - getting long from C-created struct +ok 8 - getting num from C-created struct +ok 9 - getting int8 from C-created struct +ok 10 - getting num32 from C-created struct +ok 11 - long in union +ok 12 - int in union +ok 13 - short in union +ok 14 - char in union +ok 15 - sizeof(MyStruct2) +ok 16 - getting long from C-created struct +ok 17 - getting num from C-created struct +ok 18 - getting int8 from C-created struct +ok 19 - getting num32 from C-created struct +ok 20 - long in union* +ok 21 - int in union* +ok 22 - short in union* +ok 23 - char in union* +ok 24 - sizeof(UnionOfStructs) +ok 25 - member a of union is-a MyStruct +ok 26 - member b of union is-a YourStruct +ok 27 - a.byte was set to 42 by C +ok 28 - b.byte must be the same +ok +t/04-nativecall/14-rw-attrs.t ................................... +1..16 +ok 1 - got initialized (long) +ok 2 - got initialized (double) +ok 3 - got initialized (char) +ok 4 - got initialized (float) +ok 5 - set in C (long) +ok 6 - set in C (double) +ok 7 - set in C (char) +ok 8 - set in C (float) +ok 9 - set in Raku (long) +ok 10 - set in Raku (double) +ok 11 - set in Raku (char) +ok 12 - set in Raku (float) +ok 13 - C confirms (long) +ok 14 - C confirms (double) +ok 15 - C confirms (char) +ok 16 - C confirms (float) +ok +t/04-nativecall/15-rw-args.t .................................... +1..24 +ok 1 - Raku's rw variable was set by C (char) +ok 2 - Raku's rw variable was passed and returned by C (char) +ok 3 - Raku's rw variable was set by C (short) +ok 4 - Raku's rw variable was passed and returned by C (short) +ok 5 - Raku's rw variable was set by C (long) +ok 6 - Raku's rw variable was passed and returned by C (long) +ok 7 - Raku's rw variable was set by C (long long) +ok 8 - Raku's rw variable was passed and returned by C (longlong) +ok 9 - Raku's rw variable was set by C (float) +ok 10 - Raku's rw variable was passed and returned by C (float) +ok 11 - Raku's rw variable was set by C (double) +ok 12 - Raku's rw variable was passed and returned by C (double) +ok 13 - Raku's rw variable was set by C (unsigned char) +ok 14 - Raku's rw variable was passed and returned by C (unsigned char) +ok 15 - Raku's rw variable was set by C (unsigned short) +ok 16 - Raku's rw variable was passed and returned by C (unsigned short) +ok 17 - Raku's rw variable was set by C (unsigned long) +ok 18 - Raku's rw variable was passed and returned by C (unsigned long) +ok 19 - Raku's rw variable was set by C (unsigned long long) +ok 20 - Raku's rw variable was passed and returned by C (unsigned long long) +ok 21 - Raku's rw variable was set by C (size_t) +ok 22 - Raku's rw variable was passed and returned by C (size_t) +ok 23 - Can pass an instantiated pointer with rw-trait to C +ok 24 - Raku's rw variable was set by C (pointer) +ok +t/04-nativecall/16-rt125408.t ................................... +1..1 +ok 1 - stayed fixed +ok +t/04-nativecall/16-rt125729.t ................................... +1..1 +ok 1 - symbol reexported by NativeCall used to cause trouble +ok +t/04-nativecall/17-libnames.t ................................... +1..7 +ok 1 - foo is libfoo.so and should warn +ok 2 - foo , 1 is libfoo.so.1 +ok 3 - foo , v1.2.3 is libfoo.so.1.2.3 +ok 4 - libfoo.so is libfoo.so +ok 5 - ./foo is ./libfoo.so +ok 6 - ./libfoo.so is ./libfoo.so +ok 7 - /libfoo.so is /libfoo.so +ok +t/04-nativecall/18-routine-sig-sanity.t ......................... +ok 1 - Taking a pointer is fine +ok 2 - Taking a Pointer[int32] is fine +# Subtest: Taking a Pointer[Int] is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 3 - Taking a Pointer[Int] is NOT fine +ok 4 - Taking a CStruct is fine +ok 5 - Taking a CArray is fine +ok 6 - Taking a Buf is fine +# Subtest: Taking a CArray[int] is not fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 7 - Taking a CArray[int] is not fine +# Subtest: Taking a Raku class is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 8 - Taking a Raku class is NOT fine +ok 9 - Taking a int32 is fine +# Subtest: Taking a Int is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 10 - Taking a Int is NOT fine +# Subtest: Taking a int is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 11 - Taking a int is NOT fine +ok 12 - Taking a num32 is fine +# Subtest: Taking a Num is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 13 - Taking a Num is NOT fine +# Subtest: Taking a num is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 14 - Taking a num is NOT fine +ok 15 - Taking a Str is fine +ok 16 - FIXME: Taking a str is buggy but should be fine? +ok 17 - Returning a pointer is fine +ok 18 - Returning a CStruct is fine +ok 19 - Returning a CArray is fine +ok 20 - Returning a int32 is fine +# Subtest: Returning a Int is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 21 - Returning a Int is NOT fine +# Subtest: Returning a int is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 22 - Returning a int is NOT fine +ok 23 - Returning a num32 is fine +# Subtest: Returning a Num is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 24 - Returning a Num is NOT fine +# Subtest: Returning a num is NOT fine + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::FailOnWarn) +ok 25 - Returning a num is NOT fine +ok 26 - Returning a bool is fine +ok 27 - FIXME: Returning a Bool maybe be bugged +ok 28 - Taking an encoded Str is fine +ok 29 - Returning an encoded Str is fine +ok 30 - Good trait declaration +ok 31 - Embeded type +ok 32 - Void function +ok 33 - Method are silly +ok 34 - Blob should work +ok 35 - Return a type in its definition +1..35 +ok +t/04-nativecall/19-function-pointers.t .......................... +1..1 +ok 1 - Pointer cast to Raku Sub +ok +t/04-nativecall/20-concurrent.t ................................. +1..3 +ok 1 - Correct results when running native code across threads +ok 2 - A sleeping native call does not block running/GC in another thread +ok 3 - Can call native function while one in another thread is sleeping +ok +t/04-nativecall/21-callback-other-thread.t ...................... +1..9 +ok 1 - Sanity check: Calling callback on thread that set it works +ok 2 - Calling callback on another thread works (5) +ok 3 - Calling callback on another thread works (4) +ok 4 - Calling callback on another thread works (2) +ok 5 - Calling callback on another thread works (0) +ok 6 - Calling callback on another thread works (7) +ok 7 - Calling callback on another thread works (1) +ok 8 - Calling callback on another thread works (3) +ok 9 - Calling callback on another thread works (6) +ok +t/04-nativecall/22-method.t ..................................... +1..2 +ok 1 - native sub as method +ok 2 - and got the result we expected +ok +t/04-nativecall/23-incomplete-types.t ........................... +1..6 +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /inline.*before.*definition/ +ok 1 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /inline.*before.*definition/ +ok 2 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /inline.*before.*definition/ +ok 3 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /inline.*before.*definition/ +ok 4 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /inline.*before.*definition/ +ok 5 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /inline.*before.*definition/ +ok 6 - did we throws-like Exception? +ok +t/04-nativecall/24-cpp_param_letter.t ........................... +1..76 +ok 1 - The object is-a 'Str' +ok 2 - test GNU Bool with :w, :g, :h +ok 3 - The object is-a 'Str' +ok 4 - test GNU int16 with :e, :h, :v +ok 5 - The object is-a 'Str' +ok 6 - test GNU int32 with :f, :e, :b +ok 7 - The object is-a 'Str' +ok 8 - test GNU int64 with :q, :n, :x +ok 9 - The object is-a 'Str' +ok 10 - test GNU int8 with :k, :j, :n +ok 11 - The object is-a 'Str' +ok 12 - test GNU NativeCall::Types::CArray[int] with :, :e, :w +ok 13 - The object is-a 'Str' +ok 14 - test GNU NativeCall::Types::long with :p, :c, :d +ok 15 - The object is-a 'Str' +ok 16 - test GNU NativeCall::Types::longlong with :j, :d, :g +ok 17 - The object is-a 'Str' +ok 18 - test GNU NativeCall::Types::Pointer[int] with :, :c, :r +ok 19 - The object is-a 'Str' +ok 20 - test GNU NativeCall::Types::ulong with :x, :o, :f +ok 21 - The object is-a 'Str' +ok 22 - test GNU NativeCall::Types::ulonglong with :d, :g, :i +ok 23 - The object is-a 'Str' +ok 24 - test GNU NativeCall::Types::void with :s, :u, :a +ok 25 - The object is-a 'Str' +ok 26 - test GNU num32 with :g, :i, :e +ok 27 - The object is-a 'Str' +ok 28 - test GNU num64 with :q, :p, :x +ok 29 - The object is-a 'Str' +ok 30 - test GNU Str with :, :z, :p +ok 31 - The object is-a 'Str' +ok 32 - test GNU uint16 with :y, :p, :x +ok 33 - The object is-a 'Str' +ok 34 - test GNU uint32 with :h, :w, :b +ok 35 - The object is-a 'Str' +ok 36 - test GNU uint64 with :i, :n, :c +ok 37 - The object is-a 'Str' +ok 38 - test GNU uint8 with :y, :v, :u +ok 39 - The object is-a 'Str' +ok 40 - test MSVC Bool with :f, :z, :x +ok 41 - The object is-a 'Str' +ok 42 - test MSVC int16 with :a, :n, :e +ok 43 - The object is-a 'Str' +ok 44 - test MSVC int32 with :u, :i, :b +ok 45 - The object is-a 'Str' +ok 46 - test MSVC int64 with :m, :h, :u +ok 47 - The object is-a 'Str' +ok 48 - test MSVC int8 with :z, :w, :x +ok 49 - The object is-a 'Str' +ok 50 - test MSVC NativeCall::Types::CArray[int] with :j, :u, :w +ok 51 - The object is-a 'Str' +ok 52 - test MSVC NativeCall::Types::long with :l, :t, :h +ok 53 - The object is-a 'Str' +ok 54 - test MSVC NativeCall::Types::longlong with :s, :z, :t +ok 55 - The object is-a 'Str' +ok 56 - test MSVC NativeCall::Types::Pointer[int] with :w, :e, :l +ok 57 - The object is-a 'Str' +ok 58 - test MSVC NativeCall::Types::ulong with :z, :p, :w +ok 59 - The object is-a 'Str' +ok 60 - test MSVC NativeCall::Types::ulonglong with :a, :l, :f +ok 61 - The object is-a 'Str' +ok 62 - test MSVC NativeCall::Types::void with :i, :v, :a +ok 63 - The object is-a 'Str' +ok 64 - test MSVC num32 with :z, :c, :p +ok 65 - The object is-a 'Str' +ok 66 - test MSVC num64 with :r, :z, :e +ok 67 - The object is-a 'Str' +ok 68 - test MSVC Str with :l, :h, :v +ok 69 - The object is-a 'Str' +ok 70 - test MSVC uint16 with :i, :h, :g +ok 71 - The object is-a 'Str' +ok 72 - test MSVC uint32 with :h, :z, :n +ok 73 - The object is-a 'Str' +ok 74 - test MSVC uint64 with :q, :m, :w +ok 75 - The object is-a 'Str' +ok 76 - test MSVC uint8 with :h, :j, :f +ok +t/05-messages/01-errors.t ....................................... +1..51 +# Subtest: point out matching `is rw` candidates when passing non-rw + 1..3 + ok 1 - '1++' died + ok 2 - right exception type (X::Multi::NoMatch) + ok 3 - .message matches /'but require mutable arguments'/ +ok 1 - point out matching `is rw` candidates when passing non-rw +# Subtest: curly quotes are not called smart quotes + 1..6 + # Subtest: ‘ (U+2018) quote is called curly, not smart + 1..3 + ok 1 - '‘' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78290624) ... } + ok 1 - ‘ (U+2018) quote is called curly, not smart + # Subtest: ‚ (U+201A) quote is called curly, not smart + 1..3 + ok 1 - '‚' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78291184) ... } + ok 2 - ‚ (U+201A) quote is called curly, not smart + # Subtest: ’ (U+2019) quote is called curly, not smart + 1..3 + ok 1 - '’' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78291304) ... } + ok 3 - ’ (U+2019) quote is called curly, not smart + # Subtest: “ (U+201C) quote is called curly, not smart + 1..3 + ok 1 - '“' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78291544) ... } + ok 4 - “ (U+201C) quote is called curly, not smart + # Subtest: „ (U+201E) quote is called curly, not smart + 1..3 + ok 1 - '„' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78291784) ... } + ok 5 - „ (U+201E) quote is called curly, not smart + # Subtest: ” (U+201D) quote is called curly, not smart + 1..3 + ok 1 - '”' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78291904) ... } + ok 6 - ” (U+201D) quote is called curly, not smart +ok 2 - curly quotes are not called smart quotes +# Subtest: typing "return" instead of "returns" gives a fixing hint + 1..3 + ok 1 - 'sub infix:<$>() return Nil {}' died + ok 2 - right exception type (X::AdHoc) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78294384) ... } +ok 3 - typing "return" instead of "returns" gives a fixing hint +# Subtest: .Rat.nude on non-numeric string does not reference guts in error + 1..3 + ok 1 - ''4x'.Rat.nude' died + ok 2 - right exception type (X::Str::Numeric) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82900744) ... } +ok 4 - .Rat.nude on non-numeric string does not reference guts in error +# Subtest: stub code does not reference guts when executed + 1..3 + ok 1 - '…' died + ok 2 - right exception type (X::StubCode) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|84302736) ... } +ok 5 - stub code does not reference guts when executed +# Subtest: chr with large codepoints throws useful error + 1..6 + # Subtest: "chr 2⁶³-1" + 1..3 + ok 1 - 'chr 2⁶³-1' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|96163832) ... } + ok 1 - "chr 2⁶³-1" + # Subtest: "(2⁶³-1).chr" + 1..3 + ok 1 - '(2⁶³-1).chr' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|96165352) ... } + ok 2 - "(2⁶³-1).chr" + # Subtest: "chr 2⁶³" + 1..3 + ok 1 - 'chr 2⁶³' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|96166832) ... } + ok 3 - "chr 2⁶³" + # Subtest: "2⁶³.chr" + 1..3 + ok 1 - '2⁶³.chr' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|96168352) ... } + ok 4 - "2⁶³.chr" + # Subtest: "chr 2¹⁰⁰" + 1..3 + ok 1 - 'chr 2¹⁰⁰' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|98983720) ... } + ok 5 - "chr 2¹⁰⁰" + # Subtest: "(2¹⁰⁰).chr" + 1..3 + ok 1 - '(2¹⁰⁰).chr' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|98985240) ... } + ok 6 - "(2¹⁰⁰).chr" +ok 6 - chr with large codepoints throws useful error +# Subtest: <-> does not prevent an error suggesting to use `do for` + 1..3 + ok 1 - 'my @a = for 1..3 <-> { $_ }' died + ok 2 - right exception type (Exception) + ok 3 - .message matches /«'do for'»/ +ok 7 - <-> does not prevent an error suggesting to use `do for` +# Subtest: making an "is rw" parameter optional dies with adequate error message and mentions the parameter name + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot use 'is rw' on optional parameter '$bar'. +ok 8 - making an "is rw" parameter optional dies with adequate error message and mentions the parameter name +# Subtest: making an "is rw" parameter optional dies with adequate error message and mentions the parameter name + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot use 'is rw' on optional parameter '$bar'. +ok 9 - making an "is rw" parameter optional dies with adequate error message and mentions the parameter name +# Subtest: a space in a literal param to a MAIN() multi makes the suggestion quoted + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 10 - a space in a literal param to a MAIN() multi makes the suggestion quoted +# Subtest: a double qoute in a literal param to a MAIN() multi makes the suggestion quoted + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 11 - a double qoute in a literal param to a MAIN() multi makes the suggestion quoted +# Subtest: a single qoute in a literal param to a MAIN() multi makes the suggestion quoted + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 12 - a single qoute in a literal param to a MAIN() multi makes the suggestion quoted +# Subtest: The message when trying to pun a role with required methods should have the names of the child, parent, required methods, and suggest "does" + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/<<'C'>>/, /<<'R'>>/, /<<'a,' \s* 'c'>>/, /<<'does'>>/) +ok 13 - The message when trying to pun a role with required methods should have the names of the child, parent, required methods, and suggest "does" +# Subtest: types and names shown in the exception message are correct + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/Parameter/, /\W '$a'>>/, /<<'f'>>/, /<>/, /<>/, /<<'Mu'>>/, /<<'Int'>>/, /\W '.new'>>/) +ok 14 - types and names shown in the exception message are correct +# Subtest: types shown in the exception message are correct + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/'Parameter'/, /\W '$a'>>/, /<<'f'>>/, /<>/, /<>/, /<<'Mu'>>/, /<<'Int'>>/, /<<'multi'>>/) +ok 15 - types shown in the exception message are correct +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - 'X::NYI.fail' died + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/'Invocant'/, /<<$meth>>/, /<<'must be an object instance'>>/, /<<'not a type object'>>/, /<<'Exception'>>/, /<<'X::NYI'>>/, /\W '.new'>>/) +ok 16 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - 'X::NYI.die' died + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/'Invocant'/, /<<$meth>>/, /<<'must be an object instance'>>/, /<<'not a type object'>>/, /<<'Exception'>>/, /<<'X::NYI'>>/, /\W '.new'>>/) +ok 17 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - 'X::NYI.throw' died + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/'Invocant'/, /<<$meth>>/, /<<'must be an object instance'>>/, /<<'not a type object'>>/, /<<'Exception'>>/, /<<'X::NYI'>>/, /\W '.new'>>/) +ok 18 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - 'X::NYI.rethrow' died + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/'Invocant'/, /<<$meth>>/, /<<'must be an object instance'>>/, /<<'not a type object'>>/, /<<'Exception'>>/, /<<'X::NYI'>>/, /\W '.new'>>/) +ok 19 - did we throws-like Exception? +# Subtest: did we throws-like Exception? + 1..3 + ok 1 - 'X::NYI.resume' died + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/'Invocant'/, /<<$meth>>/, /<<'must be an object instance'>>/, /<<'not a type object'>>/, /<<'Exception'>>/, /<<'X::NYI'>>/, /\W '.new'>>/) +ok 20 - did we throws-like Exception? +# Subtest: sinking to a code object in a feed suggests calling the routine + 1..3 + ok 1 - '3 ==> &sin ==> &say' died + ok 2 - right exception type (Exception) + ok 3 - .message matches /<<'sin()'\W/ +ok 21 - sinking to a code object in a feed suggests calling the routine +# Subtest: trying to instantiate a non-class gives the name in the error + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /'cannot create' .+ «RT122232»/ +ok 22 - trying to instantiate a non-class gives the name in the error +# Subtest: trying to instantiate a non-class gives the name in the error + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /'cannot create' .+ «RT122232»/ +ok 23 - trying to instantiate a non-class gives the name in the error +# Subtest: non-ASCII digits > 7 in leading-zero-octal warning + 1..2 + ok 1 - STDOUT is right + ok 2 - STDERR mentions the end-result is not valid octal +ok 24 - non-ASCII digits > 7 in leading-zero-octal warning +# Subtest: wrong arity in a signature has correct values in error message + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/<<'Too many'>>/, /<<'expected 1'>>/, /<<'got 2'>>/) +ok 25 - wrong arity in a signature has correct values in error message +# Subtest: wrong arity in a signature has correct values in error message + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/<<'Too few'>>/, /<<'expected 2'>>/, /<<'got 1'>>/) +ok 26 - wrong arity in a signature has correct values in error message +# Subtest: wrong arity in a sub-signature has correct values in error message + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/<<'Too many'>>/, /<<'expected 1'>>/, /<<'got 2'>>/, /<<'sub-signature'>>/) +ok 27 - wrong arity in a sub-signature has correct values in error message +# Subtest: wrong arity in a sub-signature with a named parameter has correct values in error message + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches all(/<<'Too few'>>/, /<<'expected 2'>>/, /<<'got 1'>>/, /<<'sub-signature'>>/, /<<'parameter @bar'>>/) +ok 28 - wrong arity in a sub-signature with a named parameter has correct values in error message +# Subtest: wrong arity in a signature mentions the name of the sub + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /<<'foo'>>/ +ok 29 - wrong arity in a signature mentions the name of the sub +# Subtest: wrong arity in a signature mentions the name of the method + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches /<<'foo'>>/ +ok 30 - wrong arity in a signature mentions the name of the method +# Subtest: .length on non-List Cool + 1..3 + ok 1 - '42.length ' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|72306944) ... } +ok 31 - .length on non-List Cool +# Subtest: .length on List + 1..3 + ok 1 - '[].length ' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|72684528) ... } +ok 32 - .length on List +# Subtest: .length on non-Cool + 1..3 + ok 1 - 'bag(1).length ' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|99843120) ... } +ok 33 - .length on non-Cool +# Subtest: &length + 1..3 + ok 1 - 'length 42 ' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|99203792) ... } +ok 34 - &length +# Subtest: error points out only only proto is defined + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Multi::NoMatch) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|65296040) ... } +ok 35 - error points out only only proto is defined +# Subtest: error points out only only proto is defined (Blob.split) + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Multi::NoMatch) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|65296400) ... } +ok 36 - error points out only only proto is defined (Blob.split) +# Subtest: error points out only only proto is defined (Blob.splice) + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Multi::NoMatch) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|65296640) ... } +ok 37 - error points out only only proto is defined (Blob.splice) +# Subtest: a private method of the same name as the public missing method is suggested + 1..3 + ok 1 - ' class RT123078_1 { method foo { self.bar }; method !bar { }; method baz { } }; RT123078_1.new.foo ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .message matches all(/<<"No such method 'bar'" \W/, /<<'RT123078_1'>>/, /\W '!bar'>>/, /<<'baz'>>/) +ok 38 - a private method of the same name as the public missing method is suggested +# Subtest: a public method of the same name as the missing private method is suggested + 1..3 + ok 1 - ' class RT123078_2 { method foo { self!bar }; method bar { }; method baz { } } ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .message matches all(/<<"No such private method '!bar'" \W/, /<<'RT123078_2'>>/, /<<'bar'>>/, /<<'baz'>>/) +ok 39 - a public method of the same name as the missing private method is suggested +# Subtest: a private method of the same name as the public missing method is not suggested for out-of-class call + 1..4 + ok 1 - ' class RT123078_3 { method !bar { }; method baz { } }; RT123078_3.new.bar ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .suggestions matches (Bag VAR baz) + ok 4 - .message matches all(/<<"No such method 'bar'" \W/, /<<'RT123078_3'>>/, /\s+ Did \s+ you \s+ mean/) +ok 40 - a private method of the same name as the public missing method is not suggested for out-of-class call +# Subtest: potentially common misspelling gives the right suggestion + 1..3 + ok 1 - ' .uniq ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .message matches all(/<<"No such method 'uniq'" \W/, /<<'unique'>>/) +ok 41 - potentially common misspelling gives the right suggestion +# Subtest: longer method names are suggested also + 1..3 + ok 1 - ' ‘foo’.starts-wizh(‘f’) ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .message matches all(/<<"No such method 'starts-wizh'" \W/, /<<'starts-with'>>/) +ok 42 - longer method names are suggested also +# Subtest: Ancestor submethods should not be typo-suggested + 1..3 + ok 1 - ' class GH1758_1 { submethod x { }; }; class B is GH1758_1 {}; B.new._ ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|89210184) ... } +ok 43 - Ancestor submethods should not be typo-suggested +# Subtest: Submethods at the same inheritance level should be typo-suggested + 1..3 + ok 1 - ' class GH1758_2 { submethod x { };}; GH1758_2.new._ ' died + ok 2 - right exception type (X::Method::NotFound) + ok 3 - .message matches /"Did you mean 'x'"/ +ok 44 - Submethods at the same inheritance level should be typo-suggested +# Subtest: `IO::Socket::INET.new: :listen` fails with useful error + 1..3 + ok 1 - got a Failure + ok 2 - Failure is unhandled + ok 3 - error mentions port +ok 45 - `IO::Socket::INET.new: :listen` fails with useful error +# Subtest: `use v5` in code does not try to load non-existent modules + 1..2 + ok 1 - 'use v5' died + ok 2 - right exception type (X::Language::Unsupported) +ok 46 - `use v5` in code does not try to load non-existent modules +# Subtest: Duration.new with bad args does not reference guts + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 47 - Duration.new with bad args does not reference guts +# Subtest: sane error when missing variables with my and where + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 48 - sane error when missing variables with my and where +# Subtest: sane NYI error for num32 Blob + 1..3 + ok 1 - 'Blob[num32].new: 2e0' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108157256) ... } +ok 49 - sane NYI error for num32 Blob +# Subtest: callframe.my throws sane NYI error message + 1..2 + ok 1 - 'callframe.callframe(1).my.raku' died + ok 2 - right exception type (X::NYI) +ok 50 - callframe.my throws sane NYI error message +# Subtest: .new on native types works (deprecated; will die) + 1..18 + # Subtest: int no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108159736) ... } + ok 1 - int no args + # Subtest: int with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108159856) ... } + ok 2 - int with args + # Subtest: int8 no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108159896) ... } + ok 3 - int8 no args + # Subtest: int8 with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108159936) ... } + ok 4 - int8 with args + # Subtest: int16 no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108159976) ... } + ok 5 - int16 no args + # Subtest: int16 with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160016) ... } + ok 6 - int16 with args + # Subtest: int32 no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160056) ... } + ok 7 - int32 no args + # Subtest: int32 with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160096) ... } + ok 8 - int32 with args + # Subtest: int64 no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160136) ... } + ok 9 - int64 no args + # Subtest: int64 with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160176) ... } + ok 10 - int64 with args + # Subtest: num no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160216) ... } + ok 11 - num no args + # Subtest: num with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160256) ... } + ok 12 - num with args + # Subtest: num32 no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160296) ... } + ok 13 - num32 no args + # Subtest: num32 with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160336) ... } + ok 14 - num32 with args + # Subtest: num64 no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160376) ... } + ok 15 - num64 no args + # Subtest: num64 with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160416) ... } + ok 16 - num64 with args + # Subtest: str no args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160456) ... } + ok 17 - str no args + # Subtest: str with args + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|108160496) ... } + ok 18 - str with args +ok 51 - .new on native types works (deprecated; will die) +ok +t/05-messages/02-errors.t ....................................... +1..47 +# Subtest: :2(1) suggests using 1.base(2) + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 1 - :2(1) suggests using 1.base(2) +# Subtest: anonymous subs get '' in arity error messages + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches / '' / +ok 2 - anonymous subs get '' in arity error messages +# Subtest: did we throws-like X::TypeCheck::Binding::Parameter? + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Binding::Parameter) + ok 3 - .message matches /'type check failed'/ +ok 3 - did we throws-like X::TypeCheck::Binding::Parameter? +ok 4 - auto-generated methods present in .^methods +# Subtest: Failure.new(Exception.new) does not segfault + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 5 - Failure.new(Exception.new) does not segfault +# Subtest: Trying to assign to immutable List element gives useful error + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Assignment::RO) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78173960) ... } +ok 6 - Trying to assign to immutable List element gives useful error +# Subtest: death in whenevered Supply referenced original location of throw + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 7 - death in whenevered Supply referenced original location of throw +# Subtest: using wrong sigil on var suggests correct variable name + 1..3 + # Subtest: @array for $array + 1..3 + ok 1 - 'my @foo; $foo[1] = 42' died + ok 2 - right exception type (X::Undeclared) + ok 3 - .message matches /'Did you mean' .+ '@foo'/ + ok 1 - @array for $array + # Subtest: %hash for $hash + 1..3 + ok 1 - 'my %foo; $foo<2> = 42' died + ok 2 - right exception type (X::Undeclared) + ok 3 - .message matches /'Did you mean' .+ '%foo'/ + ok 2 - %hash for $hash + # Subtest: @foo and %foo for $foo, when both are declared + 1..3 + ok 1 - 'my @foo; my %foo; $foo<2> = 42' died + ok 2 - right exception type (X::Undeclared) + ok 3 - .message matches /'Did you mean' .+ [ '@foo' .+ '%foo' | '%foo' .+ '@foo' ]/ + ok 3 - @foo and %foo for $foo, when both are declared +ok 8 - using wrong sigil on var suggests correct variable name +# Subtest: RO assignment indicates value of the thing being assigned into + 1..3 + ok 1 - 'my $x; $x = 50; 42 = $x' died + ok 2 - right exception type (X::Assignment::RO) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78256728) ... } +ok 9 - RO assignment indicates value of the thing being assigned into +# Subtest: declaring enum with uninitialized hash warns about it + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 10 - declaring enum with uninitialized hash warns about it +# Subtest: error with `=end FOO` suggests Pod mistake and offers `=begin FOO` + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 11 - error with `=end FOO` suggests Pod mistake and offers `=begin FOO` +# Subtest: error for `=for` suggests it might be a Pod mistake + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 12 - error for `=for` suggests it might be a Pod mistake +# Subtest: `say 1 if;` does not repeat error + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 13 - `say 1 if;` does not repeat error +# Subtest: `say 1 unless;` does not repeat error + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 14 - `say 1 unless;` does not repeat error +# Subtest: C3 linearization mentions line number + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 15 - C3 linearization mentions line number +# Subtest: no guts spillage with `(:::[])` + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 16 - no guts spillage with `(:::[])` +# Subtest: cmp-ok with Str metaop comparator suggests a working alternative` + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 17 - cmp-ok with Str metaop comparator suggests a working alternative` +# Subtest: an ambiguous call includes the arguments in the error message + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Multi::Ambiguous) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3993335496) ... } +ok 18 - an ambiguous call includes the arguments in the error message +# Subtest: sprintf %d directive with one directive and no corresponding argument throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Str::Sprintf::Directives::Count) + ok 3 - .args-have matches 0 + ok 4 - .args-used matches 1 +ok 19 - sprintf %d directive with one directive and no corresponding argument throws +# Subtest: error message when binding to native int array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot bind to a native int array +ok 20 - error message when binding to native int array +# Subtest: error message when :deleting from native int array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot delete from a native int array +ok 21 - error message when :deleting from native int array +# Subtest: error message when binding to native int array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot bind to a native int array +ok 22 - error message when binding to native int array +# Subtest: error message when :deleting from shaped native int array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot delete from a native int array +ok 23 - error message when :deleting from shaped native int array +# Subtest: error message when binding to native num array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot bind to a native num array +ok 24 - error message when binding to native num array +# Subtest: error message when :deleting from native num array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot delete from a native num array +ok 25 - error message when :deleting from native num array +# Subtest: error message when binding to native num array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot bind to a native num array +ok 26 - error message when binding to native num array +# Subtest: error message when :deleting from shaped native num array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot delete from a native num array +ok 27 - error message when :deleting from shaped native num array +# Subtest: error message when binding to native str array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot bind to a native str array +ok 28 - error message when binding to native str array +# Subtest: error message when :deleting from native str array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot delete from a native str array +ok 29 - error message when :deleting from native str array +# Subtest: error message when binding to native str array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot bind to a native str array +ok 30 - error message when binding to native str array +# Subtest: error message when :deleting from shaped native str array + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches Cannot delete from a native str array +ok 31 - error message when :deleting from shaped native str array +# Subtest: USAGE with subsets/where and variables with quotes + 1..3 + # Subtest: named params + 1..3 + # Subtest: mentions subset name + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - mentions subset name + # Subtest: Type + where clauses shown sanely + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - Type + where clauses shown sanely + # Subtest: subset + where clauses shown sanely + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - subset + where clauses shown sanely + ok 1 - named params + # Subtest: anon positional params + 1..3 + # Subtest: mentions subset name + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - mentions subset name + # Subtest: where clauses shown sanely + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - where clauses shown sanely + # Subtest: subset + where clauses shown sanely + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - subset + where clauses shown sanely + ok 2 - anon positional params + # Subtest: variable name does not get special quote treatment + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - variable name does not get special quote treatment +ok 32 - USAGE with subsets/where and variables with quotes +# Subtest: :bundling and negation/explicit arguments + 1..6 + # Subtest: cannot combine bundling with explicit arguments + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - cannot combine bundling with explicit arguments + # Subtest: cannot combine bundling with explicit arguments, even the empty string + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - cannot combine bundling with explicit arguments, even the empty string + # Subtest: cannot combine bundling with explicit arguments, even a nil argument + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - cannot combine bundling with explicit arguments, even a nil argument + # Subtest: can pass explicit argument to a single option, even with bundling enabled + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 4 - can pass explicit argument to a single option, even with bundling enabled + # Subtest: cannot combine bundling with negation + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 5 - cannot combine bundling with negation + # Subtest: can negate single option, even with bundling enabled + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 6 - can negate single option, even with bundling enabled +ok 33 - :bundling and negation/explicit arguments +# Subtest: did we throws-like X::OutOfRange? + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::OutOfRange) + ok 3 - .message matches /'Start argument to substr' .+ 'should be in 0..3' .+ '*-5'/ +ok 34 - did we throws-like X::OutOfRange? +# Subtest: did we throws-like X::OutOfRange? + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::OutOfRange) + ok 3 - .message matches /'should be in 0..0' .+ '*-1000'/ +ok 35 - did we throws-like X::OutOfRange? +# Subtest: .tap block with incorrect signature must fail + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 36 - .tap block with incorrect signature must fail +# Subtest: .tap block with incorrect signature must fail + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 37 - .tap block with incorrect signature must fail +# Subtest: X::Multi::NoMatch does not dump entire contents of variables + 1..3 + ok 1 - ' + # multi z (@a, Int, :$x where 1) {} + # multi z (@a, Str, :$x where 1) {} + # my @a = 1..200; z(@a, <1>, :x[1..200]) + # ' died + ok 2 - right exception type (X::Multi::NoMatch) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|4020496536) ... } +ok 38 - X::Multi::NoMatch does not dump entire contents of variables +# Subtest: X::Assignment::RO does not dump entire contents of variables + 1..3 + ok 1 - 'Set.new(1..300)<42> = 42' died + ok 2 - right exception type (X::Assignment::RO) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83335344) ... } +ok 39 - X::Assignment::RO does not dump entire contents of variables +# Subtest: cannot use Int type object as an operand + 1..14 + # Subtest: A Rational instance cannot be added by an Int type object + 1..2 + ok 1 - '(1/1)+Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 1 - A Rational instance cannot be added by an Int type object + # Subtest: An Int type object cannot be added by a Rational instance + 1..2 + ok 1 - 'Int+(1/1)' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 2 - An Int type object cannot be added by a Rational instance + # Subtest: A Rational instance cannot be subtracted by an Int type object + 1..2 + ok 1 - '(1/1)-Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 3 - A Rational instance cannot be subtracted by an Int type object + # Subtest: An Int type object cannot be subtracted by a Rational instance + 1..2 + ok 1 - 'Int-(1/1)' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 4 - An Int type object cannot be subtracted by a Rational instance + # Subtest: A Rational instance cannot be multiplied by an Int type object + 1..2 + ok 1 - '(1/1)*Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 5 - A Rational instance cannot be multiplied by an Int type object + # Subtest: An Int type object cannot be multiplied by a Rational instance + 1..2 + ok 1 - 'Int*(1/1)' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 6 - An Int type object cannot be multiplied by a Rational instance + # Subtest: A Rational instance cannot be divided by an Int type object + 1..2 + ok 1 - '(1/1)/Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 7 - A Rational instance cannot be divided by an Int type object + # Subtest: An Int type object cannot be divided by a Rational instance + 1..2 + ok 1 - 'Int/(1/1)' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 8 - An Int type object cannot be divided by a Rational instance + # Subtest: An Int type object cannot be divided by an Int type object + 1..2 + ok 1 - 'Int/Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 9 - An Int type object cannot be divided by an Int type object + # Subtest: An Int type object cannot be divided by an Int instance + 1..2 + ok 1 - 'Int/1' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 10 - An Int type object cannot be divided by an Int instance + # Subtest: An Int instance cannot be divided by an Int type object + 1..2 + ok 1 - '1/Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 11 - An Int instance cannot be divided by an Int type object + # Subtest: A Rational instance modulo an Int type object is incalculable + 1..2 + ok 1 - '(1/1)%Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 12 - A Rational instance modulo an Int type object is incalculable + # Subtest: An Int type object modulo a Rational instance is incalculable + 1..2 + ok 1 - 'Int%(1/1)' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 13 - An Int type object modulo a Rational instance is incalculable + # Subtest: A Rational instance cannot be powered by an Int type object + 1..2 + ok 1 - '(1/1)**Int' died + ok 2 - right exception type (X::Numeric::Uninitialized) + ok 14 - A Rational instance cannot be powered by an Int type object +ok 40 - cannot use Int type object as an operand +# Subtest: unit-scoped sub def mentions potential unwanted semicolon + 1..3 + ok 1 - 'sub meows;' died + ok 2 - right exception type (X::UnitScope::Invalid) + ok 3 - .message matches / + # "placed a semicolon after routine's definition" + # / +ok 41 - unit-scoped sub def mentions potential unwanted semicolon +# Subtest: Trying to assign to immutable Range element gives useful error + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Assignment::RO) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|87670816) ... } +ok 42 - Trying to assign to immutable Range element gives useful error +# Subtest: optimizer flag gets propagated to EVAL + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 43 - optimizer flag gets propagated to EVAL +# Subtest: suggests to use "use v6;" or "use v6.c;" when "use 6.0" is called + 1..3 + ok 1 - 'use 6.0;' died + ok 2 - right exception type (X::Undeclared::Symbols) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|88825192) ... } +ok 44 - suggests to use "use v6;" or "use v6.c;" when "use 6.0" is called +# Subtest: suggests to use "use v6;" or "use v6.c;" when "need 6.0" is called + 1..3 + ok 1 - 'need 6.0;' died + ok 2 - right exception type (X::Undeclared::Symbols) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|89067224) ... } +ok 45 - suggests to use "use v6;" or "use v6.c;" when "need 6.0" is called +# Subtest: suggests to use "use v6;" or "use v6.c;" when "need v6.0" is called + 1..3 + ok 1 - 'need v6.0;' died + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|89067984) ... } +ok 46 - suggests to use "use v6;" or "use v6.c;" when "need v6.0" is called +# Subtest: detached non-alpha method says what the problem is + 1..3 + ok 1 - '^42 .^methods.say' died + ok 2 - right exception type (X::Syntax::Malformed) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|89068824) ... } +ok 47 - detached non-alpha method says what the problem is +ok +t/05-messages/03-errors.t ....................................... +1..26 +# Subtest: .map does not explode in optimizer + 1..3 + # Subtest: Hash + 1..2 + ok 1 - '^4 .map: {}' died + ok 2 - right exception type (X::Cannot::Map) + ok 1 - Hash + # Subtest: Int + 1..2 + ok 1 - '^4 .map: 42' died + ok 2 - right exception type (X::Cannot::Map) + ok 2 - Int + ok 3 - subroutine +ok 1 - .map does not explode in optimizer +# Subtest: nodemap mentions right action when throwing on lazies + 1..3 + ok 1 - '(lazy ).nodemap: {;}' died + ok 2 - right exception type (X::Cannot::Lazy) + ok 3 - .action matches nodemap +ok 2 - nodemap mentions right action when throwing on lazies +# Subtest: using substr instead of subst + 1..3 + ok 1 - ''x'.substr: /x/, 'x'' died + ok 2 - right exception type (Exception) + ok 3 - .message matches /｢did you mean 'subst'｣/ +ok 3 - using substr instead of subst +# Subtest: errors from sprintf include location of error + 1..3 + ok 1 - 'sprintf "%d", class Foo {}.new' died + ok 2 - right exception type (X::Str::Sprintf::Directives::BadType) + ok 3 - .gist matches /«line\s+\d+$$/ +ok 4 - errors from sprintf include location of error +# Subtest: subsets get named in typecheck errors + 1..4 + # Subtest: type only, with wrong type given + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Binding::Parameter) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|70597920) ... } + ok 1 - type only, with wrong type given + # Subtest: type + where, with wrong type given + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Binding::Parameter) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|70598160) ... } + ok 2 - type + where, with wrong type given + # Subtest: type only, with failing constraint + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Binding::Parameter) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|70598920) ... } + ok 3 - type only, with failing constraint + # Subtest: type + where, with failing constraint + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Binding::Parameter) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|70599080) ... } + ok 4 - type + where, with failing constraint +ok 5 - subsets get named in typecheck errors +# Subtest: like/unlike failures give useful diagnostics + 1..2 + # Subtest: `like` says it wanted a match, not just "expected" + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - `like` says it wanted a match, not just "expected" + # Subtest: `unlike` says it wanted no match, not just "expected" + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - `unlike` says it wanted no match, not just "expected" +ok 6 - like/unlike failures give useful diagnostics +# Subtest: trying to bind Proc::Async to unopened handle gives useful error + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|67487568) ... } +ok 7 - trying to bind Proc::Async to unopened handle gives useful error +# Subtest: unclosed hash quote index operator <> message + 1..2 + # Subtest: good error message for unclosed <> hash operator + 1..3 + ok 1 - ' + # + # say $< + # + # ' died + ok 2 - right exception type (X::Comp::AdHoc) + ok 3 - .gist matches all(/:i:s<\'/, /:s< hash operator + # Subtest: better and shorter error message for unclosed <> hash operator + 1..3 + ok 1 - 'say $<' died + ok 2 - right exception type (X::Comp::AdHoc) + not ok 3 - .gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|67909848) ... } # TODO remove "expecting any of:" + # Failed test '.gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|67909848) ... }' + # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 + # Expected: -> ;; $_? is raw = OUTER::<$_> { #`(Block|67909848) ... } + # Got: ===SORRY!=== Error while compiling /build/reproducible-path/rakudo-2024.09/EVAL_6 + # Unable to parse quote-words subscript; couldn't find '>' (corresponding '<' was at line 1) + # at /build/reproducible-path/rakudo-2024.09/EVAL_6:1 + # ------> say $<⏏ + # expecting any of: + # argument list + # term + not ok 2 - better and shorter error message for unclosed <> hash operator # TODO remove "expecting any of:" + # Failed test 'better and shorter error message for unclosed <> hash operator' + # at t/05-messages/03-errors.t line 80 +ok 8 - unclosed hash quote index operator <> message +# Subtest: Don't report "missing semicolon" when semicolon present with complicated punctuation. + 1..3 + ok 1 - 'Int:erator:$;' died + ok 2 - right exception type (X::InvalidTypeSmiley) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|67911648) ... } +ok 9 - Don't report "missing semicolon" when semicolon present with complicated punctuation. +# Subtest: non-found module in core namespace is not claimed to be built-in + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 10 - non-found module in core namespace is not claimed to be built-in +# Subtest: X::TypeCheck does not prematurely chop off the .raku + 1..3 + ok 1 - ' + # my class Supercalifragilisticexpialidocious {}; + # (my $x := my class {}.new).^set_name: ; + # -> Supercalifragilisticexpialidocious {}($x) + # ' died + ok 2 - right exception type (X::TypeCheck) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3999708840) ... } +ok 11 - X::TypeCheck does not prematurely chop off the .raku +# Subtest: .polymod with zero divisor does not reference guts in error + 1..4 + # Subtest: Int + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Numeric::DivideByZero) + ok 3 - .gist matches /^ [ . ]+ $/ + ok 1 - Int + # Subtest: Real + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Numeric::DivideByZero) + ok 3 - .gist matches /^ [ . ]+ $/ + ok 2 - Real + # Subtest: Int (lazy) + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Numeric::DivideByZero) + ok 3 - .gist matches /^ [ . ]+ $/ + ok 3 - Int (lazy) + # Subtest: Real (lazy) + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::Numeric::DivideByZero) + ok 3 - .gist matches /^ [ . ]+ $/ + ok 4 - Real (lazy) +ok 12 - .polymod with zero divisor does not reference guts in error +# Subtest: ++.++ construct does not throw LTA errors + 1..2 + ok 1 - '++.++' died + ok 2 - right exception type (X::Multi::NoMatch) +ok 13 - ++.++ construct does not throw LTA errors +# Subtest: lack of whitespace in while (0){} suggests misparse as hash subscript + 1..3 + ok 1 - 'while (0){}' died + ok 2 - right exception type (X::Syntax::Missing) + ok 3 - .message matches /'whitespace' .* 'before curlies' .* 'hash subscript'/ +ok 14 - lack of whitespace in while (0){} suggests misparse as hash subscript +# Subtest: runtime time errors do not contain ==SORRY== + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 15 - runtime time errors do not contain ==SORRY== +# Subtest: `quantifier with %` error includes the token it appears in + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 16 - `quantifier with %` error includes the token it appears in +# Subtest: using two `returns` traits does not cry about unhandled CONTROl exceptions + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 17 - using two `returns` traits does not cry about unhandled CONTROl exceptions +# Subtest: .classify() on Any throws + 1..2 + ok 1 - code dies + ok 2 - right exception type (Exception) +ok 18 - .classify() on Any throws +# Subtest: .categorize() on Any throws + 1..2 + ok 1 - code dies + ok 2 - right exception type (Exception) +ok 19 - .categorize() on Any throws +# Subtest: numeric backslash errors do not get accompanied by confusing others + 1..3 + # Subtest: regex + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - regex + # Subtest: double quotes + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - double quotes + # Subtest: :qq:cc quoter + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - :qq:cc quoter +ok 20 - numeric backslash errors do not get accompanied by confusing others +# Subtest: heredoc trimming warnings do not reference guts + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 21 - heredoc trimming warnings do not reference guts +ok 22 - X::OutOfRange does not stringify given Ranges +# Subtest: Use placeholder variables in a method should yield a useful error message + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 23 - Use placeholder variables in a method should yield a useful error message +# Subtest: Role methods implemented by a class are checked for return type as well as for arguments + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 24 - Role methods implemented by a class are checked for return type as well as for arguments +# Subtest: Absurd adverbing results in a proper error message + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 25 - Absurd adverbing results in a proper error message +# Subtest: An attempt to use a closed handle results in a proper error message + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 26 - An attempt to use a closed handle results in a proper error message +ok +t/05-messages/10-warnings.t ..................................... +1..9 +# Subtest: Supply.interval with negative value warns + 1..2 + ok 1 - useful warning + ok 2 - intervaled code ran +ok 1 - Supply.interval with negative value warns +# Subtest: no useless-use warning on return when KEEP/UNDO phasers used + 1..3 + # Subtest: we get warnings with phasers that do not care about return value + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - we get warnings with phasers that do not care about return value + # Subtest: no warnings with KEEP phaser + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - no warnings with KEEP phaser + # Subtest: no warnings with UNDO phaser + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - no warnings with UNDO phaser +ok 2 - no useless-use warning on return when KEEP/UNDO phasers used +# Subtest: no useless-use warning in andthen/notandthen/orelse/ chains + 1..2 + # Subtest: we get warnings when last value is useless + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - we get warnings when last value is useless + # Subtest: no warnings when last value is useful + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - no warnings when last value is useful +ok 3 - no useless-use warning in andthen/notandthen/orelse/ chains +# Subtest: no spurious warnings when invoking colonpaired routine + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 4 - no spurious warnings when invoking colonpaired routine +# Subtest: metaops + metaassign op do not produce spurious warnings + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 5 - metaops + metaassign op do not produce spurious warnings +# Subtest: no spurious warnings with `try` thunks in blocks + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 6 - no spurious warnings with `try` thunks in blocks +# Subtest: no warnings when sinking variables + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 7 - no warnings when sinking variables +# Subtest: args to macros do not cause useless use warnings + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 8 - args to macros do not cause useless use warnings +# Subtest: ignored shape specification issues a warning + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 9 - ignored shape specification issues a warning +ok +t/05-messages/11-overflow.t ..................................... +1..2 +# Subtest: .roll + 1..3 + # Subtest: (1) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|81977496) ... } + ok 1 - (1) + # Subtest: (2) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|81978256) ... } + ok 2 - (2) + # Subtest: (3) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83928152) ... } + ok 3 - (3) +ok 1 - .roll +# Subtest: .indent + 1..6 + # Subtest: (1) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83931072) ... } + ok 1 - (1) + # Subtest: (2) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83931192) ... } + ok 2 - (2) + # Subtest: (3) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83931312) ... } + ok 3 - (3) + # Subtest: (4) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83934872) ... } + ok 4 - (4) + # Subtest: (5) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83934992) ... } + ok 5 - (5) + # Subtest: (6) + 1..3 + ok 1 - code dies + ok 2 - right exception type (Exception) + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83935112) ... } + ok 6 - (6) +ok 2 - .indent +ok +t/05-messages/moar/01-errors.t .................................. +1..1 +# Subtest: no SEGV with failed opens of MVM debug files + 1..3 + # Subtest: MVM_SPESH_LOG + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - MVM_SPESH_LOG + # Subtest: MVM_DYNVAR_LOG + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 2 - MVM_DYNVAR_LOG + # Subtest: MVM_COVERAGE_LOG + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 3 - MVM_COVERAGE_LOG +ok 1 - no SEGV with failed opens of MVM debug files +ok +t/05-messages/v6.d-tests/01-errors.t ............................ +1..1 +# Subtest: giving await non-Awaitable things throws + 1..2 + ok 1 - code dies + ok 2 - right exception type (Exception) +ok 1 - giving await non-Awaitable things throws +ok +t/06-telemetry/01-basic.t ....................................... +1..42 +ok 1 - did we get a Telemetry object from T +ok 2 - did we get a non-zero value for wallclock using AT-KEY +ok 3 - did we get a non-zero value for wallclock with a method +ok 4 - did we get a non-zero value for cpu using AT-KEY +ok 5 - did we get a non-zero value for cpu with a method +ok 6 - did we get a non-zero value for max-rss using AT-KEY +ok 7 - did we get a non-zero value for max-rss with a method +ok 8 - did we get a Telemetry object from T.raku.EVAL +ok 9 - did wallclock roundtrip ok in Telemetry? +ok 10 - did cpu roundtrip ok in Telemetry? +ok 11 - did max-rss roundtrip ok in Telemetry? +ok 12 - Did we get a Telemetry::Period +ok 13 - did we get a non-zero value for wallclock using AT-KEY +ok 14 - did we get a non-zero value for wallclock using AT-KEY +ok 15 - did we get a non-zero value for cpu using AT-KEY +ok 16 - did we get a non-zero value for cpu using AT-KEY +ok 17 - did we get a Telemetry::Period object from period.raku.EVAL +ok 18 - did wallclock roundtrip ok in Telemetry::Period? +ok 19 - did cpu roundtrip ok in Telemetry::Period? +ok 20 - did max-rss roundtrip ok in Telemetry::Period? +ok 21 - did it contain a Sampler +ok 22 - there are 2 default default instruments +ok 23 - did we get a Telemetry::Instrument::Usage +ok 24 - did we get a Telemetry::Instrument::ThreadPool +ok 25 - was &snap exported +ok 26 - was &snapper exported +ok 27 - was &periods exported +ok 28 - was &report exported +ok 29 - was &safe-ctrl-c exported +ok 30 - was &T exported +ok 31 - did the snap return nothing +ok 32 - did periods auto-add an extra snap? +ok 33 - is it a Telemetry::Period +ok 34 - Did the call to periods remove all of the snaps? +ok 35 - did the snapper return nothing +ok 36 - did the snapper start taking snaps +ok 37 - did the snapper actually stop +ok 38 - did the snapper start taking snaps +ok 39 - did we only get the header of the report +ok 40 - line 1 of report +ok 41 - line 2 of report +# Subtest: giving unknown column in RAKUDO_REPORT_COLUMNS warns instead of crashing + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 42 - giving unknown column in RAKUDO_REPORT_COLUMNS warns instead of crashing +ok +t/06-telemetry/02-usage.t ....................................... +1..194 +ok 1 - return Nil when setting with Str +ok 2 - Was one instrument set with Str +ok 3 - do we get the right class when setting with Str +ok 4 - return Nil when setting with Telemetry::Instrument::Usage +ok 5 - Was one instrument set with Telemetry::Instrument::Usage +ok 6 - do we get the right class when setting with Telemetry::Instrument::Usage +ok 7 - are the columns in alphabetical order +ok 8 - The object is-a 'Telemetry::Instrument::Usage::Snap' +ok 9 - Did we get a Any after roundtripping +ok 10 - did we get the same value for cpu +ok 11 - did we get the same value for cpu-sys +ok 12 - did we get the same value for cpu-user +ok 13 - did we get the same value for cpus +ok 14 - did we get the same value for id-rss +ok 15 - did we get the same value for inb +ok 16 - did we get the same value for invcsw +ok 17 - did we get the same value for is-rss +ok 18 - did we get the same value for ix-rss +ok 19 - did we get the same value for majf +ok 20 - did we get the same value for max-rss +ok 21 - did we get the same value for minf +ok 22 - did we get the same value for mrcv +ok 23 - did we get the same value for msnd +ok 24 - did we get the same value for nsig +ok 25 - did we get the same value for nswp +ok 26 - did we get the same value for outb +ok 27 - did we get the same value for util% +ok 28 - did we get the same value for volcsw +ok 29 - did we get the same value for wallclock +ok 30 - did we get a Snap object from first set of values +ok 31 - did we get a Telemetry object from $S1 +ok 32 - does cpu exist in Telemetry? +ok 33 - did we get a non-zero value for cpu using AT-KEY +ok 34 - did we get a non-zero value for cpu with a method +ok 35 - did AT-KEY and method on T give the same value +ok 36 - does cpu-sys exist in Telemetry? +ok 37 - did we get a non-zero value for cpu-sys using AT-KEY +ok 38 - did we get a non-zero value for cpu-sys with a method +ok 39 - did AT-KEY and method on T give the same value +ok 40 - does cpu-user exist in Telemetry? +ok 41 - did we get a non-zero value for cpu-user using AT-KEY +ok 42 - did we get a non-zero value for cpu-user with a method +ok 43 - did AT-KEY and method on T give the same value +ok 44 - does cpus exist in Telemetry? +ok 45 - did we get a non-zero value for cpus using AT-KEY +ok 46 - did we get a non-zero value for cpus with a method +ok 47 - did AT-KEY and method on T give the same value +ok 48 - does id-rss exist in Telemetry? +ok 49 - did we get a non-zero value for id-rss using AT-KEY +ok 50 - did we get a non-zero value for id-rss with a method +ok 51 - did AT-KEY and method on T give the same value +ok 52 - does inb exist in Telemetry? +ok 53 - did we get a non-zero value for inb using AT-KEY +ok 54 - did we get a non-zero value for inb with a method +ok 55 - did AT-KEY and method on T give the same value +ok 56 - does invcsw exist in Telemetry? +ok 57 - did we get a non-zero value for invcsw using AT-KEY +ok 58 - did we get a non-zero value for invcsw with a method +ok 59 - did AT-KEY and method on T give the same value +ok 60 - does is-rss exist in Telemetry? +ok 61 - did we get a non-zero value for is-rss using AT-KEY +ok 62 - did we get a non-zero value for is-rss with a method +ok 63 - did AT-KEY and method on T give the same value +ok 64 - does ix-rss exist in Telemetry? +ok 65 - did we get a non-zero value for ix-rss using AT-KEY +ok 66 - did we get a non-zero value for ix-rss with a method +ok 67 - did AT-KEY and method on T give the same value +ok 68 - does majf exist in Telemetry? +ok 69 - did we get a non-zero value for majf using AT-KEY +ok 70 - did we get a non-zero value for majf with a method +ok 71 - did AT-KEY and method on T give the same value +ok 72 - does max-rss exist in Telemetry? +ok 73 - did we get a non-zero value for max-rss using AT-KEY +ok 74 - did we get a non-zero value for max-rss with a method +ok 75 - did AT-KEY and method on T give the same value +ok 76 - does minf exist in Telemetry? +ok 77 - did we get a non-zero value for minf using AT-KEY +ok 78 - did we get a non-zero value for minf with a method +ok 79 - did AT-KEY and method on T give the same value +ok 80 - does mrcv exist in Telemetry? +ok 81 - did we get a non-zero value for mrcv using AT-KEY +ok 82 - did we get a non-zero value for mrcv with a method +ok 83 - did AT-KEY and method on T give the same value +ok 84 - does msnd exist in Telemetry? +ok 85 - did we get a non-zero value for msnd using AT-KEY +ok 86 - did we get a non-zero value for msnd with a method +ok 87 - did AT-KEY and method on T give the same value +ok 88 - does nsig exist in Telemetry? +ok 89 - did we get a non-zero value for nsig using AT-KEY +ok 90 - did we get a non-zero value for nsig with a method +ok 91 - did AT-KEY and method on T give the same value +ok 92 - does nswp exist in Telemetry? +ok 93 - did we get a non-zero value for nswp using AT-KEY +ok 94 - did we get a non-zero value for nswp with a method +ok 95 - did AT-KEY and method on T give the same value +ok 96 - does outb exist in Telemetry? +ok 97 - did we get a non-zero value for outb using AT-KEY +ok 98 - did we get a non-zero value for outb with a method +ok 99 - did AT-KEY and method on T give the same value +ok 100 - does util% exist in Telemetry? +ok 101 - did we get a non-zero value for util% using AT-KEY +ok 102 - did we get a non-zero value for util% with a method +ok 103 - did AT-KEY and method on T give the same value +ok 104 - does volcsw exist in Telemetry? +ok 105 - did we get a non-zero value for volcsw using AT-KEY +ok 106 - did we get a non-zero value for volcsw with a method +ok 107 - did AT-KEY and method on T give the same value +ok 108 - does wallclock exist in Telemetry? +ok 109 - did we get a non-zero value for wallclock using AT-KEY +ok 110 - did we get a non-zero value for wallclock with a method +ok 111 - did AT-KEY and method on T give the same value +ok 112 - did we get a Snap object from second set of values +ok 113 - did we get a Telemetry object from $S2 +ok 114 - Did we get a T::Period +ok 115 - does cpu exist in Telemetry::Period? +ok 116 - did we get a positive value for cpu using AT-KEY +ok 117 - did we get a positive value for cpu using AT-KEY +ok 118 - did AT-KEY/method on T:P give same value for cpu +ok 119 - does cpu-sys exist in Telemetry::Period? +ok 120 - did we get a positive value for cpu-sys using AT-KEY +ok 121 - did we get a positive value for cpu-sys using AT-KEY +ok 122 - did AT-KEY/method on T:P give same value for cpu-sys +ok 123 - does cpu-user exist in Telemetry::Period? +ok 124 - did we get a positive value for cpu-user using AT-KEY +ok 125 - did we get a positive value for cpu-user using AT-KEY +ok 126 - did AT-KEY/method on T:P give same value for cpu-user +ok 127 - does cpus exist in Telemetry::Period? +ok 128 - did we get a positive value for cpus using AT-KEY +ok 129 - did we get a positive value for cpus using AT-KEY +ok 130 - did AT-KEY/method on T:P give same value for cpus +ok 131 - does id-rss exist in Telemetry::Period? +ok 132 - did we get a positive value for id-rss using AT-KEY +ok 133 - did we get a positive value for id-rss using AT-KEY +ok 134 - did AT-KEY/method on T:P give same value for id-rss +ok 135 - does inb exist in Telemetry::Period? +ok 136 - did we get a positive value for inb using AT-KEY +ok 137 - did we get a positive value for inb using AT-KEY +ok 138 - did AT-KEY/method on T:P give same value for inb +ok 139 - does invcsw exist in Telemetry::Period? +ok 140 - did we get a positive value for invcsw using AT-KEY +ok 141 - did we get a positive value for invcsw using AT-KEY +ok 142 - did AT-KEY/method on T:P give same value for invcsw +ok 143 - does is-rss exist in Telemetry::Period? +ok 144 - did we get a positive value for is-rss using AT-KEY +ok 145 - did we get a positive value for is-rss using AT-KEY +ok 146 - did AT-KEY/method on T:P give same value for is-rss +ok 147 - does ix-rss exist in Telemetry::Period? +ok 148 - did we get a positive value for ix-rss using AT-KEY +ok 149 - did we get a positive value for ix-rss using AT-KEY +ok 150 - did AT-KEY/method on T:P give same value for ix-rss +ok 151 - does majf exist in Telemetry::Period? +ok 152 - did we get a positive value for majf using AT-KEY +ok 153 - did we get a positive value for majf using AT-KEY +ok 154 - did AT-KEY/method on T:P give same value for majf +ok 155 - does max-rss exist in Telemetry::Period? +ok 156 - did we get a positive value for max-rss using AT-KEY +ok 157 - did we get a positive value for max-rss using AT-KEY +ok 158 - did AT-KEY/method on T:P give same value for max-rss +ok 159 - does minf exist in Telemetry::Period? +ok 160 - did we get a positive value for minf using AT-KEY +ok 161 - did we get a positive value for minf using AT-KEY +ok 162 - did AT-KEY/method on T:P give same value for minf +ok 163 - does mrcv exist in Telemetry::Period? +ok 164 - did we get a positive value for mrcv using AT-KEY +ok 165 - did we get a positive value for mrcv using AT-KEY +ok 166 - did AT-KEY/method on T:P give same value for mrcv +ok 167 - does msnd exist in Telemetry::Period? +ok 168 - did we get a positive value for msnd using AT-KEY +ok 169 - did we get a positive value for msnd using AT-KEY +ok 170 - did AT-KEY/method on T:P give same value for msnd +ok 171 - does nsig exist in Telemetry::Period? +ok 172 - did we get a positive value for nsig using AT-KEY +ok 173 - did we get a positive value for nsig using AT-KEY +ok 174 - did AT-KEY/method on T:P give same value for nsig +ok 175 - does nswp exist in Telemetry::Period? +ok 176 - did we get a positive value for nswp using AT-KEY +ok 177 - did we get a positive value for nswp using AT-KEY +ok 178 - did AT-KEY/method on T:P give same value for nswp +ok 179 - does outb exist in Telemetry::Period? +ok 180 - did we get a positive value for outb using AT-KEY +ok 181 - did we get a positive value for outb using AT-KEY +ok 182 - did AT-KEY/method on T:P give same value for outb +ok 183 - does util% exist in Telemetry::Period? +ok 184 - did we get a positive value for util% using AT-KEY +ok 185 - did we get a positive value for util% using AT-KEY +ok 186 - did AT-KEY/method on T:P give same value for util% +ok 187 - does volcsw exist in Telemetry::Period? +ok 188 - did we get a positive value for volcsw using AT-KEY +ok 189 - did we get a positive value for volcsw using AT-KEY +ok 190 - did AT-KEY/method on T:P give same value for volcsw +ok 191 - does wallclock exist in Telemetry::Period? +ok 192 - did we get a positive value for wallclock using AT-KEY +ok 193 - did we get a positive value for wallclock using AT-KEY +ok 194 - did AT-KEY/method on T:P give same value for wallclock +ok +t/06-telemetry/03-thread.t ...................................... +1..68 +ok 1 - return Nil when setting with Str +ok 2 - Was one instrument set with Str +ok 3 - do we get the right class when setting with Str +ok 4 - return Nil when setting with Telemetry::Instrument::Thread +ok 5 - Was one instrument set with Telemetry::Instrument::Thread +ok 6 - do we get the right class when setting with Telemetry::Instrument::Thread +ok 7 - are the columns in alphabetical order +ok 8 - The object is-a 'Telemetry::Instrument::Thread::Snap' +ok 9 - Did we get a Any after roundtripping +ok 10 - did we get the same value for tad +ok 11 - did we get the same value for tcd +ok 12 - did we get the same value for thid +ok 13 - did we get the same value for tjd +ok 14 - did we get the same value for tsd +ok 15 - did we get the same value for tys +ok 16 - did we get a Snap object from first set of values +ok 17 - did we get a Telemetry object from $S1 +ok 18 - does tad exist in Telemetry? +ok 19 - did we get a non-zero value for tad using AT-KEY +ok 20 - did we get a non-zero value for tad with a method +ok 21 - did AT-KEY and method on T give the same value +ok 22 - does tcd exist in Telemetry? +ok 23 - did we get a non-zero value for tcd using AT-KEY +ok 24 - did we get a non-zero value for tcd with a method +ok 25 - did AT-KEY and method on T give the same value +ok 26 - does thid exist in Telemetry? +ok 27 - did we get a non-zero value for thid using AT-KEY +ok 28 - did we get a non-zero value for thid with a method +ok 29 - did AT-KEY and method on T give the same value +ok 30 - does tjd exist in Telemetry? +ok 31 - did we get a non-zero value for tjd using AT-KEY +ok 32 - did we get a non-zero value for tjd with a method +ok 33 - did AT-KEY and method on T give the same value +ok 34 - does tsd exist in Telemetry? +ok 35 - did we get a non-zero value for tsd using AT-KEY +ok 36 - did we get a non-zero value for tsd with a method +ok 37 - did AT-KEY and method on T give the same value +ok 38 - does tys exist in Telemetry? +ok 39 - did we get a non-zero value for tys using AT-KEY +ok 40 - did we get a non-zero value for tys with a method +ok 41 - did AT-KEY and method on T give the same value +ok 42 - did we get a Snap object from second set of values +ok 43 - did we get a Telemetry object from $S2 +ok 44 - Did we get a T::Period +ok 45 - does tad exist in Telemetry::Period? +ok 46 - did we get a positive value for tad using AT-KEY +ok 47 - did we get a positive value for tad using AT-KEY +ok 48 - did AT-KEY/method on T:P give same value for tad +ok 49 - does tcd exist in Telemetry::Period? +ok 50 - did we get a positive value for tcd using AT-KEY +ok 51 - did we get a positive value for tcd using AT-KEY +ok 52 - did AT-KEY/method on T:P give same value for tcd +ok 53 - does thid exist in Telemetry::Period? +ok 54 - did we get a positive value for thid using AT-KEY +ok 55 - did we get a positive value for thid using AT-KEY +ok 56 - did AT-KEY/method on T:P give same value for thid +ok 57 - does tjd exist in Telemetry::Period? +ok 58 - did we get a positive value for tjd using AT-KEY +ok 59 - did we get a positive value for tjd using AT-KEY +ok 60 - did AT-KEY/method on T:P give same value for tjd +ok 61 - does tsd exist in Telemetry::Period? +ok 62 - did we get a positive value for tsd using AT-KEY +ok 63 - did we get a positive value for tsd using AT-KEY +ok 64 - did AT-KEY/method on T:P give same value for tsd +ok 65 - does tys exist in Telemetry::Period? +ok 66 - did we get a positive value for tys using AT-KEY +ok 67 - did we get a positive value for tys using AT-KEY +ok 68 - did AT-KEY/method on T:P give same value for tys +ok +t/06-telemetry/04-threadpool.t .................................. +1..104 +ok 1 - return Nil when setting with Str +ok 2 - Was one instrument set with Str +ok 3 - do we get the right class when setting with Str +ok 4 - return Nil when setting with Telemetry::Instrument::ThreadPool +ok 5 - Was one instrument set with Telemetry::Instrument::ThreadPool +ok 6 - do we get the right class when setting with Telemetry::Instrument::ThreadPool +ok 7 - are the columns in alphabetical order +ok 8 - The object is-a 'Telemetry::Instrument::ThreadPool::Snap' +ok 9 - Did we get a Any after roundtripping +ok 10 - did we get the same value for atc +ok 11 - did we get the same value for atq +ok 12 - did we get the same value for aw +ok 13 - did we get the same value for gtc +ok 14 - did we get the same value for gtq +ok 15 - did we get the same value for gw +ok 16 - did we get the same value for s +ok 17 - did we get the same value for ttc +ok 18 - did we get the same value for ttq +ok 19 - did we get the same value for tw +ok 20 - did we get a Snap object from first set of values +ok 21 - did we get a Telemetry object from $S1 +ok 22 - does atc exist in Telemetry? +ok 23 - did we get a non-zero value for atc using AT-KEY +ok 24 - did we get a non-zero value for atc with a method +ok 25 - did AT-KEY and method on T give the same value +ok 26 - does atq exist in Telemetry? +ok 27 - did we get a non-zero value for atq using AT-KEY +ok 28 - did we get a non-zero value for atq with a method +ok 29 - did AT-KEY and method on T give the same value +ok 30 - does aw exist in Telemetry? +ok 31 - did we get a non-zero value for aw using AT-KEY +ok 32 - did we get a non-zero value for aw with a method +ok 33 - did AT-KEY and method on T give the same value +ok 34 - does gtc exist in Telemetry? +ok 35 - did we get a non-zero value for gtc using AT-KEY +ok 36 - did we get a non-zero value for gtc with a method +ok 37 - did AT-KEY and method on T give the same value +ok 38 - does gtq exist in Telemetry? +ok 39 - did we get a non-zero value for gtq using AT-KEY +ok 40 - did we get a non-zero value for gtq with a method +ok 41 - did AT-KEY and method on T give the same value +ok 42 - does gw exist in Telemetry? +ok 43 - did we get a non-zero value for gw using AT-KEY +ok 44 - did we get a non-zero value for gw with a method +ok 45 - did AT-KEY and method on T give the same value +ok 46 - does s exist in Telemetry? +ok 47 - did we get a non-zero value for s using AT-KEY +ok 48 - did we get a non-zero value for s with a method +ok 49 - did AT-KEY and method on T give the same value +ok 50 - does ttc exist in Telemetry? +ok 51 - did we get a non-zero value for ttc using AT-KEY +ok 52 - did we get a non-zero value for ttc with a method +ok 53 - did AT-KEY and method on T give the same value +ok 54 - does ttq exist in Telemetry? +ok 55 - did we get a non-zero value for ttq using AT-KEY +ok 56 - did we get a non-zero value for ttq with a method +ok 57 - did AT-KEY and method on T give the same value +ok 58 - does tw exist in Telemetry? +ok 59 - did we get a non-zero value for tw using AT-KEY +ok 60 - did we get a non-zero value for tw with a method +ok 61 - did AT-KEY and method on T give the same value +ok 62 - did we get a Snap object from second set of values +ok 63 - did we get a Telemetry object from $S2 +ok 64 - Did we get a T::Period +ok 65 - does atc exist in Telemetry::Period? +ok 66 - did we get a positive value for atc using AT-KEY +ok 67 - did we get a positive value for atc using AT-KEY +ok 68 - did AT-KEY/method on T:P give same value for atc +ok 69 - does atq exist in Telemetry::Period? +ok 70 - did we get a positive value for atq using AT-KEY +ok 71 - did we get a positive value for atq using AT-KEY +ok 72 - did AT-KEY/method on T:P give same value for atq +ok 73 - does aw exist in Telemetry::Period? +ok 74 - did we get a positive value for aw using AT-KEY +ok 75 - did we get a positive value for aw using AT-KEY +ok 76 - did AT-KEY/method on T:P give same value for aw +ok 77 - does gtc exist in Telemetry::Period? +ok 78 - did we get a positive value for gtc using AT-KEY +ok 79 - did we get a positive value for gtc using AT-KEY +ok 80 - did AT-KEY/method on T:P give same value for gtc +ok 81 - does gtq exist in Telemetry::Period? +ok 82 - did we get a positive value for gtq using AT-KEY +ok 83 - did we get a positive value for gtq using AT-KEY +ok 84 - did AT-KEY/method on T:P give same value for gtq +ok 85 - does gw exist in Telemetry::Period? +ok 86 - did we get a positive value for gw using AT-KEY +ok 87 - did we get a positive value for gw using AT-KEY +ok 88 - did AT-KEY/method on T:P give same value for gw +ok 89 - does s exist in Telemetry::Period? +ok 90 - did we get a positive value for s using AT-KEY +ok 91 - did we get a positive value for s using AT-KEY +ok 92 - did AT-KEY/method on T:P give same value for s +ok 93 - does ttc exist in Telemetry::Period? +ok 94 - did we get a positive value for ttc using AT-KEY +ok 95 - did we get a positive value for ttc using AT-KEY +ok 96 - did AT-KEY/method on T:P give same value for ttc +ok 97 - does ttq exist in Telemetry::Period? +ok 98 - did we get a positive value for ttq using AT-KEY +ok 99 - did we get a positive value for ttq using AT-KEY +ok 100 - did AT-KEY/method on T:P give same value for ttq +ok 101 - does tw exist in Telemetry::Period? +ok 102 - did we get a positive value for tw using AT-KEY +ok 103 - did we get a positive value for tw using AT-KEY +ok 104 - did AT-KEY/method on T:P give same value for tw +ok +t/07-pod-to-text/01-whitespace.t ................................ +1..4 +# Subtest: Code blocks + 1..3 + ok 1 - Empty lines don't get added spaces + ok 2 - Plain continuation lines are aligned + ok 3 - Formatting Codes in code block +ok 1 - Code blocks +# Subtest: Input blocks + 1..3 + ok 1 - Empty lines don't get added spaces + ok 2 - Plain continuation lines are aligned + ok 3 - Formatting Codes in input block +ok 2 - Input blocks +# Subtest: Output blocks + 1..3 + ok 1 - Empty lines don't get added spaces + ok 2 - Plain continuation lines are aligned + ok 3 - Formatting Codes in output block +ok 3 - Output blocks +# Subtest: Tables + 1..1 + ok 1 - Final table row is not space-padded +ok 4 - Tables +ok +t/07-pod-to-text/02-input-output.t .............................. +1..20 +ok 1 - The object is-a 'Pod::Block::Code' +ok 2 - +ok 3 - The object is-a 'Pod::Block::Code' +ok 4 - +ok 5 - The object is-a 'Pod::Block::Code' +ok 6 - +ok 7 - The object is-a 'Pod::Block::Code' +ok 8 - +ok 9 - The object is-a 'Pod::Block::Code' +ok 10 - +ok 11 - The object is-a 'Pod::Block::Code' +ok 12 - +ok 13 - The object is-a 'Pod::Block::Code' +ok 14 - +ok 15 - The object is-a 'Pod::Block::Code' +ok 16 - +ok 17 - The object is-a 'Pod::Block::Code' +ok 18 - +ok 19 - The object is-a 'Pod::Defn' +ok 20 - +ok +t/08-performance/01-iterators.t ................................. +1..6 +ok 1 - combinations() iterator implements efficient .count-only +ok 2 - combinations() iterator implements efficient .bool-only +ok 3 - &permutations() iterator implements efficient .count-only +ok 4 - &permutations() iterator implements efficient .bool-only +ok 5 - .permutations() iterator implements efficient .count-only +ok 6 - .permutations() iterator implements efficient .bool-only +ok +t/08-performance/02-qast-rewrites.t ............................. +1..4 +# Subtest: postfix-inc/dec on natives gets overwritten to prefix + 1..8 + ok 1 - int, void context ++ + ok 2 - int, non-void context ++ + ok 3 - int, void context -- + ok 4 - int, non-void context -- + ok 5 - num, void context ++ + ok 6 - num, non-void context ++ + ok 7 - num, void context -- + ok 8 - num, non-void context -- +ok 1 - postfix-inc/dec on natives gets overwritten to prefix +# Subtest: .dispatch:<.=> gets rewritten to simple ops + 1..15 + ok 1 - (my Int $x .=new).="{"new"}"(42); + ok 2 - my Int $x; .=new andthen .=new orelse .=new; + ok 3 - my \foo .= new + ok 4 - my Int \foo .= new + ok 5 - my Int $a; .=new without $a + ok 6 - my Int $a; .=new with $a + ok 7 - my Int $a; $a .= new + ok 8 - my @a; @a .= new + ok 9 - my @a .= new + ok 10 - my %a; %a .= new + ok 11 - my %a .= new + ok 12 - my &a; &a .= new + ok 13 - my &a .= new + ok 14 - my $b = "meows"; $b .= WHAT + ok 15 - my @b = ; @b .= sort +ok 2 - .dispatch:<.=> gets rewritten to simple ops +# Subtest: for {} + 1..13 + ok 1 - for ^10 {} case gets optimized entirely + ok 2 - for 1..10 {} case gets optimized entirely + ok 3 - for 1..^10 {} case gets optimized entirely + ok 4 - for 1^..10 {} case gets optimized entirely + ok 5 - for 1^..^10 {} case gets optimized entirely + ok 6 - for 1...10 {} case gets optimized entirely + ok 7 - for 1, 2...10 {} case gets optimized entirely + ok 8 - for 10...2 {} case gets optimized entirely + ok 9 - for 1,3...9 {} case gets optimized entirely + ok 10 - for 9,7...1 {} case gets optimized entirely + ok 11 - for ^10 .reverse {} case gets optimized entirely + ok 12 - simple `for ^10 {}` case gets `p6forstmt` op to use + ok 13 - named arg does not accidentally get counted as a positional +ok 3 - for {} +# Subtest: nested metaops get fully rewritten away from &METAOP sub calls + 1..2 + ok 1 - (//=)+= + ok 2 - ((((//=)+=) //=) +=) +ok 4 - nested metaops get fully rewritten away from &METAOP sub calls +ok +t/08-performance/03-optimizer-regressions.t ..................... +1..1 +ok 1 - Smartmatch optimization does not lead to non-Mu:U object smartmatching with Mu:U +ok +t/08-performance/05-processkeys.t ............................... +1..2 +ok 1 - control for $*EXECUTABLE +ok 2 - No unexpected entries in PROCESS:: +ok +t/09-moar/00-misc.t ............................................. +1..5 +# Subtest: no SPESH crashes with duplicate `use Test` + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 1 - no SPESH crashes with duplicate `use Test` +ok 2 - No SEGV when many threads try to change the debug type name +ok 3 - does srand produce same rand_I values +ok 4 - does srand produce same rand_n values +ok 5 - Repeatedly trying to clone a Lock does not lead to a crash +ok +t/09-moar/General_Category__UnicodeData__2.t .................... +ok 1 - Property: General_Category from file: UnicodeData.txt (Correct: 34924 Wrong: 0) +1..1 +ok +t/09-moar/General_Category__extracted-DerivedGeneralCategory.t .. +ok 1 - Property: General_Category=Cn from file: extracted/DerivedGeneralCategory.txt (Correct: 825324 Wrong: 21). Todo'd if < 21 failures. +1..1 +ok +t/09-moar/Line_Break__LineBreak.t ............................... +ok 1 - Property: Line_Break=ID from file: LineBreak.txt (Correct: 109886 Wrong: 62579). Todo'd if < 62579 failures. +ok 2 - Property: Line_Break=PR from file: LineBreak.txt (Correct: 52 Wrong: 15). Todo'd if < 15 failures. +1..2 +ok +t/09-moar/NAME__UnicodeData.t ................................... +ok 1 - Property: NAME from file: UnicodeData.txt (Correct: 277530 Wrong: 0) +1..1 +ok +t/10-qast/00-misc.t ............................................. +1..1 +ok 1 - whatever curries with 3+ args do not duplicate p6bindsig op +ok +t/12-rakuast/block.rakutest ..................................... +1..5 +# Subtest: A pointy block node evaluates to a Block + # -> { + # 101 + # } + ok 1 - deparse + ok 2 - AST: A pointy block node evaluates to a Block + ok 3 - AST: The block has no parameters + ok 4 - AST: The block has 0 arity + ok 5 - AST: The block has 0 count + ok 6 - AST: Invoking the block returns the expected value + ok 7 - AST: Invoking the block with an argument dies + ok 8 - Str: A pointy block node evaluates to a Block + ok 9 - Str: The block has no parameters + ok 10 - Str: The block has 0 arity + ok 11 - Str: The block has 0 count + ok 12 - Str: Invoking the block returns the expected value + ok 13 - Str: Invoking the block with an argument dies + ok 14 - Raku: A pointy block node evaluates to a Block + ok 15 - Raku: The block has no parameters + ok 16 - Raku: The block has 0 arity + ok 17 - Raku: The block has 0 count + ok 18 - Raku: Invoking the block returns the expected value + ok 19 - Raku: Invoking the block with an argument dies + 1..19 +ok 1 - A pointy block node evaluates to a Block +# Subtest: A pointy block node taking a parameter evaluates to a Block + # -> $param { + # $param + # } + ok 1 - deparse + ok 2 - AST: A pointy block node taking a parameter evaluates to a Block + ok 3 - AST: The block has one parameters + ok 4 - AST: The block has 1 arity + ok 5 - AST: The block has 1 count + ok 6 - AST: Invoking the block with an argument returns the expected value + ok 7 - AST: Argument is bound read-only + ok 8 - AST: Invoking the block without an argument dies + ok 9 - Str: A pointy block node taking a parameter evaluates to a Block + ok 10 - Str: The block has one parameters + ok 11 - Str: The block has 1 arity + ok 12 - Str: The block has 1 count + ok 13 - Str: Invoking the block with an argument returns the expected value + ok 14 - Str: Argument is bound read-only + ok 15 - Str: Invoking the block without an argument dies + ok 16 - Raku: A pointy block node taking a parameter evaluates to a Block + ok 17 - Raku: The block has one parameters + ok 18 - Raku: The block has 1 arity + ok 19 - Raku: The block has 1 count + ok 20 - Raku: Invoking the block with an argument returns the expected value + ok 21 - Raku: Argument is bound read-only + ok 22 - Raku: Invoking the block without an argument dies + 1..22 +ok 2 - A pointy block node taking a parameter evaluates to a Block +# Subtest: Bare block at statement level is executed + # { + # $x++ + # } + ok 1 - deparse + ok 2 - AST: Bare block at statement level is executed + ok 3 - AST: Side-effects were performed as expected + ok 4 - Str: Bare block at statement level is executed + ok 5 - Str: Side-effects were performed as expected + ok 6 - Raku: Bare block at statement level is executed + ok 7 - Raku: Side-effects were performed as expected + 1..7 +ok 3 - Bare block at statement level is executed +# Subtest: Bare block in parentheses evaluates to Block + # ({ + # $x++ + # }) + ok 1 - deparse + ok 2 - AST: Bare block in parentheses evaluates to Block + ok 3 - AST: Block has arity 0 + ok 4 - AST: Block has count 1 + ok 5 - AST: No side-effects were performed + ok 6 - AST: Can evaluate the returned block + ok 7 - AST: Block did perform side-effects when evaluated + ok 8 - Str: Bare block in parentheses evaluates to Block + ok 9 - Str: Block has arity 0 + ok 10 - Str: Block has count 1 + ok 11 - Str: No side-effects were performed + ok 12 - Str: Can evaluate the returned block + ok 13 - Str: Block did perform side-effects when evaluated + 1..13 +ok 4 - Bare block in parentheses evaluates to Block +# Subtest: Block has default parameter + # ({ + # $_ + # }) + ok 1 - deparse + ok 2 - AST: Block has default AST parameter + ok 3 - AST: That AST parameter is optional + ok 4 - Str: Block has default Str parameter + ok 5 - Str: That Str parameter is optional + 1..5 +ok 5 - Block has default parameter +ok +t/12-rakuast/call-method.rakutest ............................... +1..15 +# Subtest: Can make a call on a method without arguments + # TestTarget.route + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Can make a call on a method without arguments +# Subtest: Can make a call on a submethod without arguments + # TestTarget.subby + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Can make a call on a submethod without arguments +# Subtest: Can make a call on a method with positional arguments + # TestTarget.subtract(14, 6) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Can make a call on a method with positional arguments +# Subtest: Method call WHAT compiles into MOP primitive + # 42.WHAT + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Method call WHAT compiles into MOP primitive +# Subtest: Method call HOW compiles into MOP primitive + # 42.HOW + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Method call HOW compiles into MOP primitive +# Subtest: Method call WHO compiles into MOP primitive + # 42.WHO + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Method call WHO compiles into MOP primitive +# Subtest: Method call DEFINITE compiles into MOP primitive + # 42.DEFINITE + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Method call DEFINITE compiles into MOP primitive +# Subtest: Method call REPR compiles into MOP primitive + # 42.REPR + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - Method call REPR compiles into MOP primitive +# Subtest: Can make a quoted call on a method without arguments + # TestTarget."route"() + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - Can make a quoted call on a method without arguments +# Subtest: Can make a quoted call on a method with positional arguments + # TestTarget."subtract"(14, 6) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Can make a quoted call on a method with positional arguments +# Subtest: Can make a meta-method call + # 42.^name + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Can make a meta-method call +# Subtest: Can make a method call if the method exists + # TestTarget.?subtract(50, 8) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 12 - Can make a method call if the method exists +# Subtest: Can make a method call if the method does not exist + # TestTarget.?dunno + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 13 - Can make a method call if the method does not exist +# Subtest: Can make a private method call + # A!private + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 14 - Can make a private method call +# Subtest: Can make a method call on a sub + # "foo".&uc() + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 15 - Can make a method call on a sub +ok +t/12-rakuast/call-name.rakutest ................................. +1..8 +# Subtest: Can make a named call with no arguments + # no-args() + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Can make a named call with no arguments +# Subtest: Can make a named call with one positional argument + # one-arg(5) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Can make a named call with one positional argument +# Subtest: Can make a named call with two positional arguments + # two-args(5, 3) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Can make a named call with two positional arguments +# Subtest: Can make a named call with two named arguments + # two-named(n1 => 200, n2 => 4) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Can make a named call with two named arguments +# Subtest: Duplicated named arguments are correctly handled + # two-named(n1 => 200, n2 => 4, n1 => 400) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Duplicated named arguments are correctly handled +# Subtest: Can make a call on a term with two positional arguments + # $target(9, 4) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Can make a call on a term with two positional arguments +# Subtest: Can make a call that flattens into array + # no-args(|@args) + ok 1 - deparsed + ok 2 - AST: flattening empty list + ok 3 - Str: flattening empty list + ok 4 - Raku: flattening empty list + # two-args(|@args) + ok 5 - deparsed + ok 6 - AST: two positional arguments + ok 7 - Str: two positional arguments + ok 8 - Raku: two positional arguments + 1..8 +ok 7 - Can make a call that flattens into array +# Subtest: Can make a call that flattens into hash + # no-args(|%args) + ok 1 - deparsed + ok 2 - AST: flattening empty list + ok 3 - Str: flattening empty list + ok 4 - Raku: flattening empty list + # two-named(|%args) + ok 5 - deparsed + ok 6 - AST: flattening two named arguments + ok 7 - Str: flattening two named arguments + ok 8 - Raku: flattening two named arguments + 1..8 +ok 8 - Can make a call that flattens into hash +ok +t/12-rakuast/circumfix.rakutest ................................. +1..7 +# Subtest: Parenthesized expressions compile correctly + # 2 * (3 + 4) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Parenthesized expressions compile correctly +# Subtest: Multi-statement semilist compiles into a List + # (3, 4) + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Multi-statement semilist compiles into a List +# Subtest: Array composer produces an array + # [9, 10, 11] + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Array composer produces an array +# Subtest: Array composer works correctly with a single argument + # [5 .. 9] + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Array composer works correctly with a single argument +# Subtest: Empty hash composer works correctly + # {} + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Empty hash composer works correctly +# Subtest: Hash composer with fatarrow works correctly + # {a => 42} + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Hash composer with fatarrow works correctly +# Subtest: Hash composer with list of fat arrows works correctly + # {x => 11, y => 22} + ok 1 - deparsed + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Hash composer with list of fat arrows works correctly +ok +t/12-rakuast/class.rakutest ..................................... +1..13 +# Subtest: Create an empty class + # my class MyTestClass { } + ok 1 - deparse + ok 2 - AST: Class evaluates to a type object + ok 3 - AST: Correct class name + ok 4 - AST: Correct representation + ok 5 - Str: Class evaluates to a type object + ok 6 - Str: Correct class name + ok 7 - Str: Correct representation + ok 8 - Raku: Class evaluates to a type object + ok 9 - Raku: Correct class name + ok 10 - Raku: Correct representation + 1..10 +ok 1 - Create an empty class +# Subtest: Create a class with a method + # my class TestClassWithMethods { + # method test-meth { + # 456 + # } + # } + ok 1 - deparse + ok 2 - AST: Class with method evaluates to a type object + ok 3 - AST: Correct class name + ok 4 - AST: The class has a test-meth method + ok 5 - AST: Can call method without signature and get expected value + ok 6 - Str: Class with method evaluates to a type object + ok 7 - Str: Correct class name + ok 8 - Str: The class has a test-meth method + ok 9 - Str: Can call method without signature and get expected value + ok 10 - Raku: Class with method evaluates to a type object + ok 11 - Raku: Correct class name + ok 12 - Raku: The class has a test-meth method + ok 13 - Raku: Can call method without signature and get expected value + 1..13 +ok 2 - Create a class with a method +# Subtest: Create a class with a submethod + # my class TestClassWithSubmethods { + # submethod test-submeth { + # 137 + # } + # } + ok 1 - deparse + ok 2 - AST: Class with method evaluates to a type object + ok 3 - AST: Correct class name + ok 4 - AST: The class has a test-submeth method + ok 5 - AST: Can call method without signature and get expected value + ok 6 - Str: Class with method evaluates to a type object + ok 7 - Str: Correct class name + ok 8 - Str: The class has a test-submeth method + ok 9 - Str: Can call method without signature and get expected value + ok 10 - Raku: Class with method evaluates to a type object + ok 11 - Raku: Correct class name + ok 12 - Raku: The class has a test-submeth method + ok 13 - Raku: Can call method without signature and get expected value + 1..13 +ok 3 - Create a class with a submethod +# Subtest: Check lexically resolving of a class + # my class LexicalTestClass { } + # LexicalTestClass + ok 1 - deparse + ok 2 - AST: Got type object back from looking up package + ok 3 - AST: Resolved lexically to the correct class + ok 4 - AST: Was not installed globally + ok 5 - Str: Got type object back from looking up package + ok 6 - Str: Resolved lexically to the correct class + ok 7 - Str: Was not installed globally + ok 8 - Raku: Got type object back from looking up package + ok 9 - Raku: Resolved lexically to the correct class + ok 10 - Raku: Was not installed globally + 1..10 +ok 4 - Check lexically resolving of a class +# Subtest: Check globally resolving of a class + # class OurTestClassAST { } + # OurTestClassAST + ok 1 - deparse + ok 2 - Got type object back from looking up our-scoped package + ok 3 - Resolved to the correct class + ok 4 - Was installed globally + ok 5 - Correct thing installed + # class OurTestClassStr { } + # OurTestClassStr + ok 6 - deparse + ok 7 - Got type object back from looking up our-scoped package + ok 8 - Resolved to the correct class + ok 9 - Was installed globally + ok 10 - Correct thing installed + # class OurTestClassRaku { } + # OurTestClassRaku + ok 11 - deparse + ok 12 - Got type object back from looking up our-scoped package + ok 13 - Resolved to the correct class + ok 14 - Was installed globally + ok 15 - Correct thing installed + 1..15 +ok 5 - Check globally resolving of a class +# Subtest: our class inside an enclosing module + # class OurEnclosedClassAST { } + # OurEnclosedClassAST + ok 1 - deparse + ok 2 - AST: EVAL of package AST inside a module works # TODO bug in enclosed package naming + ok 3 - AST: Was not installed globally + ok 4 - AST: Was installed in the current package + ok 5 - AST: Correct thing installed + # class OurEnclosedClassStr { } + # OurEnclosedClassStr + ok 6 - deparse + ok 7 - Str: EVAL of package AST inside a module works + ok 8 - Str: Was not installed globally + ok 9 - Str: Was installed in the current package + ok 10 - Str: Correct thing installed + # class OurEnclosedClassRaku { } + # OurEnclosedClassRaku + ok 11 - deparse + ok 12 - Raku: EVAL of package AST inside a module works + ok 13 - Raku: Was not installed globally + ok 14 - Raku: Was installed in the current package + ok 15 - Raku: Correct thing installed + 1..15 +ok 6 - our class inside an enclosing module +# Subtest: class with attribute + # my class TestClassWithAttribute { + # has $!foo + # } + ok 1 - deparse + ok 2 - AST: Class with attribute evluates to a type object + ok 3 - AST: Correct class name + ok 4 - AST: Class has one attribute + ok 5 - AST: Correct attribute name + ok 6 - AST: Correct (default) type + ok 7 - AST: Correctly claims to have no accessor + ok 8 - AST: No accessor method was generated + ok 9 - Str: Class with attribute evluates to a type object + ok 10 - Str: Correct class name + ok 11 - Str: Class has one attribute + ok 12 - Str: Correct attribute name + ok 13 - Str: Correct (default) type + ok 14 - Str: Correctly claims to have no accessor + ok 15 - Str: No accessor method was generated + ok 16 - Raku: Class with attribute evluates to a type object + ok 17 - Raku: Correct class name + ok 18 - Raku: Class has one attribute + ok 19 - Raku: Correct attribute name + ok 20 - Raku: Correct (default) type + ok 21 - Raku: Correctly claims to have no accessor + ok 22 - Raku: No accessor method was generated + 1..22 +ok 7 - class with attribute +# Subtest: class with attribute and accessor + # my class TestClassWithAttributeAccessor { + # has Int $.foo + # } + ok 1 - deparse + ok 2 - AST: Class with attribute with accessor evluates to a type object + ok 3 - AST: Correct class name + ok 4 - AST: Class has one attribute + ok 5 - AST: Correct attribute name + ok 6 - AST: Correct type constraint + ok 7 - AST: Correctly claims to have an accessor + ok 8 - AST: Seems like an accessor method was generated + ok 9 - AST: Accessor and default constructor work fine + ok 10 - Str: Class with attribute with accessor evluates to a type object + ok 11 - Str: Correct class name + ok 12 - Str: Class has one attribute + ok 13 - Str: Correct attribute name + ok 14 - Str: Correct type constraint + ok 15 - Str: Correctly claims to have an accessor + ok 16 - Str: Seems like an accessor method was generated + ok 17 - Str: Accessor and default constructor work fine + ok 18 - Raku: Class with attribute with accessor evluates to a type object + ok 19 - Raku: Correct class name + ok 20 - Raku: Class has one attribute + ok 21 - Raku: Correct attribute name + ok 22 - Raku: Correct type constraint + ok 23 - Raku: Correctly claims to have an accessor + ok 24 - Raku: Seems like an accessor method was generated + ok 25 - Raku: Accessor and default constructor work fine + 1..25 +ok 8 - class with attribute and accessor +# Subtest: class with accessor usage + # my class TestClassWithAttributeUsage { + # has Int $.bar; + # method test-meth { + # $!bar + # } + # method test-accessor { + # $.bar + # } + # } + ok 1 - deparse + ok 2 - AST: Class with accessor usage evaluates to a type object + ok 3 - AST: Correct class name + ok 4 - AST: Attribute access compiles correctly + ok 5 - Str: Class with accessor usage evaluates to a type object + ok 6 - Str: Correct class name + ok 7 - Str: Attribute access compiles correctly + ok 8 - Raku: Class with accessor usage evaluates to a type object + ok 9 - Raku: Correct class name + ok 10 - Raku: Attribute access compiles correctly + 1..10 +ok 9 - class with accessor usage +# Subtest: class with does trait really does the role + # my class TestRoleTarget does TestRole { } + ok 1 - deparse + ok 2 - AST: Class with does trait gets correct name + ok 3 - AST: Class with does trait does the role + ok 4 - AST: The role method can be called + ok 5 - Str: Class with does trait gets correct name + ok 6 - Str: Class with does trait does the role + ok 7 - Str: The role method can be called + ok 8 - Raku: Class with does trait gets correct name + ok 9 - Raku: Class with does trait does the role + ok 10 - Raku: The role method can be called + 1..10 +ok 10 - class with does trait really does the role +# Subtest: class with is trait really inherits + # my class TestChild is TestBase { } + ok 1 - deparse + ok 2 - AST: Class with is trait gets correct name + ok 3 - AST: Class with is trait inherits the base class + ok 4 - AST: A base class method can be called + ok 5 - Str: Class with is trait gets correct name + ok 6 - Str: Class with is trait inherits the base class + ok 7 - Str: A base class method can be called + ok 8 - Raku: Class with is trait gets correct name + ok 9 - Raku: Class with is trait inherits the base class + ok 10 - Raku: A base class method can be called + 1..10 +ok 11 - class with is trait really inherits +# Subtest: class that hides Any + # my class HidesAny hides Any { + # method list { + # nextsame() + # } + # } + ok 1 - deparse + ok 2 - AST: Class with hides trait gets correct name + ok 3 - AST: Calling .list will not dispatch to Any.list + ok 4 - Str: Class with hides trait gets correct name + ok 5 - Str: Calling .list will not dispatch to Any.list + ok 6 - Raku: Class with hides trait gets correct name + ok 7 - Raku: Calling .list will not dispatch to Any.list + 1..7 +ok 12 - class that hides Any +# Subtest: unit scoped class + # #| leading + # unit class Goo; #= trailing + # method goo { + # 42 + # } + ok 1 - deparse + ok 2 - AST: unit scoped class is returned + ok 3 - AST: Calling .goo works + 1..3 +ok 13 - unit scoped class +ok +t/12-rakuast/contextualizer.rakutest ............................ +1..7 +# Subtest: Item contextualizer from empty sequence + # $() + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 1 - Item contextualizer from empty sequence +# Subtest: Hash contextualizer from empty sequence + # %() + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 2 - Hash contextualizer from empty sequence +# Subtest: List contextualizer from empty sequence + # @() + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 3 - List contextualizer from empty sequence +# Subtest: Item contextualizer with single value + # $(42) + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 4 - Item contextualizer with single value +# Subtest: Item contextualizer with multiple values + # $(42, 666) + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 5 - Item contextualizer with multiple values +# Subtest: Hash contextualizer from pairs + # %(a => 1, b => 2) + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 6 - Hash contextualizer from pairs +# Subtest: List contextualizer from pairs + # @(a => 1, b => 2) + ok 1 - deparse + ok 2 - AST: Contextualizer gives expected result + ok 3 - Str: Contextualizer gives expected result + ok 4 - Raku: Contextualizer gives expected result + 1..4 +ok 7 - List contextualizer from pairs +ok +t/12-rakuast/doc-block.rakutest ................................. +1..11 +# Subtest: simple documentation + # =begin doc + # + # This is documentation + # + # =end doc + # + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 1 - simple documentation +# Subtest: simple documentation abbreviated + # =doc This is documentation + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 2 - simple documentation abbreviated +# Subtest: simple documentation with markup + # =begin doc + # + # This is Bumentation + # + # =end doc + # + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 3 - simple documentation with markup +# Subtest: simple documentation in a statementlist (1) + # 42 + # =begin doc + # + # This is documentation + # + # =end doc + # + ok 1 - do we get the final result + ok 2 - Str: deparse + ok 3 - Raku: deparse + 1..3 +ok 4 - simple documentation in a statementlist (1) +# Subtest: simple documentation in a statementlist (2) + # =begin doc + # + # This is documentation + # + # =end doc + # + # 42 + ok 1 - do we get the final result + ok 2 - Str: deparse + ok 3 - Raku: deparse + 1..3 +ok 5 - simple documentation in a statementlist (2) +# Subtest: abbreviated documentation in a statementlist (1) + # 42 + # =head1 This is documentation + ok 1 - do we get the final result + ok 2 - Str: deparse + ok 3 - Raku: deparse + 1..3 +ok 6 - abbreviated documentation in a statementlist (1) +# Subtest: abbreviated documentation in a statementlist (2) + # =head1 # This is documentation + # + # 42 + ok 1 - do we get the final result + ok 2 - Str: deparse + ok 3 - Raku: deparse + 1..3 +ok 7 - abbreviated documentation in a statementlist (2) +# Subtest: alias directive in a statement list + # =alias FOO bar + # = 137 + # 42 + ok 1 - do we get the final result + ok 2 - Str: deparse + ok 3 - Raku: deparse + 1..3 +ok 8 - alias directive in a statement list +# Subtest: row directive in a statement list + # =begin table + # + # =row :align + # =end table + # + # 42 + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 9 - row directive in a statement list +# Subtest: column directive in a statement list + # =begin table + # + # =column :align + # =end table + # + # 42 + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 10 - column directive in a statement list +# Subtest: abbreviated defn in a statement list + # =defn Foo Bar + # baz + # + # 42 + ok 1 - do we get the final result + ok 2 - Str: deparse + ok 3 - Raku: deparse + 1..3 +ok 11 - abbreviated defn in a statement list +ok +t/12-rakuast/doc-declarator.rakutest ............................ +1..20 +# Subtest: Simple leading and trailing pod declarator test + # #| leading comment + # sub a { #= trailing comment + # 42 + # } + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 1 - Simple leading and trailing pod declarator test +# Subtest: Simple block with leading and trailing pod test + # #| leading comment + # { #= trailing comment + # 42 + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a block + ok 3 - AST: can it run and return value + ok 4 - AST: did we get an Array + ok 5 - AST: does it have one element + ok 6 - AST: did we get a Pod::Block::Declarator + ok 7 - AST: is the object the target of the declarator + ok 8 - AST: is the leading comment correct + ok 9 - AST: is the trailing comment correct + ok 10 - Str: did we get a block + ok 11 - Str: can it run and return value + ok 12 - Str: did we get an Array + ok 13 - Str: does it have one element + ok 14 - Str: did we get a Pod::Block::Declarator + ok 15 - Str: is the object the target of the declarator + ok 16 - Str: is the leading comment correct + ok 17 - Str: is the trailing comment correct + ok 18 - Raku: did we get a block + ok 19 - Raku: can it run and return value + ok 20 - Raku: did we get an Array + ok 21 - Raku: does it have one element + ok 22 - Raku: did we get a Pod::Block::Declarator + ok 23 - Raku: is the object the target of the declarator + ok 24 - Raku: is the leading comment correct + ok 25 - Raku: is the trailing comment correct + 1..25 +ok 2 - Simple block with leading and trailing pod test +# Subtest: Simple pointy block with leading and trailing pod test + # #| leading comment + # -> { #= trailing comment + # 42 + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a block + ok 3 - AST: can it run and return value + ok 4 - AST: did we get an Array + ok 5 - AST: does it have one element + ok 6 - AST: did we get a Pod::Block::Declarator + ok 7 - AST: is the object the target of the declarator + ok 8 - AST: is the leading comment correct + ok 9 - AST: is the trailing comment correct + ok 10 - Str: did we get a block + ok 11 - Str: can it run and return value + ok 12 - Str: did we get an Array + ok 13 - Str: does it have one element + ok 14 - Str: did we get a Pod::Block::Declarator + ok 15 - Str: is the object the target of the declarator + ok 16 - Str: is the leading comment correct + ok 17 - Str: is the trailing comment correct + ok 18 - Raku: did we get a block + ok 19 - Raku: can it run and return value + ok 20 - Raku: did we get an Array + ok 21 - Raku: does it have one element + ok 22 - Raku: did we get a Pod::Block::Declarator + ok 23 - Raku: is the object the target of the declarator + ok 24 - Raku: is the leading comment correct + ok 25 - Raku: is the trailing comment correct + 1..25 +ok 3 - Simple pointy block with leading and trailing pod test +# Subtest: Simple sub with leading and trailing pod test + # #| leading comment + # sub a { #= trailing comment + # 42 + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a sub + ok 3 - AST: did it get the right name + ok 4 - AST: can it run and return value + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a sub + ok 12 - Str: did it get the right name + ok 13 - Str: can it run and return value + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a sub + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it run and return value + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 4 - Simple sub with leading and trailing pod test +# Subtest: Simple class with declarator pod + # #| leading comment + # my class A { #= trailing comment + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 5 - Simple class with declarator pod +# Subtest: Simple class with declarator pod, one attribute + # my class A { + # #| leading comment + # has $.foo #= trailing comment + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + not ok 19 - Str: is the trailing comment correct # TODO Str: trailing comment dropped somehow + # Failed test 'Str: is the trailing comment correct' + # at t/12-rakuast/doc-declarator.rakutest line 58 + # expected: "trailing comment" + # got: Nil + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 6 - Simple class with declarator pod, one attribute +# Subtest: Simple class with declarator pod, two attributes + # my class A { + # #| leading comment + # has $.foo; #= trailing comment + # has $.bar + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 7 - Simple class with declarator pod, two attributes +# Subtest: Simple class with declarator pod, one method + # my class A { + # #| leading comment + # method foo { #= trailing comment + # } + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 8 - Simple class with declarator pod, one method +# Subtest: Simple class with declarator pod, one submethod + # my class A { + # #| leading comment + # submethod foo { #= trailing comment + # } + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 9 - Simple class with declarator pod, one submethod +# Subtest: Simple class with declarator pod, one private method + # my class A { + # #| leading comment + # method !foo { #= trailing comment + # } + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 10 - Simple class with declarator pod, one private method +# Subtest: Simple class with declarator pod, one meta method + # my class A { + # #| leading comment + # method ^foo { #= trailing comment + # } + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 11 - Simple class with declarator pod, one meta method +# Subtest: Simple class with declarator pod, two methods + # my class A { + # #| leading comment + # method foo { #= trailing comment + # } + # method bar { } + # }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a class + ok 3 - AST: did it get the right name + ok 4 - AST: can it instantiate + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a class + ok 12 - Str: did it get the right name + ok 13 - Str: can it instantiate + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a class + ok 21 - Raku: did it get the right name + ok 22 - Raku: can it instantiate + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 12 - Simple class with declarator pod, two methods +# Subtest: Simple enum with declarator pod + # #| leading comment + # my enum Foo #= trailing comment + # , $=pod + ok 1 - deparse + ok 2 - AST: did we get a Map + ok 3 - AST: did we get an Array + ok 4 - AST: does it have one element + ok 5 - AST: did we get a Pod::Block::Declarator + ok 6 - AST: is the leading comment correct + ok 7 - AST: is the trailing comment correct + ok 8 - Str: did we get a Map + ok 9 - Str: did we get an Array + ok 10 - Str: does it have one element + ok 11 - Str: did we get a Pod::Block::Declarator + ok 12 - Str: is the leading comment correct + not ok 13 - Str: is the trailing comment correct # TODO Str: trailing comment dropped somehow + # Failed test 'Str: is the trailing comment correct' + # at t/12-rakuast/doc-declarator.rakutest line 58 + # expected: "trailing comment" + # got: Nil + ok 14 - Raku: did we get a Map + ok 15 - Raku: did we get an Array + ok 16 - Raku: does it have one element + ok 17 - Raku: did we get a Pod::Block::Declarator + ok 18 - Raku: is the leading comment correct + ok 19 - Raku: is the trailing comment correct + 1..19 +ok 13 - Simple enum with declarator pod +# Subtest: Simple subset with declarator pod + # #| leading comment + # my subset Foo of Int #= trailing comment + # , $=pod + ok 1 - deparse + ok 2 - AST: did we get a subset + ok 3 - AST: did it get the right name + ok 4 - AST: does the subset accept Int + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a subset + ok 12 - Str: did it get the right name + ok 13 - Str: does the subset accept Int + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + not ok 19 - Str: is the trailing comment correct # TODO Str: trailing comment dropped somehow + # Failed test 'Str: is the trailing comment correct' + # at t/12-rakuast/doc-declarator.rakutest line 58 + # expected: "trailing comment" + # got: Nil + ok 20 - Raku: did we get a subset + ok 21 - Raku: did it get the right name + ok 22 - Raku: does the subset accept Int + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 14 - Simple subset with declarator pod +# Subtest: Simple regex with declarator pod + # #| leading comment + # my regex foo { #= trailing comment + # bar }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a regex + ok 3 - AST: did it get the right name + ok 4 - AST: did we get an Array + ok 5 - AST: does it have one element + ok 6 - AST: did we get a Pod::Block::Declarator + ok 7 - AST: is the object the target of the declarator + ok 8 - AST: is the leading comment correct + ok 9 - AST: is the trailing comment correct + ok 10 - Str: did we get a regex + ok 11 - Str: did it get the right name + ok 12 - Str: did we get an Array + ok 13 - Str: does it have one element + ok 14 - Str: did we get a Pod::Block::Declarator + ok 15 - Str: is the object the target of the declarator + ok 16 - Str: is the leading comment correct + ok 17 - Str: is the trailing comment correct + ok 18 - Raku: did we get a regex + ok 19 - Raku: did it get the right name + ok 20 - Raku: did we get an Array + ok 21 - Raku: does it have one element + ok 22 - Raku: did we get a Pod::Block::Declarator + ok 23 - Raku: is the object the target of the declarator + ok 24 - Raku: is the leading comment correct + ok 25 - Raku: is the trailing comment correct + 1..25 +ok 15 - Simple regex with declarator pod +# Subtest: Sub with declarator pod on parameter (1) + # sub a ( + # #| leading comment + # $b #= trailing comment + # ) { }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a sub + ok 3 - AST: did sub get the right name + ok 4 - AST: did parameter get the right name + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a sub + ok 12 - Str: did sub get the right name + ok 13 - Str: did parameter get the right name + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a sub + ok 21 - Raku: did sub get the right name + ok 22 - Raku: did parameter get the right name + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 16 - Sub with declarator pod on parameter (1) +# Subtest: Sub with declarator pod on parameter (2) + # sub a ( + # #| leading comment + # $b, #= trailing comment + # $c + # ) { }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a sub + ok 3 - AST: did sub get the right name + ok 4 - AST: did parameter get the right name + ok 5 - AST: did we get an Array + ok 6 - AST: does it have one element + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading comment correct + ok 10 - AST: is the trailing comment correct + ok 11 - Str: did we get a sub + ok 12 - Str: did sub get the right name + ok 13 - Str: did parameter get the right name + ok 14 - Str: did we get an Array + ok 15 - Str: does it have one element + ok 16 - Str: did we get a Pod::Block::Declarator + ok 17 - Str: is the object the target of the declarator + ok 18 - Str: is the leading comment correct + ok 19 - Str: is the trailing comment correct + ok 20 - Raku: did we get a sub + ok 21 - Raku: did sub get the right name + ok 22 - Raku: did parameter get the right name + ok 23 - Raku: did we get an Array + ok 24 - Raku: does it have one element + ok 25 - Raku: did we get a Pod::Block::Declarator + ok 26 - Raku: is the object the target of the declarator + ok 27 - Raku: is the leading comment correct + ok 28 - Raku: is the trailing comment correct + 1..28 +ok 17 - Sub with declarator pod on parameter (2) +# Subtest: Sub with declarator pod on parameter (3) + # sub a ( + # #| leading comment b + # $b, + # #| leading comment c + # $c + # ) { }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a sub + ok 3 - AST: did sub get the right name + ok 4 - AST: did first parameter get the right name + ok 5 - AST: did second parameter get the right name + ok 6 - AST: did we get an Array + ok 7 - AST: does it have two elements + ok 8 - AST: did we get a Pod::Block::Declarator + ok 9 - AST: is the object the target of the declarator + ok 10 - AST: is the leading comment b correct + ok 11 - AST: did we get a Pod::Block::Declarator + ok 12 - AST: is the object the target of the declarator + ok 13 - AST: is the leading comment c correct + ok 14 - Str: did we get a sub + ok 15 - Str: did sub get the right name + ok 16 - Str: did first parameter get the right name + ok 17 - Str: did second parameter get the right name + ok 18 - Str: did we get an Array + ok 19 - Str: does it have two elements + ok 20 - Str: did we get a Pod::Block::Declarator + ok 21 - Str: is the object the target of the declarator + ok 22 - Str: is the leading comment b correct + ok 23 - Str: did we get a Pod::Block::Declarator + ok 24 - Str: is the object the target of the declarator + ok 25 - Str: is the leading comment c correct + ok 26 - Raku: did we get a sub + ok 27 - Raku: did sub get the right name + ok 28 - Raku: did first parameter get the right name + ok 29 - Raku: did second parameter get the right name + ok 30 - Raku: did we get an Array + ok 31 - Raku: does it have two elements + ok 32 - Raku: did we get a Pod::Block::Declarator + ok 33 - Raku: is the object the target of the declarator + ok 34 - Raku: is the leading comment b correct + ok 35 - Raku: did we get a Pod::Block::Declarator + ok 36 - Raku: is the object the target of the declarator + ok 37 - Raku: is the leading comment c correct + 1..37 +ok 18 - Sub with declarator pod on parameter (3) +# Subtest: Sub with declarator pod on parameter (4) + # #| leading sub + # sub a ( #= trailing sub + # #| leading param + # $b #= trailing param + # ) { }, $=pod + ok 1 - deparse + ok 2 - AST: did we get a sub + ok 3 - AST: did sub get the right name + ok 4 - AST: did parameter get the right name + ok 5 - AST: did we get an Array + ok 6 - AST: does it have two elements + ok 7 - AST: did we get a Pod::Block::Declarator + ok 8 - AST: is the object the target of the declarator + ok 9 - AST: is the leading sub correct + ok 10 - AST: is the trailing sub correct + ok 11 - AST: did we get a Pod::Block::Declarator + ok 12 - AST: is the object the target of the declarator + ok 13 - AST: is the leading param correct + ok 14 - AST: is the trailing param correct + ok 15 - Str: did we get a sub + ok 16 - Str: did sub get the right name + ok 17 - Str: did parameter get the right name + ok 18 - Str: did we get an Array + ok 19 - Str: does it have two elements + ok 20 - Str: did we get a Pod::Block::Declarator + ok 21 - Str: is the object the target of the declarator + ok 22 - Str: is the leading sub correct + ok 23 - Str: is the trailing sub correct + ok 24 - Str: did we get a Pod::Block::Declarator + ok 25 - Str: is the object the target of the declarator + ok 26 - Str: is the leading param correct + ok 27 - Str: is the trailing param correct + ok 28 - Raku: did we get a sub + ok 29 - Raku: did sub get the right name + ok 30 - Raku: did parameter get the right name + ok 31 - Raku: did we get an Array + ok 32 - Raku: does it have two elements + ok 33 - Raku: did we get a Pod::Block::Declarator + ok 34 - Raku: is the object the target of the declarator + ok 35 - Raku: is the leading sub correct + ok 36 - Raku: is the trailing sub correct + ok 37 - Raku: did we get a Pod::Block::Declarator + ok 38 - Raku: is the object the target of the declarator + ok 39 - Raku: is the leading param correct + ok 40 - Raku: is the trailing param correct + 1..40 +ok 19 - Sub with declarator pod on parameter (4) +# Subtest: a simple lexical var + # #| leading B + # my $foo #= trailing C + # , $=pod + ok 1 - deparse + ok 2 - did we find the paragraphs ok + 1..2 +ok 20 - a simple lexical var +ok +t/12-rakuast/doc-markup.rakutest ................................ +1..4 +# Subtest: simple bold markup + # B + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 1 - simple bold markup +# Subtest: simple bold with italics markup + # B bold> + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 2 - simple bold with italics markup +# Subtest: link with code markup + # L Programming Language|https://raku.org> + ok 1 - Str: deparse + ok 2 - Raku: deparse + 1..2 +ok 3 - link with code markup +# Subtest: index entry with multiple lemmas + # D + ok 1 - Str: deparse + ok 2 - Raku: deparse + # M + ok 3 - Str: deparse + ok 4 - Raku: deparse + # X + ok 5 - Str: deparse + ok 6 - Raku: deparse + 1..6 +ok 4 - index entry with multiple lemmas +ok +t/12-rakuast/enum.rakutest ...................................... +1..3 +# Subtest: Simple enum + # enum foo + ok 1 - deparse + ok 2 - AST: did it produce the right Map + ok 3 - AST: was the enum installed +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 21 + ok 4 - AST: first enum element +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 23 + not ok 5 - AST: second enum element # TODO keys are not yet installed in OUR:: + # Failed test 'AST: second enum element' + # at t/12-rakuast/enum.rakutest line 42 + # expected: 1 + # got: 0 +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 25 + not ok 6 - AST: third enum element # TODO keys are not yet installed in OUR:: + # Failed test 'AST: third enum element' + # at t/12-rakuast/enum.rakutest line 42 + # expected: 2 + # got: 0 + ok 7 - Str: did it produce the right Map + ok 8 - Str: was the enum installed + ok 9 - Str: first enum element + ok 10 - Str: second enum element # TODO keys are not yet installed in OUR:: + ok 11 - Str: third enum element # TODO keys are not yet installed in OUR:: + ok 12 - Raku: did it produce the right Map + ok 13 - Raku: was the enum installed +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 21 + ok 14 - Raku: first enum element +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 23 + not ok 15 - Raku: second enum element # TODO keys are not yet installed in OUR:: + # Failed test 'Raku: second enum element' + # at t/12-rakuast/enum.rakutest line 44 + # expected: 1 + # got: 0 +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 25 + not ok 16 - Raku: third enum element # TODO keys are not yet installed in OUR:: + # Failed test 'Raku: third enum element' + # at t/12-rakuast/enum.rakutest line 44 + # expected: 2 + # got: 0 + 1..16 +ok 1 - Simple enum +# Subtest: Simple lexical enum + # my enum foo ; + # MY:: + ok 1 - deparse + ok 2 - AST: is the constant *not* in OUR:: + ok 3 - AST: was enum installed + ok 4 - AST: first enum element + ok 5 - AST: second enum element + ok 6 - AST: third enum element + ok 7 - Str: is the constant *not* in OUR:: + ok 8 - Str: was enum installed + ok 9 - Str: first enum element + ok 10 - Str: second enum element + ok 11 - Str: third enum element + ok 12 - Raku: is the constant *not* in OUR:: + ok 13 - Raku: was enum installed + ok 14 - Raku: first enum element + ok 15 - Raku: second enum element + ok 16 - Raku: third enum element + 1..16 +ok 2 - Simple lexical enum +# Subtest: Enum with preset values + # enum foo (:0a, :1b, :2c) + ok 1 - deparse + ok 2 - AST: did it produce the right Map + ok 3 - AST: was the enum installed +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 21 + ok 4 - AST: first enum element +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 23 + not ok 5 - AST: second enum element # TODO keys are not yet installed in OUR:: + # Failed test 'AST: second enum element' + # at t/12-rakuast/enum.rakutest line 118 + # expected: 1 + # got: 0 +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 25 + not ok 6 - AST: third enum element # TODO keys are not yet installed in OUR:: + # Failed test 'AST: third enum element' + # at t/12-rakuast/enum.rakutest line 118 + # expected: 2 + # got: 0 + ok 7 - Str: did it produce the right Map + ok 8 - Str: was the enum installed + ok 9 - Str: first enum element + ok 10 - Str: second enum element # TODO keys are not yet installed in OUR:: + ok 11 - Str: third enum element # TODO keys are not yet installed in OUR:: + ok 12 - Raku: did it produce the right Map + ok 13 - Raku: was the enum installed +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 21 + ok 14 - Raku: first enum element +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 23 + not ok 15 - Raku: second enum element # TODO keys are not yet installed in OUR:: + # Failed test 'Raku: second enum element' + # at t/12-rakuast/enum.rakutest line 120 + # expected: 1 + # got: 0 +Use of uninitialized value of type Any in numeric context + in sub test-enum at t/12-rakuast/enum.rakutest line 25 + not ok 16 - Raku: third enum element # TODO keys are not yet installed in OUR:: + # Failed test 'Raku: third enum element' + # at t/12-rakuast/enum.rakutest line 120 + # expected: 2 + # got: 0 + 1..16 +ok 3 - Enum with preset values +ok +t/12-rakuast/errors.rakutest .................................... +1..1 +# Subtest: did we throws-like X::Syntax::Self::WithoutObject? + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::Syntax::Self::WithoutObject) +ok 1 - did we throws-like X::Syntax::Self::WithoutObject? +ok +t/12-rakuast/heredocs.rakutest .................................. +1..12 +# Subtest: One-part heredoc with literal piece + # qq:to/CODE/ + # hello + # + # goodbye + # CODE + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - One-part heredoc with literal piece +# Subtest: Heredoc with interpolated string variable works + # qq:to/MESSAGE/ + # $str world + # MESSAGE + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Heredoc with interpolated string variable works +# Subtest: Heredoc with interpolated integer variable + # qq:to/INTY/ + # $int is the answer + # INTY + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Heredoc with interpolated integer variable +# Subtest: Heredoc with 3 parts works + # qq:to/MORE/ + # The answer is $int of course! + # MORE + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Heredoc with 3 parts works +# Subtest: Heredoc involving an interpolated block + # qq:to// + # An { + # $bv + # } block + # + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Heredoc involving an interpolated block +# Subtest: words processor splits a heredoc into words + # qq:w:to/WORDS/ + # foo bar 42 + # WORDS + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - words processor splits a heredoc into words +# Subtest: Words processor applied to a heredoc with interpolation + # qq:w:to/WORDS/ + # ba$stuff 66 + # WORDS + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Words processor applied to a heredoc with interpolation +# Subtest: Using the val processor alone on a heredoc + # qq:v:to/VAL/ + # 42 + # VAL + ok 1 - deparse + ok 2 - AST + not ok 3 - Str # TODO problem in parsing static heredocs and :v + # Failed test 'Str' + # at t/12-rakuast/heredocs.rakutest line 181 + # expected: IntStr.new(42, "42\n") + # got: "42\n" + ok 4 - Raku # TODO problem in parsing static heredocs and :v + 1..4 +ok 8 - Using the val processor alone on a heredoc +# Subtest: Using the val processor in heredoc with interpolation + # qq:v:to/VAL/ + # 4$end + # VAL + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - Using the val processor in heredoc with interpolation +# Subtest: Using the words and val processor in a heredoc + # qq:w:v:to/VALS/ + # foo bar 42 + # VALS + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Using the words and val processor in a heredoc +# Subtest: Words processor applied to a heredoc with interpolation + # qq:w:v:to/HUH/ + # ba$stuff 66 + # HUH + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Words processor applied to a heredoc with interpolation +# Subtest: Using the exec processor alone gives expected result + # qq:x:to/GO/ + # echo 123 + # GO + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 12 - Using the exec processor alone gives expected result +ok +t/12-rakuast/highlight.rakutest ................................. +1..32 +# Subtest: 'use nqp' not allowed + 1..3 + ok 1 - code dies + ok 2 - right exception type (SafeActions::X::NotAllowedHighlighting) + ok 3 - .what matches use nqp +ok 1 - 'use nqp' not allowed +# Subtest: 'use MONKEY' not allowed + 1..3 + ok 1 - code dies + ok 2 - right exception type (SafeActions::X::NotAllowedHighlighting) + ok 3 - .what matches use MONKEY +ok 2 - 'use MONKEY' not allowed +# Subtest: 'use MONKEY-GUTS' not allowed + 1..3 + ok 1 - code dies + ok 2 - right exception type (SafeActions::X::NotAllowedHighlighting) + ok 3 - .what matches use MONKEY-GUTS +ok 3 - 'use MONKEY-GUTS' not allowed +# Subtest: 'use Test' not allowed + 1..3 + ok 1 - code dies + ok 2 - right exception type (SafeActions::X::NotAllowedHighlighting) + ok 3 - .what matches module loading +ok 4 - 'use Test' not allowed +# Subtest: use and pass + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 5 - use and pass +# Subtest: class and attributes + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 6 - class and attributes +# Subtest: vars, if and say + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 7 - vars, if and say +# Subtest: simple regex + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 8 - simple regex +# Subtest: =alias + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 9 - =alias +# Subtest: =defn + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 10 - =defn +# Subtest: =for defn + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 11 - =for defn +# Subtest: =begin defn + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 12 - =begin defn +# Subtest: =config zip + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 13 - =config zip +# Subtest: =config zap + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 14 - =config zap +# Subtest: =config zop + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 15 - =config zop +# Subtest: =place zip + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 16 - =place zip +# Subtest: =place zap + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 17 - =place zap +# Subtest: =place zop + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 18 - =place zop +# Subtest: no statements, =finish + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 19 - no statements, =finish +# Subtest: statements, =finish + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 20 - statements, =finish +# Subtest: no statements, no =finish + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 21 - no statements, no =finish +# Subtest: =code + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 22 - =code +# Subtest: =for code + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 23 - =for code +# Subtest: =begin code + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 24 - =begin code +# Subtest: implicit code block + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 25 - implicit code block +# Subtest: procedural table + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 26 - procedural table +# Subtest: declarator doc + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 27 - declarator doc +# Subtest: abbreviated visual table + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 28 - abbreviated visual table +# Subtest: for visual table + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 29 - for visual table +# Subtest: visual table + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 30 - visual table +# Subtest: use v6 (1) + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 31 - use v6 (1) +# Subtest: use v6 (2) + 1..2 + ok 1 - using default + ok 2 - using mapping +ok 32 - use v6 (2) +ok +t/12-rakuast/label.rakutest ..................................... +1..19 +ok 1 - .new constructs a label +ok 2 - is the name correct +ok 3 - is default scope ok +ok 4 - are allowed-scopes ok +ok 5 - Deparses in an expected way +# Subtest: Statement list with labels evaluates to its final statement + # FOO: ++$x; + # BAR: ; + # ++$y + ok 1 - deparse + 1..1 +ok 6 - Statement list with labels evaluates to its final statement +# Subtest: Basic if structure with a label + # FOO: if $a { + # 1 + # } + ok 1 - deparse + 1..1 +ok 7 - Basic if structure with a label +# Subtest: Basic with structure with label + # FOO: with $a -> $x { + # $x + # } + ok 1 - deparse + 1..1 +ok 8 - Basic with structure with label +# Subtest: simple unless with a false condition and a label + # FOO: unless $x { + # ++$y + # } + ok 1 - deparse + 1..1 +ok 9 - simple unless with a false condition and a label +# Subtest: simple without with an undefined condition and a label + # FOO: without $x { + # $y++ + # } + ok 1 - deparse + 1..1 +ok 10 - simple without with an undefined condition and a label +# Subtest: given with explicit signature + # FOO: given $a -> $x { + # $x + # } + ok 1 - deparse + 1..1 +ok 11 - given with explicit signature +# Subtest: While loop at statement level evaluates to Nil + # FOO: while $x { + # --$x + # } + ok 1 - deparse + ok 2 - AST: while loop at statement level evaluates to Nil + ok 3 - AST: Loop variable was decremented to zero + ok 4 - Str: while loop at statement level evaluates to Nil + ok 5 - Str: Loop variable was decremented to zero + 1..5 +ok 12 - While loop at statement level evaluates to Nil +# Subtest: Until loop at statement level evaluates to Nil + # FOO: until !$x { + # --$x + # } + ok 1 - deparse + ok 2 - AST: until loop at statement level evaluates to Nil + ok 3 - AST: Loop variable was decremented to zero + ok 4 - Str: until loop at statement level evaluates to Nil + ok 5 - Str: Loop variable was decremented to zero + 1..5 +ok 13 - Until loop at statement level evaluates to Nil +# Subtest: Repeat while loop at statement level evaluates to Nil + # FOO: repeat { + # --$x + # } while $x + ok 1 - deparse + ok 2 - AST: repeat until loop at statement level evaluates to Nil + ok 3 - AST: loop variable decremented to 0 + ok 4 - Str: repeat until loop at statement level evaluates to Nil + ok 5 - Str: loop variable decremented to 0 + 1..5 +ok 14 - Repeat while loop at statement level evaluates to Nil +# Subtest: Repeat until loop at statement level evaluates to Nil + # FOO: repeat { + # --$x + # } until $x + ok 1 - deparse + ok 2 - AST: repeat until loop at statement level evaluates to Nil + ok 3 - AST: loop ran once + ok 4 - DEPARSE: repeat until loop at statement level evaluates to Nil + ok 5 - DEPARSE: loop ran once + 1..5 +ok 15 - Repeat until loop at statement level evaluates to Nil +# Subtest: Loop block with setup and increment expression + # FOO: loop (my $i = 9; $i; --$i) { + # ++$count + # } + ok 1 - deparse + ok 2 - AST: loop with setup and increment evaluates to Nil + ok 3 - AST: loop ran as expected + ok 4 - Str: loop with setup and increment evaluates to Nil + ok 5 - Str: loop ran as expected + 1..5 +ok 16 - Loop block with setup and increment expression +# Subtest: Statement level for loop + # FOO: for 2 .. 7 -> $x { + # ++$count + # } + ok 1 - deparse + ok 2 - AST: for loop evaluates to Nil + ok 3 - AST: loop ran with expected number of times + ok 4 - Str: for loop evaluates to Nil + ok 5 - Str: loop ran with expected number of times + 1..5 +ok 17 - Statement level for loop +# FOO: use Test; +# ok(1, "use statements work") +ok 18 - deparse +# Subtest: check parsing of 'need' pragma + # FOO: need Test + ok 1 - deparse + 1..1 +ok 19 - check parsing of 'need' pragma +ok +t/12-rakuast/literals.rakutest .................................. +1..9 +# Subtest: RakuAST::IntLiteral with constant + 1..4 + # 42 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 1 - RakuAST::IntLiteral with constant +# Subtest: RakuAST::IntLiteral with calculated value + 1..4 + # 106 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 2 - RakuAST::IntLiteral with calculated value +# Subtest: RakuAST::NumLiteral with constant + 1..4 + # 400e0 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 3 - RakuAST::NumLiteral with constant +# Subtest: RakuAST::NumLiteral with calculated value + 1..4 + # 20050e0 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 4 - RakuAST::NumLiteral with calculated value +# Subtest: RakuAST::RatLiteral with constant + 1..4 + # 1.5 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 5 - RakuAST::RatLiteral with constant +# Subtest: RakuAST::RatLiteral with calculated value + 1..4 + # 4.5 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 6 - RakuAST::RatLiteral with calculated value +# Subtest: RakuAST::ComplexLiteral with constant + 1..4 + # <42+6.66i> + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 7 - RakuAST::ComplexLiteral with constant +# Subtest: RakuAST::VersionLiteral with constant + 1..4 + # v4.2 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 8 - RakuAST::VersionLiteral with constant +# Subtest: RakuAST::VersionLiteral with constructed version + 1..4 + # v6.66 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku +ok 9 - RakuAST::VersionLiteral with constructed version +ok +t/12-rakuast/meta-operators.rakutest ............................ +1..11 +# Subtest: Negate meta-op evaluates to expected value + # 1 !== 2 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Negate meta-op evaluates to expected value +# Subtest: Assignment meta-op evaluates to expected value + # $a += 3 + ok 1 - deparse + ok 2 - AST: evaluates to expected value + ok 3 - AST: Really did mutate the variable + ok 4 - Str: evaluates to expected value + ok 5 - Str: Really did mutate the variable + ok 6 - Raku: evaluates to expected value + ok 7 - Raku: Really did mutate the variable + 1..7 +ok 2 - Assignment meta-op evaluates to expected value +# Subtest: Reverse meta-op evaluates to expected value + # 42 R- 666 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Reverse meta-op evaluates to expected value +# Subtest: Cross meta-op evaluates to expected value + # (1, 2) X+ (1, 3) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Cross meta-op evaluates to expected value +# Subtest: Hyper meta-op evaluates to expected value + # (1, 2) >>+>> 1 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Hyper meta-op evaluates to expected value +# Subtest: Hypering evaluates to expected value + # >>.uc + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Hypering evaluates to expected value +# Subtest: Zip meta-op evaluates to expected value + # (1, 2) Z== (1, 3) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Zip meta-op evaluates to expected value +# Subtest: Assignment meta-op with short-circuit || evaluates to true LHS + # $test ||= $update++ + ok 1 - deparse + ok 2 - AST: short-circuit || evaluates to true LHS + ok 3 - AST: Really did short-circuit, and not evaluate RHS + ok 4 - Str: short-circuit || evaluates to true LHS + ok 5 - Str: Really did short-circuit, and not evaluate RHS + ok 6 - Raku: short-circuit || evaluates to true LHS + ok 7 - Raku: Really did short-circuit, and not evaluate RHS + ok 8 - Str: short-circuit || evaluates to true LHS + ok 9 - Str: Really did short-circuit, and not evaluate RHS + ok 10 - AST: no short-circuit || evaluates to RHS when LHS false + ok 11 - AST: Really did evaluate RHS + ok 12 - Str: no short-circuit || evaluates to RHS when LHS false + ok 13 - Str: Really did evaluate RHS + ok 14 - Raku: no short-circuit || evaluates to RHS when LHS false + ok 15 - Raku: Really did evaluate RHS + 1..15 +ok 8 - Assignment meta-op with short-circuit || evaluates to true LHS +# Subtest: Literal reduce meta-op on left associative operator + # [+] 1, 2, 3 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - Literal reduce meta-op on left associative operator +# Subtest: Array reduce meta-op on left associative operator + # [+] @a + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Array reduce meta-op on left associative operator +# Subtest: Triangle reduce meta-op on left associative operator + # [\+] 1, 2, 3 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Triangle reduce meta-op on left associative operator +ok +t/12-rakuast/name.rakutest ...................................... +1..4 +# Subtest: name from identifier + ok 1 - .from-identifier constructs a name + ok 2 - The element is considered an identifier + ok 3 - Has one part + ok 4 - Name has a single part + ok 5 - Part has expected name + ok 6 - Deparses in an expected way + ok 7 - rakufies in an expected way + 1..7 +ok 1 - name from identifier +# Subtest: name from identifier parts + ok 1 - .from-identifier-parts constructs a name + ok 2 - the element is NOT considered an identifier + ok 3 - Has two parts + ok 4 - first part is simple + ok 5 - second part is simple + ok 6 - part 1 has expected name + ok 7 - part 2 has expected name + ok 8 - deparses in an expected way + ok 9 - rakufies in an expected way + 1..9 +ok 2 - name from identifier parts +# Subtest: name from different parts + ok 1 - .new constructs a name + ok 2 - the element is NOT considered an identifier + ok 3 - Has two parts + ok 4 - first part is simple + ok 5 - second part is empty + ok 6 - part 1 has expected name + ok 7 - deparses in an expected way + ok 8 - rakufies in an expected way + 1..8 +ok 3 - name from different parts +# Subtest: name from expressions + ok 1 - .new constructs a name + ok 2 - the element is NOT considered an identifier + ok 3 - Has one parts + ok 4 - second part is ok + ok 5 - deparses in an expected way + ok 6 - rakufies in an expected way + 1..6 +ok 4 - name from expressions +ok +t/12-rakuast/nqp.rakutest ....................................... +1..4 +# Subtest: Check number of chars + # nqp::chars($x) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Check number of chars +# Subtest: Check constant + # nqp::const::STAT_FILESIZE + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Check constant +# Subtest: Set up a lookup hash + # nqp::hash("a", 42, "b", 666) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Set up a lookup hash +# Subtest: Set up a list + # nqp::list("a", "b", "c") + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Set up a list +ok +t/12-rakuast/operators.rakutest ................................. +1..30 +# Subtest: Application of an infix operator on two literals + # 44 + 22 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Application of an infix operator on two literals +# Subtest: The special form || operator works (1) + # 22 || 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - The special form || operator works (1) +# Subtest: The special form || operator works (2) + # 0 || 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - The special form || operator works (2) +# Subtest: The special form or operator works (1) + # 22 or 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - The special form or operator works (1) +# Subtest: The special form or operator works (2) + # 0 or 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - The special form or operator works (2) +# Subtest: The special form && operator works (1) + # 22 && 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - The special form && operator works (1) +# Subtest: The special form && operator works (2) + # 0 && 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - The special form && operator works (2) +# Subtest: The special form and operator works (1) + # 22 and 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - The special form and operator works (1) +# Subtest: The special form and operator works (2) + # 0 and 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - The special form and operator works (2) +# Subtest: Application of a prefix operator to a literal (1) + # ?2 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Application of a prefix operator to a literal (1) +# Subtest: Application of a prefix operator to a literal (2) + # ?0 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Application of a prefix operator to a literal (2) +# Subtest: Basic assignment to a Scalar container + # $a = 4 + ok 1 - deparse + ok 2 - AST: return value is ok + ok 3 - AST: was variable set ok + ok 4 - Str: return value is ok + ok 5 - Str: was variable set ok + ok 6 - Raku: return value is ok + ok 7 - Raku: was variable set ok + 1..7 +ok 12 - Basic assignment to a Scalar container +# Subtest: Application of a list infix operator on three operands + # 10, 11, 12 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 13 - Application of a list infix operator on three operands +# Subtest: Application of a list infix operator on no operands + # () + ok 1 - deparse + ok 2 - AST + ok 3 - Str + 1..3 +ok 14 - Application of a list infix operator on no operands +# Subtest: Chaining operator has correct outcome + # 5 > $x++ > 3 + ok 1 - deparse + ok 2 - AST: did the expression get evaluated + ok 3 - AST: was the update done + ok 4 - Str: did the expression get evaluated + ok 5 - Str: was the update done + ok 6 - Raku: did the expression get evaluated + ok 7 - Raku: was the update done + 1..7 +ok 15 - Chaining operator has correct outcome +# Subtest: Correct outcome of ternary operator + # $a ?? 22 !! 33 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + ok 5 - AST + ok 6 - Str + ok 7 - Raku + 1..7 +ok 16 - Correct outcome of ternary operator +# Subtest: Correct outcome of nested ternary operator + # $a + # ?? $b + # ?? 22 + # !! 33 + # !! 44 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + ok 5 - AST + ok 6 - Str + ok 7 - Raku + ok 8 - AST + ok 9 - Str + ok 10 - Raku + ok 11 - AST + ok 12 - Str + ok 13 - Raku + 1..13 +ok 17 - Correct outcome of nested ternary operator +# Subtest: Application of dotty infix `.` + # "foo" .uc + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 18 - Application of dotty infix `.` +# Subtest: Application of dotty infix `.=` evaluates to expected value + # $var .= tc + ok 1 - deparse + ok 2 - AST: did we get the right value + ok 3 - AST: was the value stored + ok 4 - Str: did we get the right value + ok 5 - Str: was the value stored + ok 6 - Raku: did we get the right value + ok 7 - Raku: was the value stored + 1..7 +ok 19 - Application of dotty infix `.=` evaluates to expected value +# Subtest: Application of a function infix on two literals + # 44 [&sum] 22 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 20 - Application of a function infix on two literals +# Subtest: Application of ff + # @source.grep({ "A" ff "B" }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 21 - Application of ff +# Subtest: Application of ^ff + # @source.grep({ "A" ^ff "B" }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 22 - Application of ^ff +# Subtest: Application of ff^ + # @source.grep({ "A" ff^ "B" }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 23 - Application of ff^ +# Subtest: Application of ^ff^ + # @source.grep({ "A" ^ff^ "B" }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 24 - Application of ^ff^ +# Subtest: Application of fff + # @source.grep({ / A/ fff / B/ }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 25 - Application of fff +# Subtest: Application of ^fff + # @source.grep({ / A/ ^fff / B/ }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 26 - Application of ^fff +# Subtest: Application of fff^ + # @source.grep({ / A/ fff^ / B/ }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 27 - Application of fff^ +# Subtest: Application of ^fff^ + # @source.grep({ / A/ ^fff^ / B/ }) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 28 - Application of ^fff^ +# Subtest: Feed operation ==> + # @a ==> map(&flip) ==> @b + ok 1 - deparse + ok 2 - AST: EVAL ==> + ok 3 - AST: stored ==> + ok 4 - Str: EVAL ==> + ok 5 - Str: stored ==> + ok 6 - Raku: EVAL ==> + ok 7 - Raku: stored ==> + 1..7 +ok 29 - Feed operation ==> +# Subtest: Feed operation <== + # @b <== map(&flip) <== @a + ok 1 - deparse + ok 2 - AST: EVAL <== + ok 3 - AST: stored <== + ok 4 - Str: EVAL <== + ok 5 - Str: stored <== + ok 6 - Raku: EVAL <== + ok 7 - Raku: stored <== + 1..7 +ok 30 - Feed operation <== +ok +t/12-rakuast/origins.rakutest ................................... +1..2 +# Subtest: Locations + 1..12 + # Subtest: Position 3 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 1 - Position 3 + # Subtest: Position 14 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 2 - Position 14 + # Subtest: Position 18 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 3 - Position 18 + # Subtest: Position 53 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 4 - Position 53 + # Subtest: Position 58 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 5 - Position 58 + # Subtest: Position 61 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 6 - Position 61 + # Subtest: Position 83 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 7 - Position 83 + # Subtest: Position 86 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 8 - Position 86 + # Subtest: Position 98 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 9 - Position 98 + # Subtest: Position 113 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 10 - Position 113 + # Subtest: Position 131 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 11 - Position 131 + # Subtest: Position 135 + 1..2 + # Subtest: Non-key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 1 - Non-key node + # Subtest: Key node + 1..5 + ok 1 - node type + ok 2 - attribute file + ok 3 - attribute from + ok 4 - attribute line + ok 5 - attribute orig-line + ok 2 - Key node + ok 12 - Position 135 +ok 1 - Locations +# Subtest: Backtrace with line directive + 1..1 + # Subtest: die after a line directive + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code + ok 1 - die after a line directive +ok 2 - Backtrace with line directive +ok +t/12-rakuast/pair.rakutest ...................................... +1..8 +# Subtest: Fat arrow syntax forms a Pair + # answer => 42 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Fat arrow syntax forms a Pair +# Subtest: True colonpair forms a Pair with value True + # :r + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - True colonpair forms a Pair with value True +# Subtest: False colonpair forms a Pair with value False + # :!r + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - False colonpair forms a Pair with value False +# Subtest: Number colonpair forms a Pair with the correct Int value + # :42answer + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Number colonpair forms a Pair with the correct Int value +# Subtest: Value colonpair forms a Pair with the correct value (1) + # :cheese("stilton") + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Value colonpair forms a Pair with the correct value (1) +# Subtest: Value colonpair forms a Pair with the correct value (2) + # :cheese + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Value colonpair forms a Pair with the correct value (2) +# Subtest: Value colonpair forms a Pair with the correct value (3) + # :cheese + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Value colonpair forms a Pair with the correct value (3) +# Subtest: Variable colonpair forms a Pair that looks up the variable + # :$curry + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - Variable colonpair forms a Pair that looks up the variable +ok +t/12-rakuast/placeholder.rakutest ............................... +1..6 +# Subtest: Placeholder positional parameter + # sub { + # $^pos + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 1 arity + ok 4 - AST: The block has 1 count + ok 5 - AST: Correct variable name + ok 6 - AST: It is not optional + ok 7 - AST: Invoking the sub with a positional argument works + ok 8 - AST: Invoking the sub without an argument dies + ok 9 - Str: Sub has one params elem + ok 10 - Str: The block has 1 arity + ok 11 - Str: The block has 1 count + ok 12 - Str: Correct variable name + ok 13 - Str: It is not optional + ok 14 - Str: Invoking the sub with a positional argument works + ok 15 - Str: Invoking the sub without an argument dies + ok 16 - Raku: Sub has one params elem + ok 17 - Raku: The block has 1 arity + ok 18 - Raku: The block has 1 count + ok 19 - Raku: Correct variable name + ok 20 - Raku: It is not optional + ok 21 - Raku: Invoking the sub with a positional argument works + ok 22 - Raku: Invoking the sub without an argument dies + 1..22 +ok 1 - Placeholder positional parameter +# Subtest: Placeholder named parameter + # sub { + # $:named + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 0 arity + ok 4 - AST: The block has 0 count + ok 5 - AST: Correct variable name + ok 6 - AST: Correct named name + ok 7 - AST: It is not optional + ok 8 - AST: Invoking the sub with a named argument works + ok 9 - AST: Invoking the sub without an argument dies + ok 10 - Str: Sub has one params elem + ok 11 - Str: The block has 0 arity + ok 12 - Str: The block has 0 count + ok 13 - Str: Correct variable name + ok 14 - Str: Correct named name + ok 15 - Str: It is not optional + ok 16 - Str: Invoking the sub with a named argument works + ok 17 - Str: Invoking the sub without an argument dies + 1..17 +ok 2 - Placeholder named parameter +# Subtest: Placeholder slurpy array + # sub { + # @_ + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 0 arity + ok 4 - AST: The block has Inf count + ok 5 - AST: Correct variable name + ok 6 - AST: It is not optional + ok 7 - AST: Invoking sub with a list works + ok 8 - AST: Invoking the sub without arguments works + ok 9 - Str: Sub has one params elem + ok 10 - Str: The block has 0 arity + ok 11 - Str: The block has Inf count + ok 12 - Str: Correct variable name + ok 13 - Str: It is not optional + ok 14 - Str: Invoking sub with a list works + ok 15 - Str: Invoking the sub without arguments works + 1..15 +ok 3 - Placeholder slurpy array +# Subtest: Placeholder slurpy hash + # sub { + # %_ + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 0 arity + ok 4 - AST: The block has 0 count + ok 5 - AST: Correct variable name + ok 6 - AST: It is not optional + ok 7 - AST: Invoking sub with nameds works + ok 8 - AST: Invoking the sub without arguments works + ok 9 - Str: Sub has one params elem + ok 10 - Str: The block has 0 arity + ok 11 - Str: The block has 0 count + ok 12 - Str: Correct variable name + ok 13 - Str: It is not optional + ok 14 - Str: Invoking sub with nameds works + ok 15 - Str: Invoking the sub without arguments works + 1..15 +ok 4 - Placeholder slurpy hash +# Subtest: Placeholder fake slurpy array + # sub (@_) { + # @_ + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 1 arity + ok 4 - AST: The block has 1 count + ok 5 - AST: Correct variable name + ok 6 - AST: It is not optional + ok 7 - AST: Invoking sub with a list works + ok 8 - AST: Invoking the sub with empty list works + ok 9 - Str: Sub has one params elem + ok 10 - Str: The block has 1 arity + ok 11 - Str: The block has 1 count + ok 12 - Str: Correct variable name + ok 13 - Str: It is not optional + ok 14 - Str: Invoking sub with a list works + ok 15 - Str: Invoking the sub with empty list works + 1..15 +ok 5 - Placeholder fake slurpy array +# Subtest: Placeholder fake slurpy hash + # sub (%_) { + # %_ + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 1 arity + ok 4 - AST: The block has 1 count + ok 5 - AST: Correct variable name + ok 6 - AST: It is not optional + ok 7 - AST: Invoking sub with hash works + ok 8 - AST: Invoking the sub with empty hash + ok 9 - Str: Sub has one params elem + ok 10 - Str: The block has 1 arity + ok 11 - Str: The block has 1 count + ok 12 - Str: Correct variable name + ok 13 - Str: It is not optional + ok 14 - Str: Invoking sub with hash works + ok 15 - Str: Invoking the sub with empty hash + 1..15 +ok 6 - Placeholder fake slurpy hash +ok +t/12-rakuast/postfix.rakutest ................................... +1..20 +# Subtest: Application of a positive power postfix operator + # 3²² + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - Application of a positive power postfix operator +# Subtest: Application of a negative power postfix operator + # 4⁻² + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Application of a negative power postfix operator +# Subtest: Application of a (user-defined) postfix operator to a literal + # 4! + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Application of a (user-defined) postfix operator to a literal +# Subtest: Basic single-dimension array index + # @a[5] + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Basic single-dimension array index +# Subtest: Basic single-dimension array index with colonpair + # @a[5]:exists + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Basic single-dimension array index with colonpair +# Subtest: Zen array slice + # @a[] + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Zen array slice +# Subtest: Zen array slice + # @a[]:v + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Zen array slice +# Subtest: Multi-dimensional array indexing + # @a[2; 1] + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - Multi-dimensional array indexing +# Subtest: Basic single-dimension hash index + # %h{"s"} + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - Basic single-dimension hash index +# Subtest: Basic single-dimension hash index with colonpairs + # %h{"s"}:p + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Basic single-dimension hash index with colonpairs +# Subtest: Zen hash slice + # %h{} + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Zen hash slice +# Subtest: Zen hash slice with colonpairs + # %h{}:k + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 12 - Zen hash slice with colonpairs +# Subtest: Basic literal hash index + # %h + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 13 - Basic literal hash index +# Subtest: Basic literal hash index with colonpairs + # %h:exists + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 14 - Basic literal hash index with colonpairs +# Subtest: Literal hash index with multiple keys + # %h + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 15 - Literal hash index with multiple keys +# Subtest: Literal hash index with multiple keys with colonpairs + # %h:exists + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 16 - Literal hash index with multiple keys with colonpairs +# Subtest: Empty literal hash index works as zen slice + # %h<> + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 17 - Empty literal hash index works as zen slice +# Subtest: Empty literal hash index works as zen slice with colonpairs + # %h<>:v + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 18 - Empty literal hash index works as zen slice with colonpairs +# Subtest: Multi-dimensional hash indexing + # %h{"y"; "a"} + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 19 - Multi-dimensional hash indexing +# Subtest: Multi-dimensional hash indexing with colonpairs + # %h{"y"; "a"}:v + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 20 - Multi-dimensional hash indexing with colonpairs +ok +t/12-rakuast/regex-assertion.rakutest ........................... +1..27 +# Subtest: Named assertion matches correctly + # / / + ok 1 - deparse + ok 2 - AST: did we get correct match + ok 3 - AST: correct match keys + ok 4 - AST: correct match captured + ok 5 - Str: did we get correct match + ok 6 - Str: correct match keys + ok 7 - Str: correct match captured + ok 8 - Raku: did we get correct match + ok 9 - Raku: correct match keys + ok 10 - Raku: correct match captured + 1..10 +ok 1 - Named assertion matches correctly +# Subtest: Non-capturing named assertion matches correctly + # / <.alpha>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 2 - Non-capturing named assertion matches correctly +# Subtest: Named assertion with alias matches correctly + # / / + ok 1 - deparse + ok 2 - AST: did we get correct match + ok 3 - AST: correct match keys + ok 4 - AST: correct match captured (original name) + ok 5 - AST: correct match captured (aliased name) + ok 6 - Str: did we get correct match + ok 7 - Str: correct match keys + ok 8 - Str: correct match captured (original name) + ok 9 - Str: correct match captured (aliased name) + 1..9 +ok 3 - Named assertion with alias matches correctly +# Subtest: Non-capturing named assertion with alias matches correctly + # / / + ok 1 - deparse + ok 2 - AST: did we get correct match + ok 3 - AST: correct match keys + ok 4 - AST: correct match captured (aliased name) + ok 5 - Str: did we get correct match + ok 6 - Str: correct match keys + ok 7 - Str: correct match captured (aliased name) + 1..7 +ok 4 - Non-capturing named assertion with alias matches correctly +# Subtest: Lookahead assertion with named rule works + # / \w/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 5 - Lookahead assertion with named rule works +# Subtest: Negated lookahead assertion with named rule works + # / \w/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 6 - Negated lookahead assertion with named rule works +# Subtest: Lookahead assertion calling before with a regex arg works + # / \w/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 7 - Lookahead assertion calling before with a regex arg works +# Subtest: Negated lookahead assertion calling before with a regex arg works + # / \w/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 8 - Negated lookahead assertion calling before with a regex arg works +# Subtest: Character class enumeration assertion works + # / <+[a \d c..f]>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 9 - Character class enumeration assertion works +# Subtest: Negated character class enumeration assertion works + # / <-[a \d c..f]>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 10 - Negated character class enumeration assertion works +# Subtest: Character property assertion works + # / <+:N>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 11 - Character property assertion works +# Subtest: Inverted character property assertion works + # / <+:!N>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 12 - Inverted character property assertion works +# Subtest: Negated character property assertion works + # / <-:N>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 13 - Negated character property assertion works +# Subtest: Multiple character property assertion works + # / <+:L -:Lu>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 14 - Multiple character property assertion works +# Subtest: Character property with expression assertion works + # / <+:Block("Basic Latin")>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 15 - Character property with expression assertion works +# Subtest: Negated character property with expression assertion works + # / <-:Block("Basic Latin")>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 16 - Negated character property with expression assertion works +# Subtest: Rule assertion works + # / <+alpha>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 17 - Rule assertion works +# Subtest: Negated rule assertion works + # / <-alpha>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 18 - Negated rule assertion works +# Subtest: Multiple rule assertions work + # / <+alpha -xdigit>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 19 - Multiple rule assertions work +# Subtest: Pass assertion works + # / a / + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 20 - Pass assertion works +# Subtest: Fail assertion works + # / a / + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL + ok 2 - Str: EVAL + ok 3 - Raku: EVAL + ok 2 - doesn't match + 1..2 +ok 21 - Fail assertion works +# Subtest: Assertion with predicate block works + # / o/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 22 - Assertion with predicate block works +# Subtest: Negated assertion with predicate block works + # / o/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 23 - Negated assertion with predicate block works +# Subtest: Assertion with interpolated var works + # / <$expected>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 24 - Assertion with interpolated var works +# Subtest: Assertion with interpolated block works + # / o<{ + # "o" + # }>/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 25 - Assertion with interpolated block works +# Subtest: Assertion with recursive ast works + # / o[<~~> | a]/ + ok 1 - deparse + # Subtest: matches + 1..9 + ok 1 - AST: EVAL + ok 2 - AST: No positional captures + ok 3 - AST: No named captures + ok 4 - Str: EVAL + ok 5 - Str: No positional captures + ok 6 - Str: No named captures + ok 7 - Raku: EVAL + ok 8 - Raku: No positional captures + ok 9 - Raku: No named captures + ok 2 - matches + 1..2 +ok 26 - Assertion with recursive ast works +# Subtest: Assertion with callable works + # / <&abc>/ + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - AST: No positional captures + ok 4 - AST: No named captures + ok 5 - Str: EVAL + ok 6 - Str: No positional captures + ok 7 - Str: No named captures + ok 8 - Raku: EVAL + ok 9 - Raku: No positional captures + ok 10 - Raku: No named captures + 1..10 +ok 27 - Assertion with callable works +ok +t/12-rakuast/regex-charclass.rakutest ........................... +1..5 +# Subtest: All of the simple character classes + # / ."\b"\r\d\e\f\h\n\0\s\t\v\w/ + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - Str: pass case + ok 4 - Raku: pass case + 1..4 +ok 1 - All of the simple character classes +# Subtest: All of the simple character classes than can be negated + # / \R\D\E\F\H\N\S\T\V\W/ + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - Str: pass case + ok 4 - Raku: pass case + 1..4 +ok 2 - All of the simple character classes than can be negated +# Subtest: A single unicode character specified by name + # / \c[COMMA]/ + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - Str: pass case + ok 4 - Raku: pass case + 1..4 +ok 3 - A single unicode character specified by name +# Subtest: Multiple unicode characters specified by name + # / \c[REGIONAL INDICATOR SYMBOL LETTER U, REGIONAL INDICATOR SYMBOL LETTER A]/ + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - Str: pass case + ok 4 - Raku: pass case + 1..4 +ok 4 - Multiple unicode characters specified by name +# Subtest: Multiple unicode characters specified by name negated + # / \C[REGIONAL INDICATOR SYMBOL LETTER U, REGIONAL INDICATOR SYMBOL LETTER A]/ + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - Str: pass case + ok 4 - Raku: pass case + 1..4 +ok 5 - Multiple unicode characters specified by name negated +ok +t/12-rakuast/regex-declaration.rakutest ......................... +1..3 +# Subtest: Simple regex declaration + # my regex aplus { a+ } + ok 1 - deparse + ok 2 - AST: is the name ok + ok 3 - AST: did we get correct match + ok 4 - AST: did we get match for 'aaaa' + ok 5 - AST: did it not match with ratchet + ok 6 - Str: is the name ok + ok 7 - Str: did we get correct match + ok 8 - Str: did we get match for 'aaaa' + ok 9 - Str: did it not match with ratchet + ok 10 - Raku: is the name ok + ok 11 - Raku: did we get correct match + ok 12 - Raku: did we get match for 'aaaa' + ok 13 - Raku: did it not match with ratchet + 1..13 +ok 1 - Simple regex declaration +# Subtest: Simple token declaration + # my token aplus { a+ } + ok 1 - deparse + ok 2 - AST: is the name ok + ok 3 - AST: did we get match + ok 4 - AST: did we get match for 'aaaa' + ok 5 - AST: did it not match + ok 6 - Str: is the name ok + ok 7 - Str: did we get match + ok 8 - Str: did we get match for 'aaaa' + ok 9 - Str: did it not match + ok 10 - Raku: is the name ok + ok 11 - Raku: did we get match + ok 12 - Raku: did we get match for 'aaaa' + ok 13 - Raku: did it not match + 1..13 +ok 2 - Simple token declaration +# Subtest: Simple rule declaration + # my rule aplus { a+ } + ok 1 - deparse + ok 2 - AST: is the name ok + ok 3 - AST: did we get match for 'aaaa' + ok 4 - AST: did we get match for 'aaaa ' + ok 5 - AST: did it not match + ok 6 - Str: is the name ok + ok 7 - Str: did we get match for 'aaaa' + ok 8 - Str: did we get match for 'aaaa ' + ok 9 - Str: did it not match + ok 10 - Raku: is the name ok + ok 11 - Raku: did we get match for 'aaaa' + ok 12 - Raku: did we get match for 'aaaa ' + ok 13 - Raku: did it not match + 1..13 +ok 3 - Simple rule declaration +ok +t/12-rakuast/regex-substitution.rakutest ........................ +1..7 +# Subtest: Simple literal substitution on topic + # s/o/x/ + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is topic changed + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is topic changed + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is topic changed + 1..10 +ok 1 - Simple literal substitution on topic +# Subtest: Simple literal modification on topic + # S/o/x/ + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is topic unchanged + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is topic unchanged + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is topic unchanged + 1..10 +ok 2 - Simple literal modification on topic +# Subtest: Simple literal substitution using infix syntax + # s{o} = "x" + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is the result correct + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is the result correct + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is the result correct + 1..10 +ok 3 - Simple literal substitution using infix syntax +# Subtest: Simple literal substitution on variable + # $string ~~ s/o/x/ + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is the result correct + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is the result correct + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is the result correct + 1..10 +ok 4 - Simple literal substitution on variable +# Subtest: Simple literal substitution on variable with adverbs + # $string ~~ s:g:i/O/x/ + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is the result correct + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is the result correct + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is the result correct + 1..10 +ok 5 - Simple literal substitution on variable with adverbs +# Subtest: Simple variable substitution on variable + # $string ~~ s/o/$x/ + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is the result correct + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is the result correct + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is the result correct + 1..10 +ok 6 - Simple variable substitution on variable +# Subtest: Simple Callable substitution on variable + # $string ~~ s/o/{ + # $x + # }/ + ok 1 - deparse + ok 2 - AST: did we get right return value + ok 3 - AST: did it set $/ correctly + ok 4 - AST: is the result correct + ok 5 - Str: did we get right return value + ok 6 - Str: did it set $/ correctly + ok 7 - Str: is the result correct + ok 8 - Raku: did we get right return value + ok 9 - Raku: did it set $/ correctly + ok 10 - Raku: is the result correct + 1..10 +ok 7 - Simple Callable substitution on variable +ok +t/12-rakuast/regex.rakutest ..................................... +1..55 +# Subtest: Simple literal regex + # / foo/ + ok 1 - deparse + ok 2 - AST: start of string + ok 3 - AST: middle of string + ok 4 - AST: not matched + ok 5 - Str: start of string + ok 6 - Str: middle of string + ok 7 - Str: not matched + ok 8 - Raku: start of string + ok 9 - Raku: middle of string + ok 10 - Raku: not matched + 1..10 +ok 1 - Simple literal regex +# Subtest: Sequential alternation takes first match even if second is longer + # / b|| bc/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 2 - Sequential alternation takes first match even if second is longer +# Subtest: Sequential alternation takes second match if first fails + # / x|| bc/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 3 - Sequential alternation takes second match if first fails +# Subtest: Sequential alternation fails if no alternative matches + # / x|| y/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 4 - Sequential alternation fails if no alternative matches +# Subtest: LTM alternation takes longest match even if it is not first + # / b| bc/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 5 - LTM alternation takes longest match even if it is not first +# Subtest: Alternation takes second match if first fails + # / x| bc/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 6 - Alternation takes second match if first fails +# Subtest: Alternation fails if no alternative matches + # / x| y/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 7 - Alternation fails if no alternative matches +# Subtest: Conjunction matches when both items match + # / .& c/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 8 - Conjunction matches when both items match +# Subtest: Conjunction fails when one item does not match + # / .& x/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 9 - Conjunction fails when one item does not match +# Subtest: Conjunction fails when items match different lengths + # / .& cd/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 10 - Conjunction fails when items match different lengths +# Subtest: Sequence needs one thing to match after the other (pass case) + # / .d/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 11 - Sequence needs one thing to match after the other (pass case) +# Subtest: Sequence needs one thing to match after the other (failure case) + # / .a/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 12 - Sequence needs one thing to match after the other (failure case) +# Subtest: Beginning of string anchor works (pass case) + # / ^ ./ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 13 - Beginning of string anchor works (pass case) +# Subtest: Beginning of string anchor works (failure case) + # / ^ b/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 14 - Beginning of string anchor works (failure case) +# Subtest: Beginning of line anchor works (pass case) + # / ^^ ./ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 15 - Beginning of line anchor works (pass case) +# Subtest: Beginning of line anchor works (failure case) + # / ^^ b/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 16 - Beginning of line anchor works (failure case) +# Subtest: End of string anchor works (pass case) + # / .$ / + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 17 - End of string anchor works (pass case) +# Subtest: End of string anchor works (failure case) + # / b$ / + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 18 - End of string anchor works (failure case) +# Subtest: End of line anchor works (pass case) + # / .$$ / + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 19 - End of line anchor works (pass case) +# Subtest: End of line anchor works (failure case) + # / b$$ / + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 20 - End of line anchor works (failure case) +# Subtest: Right word boundary works + # / .e>> / + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - AST: fail case + ok 4 - Str: pass case + ok 5 - Str: fail case + ok 6 - Raku: pass case + ok 7 - Raku: fail case + 1..7 +ok 21 - Right word boundary works +# Subtest: Left word boundary works + # / << .t/ + ok 1 - deparse + ok 2 - AST: pass case + ok 3 - AST: fail case + ok 4 - Str: pass case + ok 5 - Str: fail case + ok 6 - Raku: pass case + ok 7 - Raku: fail case + 1..7 +ok 22 - Left word boundary works +# Subtest: Quantified + built-in character class matches + # / \d+/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 23 - Quantified + built-in character class matches +# Subtest: Quantified * built-in character class matches + # / \d*/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 24 - Quantified * built-in character class matches +# Subtest: Quantified ? built-in character class matches + # / \d?/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 25 - Quantified ? built-in character class matches +# Subtest: Quantified ** built-in character class matches + # / \d** 1^..^5/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 26 - Quantified ** built-in character class matches +# Subtest: Quantified negated built-in character class matches + # / \D+/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 27 - Quantified negated built-in character class matches +# Subtest: Quantified built-in character class matches (frugal mode) + # / \d+?/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 28 - Quantified built-in character class matches (frugal mode) +# Subtest: Quantified negated built-in character class matches (frugal mode) + # / \D+?/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 29 - Quantified negated built-in character class matches (frugal mode) +# Subtest: Greedy quantifier will backtrack + # / ^ \d+!9/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 30 - Greedy quantifier will backtrack +# Subtest: Ratchet quantifier will not backtrack + # / ^ \d+:9/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 31 - Ratchet quantifier will not backtrack +# Subtest: Separator works (non-trailing case) + # / \d+% ","/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 32 - Separator works (non-trailing case) +# Subtest: Separator works (trailing case) + # / \d+%% ","/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 33 - Separator works (trailing case) +# Subtest: Separator must be between every quantified item + # / \d+% ","/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 34 - Separator must be between every quantified item +# Subtest: Regex groups compile correctly + # / [\d+]+% ","/ + ok 1 - deparse + ok 2 - AST: did we get correct match + ok 3 - AST: no positional captures from non-capturing group + ok 4 - AST: no named captures from non-capturing group + ok 5 - Str: did we get correct match + ok 6 - Str: no positional captures from non-capturing group + ok 7 - Str: no named captures from non-capturing group + ok 8 - Raku: did we get correct match + ok 9 - Raku: no positional captures from non-capturing group + ok 10 - Raku: no named captures from non-capturing group + 1..10 +ok 35 - Regex groups compile correctly +# Subtest: Regex with two positional capturing groups matches correctly + # / (\w)\d(\w)/ + ok 1 - deparse + ok 2 - AST: did we get correct match + ok 3 - AST: Two positional captures + ok 4 - AST: First positional capture is correct + ok 5 - AST: Second positional capture is correct + ok 6 - AST: No named captures + ok 7 - Str: did we get correct match + ok 8 - Str: Two positional captures + ok 9 - Str: First positional capture is correct + ok 10 - Str: Second positional capture is correct + ok 11 - Str: No named captures + ok 12 - Raku: did we get correct match + ok 13 - Raku: Two positional captures + ok 14 - Raku: First positional capture is correct + ok 15 - Raku: Second positional capture is correct + ok 16 - Raku: No named captures + 1..16 +ok 36 - Regex with two positional capturing groups matches correctly +# Subtest: Match from and match to markers works + # / b<( \d)> c/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 37 - Match from and match to markers works +# Subtest: Match involving a quoted string literal works + # / lie/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 38 - Match involving a quoted string literal works +# Subtest: Match involving a quoted string with interpolation works + # / "e$end"/ + ok 1 - deparse + ok 2 - EVAL over RakuAST + ok 3 - EVAL over deparsed AST + 1..3 +ok 39 - Match involving a quoted string with interpolation works +# Subtest: Match involving quote words works + # / <{ qqw/link inky linky/ }>/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 40 - Match involving quote words works +# Subtest: Match with positional backreference + # / (o)$0/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 41 - Match with positional backreference +# Subtest: Match with named backreference + # / $=o$/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 42 - Match with named backreference +# Subtest: Match with interpolated variable + # / $expected/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 43 - Match with interpolated variable +# Subtest: Match with block + # / o{ + # is($/, "o", "block") + # }o/ + ok 1 - deparse + # Subtest: matches + 1..6 + ok 1 - block + ok 2 - AST: EVAL is + ok 3 - block + ok 4 - Str: EVAL is + ok 5 - block + ok 6 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 44 - Match with block +# Subtest: Match with variable definition + # / o:my $foo; o/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 45 - Match with variable definition +# Subtest: Match with ignoring case + # / :i oo/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 46 - Match with ignoring case +# Subtest: Match with *not* ignoring case + # / :!i OO/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 47 - Match with *not* ignoring case +# Subtest: No match with *not* ignoring case + # / :!i oo/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 48 - No match with *not* ignoring case +# Subtest: Match with ignoring mark + # / :m oo/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 49 - Match with ignoring mark +# Subtest: Match with *not* ignoring mark + # / :!m ôô/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 50 - Match with *not* ignoring mark +# Subtest: No match with *not* ignoring mark + # / :!m oo/ + ok 1 - deparse + # Subtest: doesn't match + 1..3 + ok 1 - AST: EVAL nok + ok 2 - Str: EVAL nok + ok 3 - Raku: EVAL nok + ok 2 - doesn't match + 1..2 +ok 51 - No match with *not* ignoring mark +# Subtest: Match with ratchet + # / o:r o/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 52 - Match with ratchet +# Subtest: Match without ratchet + # / o:!r o/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 53 - Match without ratchet +# Subtest: Match with sigspace + # / o:s o / + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 54 - Match with sigspace +# Subtest: Match without sigspace + # / o :!s o/ + ok 1 - deparse + # Subtest: matches + 1..3 + ok 1 - AST: EVAL is + ok 2 - Str: EVAL is + ok 3 - Raku: EVAL is + ok 2 - matches + 1..2 +ok 55 - Match without sigspace +ok +t/12-rakuast/role.rakutest ...................................... +1..6 +# Subtest: creating an empty role + # my role Frobnicator { } + ok 1 - deparse + ok 2 - AST: role gets correct name + ok 3 - AST: does the role auto-pun + ok 4 - AST: class gets correct name + ok 5 - AST: can it be instantiated + ok 6 - AST: did the role get consumed + ok 7 - Str: role gets correct name + ok 8 - Str: does the role auto-pun + ok 9 - Str: class gets correct name + ok 10 - Str: can it be instantiated + not ok 11 - Str: did the role get consumed # TODO needs work on consuming the role + # Failed test 'Str: did the role get consumed' + # at t/12-rakuast/role.rakutest line 41 + # Type: Zippo doesn't do role Frobnicator + ok 12 - Raku: role gets correct name + ok 13 - Raku: does the role auto-pun + ok 14 - Raku: class gets correct name + ok 15 - Raku: can it be instantiated + not ok 16 - Raku: did the role get consumed # TODO needs work on consuming the role + # Failed test 'Raku: did the role get consumed' + # at t/12-rakuast/role.rakutest line 41 + # Type: Zippo doesn't do role Frobnicator + 1..16 +ok 1 - creating an empty role +# Subtest: creating a role with an attribute + # my role A { + # has $.a = 42 + # } + ok 1 - deparse + ok 2 - AST: role gets correct name + ok 3 - AST: does the role auto-pun (1) + ok 4 - AST: did the attribute get initialized (1) + ok 5 - AST: does the role auto-pun (2) + ok 6 - AST: did the attribute get initialized (2) + ok 7 - Str: role gets correct name + ok 8 - Str: does the role auto-pun (1) + ok 9 - Str: did the attribute get initialized (1) + ok 10 - Str: does the role auto-pun (2) + ok 11 - Str: did the attribute get initialized (2) + ok 12 - Raku: role gets correct name + ok 13 - Raku: does the role auto-pun (1) + ok 14 - Raku: did the attribute get initialized (1) + ok 15 - Raku: does the role auto-pun (2) + ok 16 - Raku: did the attribute get initialized (2) + 1..16 +ok 2 - creating a role with an attribute +# Subtest: creating a role that does another role + # my role B does Positional { } + ok 1 - deparse + ok 2 - AST: role gets correct name + ok 3 - AST: can we see the roles it does + ok 4 - AST: does the role auto-pun + ok 5 - Str: role gets correct name + ok 6 - Str: can we see the roles it does + ok 7 - Str: does the role auto-pun + ok 8 - Raku: role gets correct name + ok 9 - Raku: can we see the roles it does + ok 10 - Raku: does the role auto-pun + 1..10 +ok 3 - creating a role that does another role +# Subtest: creating a role that does a parameterized role + # my role C does Rational[Int, Int] { } + ok 1 - deparse + ok 2 - AST: role gets correct name + ok 3 - AST: can we see the roles it does + ok 4 - AST: does the role auto-pun + ok 5 - AST: did we get a rational 0 + ok 6 - AST: did we get a rational 1 + ok 7 - AST: did we get a rational 1/3 + ok 8 - Str: role gets correct name + ok 9 - Str: can we see the roles it does + ok 10 - Str: does the role auto-pun + ok 11 - Str: did we get a rational 0 + ok 12 - Str: did we get a rational 1 + ok 13 - Str: did we get a rational 1/3 + ok 14 - Raku: role gets correct name + ok 15 - Raku: can we see the roles it does + ok 16 - Raku: does the role auto-pun + ok 17 - Raku: did we get a rational 0 + ok 18 - Raku: did we get a rational 1 + ok 19 - Raku: did we get a rational 1/3 + 1..19 +ok 4 - creating a role that does a parameterized role +# Subtest: creating a parameterized role + # my role D[$a = 42] { + # method a { + # $a + # } + # } + ok 1 - deparse + ok 2 - AST: role gets correct name + ok 3 - AST: can we see the roles it does + ok 4 - AST: does the role auto-pun (1) + ok 5 - AST: did the default value get set + ok 6 - AST: does the role auto-pun (2) + ok 7 - AST: did the value get set + ok 8 - Str: role gets correct name + ok 9 - Str: can we see the roles it does + ok 10 - Str: does the role auto-pun (1) + ok 11 - Str: did the default value get set + ok 12 - Str: does the role auto-pun (2) + ok 13 - Str: did the value get set + ok 14 - Raku: role gets correct name + ok 15 - Raku: can we see the roles it does + ok 16 - Raku: does the role auto-pun (1) + ok 17 - Raku: did the default value get set + ok 18 - Raku: does the role auto-pun (2) + ok 19 - Raku: did the value get set + 1..19 +ok 5 - creating a parameterized role +# Subtest: creating a parameterized role with a type capture + # my role E[::T = Str] { + # method a (T:D $a) { + # $a + # } + # } + ok 1 - deparse + ok 2 - AST: role gets correct name + ok 3 - AST: can we see the roles it does + ok 4 - AST: does the role auto-pun (1) + ok 5 - AST: value returned (1) + ok 6 - AST: does uninstantiated type die (1) # TODO :D not yet being applied in type check + ok 7 - AST: does incorrect type die (1) + ok 8 - AST: does the role auto-pun (2) + ok 9 - AST: value returned (2) + ok 10 - AST: does uninstantiated type die (2) # TODO :D not yet being applied in type check + ok 11 - AST: does incorrect type die (2) + ok 12 - Str: role gets correct name + ok 13 - Str: can we see the roles it does + ok 14 - Str: does the role auto-pun (1) + ok 15 - Str: value returned (1) + ok 16 - Str: does uninstantiated type die (1) # TODO :D not yet being applied in type check + ok 17 - Str: does incorrect type die (1) + ok 18 - Str: does the role auto-pun (2) + ok 19 - Str: value returned (2) + ok 20 - Str: does uninstantiated type die (2) # TODO :D not yet being applied in type check + ok 21 - Str: does incorrect type die (2) + ok 22 - Raku: role gets correct name + ok 23 - Raku: can we see the roles it does + ok 24 - Raku: does the role auto-pun (1) + ok 25 - Raku: value returned (1) + ok 26 - Raku: does uninstantiated type die (1) # TODO :D not yet being applied in type check + ok 27 - Raku: does incorrect type die (1) + ok 28 - Raku: does the role auto-pun (2) + ok 29 - Raku: value returned (2) + ok 30 - Raku: does uninstantiated type die (2) # TODO :D not yet being applied in type check + ok 31 - Raku: does incorrect type die (2) + 1..31 +ok 6 - creating a parameterized role with a type capture +ok +t/12-rakuast/signature.rakutest ................................. +1..13 +# Subtest: Default type for block and routine + # sub ($param) { } + ok 1 - deparse + ok 2 - AST: Default type of sub + ok 3 - Str: Default type of sub + ok 4 - Raku: Default type of sub + 1..4 +ok 1 - Default type for block and routine +# Subtest: Default type for block and routine + # -> $param { } + ok 1 - deparse + ok 2 - AST: Default type of block + ok 3 - Str: Default type of block + ok 4 - Raku: Default type of block + 1..4 +ok 2 - Default type for block and routine +# Subtest: Type constraint is enforced on Scalar + # sub (Int $x) { } + ok 1 - deparse + ok 2 - AST: Specified type is introspectable + ok 3 - AST: Passing correct type lives + ok 4 - AST: Passing wrong type dies + ok 5 - Str: Specified type is introspectable + ok 6 - Str: Passing correct type lives + ok 7 - Str: Passing wrong type dies + ok 8 - Raku: Specified type is introspectable + ok 9 - Raku: Passing correct type lives + ok 10 - Raku: Passing wrong type dies + 1..10 +ok 3 - Type constraint is enforced on Scalar +# Subtest: Anonymous parameter still enforces type constraint + # sub (Int) { } + ok 1 - deparse + ok 2 - AST: Specified type is introspectable + ok 3 - AST: Passing correct type lives + ok 4 - AST: Passing wrong type dies + ok 5 - Str: Specified type is introspectable + ok 6 - Str: Passing correct type lives + ok 7 - Str: Passing wrong type dies + ok 8 - Raku: Specified type is introspectable + ok 9 - Raku: Passing correct type lives + ok 10 - Raku: Passing wrong type dies + 1..10 +ok 4 - Anonymous parameter still enforces type constraint +# Subtest: Optional Scalar parameter defaults to type object + # sub (Int $x?) { + # $x + # } + ok 1 - deparse + ok 2 - AST: Parameter introspects as optional + ok 3 - AST: Correct arity + ok 4 - AST: Correct count + ok 5 - AST: Passing an argument gets the value + ok 6 - AST: Passing no argument gets the type object + ok 7 - Str: Parameter introspects as optional + ok 8 - Str: Correct arity + ok 9 - Str: Correct count + ok 10 - Str: Passing an argument gets the value + ok 11 - Str: Passing no argument gets the type object + ok 12 - Raku: Parameter introspects as optional + ok 13 - Raku: Correct arity + ok 14 - Raku: Correct count + ok 15 - Raku: Passing an argument gets the value + ok 16 - Raku: Passing no argument gets the type object + 1..16 +ok 5 - Optional Scalar parameter defaults to type object +# Subtest: One required named parameter + # sub (:$named!) { + # $named + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 0 arity + ok 4 - AST: The block has 0 count + ok 5 - AST: Correct variable name + ok 6 - AST: Correct named name + ok 7 - AST: It is not optional + ok 8 - AST: Invoking the sub with a named argument works + ok 9 - AST: Invoking the sub without an argument dies + ok 10 - Str: Sub has one params elem + ok 11 - Str: The block has 0 arity + ok 12 - Str: The block has 0 count + ok 13 - Str: Correct variable name + ok 14 - Str: Correct named name + ok 15 - Str: It is not optional + ok 16 - Str: Invoking the sub with a named argument works + ok 17 - Str: Invoking the sub without an argument dies + ok 18 - Raku: Sub has one params elem + ok 19 - Raku: The block has 0 arity + ok 20 - Raku: The block has 0 count + ok 21 - Raku: Correct variable name + ok 22 - Raku: Correct named name + ok 23 - Raku: It is not optional + ok 24 - Raku: Invoking the sub with a named argument works + ok 25 - Raku: Invoking the sub without an argument dies + 1..25 +ok 6 - One required named parameter +# Subtest: Required named parameter with alias + # sub (:first(:fst($var))!) { + # $var + # } + ok 1 - deparse + ok 2 - AST: Sub has one params elem + ok 3 - AST: The block has 0 arity + ok 4 - AST: The block has 0 count + ok 5 - AST: Correct variable name + ok 6 - AST: Correct named names + ok 7 - AST: It is not optional + ok 8 - AST: Invoking the sub with first alias works + ok 9 - AST: Invoking the sub with second alias works + ok 10 - AST: Invoking the sub without an argument dies + ok 11 - AST: Invoking the sub with non-named name dies + ok 12 - Str: Sub has one params elem + ok 13 - Str: The block has 0 arity + ok 14 - Str: The block has 0 count + ok 15 - Str: Correct variable name + ok 16 - Str: Correct named names + ok 17 - Str: It is not optional + ok 18 - Str: Invoking the sub with first alias works + ok 19 - Str: Invoking the sub with second alias works + ok 20 - Str: Invoking the sub without an argument dies + ok 21 - Str: Invoking the sub with non-named name dies + ok 22 - Raku: Sub has one params elem + ok 23 - Raku: The block has 0 arity + ok 24 - Raku: The block has 0 count + ok 25 - Raku: Correct variable name + ok 26 - Raku: Correct named names + ok 27 - Raku: It is not optional + ok 28 - Raku: Invoking the sub with first alias works + ok 29 - Raku: Invoking the sub with second alias works + ok 30 - Raku: Invoking the sub without an argument dies + ok 31 - Raku: Invoking the sub with non-named name dies + 1..31 +ok 7 - Required named parameter with alias +# Subtest: Slurpy hash parameter + # sub (*%h) { + # %h + # } + ok 1 - deparse + ok 2 - AST: Parameter introspects as slurpy + ok 3 - AST: Parameter introspects as named + ok 4 - AST: Correct arity + ok 5 - AST: Correct count + ok 6 - AST: Passing no argument gets empty hash + ok 7 - AST: Passing one named argument has correct hash + ok 8 - AST: Passing two named arguments has correct hash + ok 9 - Str: Parameter introspects as slurpy + ok 10 - Str: Parameter introspects as named + ok 11 - Str: Correct arity + ok 12 - Str: Correct count + ok 13 - Str: Passing no argument gets empty hash + ok 14 - Str: Passing one named argument has correct hash + ok 15 - Str: Passing two named arguments has correct hash + ok 16 - Raku: Parameter introspects as slurpy + ok 17 - Raku: Parameter introspects as named + ok 18 - Raku: Correct arity + ok 19 - Raku: Correct count + ok 20 - Raku: Passing no argument gets empty hash + ok 21 - Raku: Passing one named argument has correct hash + ok 22 - Raku: Passing two named arguments has correct hash + 1..22 +ok 8 - Slurpy hash parameter +# Subtest: Slurpy flattening array parameter + # sub (*@a) { + # @a + # } + ok 1 - deparse + ok 2 - AST: Parameter introspects as slurpy + ok 3 - AST: Parameter does not introspect as named + ok 4 - AST: Correct arity + ok 5 - AST: Correct count + ok 6 - AST: Passing no argument gets empty array + ok 7 - AST: Passing one argument has correct array + ok 8 - AST: Passing two arguments has correct array + ok 9 - AST: Flattening happens + ok 10 - Str: Parameter introspects as slurpy + ok 11 - Str: Parameter does not introspect as named + ok 12 - Str: Correct arity + ok 13 - Str: Correct count + ok 14 - Str: Passing no argument gets empty array + ok 15 - Str: Passing one argument has correct array + ok 16 - Str: Passing two arguments has correct array + ok 17 - Str: Flattening happens + ok 18 - Raku: Parameter introspects as slurpy + ok 19 - Raku: Parameter does not introspect as named + ok 20 - Raku: Correct arity + ok 21 - Raku: Correct count + ok 22 - Raku: Passing no argument gets empty array + ok 23 - Raku: Passing one argument has correct array + ok 24 - Raku: Passing two arguments has correct array + ok 25 - Raku: Flattening happens + 1..25 +ok 9 - Slurpy flattening array parameter +# Subtest: Slurpy non-flattening array parameter + # sub (**@a) { + # @a + # } + ok 1 - deparse + ok 2 - AST: Parameter introspects as slurpy + ok 3 - AST: Parameter does not introspect as named + ok 4 - AST: Correct arity + ok 5 - AST: Correct count + ok 6 - AST: Passing no argument gets empty array + ok 7 - AST: Passing one argument has correct array + ok 8 - AST: Passing two arguments has correct array + ok 9 - AST: Flattening does not happen + ok 10 - AST: Passing a list results in one-element array with the list + ok 11 - Str: Parameter introspects as slurpy + ok 12 - Str: Parameter does not introspect as named + ok 13 - Str: Correct arity + ok 14 - Str: Correct count + ok 15 - Str: Passing no argument gets empty array + ok 16 - Str: Passing one argument has correct array + ok 17 - Str: Passing two arguments has correct array + ok 18 - Str: Flattening does not happen + ok 19 - Str: Passing a list results in one-element array with the list + ok 20 - Raku: Parameter introspects as slurpy + ok 21 - Raku: Parameter does not introspect as named + ok 22 - Raku: Correct arity + ok 23 - Raku: Correct count + ok 24 - Raku: Passing no argument gets empty array + ok 25 - Raku: Passing one argument has correct array + ok 26 - Raku: Passing two arguments has correct array + ok 27 - Raku: Flattening does not happen + ok 28 - Raku: Passing a list results in one-element array with the list + 1..28 +ok 10 - Slurpy non-flattening array parameter +# Subtest: Slurpy single arg rule array parameter + # sub (+@a) { + # @a + # } + ok 1 - deparse + ok 2 - AST: Parameter introspects as slurpy + ok 3 - AST: Parameter does not introspect as named + ok 4 - AST: Correct arity + ok 5 - AST: Correct count + ok 6 - AST: Passing no argument gets empty array + ok 7 - AST: Passing one argument has correct array + ok 8 - AST: Passing two arguments has correct array + ok 9 - AST: Flattening does not happen + ok 10 - AST: Passing a list is treated as the single argument + ok 11 - Str: Parameter introspects as slurpy + ok 12 - Str: Parameter does not introspect as named + ok 13 - Str: Correct arity + ok 14 - Str: Correct count + ok 15 - Str: Passing no argument gets empty array + ok 16 - Str: Passing one argument has correct array + ok 17 - Str: Passing two arguments has correct array + ok 18 - Str: Flattening does not happen + ok 19 - Str: Passing a list is treated as the single argument + ok 20 - Raku: Parameter introspects as slurpy + ok 21 - Raku: Parameter does not introspect as named + ok 22 - Raku: Correct arity + ok 23 - Raku: Correct count + ok 24 - Raku: Passing no argument gets empty array + ok 25 - Raku: Passing one argument has correct array + ok 26 - Raku: Passing two arguments has correct array + ok 27 - Raku: Flattening does not happen + ok 28 - Raku: Passing a list is treated as the single argument + 1..28 +ok 11 - Slurpy single arg rule array parameter +# Subtest: Sigilless parameter + # sub (Int \trm) { + # trm + # } + ok 1 - deparse + ok 2 - AST: Type is introspectable + ok 3 - AST: The name matches + ok 4 - AST: The term can be resolved in the sub + ok 5 - AST: Passing wrong type dies + ok 6 - Str: Type is introspectable + ok 7 - Str: The name matches + ok 8 - Str: The term can be resolved in the sub + ok 9 - Str: Passing wrong type dies + ok 10 - Raku: Type is introspectable + ok 11 - Raku: The name matches + ok 12 - Raku: The term can be resolved in the sub + ok 13 - Raku: Passing wrong type dies + 1..13 +ok 12 - Sigilless parameter +# Subtest: Capture parameter + # sub (|c) { + # c + # } + ok 1 - deparse + ok 2 - AST: Parameter introspects as a capture + ok 3 - AST: Correct arity + ok 4 - AST: Correct count + ok 5 - AST: Passing no argument gets empty capture + ok 6 - AST: Passing positional arguments gets correct capture + ok 7 - AST: Flattening does not happen + ok 8 - AST: Passing named arguments gets correct capture + ok 9 - AST: Passing a mix of positional and named arguments gets correct capture + ok 10 - Str: Parameter introspects as a capture + ok 11 - Str: Correct arity + ok 12 - Str: Correct count + ok 13 - Str: Passing no argument gets empty capture + ok 14 - Str: Passing positional arguments gets correct capture + ok 15 - Str: Flattening does not happen + ok 16 - Str: Passing named arguments gets correct capture + ok 17 - Str: Passing a mix of positional and named arguments gets correct capture + ok 18 - Raku: Parameter introspects as a capture + ok 19 - Raku: Correct arity + ok 20 - Raku: Correct count + ok 21 - Raku: Passing no argument gets empty capture + ok 22 - Raku: Passing positional arguments gets correct capture + ok 23 - Raku: Flattening does not happen + ok 24 - Raku: Passing named arguments gets correct capture + ok 25 - Raku: Passing a mix of positional and named arguments gets correct capture + 1..25 +ok 13 - Capture parameter +ok +t/12-rakuast/statement-mods.rakutest ............................ +1..14 +# Subtest: The postfix "if" statement works with a true expression + # 42 if 666 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - The postfix "if" statement works with a true expression +# Subtest: The postfix "if" statement works with a false expression + # 42 if "" + ok 1 - deparse + ok 2 - AST + ok 3 - AST + ok 4 - AST + 1..4 +ok 2 - The postfix "if" statement works with a false expression +# Subtest: The postfix "unless" statement works with a false expression + # 42 unless "" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - The postfix "unless" statement works with a false expression +# Subtest: The postfix "unless" statement works with a true expression + # 42 unless 666 + ok 1 - deparse + ok 2 - AST + ok 3 - AST + ok 4 - AST + 1..4 +ok 4 - The postfix "unless" statement works with a true expression +# Subtest: The postfix "with" statement works with defined expression + # $_ * 2 with 42 + ok 1 - deparse +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_17: +Useless use of "*" in expression "$_ * 2" in sink context (line 1) + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - The postfix "with" statement works with defined expression +# Subtest: The postfix "with" statement works with a type object + # $_ * 2 with Int + ok 1 - deparse + ok 2 - AST +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_21: +Useless use of "*" in expression "$_ * 2" in sink context (line 1) + ok 3 - AST + ok 4 - AST + 1..4 +ok 6 - The postfix "with" statement works with a type object +# Subtest: The postfix "without" statement works with defined expression + # $_ * 2 without 42 + ok 1 - deparse + ok 2 - AST +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_25: +Useless use of "*" in expression "$_ * 2" in sink context (line 1) + ok 3 - AST + ok 4 - AST + 1..4 +ok 7 - The postfix "without" statement works with defined expression +# Subtest: The postfix "given" statement works with defined expression + # $_ * 2 given 42 + ok 1 - deparse +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_29: +Useless use of "*" in expression "$_ * 2" in sink context (line 1) + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - The postfix "given" statement works with defined expression +# Subtest: The postfix "without" statement works with a type object + # .Str without Int + ok 1 - deparse +Use of uninitialized value of type Int in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at t/12-rakuast/statement-mods.rakutest line 187 +Use of uninitialized value of type Int in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at EVAL_33 line 1 +Use of uninitialized value of type Int in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at t/12-rakuast/statement-mods.rakutest line 187 + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - The postfix "without" statement works with a type object +# Subtest: The postfix "when" statement works + # $_ = 42; + # 666 when 42 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - The postfix "when" statement works +# Subtest: The postfix "given" statement works with a type object + # .Str given Int + ok 1 - deparse +Use of uninitialized value of type Int in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at t/12-rakuast/statement-mods.rakutest line 235 +Use of uninitialized value of type Int in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at EVAL_41 line 1 +Use of uninitialized value of type Int in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at t/12-rakuast/statement-mods.rakutest line 235 + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - The postfix "given" statement works with a type object +# Subtest: The postfix "while" statement works + # ++$foo while $foo < 5 + ok 1 - deparse + ok 2 - AST + ok 3 - AST + ok 4 - Str + ok 5 - Str + ok 6 - Raku + ok 7 - Raku + 1..7 +ok 12 - The postfix "while" statement works +# Subtest: The postfix "until" statement works + # ++$foo until $foo >= 5 + ok 1 - deparse + ok 2 - AST + ok 3 - + ok 4 - Str + ok 5 - + ok 6 - Raku + ok 7 - + 1..7 +ok 13 - The postfix "until" statement works +# Subtest: The postfix "for" statement works + # ++$foo for 1 .. 5 + ok 1 - deparse + ok 2 - AST + ok 3 - AST + ok 4 - Str + ok 5 - Str + ok 6 - Raku + ok 7 - Raku + 1..7 +ok 14 - The postfix "for" statement works +ok +t/12-rakuast/statement-phaser.rakutest .......................... +1..36 +# Subtest: BEGIN phaser producing a literal expression works + # BEGIN 12 + ok 1 - deparse + ok 2 - # SKIP BEGIN phaser is having some issues yet + ok 3 - # SKIP BEGIN phaser is having some issues yet + 1..3 +ok 1 - BEGIN phaser producing a literal expression works +# Subtest: Block with CATCH/default handles exception and evaluates to Nil + # { + # CATCH { + # default { + # $handled++ + # } + # } + # die("oops") + # } + ok 1 - deparse + ok 2 - AST: block with CATCH/default handles exception, evaluates to Nil + ok 3 - AST: the exception handler ran once + ok 4 - AST: $! in the outer scope has the exception + ok 5 - Str: block with CATCH/default handles exception, evaluates to Nil + ok 6 - Str: the exception handler ran once + ok 7 - Str: $! in the outer scope has the exception + ok 8 - Raku: block with CATCH/default handles exception, evaluates to Nil + ok 9 - Raku: the exception handler ran once + ok 10 - Raku: $! in the outer scope has the exception + 1..10 +ok 2 - Block with CATCH/default handles exception and evaluates to Nil +# Subtest: Exception is rethrown if unhandled + # { + # CATCH { } + # die("gosh") + # } + ok 1 - deparse + # Subtest: AST: exception is rethrown if unhandled + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::AdHoc) + ok 3 - .message matches /gosh/ + ok 2 - AST: exception is rethrown if unhandled + # Subtest: Str: exception is rethrown if unhandled + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::AdHoc) + ok 3 - .message matches /gosh/ + ok 3 - Str: exception is rethrown if unhandled + # Subtest: Raku: exception is rethrown if unhandled + 1..3 + ok 1 - code dies + ok 2 - right exception type (X::AdHoc) + ok 3 - .message matches /gosh/ + ok 4 - Raku: exception is rethrown if unhandled + 1..4 +ok 3 - Exception is rethrown if unhandled +# Subtest: CONTROL phaser catching a warning + # CONTROL { + # isa-ok($_, CX::Warn); + # .resume + # } + # warn(); + # 42 + 1..7 + ok 1 - deparse + ok 2 - The object is-a 'CX::Warn' + ok 3 - The object is-a 'CX::Warn' + ok 4 - The object is-a 'CX::Warn' + ok 5 - AST + ok 6 - Str + ok 7 - Raku +ok 4 - CONTROL phaser catching a warning +# Subtest: CATCH phaser catching an exception + # CATCH { + # todo("Getting a warning instead of an exception???"); + # isa-ok($_, X::AdHoc); + # .resume + # } + # die(); + # 666 + 1..7 + ok 1 - deparse + not ok 2 - The object is-a 'X::AdHoc' # TODO Getting a warning instead of an exception??? + # Failed test 'The object is-a 'X::AdHoc'' + # at SETTING::src/core.c/Exception.rakumod line 65 + # Actual type: CX::Warn + not ok 3 - The object is-a 'X::AdHoc' # TODO Getting a warning instead of an exception??? + # Failed test 'The object is-a 'X::AdHoc'' + # at EVAL_14 line 3 + # Actual type: CX::Warn + not ok 4 - The object is-a 'X::AdHoc' # TODO Getting a warning instead of an exception??? + # Failed test 'The object is-a 'X::AdHoc'' + # at SETTING::src/core.c/Exception.rakumod line 65 + # Actual type: CX::Warn + ok 5 - AST + ok 6 - Str + ok 7 - Raku +ok 5 - CATCH phaser catching an exception +# Subtest: Block with INIT phaser thunk + # -> { + # INIT ++$init + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: INIT actually ran + ok 4 - AST: INIT phaser returns expression + ok 5 - Str: did we get a Block + ok 6 - Str: INIT actually ran + ok 7 - Str: INIT phaser returns expression + ok 8 - Raku: did we get a Block + ok 9 - Raku: INIT actually ran + ok 10 - Raku: INIT phaser returns expression + 1..10 +ok 6 - Block with INIT phaser thunk +# Subtest: Block with INIT phaser block + # -> { + # INIT { + # ++$init; + # 42 + # } + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: INIT actually ran + ok 4 - AST: INIT phaser returns expression + ok 5 - Str: did we get a Block + ok 6 - Str: INIT actually ran + ok 7 - Str: INIT phaser returns expression + ok 8 - Raku: did we get a Block + ok 9 - Raku: INIT actually ran + ok 10 - Raku: INIT phaser returns expression + 1..10 +ok 7 - Block with INIT phaser block +# Subtest: Block with ENTER phaser thunk + # -> { + # ENTER ++$enter + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: ENTER phaser returns expression + ok 4 - AST: ENTER actually ran + ok 5 - Str: did we get a Block + ok 6 - Str: ENTER phaser returns expression + ok 7 - Str: ENTER actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: ENTER phaser returns expression + ok 10 - Raku: ENTER actually ran + 1..10 +ok 8 - Block with ENTER phaser thunk +# Subtest: Block with ENTER phaser block + # -> { + # ENTER { + # ++$enter; + # 42 + # } + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: ENTER phaser returns expression + ok 4 - AST: ENTER actually ran + ok 5 - Str: did we get a Block + ok 6 - Str: ENTER phaser returns expression + ok 7 - Str: ENTER actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: ENTER phaser returns expression + ok 10 - Raku: ENTER actually ran + 1..10 +ok 9 - Block with ENTER phaser block +# Subtest: LEAVE phaser thunk being run + # { + # $done = False; + # LEAVE pass("leaving"); + # $done = True + # } + 1..10 + ok 1 - deparse + ok 2 - leaving + ok 3 - AST: result correct + ok 4 - AST: did block run to completion + ok 5 - leaving + ok 6 - Str: result correct + ok 7 - Str: did block run to completion + ok 8 - leaving + ok 9 - Raku: result correct + ok 10 - Raku: did block run to completion +ok 10 - LEAVE phaser thunk being run +# Subtest: LEAVE phaser block being run + # { + # $done = False; + # LEAVE { + # pass("leaving") + # } + # $done = True + # } + 1..10 + ok 1 - deparse + ok 2 - leaving + ok 3 - AST: result correct + ok 4 - AST: did block run to completion + ok 5 - leaving + ok 6 - Str: result correct + ok 7 - Str: did block run to completion + ok 8 - leaving + ok 9 - Raku: result correct + ok 10 - Raku: did block run to completion +ok 11 - LEAVE phaser block being run +# Subtest: KEEP / UNDO phaser thunk successful exit + # -> { + # KEEP ++$keep; + # UNDO ++$undo; + # 42 + # } + ok 1 - deparse + ok 2 - AST: KEEP did *not* run yet + ok 3 - AST: UNDO did *not* run yet + ok 4 - AST: did we get a Block + ok 5 - AST: exited block correctly + ok 6 - AST: KEEP actually ran + ok 7 - AST: UNDO did *not* run + ok 8 - Str: KEEP did *not* run yet + ok 9 - Str: UNDO did *not* run yet + ok 10 - Str: did we get a Block + ok 11 - Str: exited block correctly + ok 12 - Str: KEEP actually ran + ok 13 - Str: UNDO did *not* run + ok 14 - Raku: KEEP did *not* run yet + ok 15 - Raku: UNDO did *not* run yet + ok 16 - Raku: did we get a Block + ok 17 - Raku: exited block correctly + ok 18 - Raku: KEEP actually ran + ok 19 - Raku: UNDO did *not* run + 1..19 +ok 12 - KEEP / UNDO phaser thunk successful exit +# Subtest: KEEP / UNDO phaser block successful exit + # -> { + # KEEP { + # ++$keep + # } + # UNDO { + # ++$undo + # } + # 42 + # } + ok 1 - deparse + ok 2 - AST: KEEP did *not* run yet + ok 3 - AST: UNDO did *not* run yet + ok 4 - AST: did we get a Block + ok 5 - AST: exited block correctly + ok 6 - AST: KEEP actually ran + ok 7 - AST: UNDO did *not* run + ok 8 - Str: KEEP did *not* run yet + ok 9 - Str: UNDO did *not* run yet + ok 10 - Str: did we get a Block + ok 11 - Str: exited block correctly + ok 12 - Str: KEEP actually ran + ok 13 - Str: UNDO did *not* run + ok 14 - Raku: KEEP did *not* run yet + ok 15 - Raku: UNDO did *not* run yet + ok 16 - Raku: did we get a Block + ok 17 - Raku: exited block correctly + ok 18 - Raku: KEEP actually ran + ok 19 - Raku: UNDO did *not* run + 1..19 +ok 13 - KEEP / UNDO phaser block successful exit +# Subtest: KEEP / UNDO phaser thunk UNsuccessful exit + # -> { + # KEEP ++$keep; + # UNDO ++$undo; + # Int + # } + ok 1 - deparse + ok 2 - AST: KEEP did *not* run yet + ok 3 - AST: UNDO did *not* run yet + ok 4 - AST: did we get a Block + ok 5 - AST: exited block correctly + ok 6 - AST: KEEP did *not* run + ok 7 - AST: UNDO actually ran + ok 8 - Str: KEEP did *not* run yet + ok 9 - Str: UNDO did *not* run yet + ok 10 - Str: did we get a Block + ok 11 - Str: exited block correctly + ok 12 - Str: KEEP did *not* run + ok 13 - Str: UNDO actually ran + ok 14 - Raku: KEEP did *not* run yet + ok 15 - Raku: UNDO did *not* run yet + ok 16 - Raku: did we get a Block + ok 17 - Raku: exited block correctly + ok 18 - Raku: KEEP did *not* run + ok 19 - Raku: UNDO actually ran + 1..19 +ok 14 - KEEP / UNDO phaser thunk UNsuccessful exit +# Subtest: KEEP / UNDO phaser block UNsuccessful exit + # -> { + # KEEP { + # ++$keep + # } + # UNDO { + # ++$undo + # } + # Int + # } + ok 1 - deparse + ok 2 - AST: KEEP did *not* run yet + ok 3 - AST: UNDO did *not* run yet + ok 4 - AST: did we get a Block + ok 5 - AST: exited block correctly + ok 6 - AST: KEEP did *not* run + ok 7 - AST: UNDO actually ran + ok 8 - Str: KEEP did *not* run yet + ok 9 - Str: UNDO did *not* run yet + ok 10 - Str: did we get a Block + ok 11 - Str: exited block correctly + ok 12 - Str: KEEP did *not* run + ok 13 - Str: UNDO actually ran + ok 14 - Raku: KEEP did *not* run yet + ok 15 - Raku: UNDO did *not* run yet + ok 16 - Raku: did we get a Block + ok 17 - Raku: exited block correctly + ok 18 - Raku: KEEP did *not* run + ok 19 - Raku: UNDO actually ran + 1..19 +ok 15 - KEEP / UNDO phaser block UNsuccessful exit +# Subtest: END phaser thunk being run + # END pass("leaving END thunk") + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 16 - END phaser thunk being run +# Subtest: END phaser block being run + # END { + # pass("leaving END block") + # } + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 17 - END phaser block being run +# Subtest: For loop with FIRST phaser thunk + # for ^3 { + # FIRST is-deeply($run, 0, "inside FIRST"); + # FIRST ++$run + # } + 1..10 + ok 1 - deparse + ok 2 - inside FIRST + ok 3 - AST: for loop evaluates to Nil + ok 4 - AST: did second FIRST run once + ok 5 - inside FIRST + ok 6 - Str: for loop evaluates to Nil + ok 7 - Str: did second FIRST run once + ok 8 - inside FIRST + ok 9 - Raku: for loop evaluates to Nil + ok 10 - Raku: did second FIRST run once +ok 18 - For loop with FIRST phaser thunk +# Subtest: For loop with FIRST phaser block + # for ^3 { + # FIRST { + # is-deeply($run, 0, "inside FIRST") + # } + # ++$run + # } + 1..7 + ok 1 - deparse + ok 2 - inside FIRST + ok 3 - AST: for loop evaluates to Nil + ok 4 - inside FIRST + ok 5 - Str: for loop evaluates to Nil + ok 6 - inside FIRST + ok 7 - Raku: for loop evaluates to Nil +ok 19 - For loop with FIRST phaser block +# Subtest: While loop with FIRST phaser block and return value + # while $guard { + # $result = FIRST { + # is-deeply($run, 0, "inside FIRST"); + # $guard = False + # } + # ++$run + # } + 1..13 + ok 1 - deparse + ok 2 - inside FIRST + ok 3 - AST: while loop evaluates to Nil + ok 4 - AST: FIRST returns a value + ok 5 - AST: loop block ran + ok 6 - inside FIRST + not ok 7 - Str: while loop evaluates to Nil # TODO Depends on Raku grammar/actions + # Failed test 'Str: while loop evaluates to Nil' + # at t/12-rakuast/statement-phaser.rakutest line 1060 + # expected: Nil + # got: Mu + not ok 8 - Str: FIRST returns a value # TODO Depends on Raku grammar/actions + # Failed test 'Str: FIRST returns a value' + # at t/12-rakuast/statement-phaser.rakutest line 1061 + # expected: Bool::False + # got: Any + ok 9 - Str: loop block ran + ok 10 - inside FIRST + ok 11 - Raku: while loop evaluates to Nil + ok 12 - Raku: FIRST returns a value + ok 13 - Raku: loop block ran +not ok 20 - While loop with FIRST phaser block and return value # TODO Depends on Raku grammar/actions +# Failed test 'While loop with FIRST phaser block and return value' +# at t/12-rakuast/statement-phaser.rakutest line 989 +# Subtest: Subroutine with FIRST phaser block and return value + # sub s { + # $guard = FIRST { + # is-deeply($run, 0, "in FIRST"); + # $guard + 1 + # } + # $run++ + # } + # s() xx 3 + 1..13 + ok 1 - deparse + ok 2 - in FIRST + ok 3 - AST: expression returns as expected + ok 4 - AST: FIRST returns a static value + ok 5 - AST: loop block ran + ok 6 - Str: expression returns as expected + not ok 7 - Str: FIRST returns a static value # TODO Depends on Raku grammar/actions + # Failed test 'Str: FIRST returns a static value' + # at t/12-rakuast/statement-phaser.rakutest line 1157 + # expected: 42 + # got: Any + ok 8 - Str: loop block ran + ok 9 - in FIRST + ok 10 - Raku: expression returns as expected + ok 11 - Raku: FIRST returns a static value + ok 12 - Raku: loop block ran + # You planned 13 tests, but ran 12 +not ok 21 - Subroutine with FIRST phaser block and return value # TODO Depends on Raku grammar/actions +# Failed test 'Subroutine with FIRST phaser block and return value' +# at t/12-rakuast/statement-phaser.rakutest line 1067 +# Subtest: For loop with NEXT / LAST phaser thunk + # for ^3 { + # NEXT ++$next; + # LAST ++$last + # } + ok 1 - deparse + ok 2 - AST: for loop evaluates to Nil + ok 3 - AST: NEXTed expected number of times + ok 4 - AST: LASTed expected number of times + ok 5 - Str: for loop evaluates to Nil + ok 6 - Str: NEXTed expected number of times + ok 7 - Str: LASTed expected number of times + ok 8 - Raku: for loop evaluates to Nil + ok 9 - Raku: NEXTed expected number of times + ok 10 - Raku: LASTed expected number of times + 1..10 +ok 22 - For loop with NEXT / LAST phaser thunk +# Subtest: For loop with NEXT / LAST phaser block + # for ^3 { + # NEXT { + # ++$next + # } + # LAST { + # ++$last + # } + # } + ok 1 - deparse + ok 2 - AST: for loop evaluates to Nil + ok 3 - AST: NEXTed expected number of times + ok 4 - AST: LASTed expected number of times + ok 5 - Str: for loop evaluates to Nil + ok 6 - Str: NEXTed expected number of times + ok 7 - Str: LASTed expected number of times + ok 8 - Raku: for loop evaluates to Nil + ok 9 - Raku: NEXTed expected number of times + ok 10 - Raku: LASTed expected number of times + 1..10 +ok 23 - For loop with NEXT / LAST phaser block +# Subtest: Block with CLOSE phaser thunk + # -> { + # CLOSE ++$close + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + not ok 3 - AST: CLOSE phaser returns Nil # TODO Thunked CLOSE phaser returns expression + # Failed test 'AST: CLOSE phaser returns Nil' + # at t/12-rakuast/statement-phaser.rakutest line 1329 + # expected: Nil + # got: 1 + ok 4 - AST: CLOSE actually ran + ok 5 - Str: did we get a Block + not ok 6 - Str: CLOSE phaser returns Nil # TODO Thunked CLOSE phaser returns expression + # Failed test 'Str: CLOSE phaser returns Nil' + # at t/12-rakuast/statement-phaser.rakutest line 1329 + # expected: Nil + # got: 1 + ok 7 - Str: CLOSE actually ran + ok 8 - Raku: did we get a Block + not ok 9 - Raku: CLOSE phaser returns Nil # TODO Thunked CLOSE phaser returns expression + # Failed test 'Raku: CLOSE phaser returns Nil' + # at t/12-rakuast/statement-phaser.rakutest line 1329 + # expected: Nil + # got: 1 + ok 10 - Raku: CLOSE actually ran + 1..10 +ok 24 - Block with CLOSE phaser thunk +# Subtest: Block with CLOSE phaser block + # -> { + # CLOSE { + # ++$close + # } + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: CLOSE phaser returns Nil # TODO Old implementation returns expression + ok 4 - AST: CLOSE actually ran + ok 5 - Str: did we get a Block + not ok 6 - Str: CLOSE phaser returns Nil # TODO Old implementation returns expression + # Failed test 'Str: CLOSE phaser returns Nil' + # at t/12-rakuast/statement-phaser.rakutest line 1382 + # expected: Nil + # got: 1 + ok 7 - Str: CLOSE actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: CLOSE phaser returns Nil # TODO Old implementation returns expression + ok 10 - Raku: CLOSE actually ran + 1..10 +ok 25 - Block with CLOSE phaser block +# Subtest: Block with QUIT phaser block + # -> { + # QUIT { + # $quit = $_ + # } + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: QUIT phaser returns Nil # TODO Old implementation returns expression + ok 4 - AST: QUIT actually ran + ok 5 - Str: did we get a Block + not ok 6 - Str: QUIT phaser returns Nil # TODO Old implementation returns expression + # Failed test 'Str: QUIT phaser returns Nil' + # at t/12-rakuast/statement-phaser.rakutest line 1438 + # expected: Nil + # got: X::AdHoc.new(payload => "foo") + ok 7 - Str: QUIT actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: QUIT phaser returns Nil # TODO Old implementation returns expression + ok 10 - Raku: QUIT actually ran + 1..10 +ok 26 - Block with QUIT phaser block +# Subtest: Block with PRE phaser thunk + # -> { + # PRE ++$pre + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: PRE phaser does not return expression + ok 4 - AST: PRE actually ran + ok 5 - Str: did we get a Block + ok 6 - Str: PRE phaser does not return expression + ok 7 - Str: PRE actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: PRE phaser does not return expression + ok 10 - Raku: PRE actually ran + ok 11 - AST: did we get a Block + # Subtest: AST: PRE phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches Precondition '++$pre' failed + ok 4 - .phaser matches PRE + ok 12 - AST: PRE phaser throws + ok 13 - Str: did we get a Block + # Subtest: Str: PRE phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .phaser matches PRE + ok 4 - .message matches Precondition '++$pre' failed + ok 14 - Str: PRE phaser throws + ok 15 - Raku: did we get a Block + # Subtest: Raku: PRE phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .phaser matches PRE + ok 4 - .message matches Precondition '++$pre' failed + ok 16 - Raku: PRE phaser throws + 1..16 +ok 27 - Block with PRE phaser thunk +# Subtest: Block with PRE phaser block + # -> { + # PRE { + # ++$pre + # } + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: PRE phaser does not return expression + ok 4 - AST: PRE actually ran + ok 5 - Str: did we get a Block + ok 6 - Str: PRE phaser does not return expression + ok 7 - Str: PRE actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: PRE phaser does not return expression + ok 10 - Raku: PRE actually ran + ok 11 - AST: did we get a Block + # Subtest: AST: PRE phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches / '++$pre' / + ok 4 - .phaser matches PRE + ok 12 - AST: PRE phaser throws + ok 13 - AST: PRE actually ran + ok 14 - Str: did we get a Block + # Subtest: Str: PRE phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches / '++$pre' / + ok 4 - .phaser matches PRE + ok 15 - Str: PRE phaser throws + ok 16 - Str: PRE actually ran + ok 17 - Raku: did we get a Block + # Subtest: Raku: PRE phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches / '++$pre' / + ok 4 - .phaser matches PRE + ok 18 - Raku: PRE phaser throws + ok 19 - Raku: PRE actually ran + 1..19 +ok 28 - Block with PRE phaser block +# Subtest: Block with POST phaser thunk + # -> { + # POST $post = $_; + # $result + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: block returns expression + ok 4 - AST: POST actually ran + ok 5 - Str: did we get a Block + ok 6 - Str: block returns expression + ok 7 - Str: POST actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: block returns expression + ok 10 - Raku: POST actually ran + ok 11 - AST: did we get a Block + # Subtest: AST: POST phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .phaser matches POST + ok 4 - .message matches Postcondition '$post = $_' failed + ok 12 - AST: POST phaser throws + ok 13 - AST: POST actually ran + ok 14 - Str: did we get a Block + # Subtest: Str: POST phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches Postcondition '$post = $_' failed + ok 4 - .phaser matches POST + ok 15 - Str: POST phaser throws + ok 16 - Str: POST actually ran + ok 17 - Raku: did we get a Block + # Subtest: Raku: POST phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches Postcondition '$post = $_' failed + ok 4 - .phaser matches POST + ok 18 - Raku: POST phaser throws + ok 19 - Raku: POST actually ran + 1..19 +ok 29 - Block with POST phaser thunk +# Subtest: Block with POST phaser block + # -> { + # POST { + # $post = $_ + # } + # $result + # } + ok 1 - deparse + ok 2 - AST: did we get a Block + ok 3 - AST: block returns expression + ok 4 - AST: POST actually ran + ok 5 - Str: did we get a Block + ok 6 - Str: block returns expression + ok 7 - Str: POST actually ran + ok 8 - Raku: did we get a Block + ok 9 - Raku: block returns expression + ok 10 - Raku: POST actually ran + ok 11 - AST: did we get a Block + # Subtest: AST: POST phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches / '$post = $_' / + ok 4 - .phaser matches POST + ok 12 - AST: POST phaser throws + ok 13 - AST: POST actually ran + ok 14 - Str: did we get a Block + # Subtest: Str: POST phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches / '$post = $_' / + ok 4 - .phaser matches POST + ok 15 - Str: POST phaser throws + ok 16 - Str: POST actually ran + ok 17 - Raku: did we get a Block + # Subtest: Raku: POST phaser throws + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::Phaser::PrePost) + ok 3 - .message matches / '$post = $_' / + ok 4 - .phaser matches POST + ok 18 - Raku: POST phaser throws + ok 19 - Raku: POST actually ran + 1..19 +ok 30 - Block with POST phaser block +ok 31 - leaving END block +ok 32 - leaving END block +ok 33 - leaving END block +ok 34 - leaving END thunk +ok 35 - leaving END thunk +ok 36 - leaving END thunk +ok +t/12-rakuast/statement-prefix.rakutest .......................... +1..18 +# Subtest: The do statement prefix works with a statement + # do 137 + ok 1 - deparse +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_1: +Useless use of constant integer 137 in sink context (line 1) + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - The do statement prefix works with a statement +# Subtest: The do statement prefix works with a block + # do { + # 199 + # } + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - The do statement prefix works with a block +# Subtest: The quietly statement prefix works + # quietly do-warning() + ok 1 - deparse + ok 2 - AST: with a statement + ok 3 - AST: the warning was suppressed + ok 4 - Str: with a statement + ok 5 - Str: the warning was suppressed + ok 6 - Raku: with a statement + ok 7 - Raku: the warning was suppressed + # quietly { + # do-warning() + # } + ok 8 - deparse + ok 9 - AST: with a block + ok 10 - AST: the warning was suppressed + ok 11 - Str: with a block + ok 12 - Str: the warning was suppressed + ok 13 - Raku: with a block + ok 14 - Raku: the warning was suppressed + 1..14 +ok 3 - The quietly statement prefix works +# Subtest: The gather statement prefix works on a statement + # gather do-takes() + ok 1 - deparse + ok 2 - AST: Got a Seq back from gather (expression form) + ok 3 - The gather is lazy + ok 4 - Gathered the takes + ok 5 - Got correct result from the gather expression + ok 6 - Str: Got a Seq back from gather (expression form) + ok 7 - The gather is lazy + ok 8 - Gathered the takes + ok 9 - Got correct result from the gather expression + ok 10 - Raku: Got a Seq back from gather (expression form) + ok 11 - The gather is lazy + ok 12 - Gathered the takes + ok 13 - Got correct result from the gather expression + 1..13 +ok 4 - The gather statement prefix works on a statement +# Subtest: The gather statement prefix works on a block + # gather { + # do-takes() + # } + ok 1 - deparse + ok 2 - AST: Got a Seq back from gather (block form) + ok 3 - The gather is lazy + ok 4 - Gathered the takes + ok 5 - Got correct result from the gather expression + ok 6 - Str: Got a Seq back from gather (block form) + ok 7 - The gather is lazy + ok 8 - Gathered the takes + ok 9 - Got correct result from the gather expression + ok 10 - Raku: Got a Seq back from gather (block form) + ok 11 - The gather is lazy + ok 12 - Gathered the takes + ok 13 - Got correct result from the gather expression + 1..13 +ok 5 - The gather statement prefix works on a block +# Subtest: The race / hyper / lazy / eager statement prefixes work + # race $c + ok 1 - deparse + ok 2 - AST: race works with statement + ok 3 - AST: context method was called +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_26: +Useless use of $c in sink context (line 1) + ok 4 - Str: race works with statement + ok 5 - Str: context method was called + ok 6 - Raku: race works with statement + ok 7 - Raku: context method was called + # hyper $c + ok 8 - deparse + ok 9 - AST: hyper works with statement + ok 10 - AST: context method was called +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_30: +Useless use of $c in sink context (line 1) + ok 11 - Str: hyper works with statement + ok 12 - Str: context method was called + ok 13 - Raku: hyper works with statement + ok 14 - Raku: context method was called + # lazy $c + ok 15 - deparse + ok 16 - AST: lazy works with statement + ok 17 - AST: context method was called +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_34: +Useless use of $c in sink context (line 1) + ok 18 - Str: lazy works with statement + ok 19 - Str: context method was called + ok 20 - Raku: lazy works with statement + ok 21 - Raku: context method was called + # eager $c + ok 22 - deparse + ok 23 - AST: eager works with statement + ok 24 - AST: context method was called +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_38: +Useless use of $c in sink context (line 1) + ok 25 - Str: eager works with statement + ok 26 - Str: context method was called + ok 27 - Raku: eager works with statement + ok 28 - Raku: context method was called + # race { + # $c + # } + ok 29 - deparse + ok 30 - AST: race works with block + ok 31 - AST: context method was called + ok 32 - Str: race works with block + ok 33 - Str: context method was called + ok 34 - Raku: race works with block + ok 35 - Raku: context method was called + # hyper { + # $c + # } + ok 36 - deparse + ok 37 - AST: hyper works with block + ok 38 - AST: context method was called + ok 39 - Str: hyper works with block + ok 40 - Str: context method was called + ok 41 - Raku: hyper works with block + ok 42 - Raku: context method was called + # lazy { + # $c + # } + ok 43 - deparse + ok 44 - AST: lazy works with block + ok 45 - AST: context method was called + ok 46 - Str: lazy works with block + ok 47 - Str: context method was called + ok 48 - Raku: lazy works with block + ok 49 - Raku: context method was called + # eager { + # $c + # } + ok 50 - deparse + ok 51 - AST: eager works with block + ok 52 - AST: context method was called + ok 53 - Str: eager works with block + ok 54 - Str: context method was called + ok 55 - Raku: eager works with block + ok 56 - Raku: context method was called + 1..56 +ok 6 - The race / hyper / lazy / eager statement prefixes work +# Subtest: try statement prefix with expression producing value results + # try 99 + ok 1 - deparse + ok 2 - AST: correct result + ok 3 - AST: $! is Nil when not exception +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_58: +Useless use of constant integer 99 in sink context (line 1) + ok 4 - Str: correct result +Use of uninitialized value element of type Any in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at t/12-rakuast/statement-prefix.rakutest line 282 + not ok 5 - Str: $! is Nil when not exception # TODO Str: string eval does not set , also in main + # Failed test 'Str: $! is Nil when not exception' + # at t/12-rakuast/statement-prefix.rakutest line 284 + # expected: Nil + # got: Any + ok 6 - Raku: correct result + ok 7 - Raku: $! is Nil when not exception + 1..7 +ok 7 - try statement prefix with expression producing value results +# Subtest: try statement prefix with throwing expression handles the exception + # try die("hard") + ok 1 - deparse + ok 2 - AST: did we get Nil + ok 3 - AST: $! is populated with exception + ok 4 - Str: did we get Nil + ok 5 - Str: $! is populated with exception + ok 6 - Raku: did we get Nil + ok 7 - Raku: $! is populated with exception + 1..7 +ok 8 - try statement prefix with throwing expression handles the exception +# Subtest: try statement prefix with block producing value results + # try { + # 999 + # } + ok 1 - deparse + ok 2 - AST: correct result + ok 3 - AST: $! is Nil when not exception + ok 4 - Str: correct result + not ok 5 - Str: $! is Nil when not exception # TODO Str: string eval does not set $!, also in main + # Failed test 'Str: $! is Nil when not exception' + # at t/12-rakuast/statement-prefix.rakutest line 331 + # expected: Nil + # got: Any + ok 6 - Raku: correct result + ok 7 - Raku: $! is Nil when not exception + 1..7 +ok 9 - try statement prefix with block producing value results +# Subtest: try statement prefix with throwing block handles the exception + # try { + # die("another day") + # } + ok 1 - deparse + ok 2 - AST: did we get Nil + ok 3 - AST: $! is populated with exception + ok 4 - Str: did we get Nil + ok 5 - Str: $! is populated with exception + ok 6 - Raku: did we get Nil + ok 7 - Raku: $! is populated with exception + 1..7 +ok 10 - try statement prefix with throwing block handles the exception +# Subtest: start statement prefix with expression evaluates to Promise + # start 111 + ok 1 - deparse +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_73: +Useless use of constant integer 111 in sink context (line 1) + ok 2 - AST + ok 3 - Correct result from Promise + ok 4 - Str + ok 5 - Correct result from Promise + ok 6 - Raku + ok 7 - Correct result from Promise + 1..7 +ok 11 - start statement prefix with expression evaluates to Promise +# Subtest: start statement prefix with block evaluates to Promise + # start { + # 137 + # } + ok 1 - deparse + ok 2 - AST + ok 3 - Correct result from Promise + ok 4 - Str + ok 5 - Correct result from Promise + ok 6 - Raku + ok 7 - Correct result from Promise + 1..7 +ok 12 - start statement prefix with block evaluates to Promise +# Subtest: A start has a fresh $/ + # start $/ + ok 1 - deparse + ok 2 - AST: A start has a fresh $/ +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_81: +Useless use of $/ in sink context (line 1) + ok 3 - Str: A start has a fresh $/ + ok 4 - Raku: A start has a fresh $/ + 1..4 +ok 13 - A start has a fresh $/ +# Subtest: A start has a fresh $! + # start $! + ok 1 - deparse + ok 2 - AST: A start has a fresh $! +WARNINGS for /build/reproducible-path/rakudo-2024.09/EVAL_85: +Useless use of $! in sink context (line 1) + ok 3 - Str: A start has a fresh $! + ok 4 - Raku: A start has a fresh $! + 1..4 +ok 14 - A start has a fresh $! +# Subtest: supply statement prefix with expression evaluates to Supply + # supply whenever 42 { + # .emit + # } + 1..7 + ok 1 - deparse + ok 2 - AST + ok 3 - emitted value ok + ok 4 - Str + ok 5 - emitted value ok + ok 6 - Raku + ok 7 - emitted value ok +ok 15 - supply statement prefix with expression evaluates to Supply +# Subtest: supply statement prefix with block evaluates to Supply + # supply { + # whenever 42 { + # .emit + # } + # } + 1..7 + ok 1 - deparse + ok 2 - AST + ok 3 - emitted value ok + ok 4 - Str + ok 5 - emitted value ok + ok 6 - Raku + ok 7 - emitted value ok +ok 16 - supply statement prefix with block evaluates to Supply +# Subtest: react statement prefix with expression evaluates to Nil + # react whenever 42 { + # $a = $_ + # } + ok 1 - deparse + ok 2 - AST: is the result Nil + ok 3 - AST: did the code get run + ok 4 - Str: is the result Nil + ok 5 - Str: did the code get run + ok 6 - Raku: is the result Nil + ok 7 - Raku: did the code get run + 1..7 +ok 17 - react statement prefix with expression evaluates to Nil +# Subtest: react statement block with expression evaluates to Nil + # react { + # whenever 42 { + # $a = $_ + # } + # } + ok 1 - deparse + ok 2 - AST: is the result Nil + ok 3 - AST: did the code get run + ok 4 - Str: is the result Nil + ok 5 - Str: did the code get run + ok 6 - Raku: is the result Nil + ok 7 - Raku: did the code get run + 1..7 +ok 18 - react statement block with expression evaluates to Nil +ok +t/12-rakuast/statement.rakutest ................................. +1..29 +# Subtest: Statement list evaluates to its final statement + # ++$x; + # ; + # ++$y + ok 1 - deparse + ok 2 - AST: Statement list evaluates to its final statement + ok 3 - AST: First side-effecting statement was executed + ok 4 - AST: Second side-effecting statement was executed + ok 5 - Str: Statement list evaluates to its final statement + ok 6 - Str: First side-effecting statement was executed + ok 7 - Str: Second side-effecting statement was executed + ok 8 - Raku: Statement list evaluates to its final statement + ok 9 - Raku: First side-effecting statement was executed + ok 10 - Raku: Second side-effecting statement was executed + 1..10 +ok 1 - Statement list evaluates to its final statement +# Subtest: Basic if / elsif / else structure + # if $a { + # 1 + # } + # elsif $b { + # 2 + # } + # elsif $c { + # 3 + # } + # else { + # 4 + # } + ok 1 - deparse + ok 2 - AST: When all conditions False, else is evaluated + ok 3 - AST: Latest elsif reachable when matched + ok 4 - AST: First elsif reachable when matched + ok 5 - AST: When the main condition is true, the then block is picked + ok 6 - Str: When all conditions False, else is evaluated + ok 7 - Str: Latest elsif reachable when matched + ok 8 - Str: First elsif reachable when matched + ok 9 - Str: When the main condition is true, the then block is picked + ok 10 - Raku: When all conditions False, else is evaluated + ok 11 - Raku: Latest elsif reachable when matched + ok 12 - Raku: First elsif reachable when matched + ok 13 - Raku: When the main condition is true, the then block is picked + 1..13 +ok 2 - Basic if / elsif / else structure +# Subtest: simple if evaluation + # if $a { + # 1 + # } + ok 1 - deparse + ok 2 - AST: When simple if with no else has true condition + ok 3 - AST: When simple if with no else has false condition + ok 4 - Str: When simple if with no else has true condition + ok 5 - Str: When simple if with no else has false condition + ok 6 - Raku: When simple if with no else has true condition + ok 7 - Raku: When simple if with no else has false condition + 1..7 +ok 3 - simple if evaluation +# Subtest: Basic with / orwith / else structure + # with $a -> $x { + # 1 + # } + # orwith $b -> $x { + # 2 + # } + # orwith $c -> $x { + # 3 + # } + # else -> $x { + # 4 + # } + ok 1 - deparse + ok 2 - AST: When all conditions undefined, else is evaluated + ok 3 - AST: Latest orwith reachable when matched + ok 4 - AST: First orwith reachable when matched + ok 5 - AST: When the main condition is defined, the then block is picked + ok 6 - Str: When all conditions undefined, else is evaluated + ok 7 - Str: Latest orwith reachable when matched + ok 8 - Str: First orwith reachable when matched + ok 9 - Str: When the main condition is defined, the then block is picked + ok 10 - Raku: When all conditions undefined, else is evaluated + ok 11 - Raku: Latest orwith reachable when matched + ok 12 - Raku: First orwith reachable when matched + ok 13 - Raku: When the main condition is defined, the then block is picked + 1..13 +ok 4 - Basic with / orwith / else structure +# Subtest: simple with evaluation + # with $a -> $x { + # 1 + # } + ok 1 - deparse + ok 2 - AST: When simple when with no else has defined condition + ok 3 - AST: When simple with if with no else has undefined condition + ok 4 - Str: When simple when with no else has defined condition + ok 5 - Str: When simple with if with no else has undefined condition + ok 6 - Raku: When simple when with no else has defined condition + ok 7 - Raku: When simple with if with no else has undefined condition + 1..7 +ok 5 - simple with evaluation +# Subtest: with topicalizes in the body + # with $a { + # $_ + # } + # else { + # $_ + # } + ok 1 - deparse + ok 2 - AST: with topicalizes in the body + ok 3 - AST: with topicalizes in the else body too + ok 4 - Str: with topicalizes in the body + ok 5 - Str: with topicalizes in the else body too + ok 6 - Raku: with topicalizes in the body + ok 7 - Raku: with topicalizes in the else body too + 1..7 +ok 6 - with topicalizes in the body +# Subtest: simple unless with a false condition + # unless $x { + # ++$y + # } + ok 1 - deparse + ok 2 - AST: unless block with a false condition evaluates to its body + ok 3 - AST: side-effect of the body was performed + ok 4 - Str: unless block with a false condition evaluates to its body + ok 5 - Str: side-effect of the body was performed + ok 6 - Raku: unless block with a false condition evaluates to its body + ok 7 - Raku: side-effect of the body was performed + 1..7 +ok 7 - simple unless with a false condition +# Subtest: simple unless with a false condition + # unless $x { + # ++$y + # } + ok 1 - deparse + ok 2 - AST: unless block with a false condition evaluates to Empty + ok 3 - AST: side-effect of the body was not performed + ok 4 - Str: unless block with a false condition evaluates to Empty + ok 5 - Str: side-effect of the body was not performed + ok 6 - Raku: unless block with a false condition evaluates to Empty + ok 7 - Raku: side-effect of the body was not performed + 1..7 +ok 8 - simple unless with a false condition +# Subtest: simple without with an undefined condition + # without $x { + # $y++ + # } + ok 1 - deparse + ok 2 - AST: without block with an undefined object evaluates to its body + ok 3 - AST: Side-effect of the body was performed + ok 4 - Str: without block with an undefined object evaluates to its body + ok 5 - Str: Side-effect of the body was performed + ok 6 - Raku: without block with an undefined object evaluates to its body + ok 7 - Raku: Side-effect of the body was performed + 1..7 +ok 9 - simple without with an undefined condition +# Subtest: simple without with a defined condition + # without $x { + # ++$y + # } + ok 1 - deparse + ok 2 - AST: a without block with a defined object evaluates to Empty + ok 3 - AST: side-effect of the body was not performed + ok 4 - Str: a without block with a defined object evaluates to Empty + ok 5 - Str: side-effect of the body was not performed + ok 6 - Raku: a without block with a defined object evaluates to Empty + ok 7 - Raku: side-effect of the body was not performed + 1..7 +ok 10 - simple without with a defined condition +# Subtest: simple without with an undefined condition + # without $x { + # $_ + # } + ok 1 - deparse + ok 2 - AST: without block sets the topic + ok 3 - Str: without block sets the topic + ok 4 - Raku: without block sets the topic + 1..4 +ok 11 - simple without with an undefined condition +# Subtest: While loop at statement level evaluates to Nil + # while $x { + # --$x + # } + ok 1 - deparse + ok 2 - AST: while loop at statement level evaluates to Nil + ok 3 - AST: Loop variable was decremented to zero + ok 4 - Str: while loop at statement level evaluates to Nil + ok 5 - Str: Loop variable was decremented to zero + ok 6 - Raku: while loop at statement level evaluates to Nil + ok 7 - Raku: Loop variable was decremented to zero + 1..7 +ok 12 - While loop at statement level evaluates to Nil +# Subtest: Until loop at statement level evaluates to Nil + # until !$x { + # --$x + # } + ok 1 - deparse + ok 2 - AST: until loop at statement level evaluates to Nil + ok 3 - AST: Loop variable was decremented to zero + ok 4 - Str: until loop at statement level evaluates to Nil + ok 5 - Str: Loop variable was decremented to zero + ok 6 - Raku: until loop at statement level evaluates to Nil + ok 7 - Raku: Loop variable was decremented to zero + 1..7 +ok 13 - Until loop at statement level evaluates to Nil +# Subtest: Repeat while loop at statement level evaluates to Nil + # repeat { + # --$x + # } while $x + ok 1 - deparse + ok 2 - AST: repeat until loop at statement level evaluates to Nil + ok 3 - AST: loop variable decremented to 0 + ok 4 - Str: repeat until loop at statement level evaluates to Nil + ok 5 - Str: loop variable decremented to 0 + ok 6 - Raku: repeat until loop at statement level evaluates to Nil + ok 7 - Raku: loop variable decremented to 0 + 1..7 +ok 14 - Repeat while loop at statement level evaluates to Nil +# Subtest: Repeat until loop at statement level evaluates to Nil + # repeat { + # --$x + # } until $x + ok 1 - deparse + ok 2 - AST: repeat until loop at statement level evaluates to Nil + ok 3 - AST: loop ran once + ok 4 - Str: repeat until loop at statement level evaluates to Nil + ok 5 - Str: loop ran once + ok 6 - Raku: repeat until loop at statement level evaluates to Nil + ok 7 - Raku: loop ran once + 1..7 +ok 15 - Repeat until loop at statement level evaluates to Nil +# Subtest: Loop block with setup and increment expression + # loop (my $i = 9; $i; --$i) { + # ++$count + # } + ok 1 - deparse + ok 2 - AST: loop with setup and increment evaluates to Nil + ok 3 - AST: loop ran as expected + ok 4 - Str: loop with setup and increment evaluates to Nil + ok 5 - Str: loop ran as expected + ok 6 - Raku: loop with setup and increment evaluates to Nil + ok 7 - Raku: loop ran as expected + 1..7 +ok 16 - Loop block with setup and increment expression +# Subtest: Statement level for loop + # for 2 .. 7 -> $x { + # ++$count + # } + ok 1 - deparse + ok 2 - AST: for loop evaluates to Nil + ok 3 - AST: loop ran with expected number of times + ok 4 - Str: for loop evaluates to Nil + ok 5 - Str: loop ran with expected number of times + ok 6 - Raku: for loop evaluates to Nil + ok 7 - Raku: loop ran with expected number of times + 1..7 +ok 17 - Statement level for loop +# Subtest: for loop with explicit iteration variable + # for 2 .. 7 -> $x { + # $total = $total + $x + # } + ok 1 - deparse + ok 2 - AST: result value of for + ok 3 - AST: correct value in iteration variable + ok 4 - Str: result value of for + ok 5 - Str: correct value in iteration variable + ok 6 - Raku: result value of for + ok 7 - Raku: correct value in iteration variable + 1..7 +ok 18 - for loop with explicit iteration variable +# Subtest: Statement level for loop with implicit topic + # for 2 .. 7 { + # $total = $total + $_ + # } + ok 1 - deparse + ok 2 - AST: result value of for + ok 3 - AST: correct value in implicit topic + ok 4 - Str: result value of for + ok 5 - Str: correct value in implicit topic + ok 6 - Raku: result value of for + ok 7 - Raku: correct value in implicit topic + 1..7 +ok 19 - Statement level for loop with implicit topic +# Subtest: given with explicit signature + # given $a -> $x { + # $x + # } + ok 1 - deparse + ok 2 - AST: given topicalizes on the source (signature) + ok 3 - AST: given topicalizes even an undefined source (signature) + ok 4 - Str: given topicalizes on the source (signature) + ok 5 - Str: given topicalizes even an undefined source (signature) + ok 6 - Raku: given topicalizes on the source (signature) + ok 7 - Raku: given topicalizes even an undefined source (signature) + 1..7 +ok 20 - given with explicit signature +# Subtest: given with implicit signature + # given $a { + # $_ + # } + ok 1 - deparse + ok 2 - AST: given topicalizes on the source (implicit) + ok 3 - AST: given topicalizes even an undefined source (implicit) + ok 4 - Str: given topicalizes on the source (implicit) + ok 5 - Str: given topicalizes even an undefined source (implicit) + ok 6 - Raku: given topicalizes on the source (implicit) + ok 7 - Raku: given topicalizes even an undefined source (implicit) + 1..7 +ok 21 - given with implicit signature +# Subtest: given with when and default + # given $a { + # when 2 { + # "two" + # } + # when 3 { + # "three" + # } + # default { + # "another" + # } + # } + ok 1 - deparse + ok 2 - AST: first when statement matching gives correct result + ok 3 - AST: second when statement matching gives correct result + ok 4 - AST: no when statement giving default + ok 5 - Str: first when statement matching gives correct result + ok 6 - Str: second when statement matching gives correct result + ok 7 - Str: no when statement giving default + ok 8 - Raku: first when statement matching gives correct result + ok 9 - Raku: second when statement matching gives correct result + ok 10 - Raku: no when statement giving default + 1..10 +ok 22 - given with when and default +# use Test; +# ok(1, "use statements work") +ok 23 - deparse +ok 24 - use statements work +ok 25 - use statements work +ok 26 - use statements work +# Subtest: check parsing of 'use' pragma + # use MONKEY; + # nqp::const::STAT_ISDIR + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 27 - check parsing of 'use' pragma +# Subtest: check parsing of 'no' pragma + # no trace; + # 42 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 28 - check parsing of 'no' pragma +# Subtest: check parsing of 'need' pragma + # need Test; + # import Test; + # ok($type) + 1..7 + ok 1 - deparse + ok 2 - + ok 3 - AST: did eval work + ok 4 - + ok 5 - Str: did eval work + ok 6 - + ok 7 - Raku: did eval work +ok 29 - check parsing of 'need' pragma +ok +t/12-rakuast/strings.rakutest ................................... +1..13 +# Subtest: One-part quoted string with literal piece + # "hello\n" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - One-part quoted string with literal piece +# Subtest: Quoted string with interpolated string variable works + # "$str world" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Quoted string with interpolated string variable works +# Subtest: Quoted string with interpolated integer variable + # "$int is the answer" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Quoted string with interpolated integer variable +# Subtest: Quoted string consisting of only interpolated integer variable + # "$int" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Quoted string consisting of only interpolated integer variable +# Subtest: Quoted string with 3 parts works + # "The answer is $int of course!" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Quoted string with 3 parts works +# Subtest: Quoted string involving an interpolated block + # "An { + # $bv + # } block" + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Quoted string involving an interpolated block +# Subtest: words processor splits a single literal string into words + # qqw/foo bar 42/ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - words processor splits a single literal string into words +# Subtest: Words processor applied to a quoted string with interpolation + # qqw/ba$stuff 66/ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - Words processor applied to a quoted string with interpolation +# Subtest: Using the val processor alone + # qq:v/42/ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - Using the val processor alone +# Subtest: Using the val processor alone with interpolation + # qq:v/4$end/ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Using the val processor alone with interpolation +# Subtest: Using the words and val processor + # + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Using the words and val processor +# Subtest: Words processor applied to a quoted string with interpolation + # qq:w:v/ba$stuff 66/ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 12 - Words processor applied to a quoted string with interpolation +# Subtest: Using the exec processor alone gives expected result + # qx/echo 123/ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 13 - Using the exec processor alone gives expected result +ok +t/12-rakuast/stubs.rakutest ..................................... +No subtests run +t/12-rakuast/sub.rakutest ....................................... +1..11 +# Subtest: A bare sub evaluates to a Sub + # sub a { } + ok 1 - deparse + ok 2 - AST: A sub node evaluates to a Sub + ok 3 - Str: A sub node evaluates to a Sub + ok 4 - Raku: A sub node evaluates to a Sub + ok 5 - was a declarator automatically created + ok 6 - was the leading doc stored + ok 7 - was the trailing doc stored + 1..7 +ok 1 - A bare sub evaluates to a Sub +# Subtest: A sub node evaluates to a Sub + # sub ($param) { + # $param + # } + ok 1 - deparse + ok 2 - AST: A sub node evaluates to a Sub + ok 3 - AST: The sub has one parameter + ok 4 - AST: The block has 1 arity + ok 5 - AST: The block has 1 count + ok 6 - AST: Invoking the sub with an argument returns the expected value + ok 7 - AST: Invoking the sub without an argument dies + ok 8 - Str: A sub node evaluates to a Sub + ok 9 - Str: The sub has one parameter + ok 10 - Str: The block has 1 arity + ok 11 - Str: The block has 1 count + ok 12 - Str: Invoking the sub with an argument returns the expected value + ok 13 - Str: Invoking the sub without an argument dies + ok 14 - Raku: A sub node evaluates to a Sub + ok 15 - Raku: The sub has one parameter + ok 16 - Raku: The block has 1 arity + ok 17 - Raku: The block has 1 count + ok 18 - Raku: Invoking the sub with an argument returns the expected value + ok 19 - Raku: Invoking the sub without an argument dies + 1..19 +ok 2 - A sub node evaluates to a Sub +# Subtest: Can call a named sub declaration + # sub my-sub ($param) { + # $param + # } + # my-sub(66) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Can call a named sub declaration +# Subtest: A routine declared anonymous does not declare anything + # anon sub my-sub { + # 66 + # } + # my-sub() + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - A routine declared anonymous does not declare anything +# Subtest: A sub node with a trait evaluates to a Sub + # sub foo returns Int { + # 66 + # } + ok 1 - deparse + ok 2 - AST: A sub node with a trait evaluates to a Sub + ok 3 - AST: The returns trait was applied and .returns is correct + ok 4 - AST: It also does the correct parametric Callable + ok 5 - Str: A sub node with a trait evaluates to a Sub + ok 6 - Str: The returns trait was applied and .returns is correct + ok 7 - Str: It also does the correct parametric Callable + ok 8 - Raku: A sub node with a trait evaluates to a Sub + ok 9 - Raku: The returns trait was applied and .returns is correct + ok 10 - Raku: It also does the correct parametric Callable + 1..10 +ok 5 - A sub node with a trait evaluates to a Sub +# Subtest: Return type constraint + # sub foo returns Int { + # $x + # } + ok 1 - deparse + ok 2 - AST: type matches + ok 3 - AST: type does not match + ok 4 - Str: type matches + ok 5 - Str: type does not match + ok 6 - Raku: type matches + ok 7 - Raku: type does not match + 1..7 +ok 6 - Return type constraint +# Subtest: Using return with acceptable type works + # sub foo returns Int { + # return $x + # } + ok 1 - deparse + ok 2 - AST: type matches + ok 3 - AST: type does not match + ok 4 - Str: type matches + ok 5 - Str: type does not match + ok 6 - Raku: type matches + ok 7 - Raku: type does not match + 1..7 +ok 7 - Using return with acceptable type works +# Subtest: Using a string literal works + # sub ("Bee") { + # 42 + # } + ok 1 - deparse + ok 2 - AST: type matches + ok 3 - AST: type does not match + ok 4 - Str: type matches + ok 5 - Str: type does not match + ok 6 - Raku: type matches + ok 7 - Raku: type does not match + 1..7 +ok 8 - Using a string literal works +# Subtest: creating a proto sub works + # proto sub zippo (|) { + # 42 + # } + ok 1 - deparse + ok 2 - AST: did we return a dispatcher + ok 3 - did we get no dispatchees + ok 4 - AST: can call without args + ok 5 - AST: can call with positionals + ok 6 - AST: can call with nameds + ok 7 - Str: did we return a dispatcher + ok 8 - did we get no dispatchees + ok 9 - Str: can call without args + ok 10 - Str: can call with positionals + ok 11 - Str: can call with nameds + ok 12 - Raku: did we return a dispatcher + ok 13 - did we get no dispatchees + ok 14 - Raku: can call without args + ok 15 - Raku: can call with positionals + ok 16 - Raku: can call with nameds + 1..16 +ok 9 - creating a proto sub works +# Subtest: creating a multi sub without proto works + # multi sub frobnicate { + # 42 + # } + # &frobnicate + ok 1 - deparse + ok 2 - did we create a dispatcher + ok 3 - did we get 1 dispatchee + ok 4 - can call without args + ok 5 - can NOT call with positionals + ok 6 - can NOT call with nameds + ok 7 - did we create a dispatcher + ok 8 - did we get 1 dispatchee + ok 9 - can call without args + ok 10 - can NOT call with positionals + ok 11 - can NOT call with nameds + ok 12 - did we create a dispatcher + ok 13 - did we get 1 dispatchee + ok 14 - can call without args + ok 15 - can NOT call with positionals + ok 16 - can NOT call with nameds + 1..16 +ok 10 - creating a multi sub without proto works +# Subtest: creating a multi sub with existing proto works + # multi sub frobnicate { + # 42 + # } + ok 1 - deparse + ok 2 - did we get a normal sub + ok 3 - can call without args + ok 4 - can NOT call with positionals + ok 5 - can NOT call with nameds + ok 6 - did we get a normal sub + ok 7 - can call without args + ok 8 - can NOT call with positionals + ok 9 - can NOT call with nameds + ok 10 - did we get a normal sub + ok 11 - can call without args + ok 12 - can NOT call with positionals + ok 13 - can NOT call with nameds + 1..13 +ok 11 - creating a multi sub with existing proto works +ok +t/12-rakuast/subset.rakutest .................................... +1..7 +# Subtest: Simplest subset Foo + # my subset Foo + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset accepts foo + ok 7 - AST: subset accepts Any + ok 8 - AST: subset does not accept Mu + ok 9 - Str: is name ok + ok 10 - Str: is refinee ok + ok 11 - Str: is refinement ok + ok 12 - Str: subset accepts 42 + ok 13 - Str: subset accepts foo + ok 14 - Str: subset accepts Any + ok 15 - Str: subset does not accept Mu + ok 16 - Raku: is name ok + ok 17 - Raku: is refinee ok + ok 18 - Raku: is refinement ok + ok 19 - Raku: subset accepts 42 + ok 20 - Raku: subset accepts foo + ok 21 - Raku: subset accepts Any + ok 22 - Raku: subset does not accept Mu + 1..22 +ok 1 - Simplest subset Foo +# Subtest: Simple subset Foo of Int + # my subset Foo of Int + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset does not accept foo + ok 7 - AST: subset does not accept Any + ok 8 - Str: is name ok + ok 9 - Str: is refinee ok + ok 10 - Str: is refinement ok + ok 11 - Str: subset accepts 42 + ok 12 - Str: subset does not accept foo + ok 13 - Str: subset does not accept Any + ok 14 - Raku: is name ok + ok 15 - Raku: is refinee ok + ok 16 - Raku: is refinement ok + ok 17 - Raku: subset accepts 42 + ok 18 - Raku: subset does not accept foo + ok 19 - Raku: subset does not accept Any + 1..19 +ok 2 - Simple subset Foo of Int +# Subtest: Subset with a where block + # my subset Foo of Int where { + # $_ %% 2 + # } + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset does not accept 41 + ok 7 - AST: subset does not accept foo + ok 8 - AST: subset does not accept Any + ok 9 - Str: is name ok + ok 10 - Str: is refinee ok + ok 11 - Str: is refinement ok + ok 12 - Str: subset accepts 42 + ok 13 - Str: subset does not accept 41 + ok 14 - Str: subset does not accept foo + ok 15 - Str: subset does not accept Any + ok 16 - Raku: is name ok + ok 17 - Raku: is refinee ok + ok 18 - Raku: is refinement ok + ok 19 - Raku: subset accepts 42 + ok 20 - Raku: subset does not accept 41 + ok 21 - Raku: subset does not accept foo + ok 22 - Raku: subset does not accept Any + 1..22 +ok 3 - Subset with a where block +# Subtest: Subset with a where pointy block + # my subset Foo of Int where -> $a { + # $a %% 2 + # } + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset does not accept 41 + ok 7 - AST: subset does not accept foo + ok 8 - AST: subset does not accept Any + ok 9 - Str: is name ok + ok 10 - Str: is refinee ok + ok 11 - Str: is refinement ok + ok 12 - Str: subset accepts 42 + ok 13 - Str: subset does not accept 41 + ok 14 - Str: subset does not accept foo + ok 15 - Str: subset does not accept Any + ok 16 - Raku: is name ok + ok 17 - Raku: is refinee ok + ok 18 - Raku: is refinement ok + ok 19 - Raku: subset accepts 42 + ok 20 - Raku: subset does not accept 41 + ok 21 - Raku: subset does not accept foo + ok 22 - Raku: subset does not accept Any + 1..22 +ok 4 - Subset with a where pointy block +# Subtest: Subset with a where whatevercode + # my subset Foo of Int where * %% 2 + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset does not accept 41 + ok 7 - AST: subset does not accept foo + ok 8 - AST: subset does not accept Any + ok 9 - Str: is name ok + ok 10 - Str: is refinee ok + ok 11 - Str: is refinement ok + ok 12 - Str: subset accepts 42 + ok 13 - Str: subset does not accept 41 + ok 14 - Str: subset does not accept foo + ok 15 - Str: subset does not accept Any + ok 16 - Raku: is name ok + ok 17 - Raku: is refinee ok + ok 18 - Raku: is refinement ok + ok 19 - Raku: subset accepts 42 + ok 20 - Raku: subset does not accept 41 + ok 21 - Raku: subset does not accept foo + ok 22 - Raku: subset does not accept Any + 1..22 +ok 5 - Subset with a where whatevercode +# Subtest: Subset with a where literal + # my subset Foo where 42 + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset does not accept 41 + ok 7 - AST: subset does not accept foo + ok 8 - Str: is name ok + ok 9 - Str: is refinee ok + ok 10 - Str: is refinement ok + ok 11 - Str: subset accepts 42 + ok 12 - Str: subset does not accept 41 + ok 13 - Str: subset does not accept foo + ok 14 - Raku: is name ok + ok 15 - Raku: is refinee ok + ok 16 - Raku: is refinement ok + ok 17 - Raku: subset accepts 42 + ok 18 - Raku: subset does not accept 41 + ok 19 - Raku: subset does not accept foo + 1..19 +ok 6 - Subset with a where literal +# Subtest: Subset with a where regex + # my subset Foo where / 42/ + ok 1 - deparse + ok 2 - AST: is name ok + ok 3 - AST: is refinee ok + ok 4 - AST: is refinement ok + ok 5 - AST: subset accepts 42 + ok 6 - AST: subset does not accept 41 + ok 7 - AST: subset does not accept foo + ok 8 - Str: is name ok + ok 9 - Str: is refinee ok + ok 10 - Str: is refinement ok + ok 11 - Str: subset accepts 42 + ok 12 - Str: subset does not accept 41 + ok 13 - Str: subset does not accept foo + ok 14 - Raku: is name ok + ok 15 - Raku: is refinee ok + ok 16 - Raku: is refinement ok + ok 17 - Raku: subset accepts 42 + ok 18 - Raku: subset does not accept 41 + ok 19 - Raku: subset does not accept foo + 1..19 +ok 7 - Subset with a where regex +ok +t/12-rakuast/terms.rakutest ..................................... +1..13 +# Subtest: Method call via self + # my class TestClass { + # method meth-a { + # 99 + # } + # method meth-b { + # self.meth-a + # } + # } + ok 1 - deparse + ok 2 - AST: Method call via self works + ok 3 - Str: Method call via self works + ok 4 - Raku: Method call via self works + 1..4 +ok 1 - Method call via self +# Subtest: Topic call applies the call to $_ + # given "argh" { + # .uc + # } + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Topic call applies the call to $_ +# Subtest: now named term can be called + # now + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - now named term can be called +# Subtest: rand term works + # rand + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - rand term works +# Subtest: Empty set term works + # ∅ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Empty set term works +# Subtest: Name term works with single-part name + # True + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Name term works with single-part name +# Subtest: Name term works with multi-part name + # Bool::True + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Name term works with multi-part name +# Subtest: Whatever term works + # * + ok 1 - deparse + ok 2 - The object is-a 'Whatever' + ok 3 - The object is-a 'Whatever' + ok 4 - The object is-a 'Whatever' + 1..4 +ok 8 - Whatever term works +# Subtest: Hyperwhatever term works + # ** + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 9 - Hyperwhatever term works +# Subtest: Capture term can be constructed with a term + # \($var) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 10 - Capture term can be constructed with a term +# Subtest: Capture term can be constructed with an arg list + # \(6, :x) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 11 - Capture term can be constructed with an arg list +# Subtest: Radix number term + # :16("abc") + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 12 - Radix number term +# Subtest: Radix number term with multiple args + # :16[1, 2, 3] + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 13 - Radix number term with multiple args +ok +t/12-rakuast/types.rakutest ..................................... +1..10 +# Subtest: look up an existing type + # Proc::Async + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 1 - look up an existing type +# Subtest: type with definedness constraint + # Int:D + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - type with definedness constraint +# Subtest: type with undefinedness constraint + # Int:U + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - type with undefinedness constraint +# Subtest: type with unspecified coercion + # Int() + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - type with unspecified coercion +# Subtest: type with specific coercion + # Int(Str) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - type with specific coercion +# Subtest: type with chained coercion + # Int(Str()) + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - type with chained coercion +# Subtest: parameterized type without type + # Rational + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - parameterized type without type +# Subtest: parameterized type with type + # Rational[Int] + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - parameterized type with type +# Subtest: Single-part type from the setting + # SETTING:: + ok 1 - deparse + ok 2 - AST: did we get the setting version + ok 3 - Str: did we get the setting version + ok 4 - Raku: did we get the setting version + 1..4 +ok 9 - Single-part type from the setting +# Subtest: Multi-part type from the setting + # SETTING::.WHO.WHO + ok 1 - deparse + not ok 2 - AST: did we get the setting version # TODO no actual lookup in SETTING only yet + # Failed test 'AST: did we get the setting version' + # at t/12-rakuast/types.rakutest line 159 + # expected: IO::Path::Parts + # got: IO::Path::Parts + not ok 3 - Str: did we get the setting version # TODO no actual lookup in SETTING only yet + # Failed test 'Str: did we get the setting version' + # at t/12-rakuast/types.rakutest line 159 + # expected: IO::Path::Parts + # got: IO::Path::Parts + not ok 4 - Raku: did we get the setting version # TODO no actual lookup in SETTING only yet + # Failed test 'Raku: did we get the setting version' + # at t/12-rakuast/types.rakutest line 159 + # expected: IO::Path::Parts + # got: IO::Path::Parts + 1..4 +ok 10 - Multi-part type from the setting +ok +t/12-rakuast/var.rakutest ....................................... +1..59 +# Subtest: Special compiler variable $?FILE + # $?FILE + ok 1 - deparse + ok 2 - AST + not ok 3 - Str # TODO Depends on Raku grammar/actions + # Failed test 'Str' + # at t/12-rakuast/var.rakutest line 25 + # expected: "EVAL_1" + # got: "/build/reproducible-path/rakudo-2024.09/EVAL_1" + ok 4 - Raku + 1..4 +not ok 1 - Special compiler variable $?FILE # TODO Depends on Raku grammar/actions +# Failed test 'Special compiler variable $?FILE' +# at t/12-rakuast/var.rakutest line 19 +# Subtest: Special compiler variable $?FILE + # ::?CLASS + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 2 - Special compiler variable $?FILE +# Subtest: Special compiler variable $?LINE + # $?LINE + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 3 - Special compiler variable $?LINE +# Subtest: Special compiler variable $?PACKAGE + # $?PACKAGE + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 4 - Special compiler variable $?PACKAGE +# Subtest: Generic package variable lookup + # $Foo::foo + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 5 - Generic package variable lookup +# Subtest: Lexical variable lookup ($ sigil) + # $x + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 6 - Lexical variable lookup ($ sigil) +# Subtest: Lexical variable lookup (& sigil) + # &plan + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 7 - Lexical variable lookup (& sigil) +# Subtest: A variable in the setting + # SETTING::<&val> + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 8 - A variable in the setting +# Subtest: Positional capture variable lookup works + # $0 + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + # $1 + ok 5 - deparse + ok 6 - AST + ok 7 - Str + ok 8 - Raku + 1..8 +ok 9 - Positional capture variable lookup works +# Subtest: Named capture variable lookup works + # $ + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + # $ + ok 5 - deparse + ok 6 - AST + ok 7 - Str + ok 8 - Raku + 1..8 +ok 10 - Named capture variable lookup works +# Subtest: variable declaration takes scope and name + # my $foo + ok 1 - deparse + ok 2 - did we get scope: my + ok 3 - did we get the right name + # state $foo + ok 4 - deparse + ok 5 - did we get scope: state + ok 6 - did we get the right name + 1..6 +ok 11 - variable declaration takes scope and name +# Subtest: Lexical variable my|state declarations work + # my $foo; + # $foo = 10; + # $foo + ok 1 - deparse + ok 2 - AST: my + ok 3 - Str: my + ok 4 - Raku: my + # state $foo; + # $foo = 10; + # $foo + ok 5 - deparse + ok 6 - AST: state + ok 7 - Str: state + ok 8 - Raku: state + 1..8 +ok 12 - Lexical variable my|state declarations work +# Subtest: Defaults of my|state untyped container + # my $foo; + # $foo + ok 1 - deparse + ok 2 - AST: my default value is Any + ok 3 - AST: my Default constraint is Mu + ok 4 - Str: my default value is Any + ok 5 - Str: my Default constraint is Mu + ok 6 - Raku: my default value is Any + ok 7 - Raku: my Default constraint is Mu + # state $foo; + # $foo + ok 8 - deparse + ok 9 - AST: state default value is Any + ok 10 - AST: state Default constraint is Mu + ok 11 - Str: state default value is Any + ok 12 - Str: state Default constraint is Mu + ok 13 - Raku: state default value is Any + ok 14 - Raku: state Default constraint is Mu + 1..14 +ok 13 - Defaults of my|state untyped container +# Subtest: Typed variable my|state declaration (type matches in assignment) + # my Int $foo; + # $foo = 99; + # $foo + ok 1 - deparse + ok 2 - AST: my + ok 3 - Str: my + ok 4 - Raku: my + # state Int $foo; + # $foo = 99; + # $foo + ok 5 - deparse + ok 6 - AST: state + ok 7 - Str: state + ok 8 - Raku: state + 1..8 +ok 14 - Typed variable my|state declaration (type matches in assignment) +# Subtest: Typed variable my|state declaration (type mismatch throws) + # my Int $foo; + # $foo = 100000e0; + # $foo + ok 1 - deparse + # Subtest: did we throws-like X::TypeCheck::Assignment? + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - .expected matches (Int) + ok 4 - .got matches 100000 + ok 2 - did we throws-like X::TypeCheck::Assignment? + # Subtest: did we throws-like X::TypeCheck::Assignment? + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + not ok 3 - .expected matches (Int) # TODO string EVAL produces different error + # Failed test '.expected matches (Int)' + # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 +Use of uninitialized value element of type Any in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 + # Expected: Int + # Got: + not ok 4 - .got matches 100000 # TODO string EVAL produces different error + # Failed test '.got matches 100000' + # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 +Use of uninitialized value element of type Any in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 + # Expected: 100000e0 + # Got: + not ok 3 - did we throws-like X::TypeCheck::Assignment? # TODO string EVAL produces different error + # Failed test 'did we throws-like X::TypeCheck::Assignment?' + # at t/12-rakuast/var.rakutest line 295 + # Subtest: did we throws-like X::TypeCheck::Assignment? + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - .got matches 100000 + ok 4 - .expected matches (Int) + ok 4 - did we throws-like X::TypeCheck::Assignment? + # state Int $foo; + # $foo = 100000e0; + # $foo + ok 5 - deparse + # Subtest: did we throws-like X::TypeCheck::Assignment? + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - .expected matches (Int) + ok 4 - .got matches 100000 + ok 6 - did we throws-like X::TypeCheck::Assignment? + # Subtest: did we throws-like X::TypeCheck::Assignment? + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + not ok 3 - .got matches 100000 # TODO string EVAL produces different error + # Failed test '.got matches 100000' + # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 +Use of uninitialized value element of type Any in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 + # Expected: 100000e0 + # Got: + not ok 4 - .expected matches (Int) # TODO string EVAL produces different error + # Failed test '.expected matches (Int)' + # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 +Use of uninitialized value element of type Any in string context. +Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. + in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 + # Expected: Int + # Got: + not ok 7 - did we throws-like X::TypeCheck::Assignment? # TODO string EVAL produces different error + # Failed test 'did we throws-like X::TypeCheck::Assignment?' + # at t/12-rakuast/var.rakutest line 295 + # Subtest: did we throws-like X::TypeCheck::Assignment? + 1..4 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - .expected matches (Int) + ok 4 - .got matches 100000 + ok 8 - did we throws-like X::TypeCheck::Assignment? + 1..8 +ok 15 - Typed variable my|state declaration (type mismatch throws) +# Subtest: Lexical variable my|state declaration with assignment initializer + # my $var = 125; + # $var + ok 1 - deparse + ok 2 - AST: my variable declarations with assignment initializer + ok 3 - AST: my was an assignment into a Scalar container + ok 4 - AST: my is not dynamic + ok 5 - AST: my can update the container that was produced + ok 6 - Str: my variable declarations with assignment initializer + ok 7 - Str: my was an assignment into a Scalar container + ok 8 - Str: my is not dynamic + ok 9 - Str: my can update the container that was produced + ok 10 - Raku: my variable declarations with assignment initializer + ok 11 - Raku: my was an assignment into a Scalar container + ok 12 - Raku: my is not dynamic + ok 13 - Raku: my can update the container that was produced + # state $var = 125; + # $var + ok 14 - deparse + ok 15 - AST: state variable declarations with assignment initializer + ok 16 - AST: state was an assignment into a Scalar container + ok 17 - AST: state is not dynamic + ok 18 - AST: state can update the container that was produced + ok 19 - Str: state variable declarations with assignment initializer + ok 20 - Str: state was an assignment into a Scalar container + ok 21 - Str: state is not dynamic + ok 22 - Str: state can update the container that was produced + ok 23 - Raku: state variable declarations with assignment initializer + ok 24 - Raku: state was an assignment into a Scalar container + ok 25 - Raku: state is not dynamic + ok 26 - Raku: state can update the container that was produced + 1..26 +ok 16 - Lexical variable my|state declaration with assignment initializer +# Subtest: Lexical my|state array declaration with assignment initializer + # my @var = 22, 33; + # @var + ok 1 - deparse + ok 2 - AST: my + ok 3 - Str: my + ok 4 - Raku: my + # state @var = 22, 33; + # @var + ok 5 - deparse + ok 6 - AST: state + ok 7 - Str: state + ok 8 - Raku: state + 1..8 +ok 17 - Lexical my|state array declaration with assignment initializer +# Subtest: Lexical my|state variable declarations with bind initializer + # my $var := 225; + # $var + ok 1 - deparse + ok 2 - AST: my variable declarations with bind initializer + ok 3 - AST: my really was bound; no Scalar container + ok 4 - AST: my cannot assign as it is not a container + ok 5 - Str: my variable declarations with bind initializer + ok 6 - Str: my really was bound; no Scalar container + ok 7 - Str: my cannot assign as it is not a container + ok 8 - Raku: my variable declarations with bind initializer + ok 9 - Raku: my really was bound; no Scalar container + ok 10 - Raku: my cannot assign as it is not a container + # state $var := 225; + # $var + ok 11 - deparse + 1..11 +ok 18 - Lexical my|state variable declarations with bind initializer +# Subtest: Anonymous state variable declaration + # -> { + # ++$ + ++$ + # } + ok 1 - deparse + ok 2 - AST: anonymous state variables works are are distinct + ok 3 - Str: anonymous state variables works are are distinct + ok 4 - Raku: anonymous state variables works are are distinct + 1..4 +ok 19 - Anonymous state variable declaration +# Subtest: Dynamic variable access + # $*dyn + ok 1 - deparse + ok 2 - AST access outside + ok 3 - Str access outside + ok 4 - Raku access outside + ok 5 - AST access inside + ok 6 - Str access inside + # $*OUT + ok 7 - deparse + ok 8 - AST checking $*OUT + ok 9 - Str checking $*OUT + ok 10 - Raku checking $*OUT + 1..10 +ok 20 - Dynamic variable access +# Subtest: Dynamic variable declaration and assignment, dynamic lookup + # my $*var = 360; + # $*var + ok 1 - deparse + ok 2 - AST: Dynamic variable declaration and assignment, dynamic lookup + ok 3 - AST: Dynamic did an assignment into a Scalar container + ok 4 - AST: Is a dynamic + ok 5 - AST: Can update the container that was produced + ok 6 - Str: Dynamic variable declaration and assignment, dynamic lookup + ok 7 - Str: Dynamic did an assignment into a Scalar container + ok 8 - Str: Is a dynamic + ok 9 - Str: Can update the container that was produced + ok 10 - Raku: Dynamic variable declaration and assignment, dynamic lookup + ok 11 - Raku: Dynamic did an assignment into a Scalar container + ok 12 - Raku: Is a dynamic + ok 13 - Raku: Can update the container that was produced + 1..13 +ok 21 - Dynamic variable declaration and assignment, dynamic lookup +# Subtest: @ sigil my|state var is initialized to Array + # my @arr; + # @arr + ok 1 - deparse + ok 2 - AST: my @ sigil var is initialized to Array + ok 3 - AST: my @ sigil var not wrapped in Scalar + ok 4 - AST: my it is a defined Array instance + ok 5 - AST: my it is empty + ok 6 - AST: my element is a Scalar + ok 7 - AST: my contains an Any by default + ok 8 - AST: my constraint is Mu by default + ok 9 - Str: my @ sigil var is initialized to Array + ok 10 - Str: my @ sigil var not wrapped in Scalar + ok 11 - Str: my it is a defined Array instance + ok 12 - Str: my it is empty + ok 13 - Str: my element is a Scalar + ok 14 - Str: my contains an Any by default + ok 15 - Str: my constraint is Mu by default + ok 16 - Raku: my @ sigil var is initialized to Array + ok 17 - Raku: my @ sigil var not wrapped in Scalar + ok 18 - Raku: my it is a defined Array instance + ok 19 - Raku: my it is empty + ok 20 - Raku: my element is a Scalar + ok 21 - Raku: my contains an Any by default + ok 22 - Raku: my constraint is Mu by default + # state @arr; + # @arr + ok 23 - deparse + ok 24 - AST: state @ sigil var is initialized to Array + ok 25 - AST: state @ sigil var not wrapped in Scalar + ok 26 - AST: state it is a defined Array instance + ok 27 - AST: state it is empty + ok 28 - AST: state element is a Scalar + ok 29 - AST: state contains an Any by default + ok 30 - AST: state constraint is Mu by default + ok 31 - Str: state @ sigil var is initialized to Array + ok 32 - Str: state @ sigil var not wrapped in Scalar + ok 33 - Str: state it is a defined Array instance + ok 34 - Str: state it is empty + ok 35 - Str: state element is a Scalar + ok 36 - Str: state contains an Any by default + ok 37 - Str: state constraint is Mu by default + ok 38 - Raku: state @ sigil var is initialized to Array + ok 39 - Raku: state @ sigil var not wrapped in Scalar + ok 40 - Raku: state it is a defined Array instance + ok 41 - Raku: state it is empty + ok 42 - Raku: state element is a Scalar + ok 43 - Raku: state contains an Any by default + ok 44 - Raku: state constraint is Mu by default + 1..44 +ok 22 - @ sigil my|state var is initialized to Array +# Subtest: % sigil my|state var is initialized to Hash + # my %hash; + # %hash + ok 1 - deparse + ok 2 - AST: my % sigil var is initialized to Hash + ok 3 - AST: my % sigil var not wrapped in Scalar + ok 4 - AST: my it is a defined Hash instance + ok 5 - AST: my it is empty + ok 6 - AST: my element is a Scalar + ok 7 - AST: my contains an Any by default + ok 8 - AST: my constraint is Mu by default + ok 9 - Str: my % sigil var is initialized to Hash + ok 10 - Str: my % sigil var not wrapped in Scalar + ok 11 - Str: my it is a defined Hash instance + ok 12 - Str: my it is empty + ok 13 - Str: my element is a Scalar + ok 14 - Str: my contains an Any by default + ok 15 - Str: my constraint is Mu by default + ok 16 - Raku: my % sigil var is initialized to Hash + ok 17 - Raku: my % sigil var not wrapped in Scalar + ok 18 - Raku: my it is a defined Hash instance + ok 19 - Raku: my it is empty + ok 20 - Raku: my element is a Scalar + ok 21 - Raku: my contains an Any by default + ok 22 - Raku: my constraint is Mu by default + # state %hash; + # %hash + ok 23 - deparse + ok 24 - AST: state % sigil var is initialized to Hash + ok 25 - AST: state % sigil var not wrapped in Scalar + ok 26 - AST: state it is a defined Hash instance + ok 27 - AST: state it is empty + ok 28 - AST: state element is a Scalar + ok 29 - AST: state contains an Any by default + ok 30 - AST: state constraint is Mu by default + ok 31 - Str: state % sigil var is initialized to Hash + ok 32 - Str: state % sigil var not wrapped in Scalar + ok 33 - Str: state it is a defined Hash instance + ok 34 - Str: state it is empty + ok 35 - Str: state element is a Scalar + ok 36 - Str: state contains an Any by default + ok 37 - Str: state constraint is Mu by default + ok 38 - Raku: state % sigil var is initialized to Hash + ok 39 - Raku: state % sigil var not wrapped in Scalar + ok 40 - Raku: state it is a defined Hash instance + ok 41 - Raku: state it is empty + ok 42 - Raku: state element is a Scalar + ok 43 - Raku: state contains an Any by default + ok 44 - Raku: state constraint is Mu by default + 1..44 +ok 23 - % sigil my|state var is initialized to Hash +# Subtest: @ sigil my|state var with Int type is an Array + # my Int @arr; + # @arr + ok 1 - deparse + ok 2 - AST: my @ sigil var with Int type is an Array + ok 3 - AST: my it does Positional[Int] + ok 4 - AST: my .of gives Int + ok 5 - AST: my it is empty + ok 6 - AST: my element is a Scalar + ok 7 - AST: my contains an Int + ok 8 - AST: my constraint is Int + ok 9 - Str: my @ sigil var with Int type is an Array + ok 10 - Str: my it does Positional[Int] + ok 11 - Str: my .of gives Int + ok 12 - Str: my it is empty + ok 13 - Str: my element is a Scalar + ok 14 - Str: my contains an Int + ok 15 - Str: my constraint is Int + ok 16 - Raku: my @ sigil var with Int type is an Array + ok 17 - Raku: my it does Positional[Int] + ok 18 - Raku: my .of gives Int + ok 19 - Raku: my it is empty + ok 20 - Raku: my element is a Scalar + ok 21 - Raku: my contains an Int + ok 22 - Raku: my constraint is Int + # state Int @arr; + # @arr + ok 23 - deparse + ok 24 - AST: state @ sigil var with Int type is an Array + ok 25 - AST: state it does Positional[Int] + ok 26 - AST: state .of gives Int + ok 27 - AST: state it is empty + ok 28 - AST: state element is a Scalar + ok 29 - AST: state contains an Int + ok 30 - AST: state constraint is Int + ok 31 - Str: state @ sigil var with Int type is an Array + ok 32 - Str: state it does Positional[Int] + ok 33 - Str: state .of gives Int + ok 34 - Str: state it is empty + ok 35 - Str: state element is a Scalar + ok 36 - Str: state contains an Int + ok 37 - Str: state constraint is Int + ok 38 - Raku: state @ sigil var with Int type is an Array + ok 39 - Raku: state it does Positional[Int] + ok 40 - Raku: state .of gives Int + ok 41 - Raku: state it is empty + ok 42 - Raku: state element is a Scalar + ok 43 - Raku: state contains an Int + ok 44 - Raku: state constraint is Int + 1..44 +ok 24 - @ sigil my|state var with Int type is an Array +# Subtest: % sigil my|state var with Int type is a Hash + # my Int %hash; + # %hash + ok 1 - deparse + ok 2 - AST: my % sigil var with Int type is a Hash + ok 3 - AST: my it does Associative[Int] + ok 4 - AST: my .of gives Int + ok 5 - AST: my it is empty + ok 6 - AST: my element is a Scalar + ok 7 - AST: my contains an Int + ok 8 - AST: my constraint is Int + ok 9 - Str: my % sigil var with Int type is a Hash + ok 10 - Str: my it does Associative[Int] + ok 11 - Str: my .of gives Int + ok 12 - Str: my it is empty + ok 13 - Str: my element is a Scalar + ok 14 - Str: my contains an Int + ok 15 - Str: my constraint is Int + ok 16 - Raku: my % sigil var with Int type is a Hash + ok 17 - Raku: my it does Associative[Int] + ok 18 - Raku: my .of gives Int + ok 19 - Raku: my it is empty + ok 20 - Raku: my element is a Scalar + ok 21 - Raku: my contains an Int + ok 22 - Raku: my constraint is Int + # state Int %hash; + # %hash + ok 23 - deparse + ok 24 - AST: state % sigil var with Int type is a Hash + ok 25 - AST: state it does Associative[Int] + ok 26 - AST: state .of gives Int + ok 27 - AST: state it is empty + ok 28 - AST: state element is a Scalar + ok 29 - AST: state contains an Int + ok 30 - AST: state constraint is Int + ok 31 - Str: state % sigil var with Int type is a Hash + ok 32 - Str: state it does Associative[Int] + ok 33 - Str: state .of gives Int + ok 34 - Str: state it is empty + ok 35 - Str: state element is a Scalar + ok 36 - Str: state contains an Int + ok 37 - Str: state constraint is Int + ok 38 - Raku: state % sigil var with Int type is a Hash + ok 39 - Raku: state it does Associative[Int] + ok 40 - Raku: state .of gives Int + ok 41 - Raku: state it is empty + ok 42 - Raku: state element is a Scalar + ok 43 - Raku: state contains an Int + ok 44 - Raku: state constraint is Int + 1..44 +ok 25 - % sigil my|state var with Int type is a Hash +# Subtest: Can access external native int var + # $x + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 26 - Can access external native int var +# Subtest: Can access external native num var + # $x + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 27 - Can access external native num var +# Subtest: Can access external native str var + # $x + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 28 - Can access external native str var +# Subtest: int declaration creates a native int container + # my int $native-int; + # $native-int + ok 1 - deparse + ok 2 - AST: int declaration creates a native int container + ok 3 - AST: Native int initialized to 0 by default + ok 4 - Str: int declaration creates a native int container + ok 5 - Str: Native int initialized to 0 by default + ok 6 - Raku: int declaration creates a native int container + ok 7 - Raku: Native int initialized to 0 by default + 1..7 +ok 29 - int declaration creates a native int container +# Subtest: num declaration creates a native num container + # my num $native-num; + # $native-num + ok 1 - deparse + ok 2 - AST: num declaration creates a native num container + ok 3 - AST: Native num initialized to 0e0 by default + ok 4 - Str: num declaration creates a native num container + ok 5 - Str: Native num initialized to 0e0 by default + ok 6 - Raku: num declaration creates a native num container + ok 7 - Raku: Native num initialized to 0e0 by default + 1..7 +ok 30 - num declaration creates a native num container +# Subtest: str declaration creates a native str container + # my str $native-str; + # $native-str + ok 1 - deparse + ok 2 - AST: str declaration creates a native str container + ok 3 - AST: Native str initialized to empty string by default + ok 4 - Str: str declaration creates a native str container + ok 5 - Str: Native str initialized to empty string by default + ok 6 - Raku: str declaration creates a native str container + ok 7 - Raku: Native str initialized to empty string by default + 1..7 +ok 31 - str declaration creates a native str container +# Subtest: Native int assign initializer works + # my int $native-int = 963; + # $native-int + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 32 - Native int assign initializer works +# Subtest: Native num assign initializer works + # my num $native-num = 96000e0; + # $native-num + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 33 - Native num assign initializer works +# Subtest: Native str assign initializer works + # my str $native-str = "nine six three"; + # $native-str + ok 1 - deparse + ok 2 - AST + ok 3 - Str + ok 4 - Raku + 1..4 +ok 34 - Native str assign initializer works +# our $var; +# $var +ok 35 - deparse +# Subtest: AST: our-scoped variable declaration without initializer takes current value (eval mode) + ok 1 - eval AST + ok 2 - Value intact after eval + 1..2 +ok 36 - AST: our-scoped variable declaration without initializer takes current value (eval mode) +# Subtest: Str: our-scoped variable declaration without initializer takes current value (eval mode) + ok 1 - eval Str + ok 2 - Value intact after eval + 1..2 +ok 37 - Str: our-scoped variable declaration without initializer takes current value (eval mode) +# Subtest: Raku: our-scoped variable declaration without initializer takes current value (eval mode) + ok 1 - eval Str + ok 2 - Value intact after eval + 1..2 +ok 38 - Raku: our-scoped variable declaration without initializer takes current value (eval mode) +# our $x = 42; +# $x +ok 39 - deparse +# Subtest: our-scoped variable declaration with initializer works (eval mode) + ok 1 - + ok 2 - + ok 3 - + 1..3 +ok 40 - our-scoped variable declaration with initializer works (eval mode) +# our $y = 99; +# $y; +ok 41 - deparse +ok 42 - our-scoped variable declaration with initializer works (top-level mode) +ok 43 - our variable set in eval mode is installed into the current package +ok 44 - It is a bound scalar +not ok 45 - our-scoped variable declaration in top-level comp unit does not leak out # TODO NYI +# Failed test 'our-scoped variable declaration in top-level comp unit does not leak out' +# at t/12-rakuast/var.rakutest line 1022 +# Subtest: A pointy block node with a state variable + # -> { + # state $foo = 42; + # $foo++ + # } + ok 1 - deparse + ok 2 - AST: state variable initialized + ok 3 - AST: state variable kept value + ok 4 - Str: state variable initialized + ok 5 - Str: state variable kept value + ok 6 - Raku: state variable initialized + ok 7 - Raku: state variable kept value + 1..7 +ok 46 - A pointy block node with a state variable +# Subtest: Term (sigilless) variable declaration + # my \foo = 111; + # foo + ok 1 - deparse + ok 2 - AST: sigilless variable initialized with correct value + ok 3 - AST: no container produced + ok 4 - Str: sigilless variable initialized with correct value + ok 5 - Str: no container produced + ok 6 - Raku: sigilless variable initialized with correct value + ok 7 - Raku: no container produced + 1..7 +ok 47 - Term (sigilless) variable declaration +# Subtest: Lexical constant + # constant foo = "bar" + ok 1 - deparse + ok 2 - AST: did it produce 'bar' + ok 3 - AST: was the constant installed + ok 4 - Str: did it produce 'bar' + ok 5 - Str: was the constant installed + ok 6 - Raku: did it produce 'bar' + ok 7 - Raku: was the constant installed + 1..7 +ok 48 - Lexical constant +# Subtest: Lexical my constant + # my constant foo = "bar" + ok 1 - deparse + ok 2 - AST: did it produce 'bar' + ok 3 - AST: was the constant *not* installed + ok 4 - Str: did it produce 'bar' + ok 5 - Str: was the constant *not* installed + ok 6 - Raku: did it produce 'bar' + ok 7 - Raku: was the constant *not* installed + 1..7 +ok 49 - Lexical my constant +# Subtest: Lexical my constant with expression + # my constant foo = now + ok 1 - deparse + not ok 2 - AST: did it produce an Instant # TODO Unknown compilation input 'qast' + # Failed test 'AST: did it produce an Instant' + # at t/12-rakuast/var.rakutest line 1166 + # Actual type: Nil +Use of Nil in numeric context + in block at t/12-rakuast/var.rakutest line 1167 + ok 3 - AST: check that time has passed + ok 4 - AST: was the constant *not* installed + ok 5 - Str: did it produce an Instant + ok 6 - Str: check that time has passed + ok 7 - Str: was the constant *not* installed + not ok 8 - Raku: did it produce an Instant # TODO Unknown compilation input 'qast' + # Failed test 'Raku: did it produce an Instant' + # at t/12-rakuast/var.rakutest line 1166 + # Actual type: Nil +Use of Nil in numeric context + in block at t/12-rakuast/var.rakutest line 1167 + ok 9 - Raku: check that time has passed + ok 10 - Raku: was the constant *not* installed + 1..10 +ok 50 - Lexical my constant with expression +# Subtest: Special compiler variable $=pod + # $=pod + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - Str: EVAL + ok 4 - Raku: EVAL + 1..4 +ok 51 - Special compiler variable $=pod +# Subtest: Special compiler variable $=finish + # $=finish + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - Str: EVAL + ok 4 - Raku: EVAL + 1..4 +ok 52 - Special compiler variable $=finish +# Subtest: variable with a trait + # my $a is default(42) + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - Str: EVAL + ok 4 - Raku: EVAL + 1..4 +ok 53 - variable with a trait +# Subtest: scalar variable with a where guard (passing initializer) + # my $f where 5 = 5 + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - Str: EVAL + ok 4 - Raku: EVAL + 1..4 +ok 54 - scalar variable with a where guard (passing initializer) +# Subtest: scalar variable with a where guard (failing initializer) + # my $f where 5 = 6 + ok 1 - deparse + # Subtest: AST: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 2 - AST: EVAL + # Subtest: Str: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - Str: EVAL + # Subtest: Raku: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 4 - Raku: EVAL + 1..4 +ok 55 - scalar variable with a where guard (failing initializer) +# Subtest: array variable with a where guard (passing initializer) + # my @h where 5 = 5; + # @h[0] + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - Str: EVAL + ok 4 - Raku: EVAL + 1..4 +ok 56 - array variable with a where guard (passing initializer) +# Subtest: array variable with a where guard (failing initializer) + # my @h where 5 = 6 + ok 1 - deparse + # Subtest: AST: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 2 - AST: EVAL + # Subtest: Str: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - Str: EVAL + # Subtest: Raku: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 4 - Raku: EVAL + 1..4 +ok 57 - array variable with a where guard (failing initializer) +# Subtest: hash variable with a where guard (passing initializer) + # my %h where 5 = :5s; + # %h + ok 1 - deparse + ok 2 - AST: EVAL + ok 3 - Str: EVAL + ok 4 - Raku: EVAL + 1..4 +ok 58 - hash variable with a where guard (passing initializer) +# Subtest: hash variable with a where guard (failing initializer) + # my %h where 5 = :6s + ok 1 - deparse + # Subtest: AST: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 2 - AST: EVAL + # Subtest: Str: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 3 - Str: EVAL + # Subtest: Raku: EVAL + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::TypeCheck::Assignment) + ok 4 - Raku: EVAL + 1..4 +ok 59 - hash variable with a where guard (failing initializer) +ok +t/12-rakuast/xx-fixed-in-rakuast.rakutest ....................... +Potential difficulties: + Pair with <> really means an empty list, not null string; use :out('') to represent the null string, + or :out() to represent the empty list more accurately + at /build/reproducible-path/rakudo-2024.09/t/12-rakuast/xx-fixed-in-rakuast.rakutest:212 + ------>  where (*.chars == 1)|.AST.EVAL', :out<>⏏, :err<>, + Pair with <> really means an empty list, not null string; use :err('') to represent the null string, + or :err() to represent the empty list more accurately + at /build/reproducible-path/rakudo-2024.09/t/12-rakuast/xx-fixed-in-rakuast.rakutest:212 + ------> *.chars == 1)|.AST.EVAL', :out<>, :err<>⏏, +1..37 +ok 1 - .say works with chained sequence and for +# Subtest: trace pragma works with hash shapes + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 2 - trace pragma works with hash shapes +ok 3 - phasers do not fire for loop that did not run +ok 4 - multiple m// works correctly +ok 5 - creating an object hash without specifying an 'of type' defaults to Mu +ok 6 - *.uc and *.lc are not considered equivalent +ok 7 - *.uc and *.uc are considered equivalent +ok 8 - equivalence is still correct for more complicated WhateverCodes # TODO This was working but has regressed +ok 9 - the :initialize flag is not sent to Set.STORE +ok 10 - Pointy blocks are parameterized with return types +ok 11 - Pointy blocks can be assigned to a parameterized Callable container +ok 12 - creating a constant without a name dies +ok 13 - wrapping infix:<|> works +ok 14 - wrapping postfix:<++> works +ok 15 - Colonpairs with indirect-lookup as variables work +ok 16 - Colonpairs with indirect-lookup as variables work (complex) +ok 17 - no error messages from code params to regexes (<.&a>) +ok 18 - no error messages from code params to regexes (<&a>) +ok 19 - eager on parenthesized range works without issue +ok 20 - Parametarization with DefiniteHOWs is not ignored in binding +ok 21 - Parametarization with DefiniteHOWs works where it should +ok 22 - Parameterization with DefiniteHOWs is propagated to scalar container +# Subtest: Ambiguous adverb usage results in coherent exception + 1..2 + ok 1 - code dies + ok 2 - right exception type (X::Syntax::AmbiguousAdverb) +ok 23 - Ambiguous adverb usage results in coherent exception +ok 24 - String indices work where valid in multi-dimensional array access +ok 25 - unsigned native parameters wrap around when provided with negative numbers +# Subtest: No useless use of sink reporting for [[&say]] + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 26 - No useless use of sink reporting for [[&say]] +# Subtest: No useless use of sink reporting for R[&say] + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 27 - No useless use of sink reporting for R[&say] +# Subtest: No useless use of sink reporting for user-declared function + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 28 - No useless use of sink reporting for user-declared function +# Subtest: '-n' compiler option iterates once per newline of input + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 29 - '-n' compiler option iterates once per newline of input +# Subtest: '-p' compiler option iterates once per newline of input and the topic is writeable + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 30 - '-p' compiler option iterates once per newline of input and the topic is writeable +# Subtest: topic variable is successfully lowered while using '-n' + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 31 - topic variable is successfully lowered while using '-n' +ok 32 - andthen chaining does not disrupt WhateverCode construction +# Subtest: repl can successfully use and instantiate a class ('Depth') that is shadowed and surpassed by an earlier used class ('Depth::One') + 1..2 + ok 1 - stdout is correct + ok 2 - stderr is correct +ok 33 - repl can successfully use and instantiate a class ('Depth') that is shadowed and surpassed by an earlier used class ('Depth::One') +# Subtest: no worry of a useless 'useless use' for parenthesized prime expression in where clause + 1..3 + ok 1 - STDOUT + ok 2 - STDERR + ok 3 - Exit code +ok 34 - no worry of a useless 'useless use' for parenthesized prime expression in where clause +ok 35 - stubbed classes that belong to parent package cause no issues when stubbed and defined within parent package scope +ok 36 - using the topic inside a 'with' and an embedded code block in a qq string +ok 37 - did the code do the right thing +ok + +Test Summary Report +------------------- +t/12-rakuast/stubs.rakutest (Wstat: 11 (Signal: SEGV) Tests: 0 Failed: 0) + Non-zero wait status: 11 + Parse errors: No plan found in TAP output +t/12-rakuast/xx-fixed-in-rakuast.rakutest (Wstat: 0 Tests: 37 Failed: 0) + TODO passed: 8 +Files=151, Tests=2485, 1709 wallclock secs ( 2.48 usr 0.54 sys + 1515.18 cusr 62.76 csys = 1580.96 CPU) +Result: FAIL +make[2]: *** [Makefile:1185: m-coretest5] Error 1 +make[2]: Leaving directory '/build/reproducible-path/rakudo-2024.09' make[2]: Entering directory '/build/reproducible-path/rakudo-2024.09' '/usr/bin/perl' -I'/build/reproducible-path/rakudo-2024.09/tools/lib' -I'/build/reproducible-path/rakudo-2024.09/3rdparty/nqp-configure/lib' t/harness5 --moar t/01-sanity t/02-rakudo t/04-nativecall t/05-messages t/06-telemetry t/07-pod-to-text t/08-performance t/10-qast t/09-moar t/12-rakuast t/01-sanity/01-literals.t ....................................... @@ -1167,13 +13590,13 @@ 1..6 not ok 1 - # TODO should fail due to requested comparison # Failed test at t/02-rakudo/06-is.t line 11 -# expected: 'Mu<74090528>' +# expected: 'Mu<62732128>' # got: (Mu) ok 2 - should fail due to requested comparison not ok 3 - # TODO should fail due to requested comparison # Failed test at t/02-rakudo/06-is.t line 12 # expected: (Mu) -# got: 'Mu<74090696>' +# got: 'Mu<62732296>' ok 4 - should fail due to requested comparison ok 5 - is(Mu:U, Mu:U) passes ok 6 - is(Mu:D, Mu:D) passes @@ -2306,7 +14729,7 @@ 1..3 ok 1 - 'class EmptyCStructTest is repr { };' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|70836512) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|96516888) ... } ok 28 - did we throws-like Exception? ok 29 - Can inline fixed sizes array (1) ok 30 - Can inline fixed sizes array (2) @@ -2628,11 +15051,11 @@ 1..9 ok 1 - Sanity check: Calling callback on thread that set it works ok 2 - Calling callback on another thread works (4) -ok 3 - Calling callback on another thread works (6) +ok 3 - Calling callback on another thread works (5) ok 4 - Calling callback on another thread works (1) -ok 5 - Calling callback on another thread works (2) +ok 5 - Calling callback on another thread works (6) ok 6 - Calling callback on another thread works (7) -ok 7 - Calling callback on another thread works (5) +ok 7 - Calling callback on another thread works (2) ok 8 - Calling callback on another thread works (3) ok 9 - Calling callback on another thread works (0) ok @@ -2683,81 +15106,81 @@ t/04-nativecall/24-cpp_param_letter.t ........................... 1..76 ok 1 - The object is-a 'Str' -ok 2 - test GNU Bool with :p, :r, :f +ok 2 - test GNU Bool with :j, :t, :y ok 3 - The object is-a 'Str' -ok 4 - test GNU int16 with :i, :s, :f +ok 4 - test GNU int16 with :j, :y, :z ok 5 - The object is-a 'Str' -ok 6 - test GNU int32 with :t, :c, :j +ok 6 - test GNU int32 with :i, :g, :y ok 7 - The object is-a 'Str' -ok 8 - test GNU int64 with :b, :s, :m +ok 8 - test GNU int64 with :e, :c, :m ok 9 - The object is-a 'Str' -ok 10 - test GNU int8 with :i, :s, :w +ok 10 - test GNU int8 with :x, :e, :i ok 11 - The object is-a 'Str' -ok 12 - test GNU NativeCall::Types::CArray[int] with :, :j, :l +ok 12 - test GNU NativeCall::Types::CArray[int] with :, :u, :k ok 13 - The object is-a 'Str' -ok 14 - test GNU NativeCall::Types::long with :m, :n, :i +ok 14 - test GNU NativeCall::Types::long with :l, :q, :m ok 15 - The object is-a 'Str' -ok 16 - test GNU NativeCall::Types::longlong with :j, :d, :l +ok 16 - test GNU NativeCall::Types::longlong with :n, :w, :z ok 17 - The object is-a 'Str' -ok 18 - test GNU NativeCall::Types::Pointer[int] with :, :c, :v +ok 18 - test GNU NativeCall::Types::Pointer[int] with :, :t, :l ok 19 - The object is-a 'Str' -ok 20 - test GNU NativeCall::Types::ulong with :p, :x, :d +ok 20 - test GNU NativeCall::Types::ulong with :k, :v, :z ok 21 - The object is-a 'Str' -ok 22 - test GNU NativeCall::Types::ulonglong with :y, :h, :n +ok 22 - test GNU NativeCall::Types::ulonglong with :d, :t, :w ok 23 - The object is-a 'Str' -ok 24 - test GNU NativeCall::Types::void with :y, :j, :q +ok 24 - test GNU NativeCall::Types::void with :p, :w, :u ok 25 - The object is-a 'Str' -ok 26 - test GNU num32 with :z, :n, :r +ok 26 - test GNU num32 with :g, :k, :d ok 27 - The object is-a 'Str' -ok 28 - test GNU num64 with :y, :f, :m +ok 28 - test GNU num64 with :w, :l, :q ok 29 - The object is-a 'Str' -ok 30 - test GNU Str with :, :t, :l +ok 30 - test GNU Str with :, :f, :w ok 31 - The object is-a 'Str' -ok 32 - test GNU uint16 with :l, :c, :s +ok 32 - test GNU uint16 with :t, :r, :i ok 33 - The object is-a 'Str' -ok 34 - test GNU uint32 with :p, :k, :l +ok 34 - test GNU uint32 with :s, :f, :r ok 35 - The object is-a 'Str' -ok 36 - test GNU uint64 with :y, :f, :r +ok 36 - test GNU uint64 with :d, :b, :f ok 37 - The object is-a 'Str' -ok 38 - test GNU uint8 with :z, :h, :j +ok 38 - test GNU uint8 with :l, :i, :v ok 39 - The object is-a 'Str' -ok 40 - test MSVC Bool with :b, :f, :g +ok 40 - test MSVC Bool with :t, :l, :m ok 41 - The object is-a 'Str' -ok 42 - test MSVC int16 with :h, :l, :q +ok 42 - test MSVC int16 with :v, :w, :h ok 43 - The object is-a 'Str' -ok 44 - test MSVC int32 with :l, :u, :e +ok 44 - test MSVC int32 with :w, :i, :o ok 45 - The object is-a 'Str' -ok 46 - test MSVC int64 with :e, :b, :f +ok 46 - test MSVC int64 with :q, :u, :y ok 47 - The object is-a 'Str' -ok 48 - test MSVC int8 with :p, :l, :b +ok 48 - test MSVC int8 with :i, :w, :a ok 49 - The object is-a 'Str' -ok 50 - test MSVC NativeCall::Types::CArray[int] with :e, :z, :s +ok 50 - test MSVC NativeCall::Types::CArray[int] with :e, :q, :k ok 51 - The object is-a 'Str' -ok 52 - test MSVC NativeCall::Types::long with :e, :l, :q +ok 52 - test MSVC NativeCall::Types::long with :v, :w, :e ok 53 - The object is-a 'Str' -ok 54 - test MSVC NativeCall::Types::longlong with :e, :v, :y +ok 54 - test MSVC NativeCall::Types::longlong with :r, :y, :a ok 55 - The object is-a 'Str' -ok 56 - test MSVC NativeCall::Types::Pointer[int] with :r, :v, :u +ok 56 - test MSVC NativeCall::Types::Pointer[int] with :d, :i, :s ok 57 - The object is-a 'Str' -ok 58 - test MSVC NativeCall::Types::ulong with :t, :e, :d +ok 58 - test MSVC NativeCall::Types::ulong with :y, :v, :z ok 59 - The object is-a 'Str' -ok 60 - test MSVC NativeCall::Types::ulonglong with :a, :x, :t +ok 60 - test MSVC NativeCall::Types::ulonglong with :j, :y, :c ok 61 - The object is-a 'Str' -ok 62 - test MSVC NativeCall::Types::void with :v, :s, :c +ok 62 - test MSVC NativeCall::Types::void with :a, :b, :r ok 63 - The object is-a 'Str' -ok 64 - test MSVC num32 with :d, :x, :q +ok 64 - test MSVC num32 with :k, :x, :d ok 65 - The object is-a 'Str' -ok 66 - test MSVC num64 with :s, :z, :f +ok 66 - test MSVC num64 with :v, :t, :w ok 67 - The object is-a 'Str' -ok 68 - test MSVC Str with :b, :p, :n +ok 68 - test MSVC Str with :l, :r, :c ok 69 - The object is-a 'Str' -ok 70 - test MSVC uint16 with :e, :r, :u +ok 70 - test MSVC uint16 with :r, :u, :b ok 71 - The object is-a 'Str' -ok 72 - test MSVC uint32 with :y, :d, :m +ok 72 - test MSVC uint32 with :p, :y, :s ok 73 - The object is-a 'Str' -ok 74 - test MSVC uint64 with :o, :f, :x +ok 74 - test MSVC uint64 with :e, :u, :m ok 75 - The object is-a 'Str' -ok 76 - test MSVC uint8 with :e, :t, :u +ok 76 - test MSVC uint8 with :b, :k, :u ok t/05-messages/01-errors.t ....................................... 1..51 @@ -2773,56 +15196,56 @@ 1..3 ok 1 - '‘' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|66615728) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|97250496) ... } ok 1 - ‘ (U+2018) quote is called curly, not smart # Subtest: ‚ (U+201A) quote is called curly, not smart 1..3 ok 1 - '‚' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|66616288) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94980536) ... } ok 2 - ‚ (U+201A) quote is called curly, not smart # Subtest: ’ (U+2019) quote is called curly, not smart 1..3 ok 1 - '’' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|66616408) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94980656) ... } ok 3 - ’ (U+2019) quote is called curly, not smart # Subtest: “ (U+201C) quote is called curly, not smart 1..3 ok 1 - '“' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|60054704) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94980896) ... } ok 4 - “ (U+201C) quote is called curly, not smart # Subtest: „ (U+201E) quote is called curly, not smart 1..3 ok 1 - '„' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|60054944) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94981136) ... } ok 5 - „ (U+201E) quote is called curly, not smart # Subtest: ” (U+201D) quote is called curly, not smart 1..3 ok 1 - '”' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|60055064) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94981256) ... } ok 6 - ” (U+201D) quote is called curly, not smart ok 2 - curly quotes are not called smart quotes # Subtest: typing "return" instead of "returns" gives a fixing hint 1..3 ok 1 - 'sub infix:<$>() return Nil {}' died ok 2 - right exception type (X::AdHoc) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|60057544) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94983736) ... } ok 3 - typing "return" instead of "returns" gives a fixing hint # Subtest: .Rat.nude on non-numeric string does not reference guts in error 1..3 ok 1 - ''4x'.Rat.nude' died ok 2 - right exception type (X::Str::Numeric) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|68490864) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|100958704) ... } ok 4 - .Rat.nude on non-numeric string does not reference guts in error # Subtest: stub code does not reference guts when executed 1..3 ok 1 - '…' died ok 2 - right exception type (X::StubCode) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|70052432) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|102388064) ... } ok 5 - stub code does not reference guts when executed # Subtest: chr with large codepoints throws useful error 1..6 @@ -2830,37 +15253,37 @@ 1..3 ok 1 - 'chr 2⁶³-1' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|68805304) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|114208392) ... } ok 1 - "chr 2⁶³-1" # Subtest: "(2⁶³-1).chr" 1..3 ok 1 - '(2⁶³-1).chr' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|68806824) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|114209912) ... } ok 2 - "(2⁶³-1).chr" # Subtest: "chr 2⁶³" 1..3 ok 1 - 'chr 2⁶³' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|68808304) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|114211392) ... } ok 3 - "chr 2⁶³" # Subtest: "2⁶³.chr" 1..3 ok 1 - '2⁶³.chr' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|84667152) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|114212912) ... } ok 4 - "2⁶³.chr" # Subtest: "chr 2¹⁰⁰" 1..3 ok 1 - 'chr 2¹⁰⁰' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|84668632) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|117141432) ... } ok 5 - "chr 2¹⁰⁰" # Subtest: "(2¹⁰⁰).chr" 1..3 ok 1 - '(2¹⁰⁰).chr' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|84670152) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|117142952) ... } ok 6 - "(2¹⁰⁰).chr" ok 6 - chr with large codepoints throws useful error # Subtest: <-> does not prevent an error suggesting to use `do for` @@ -3010,43 +15433,43 @@ 1..3 ok 1 - '42.length ' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|87305272) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|100959104) ... } ok 31 - .length on non-List Cool # Subtest: .length on List 1..3 ok 1 - '[].length ' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|86970792) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|123082216) ... } ok 32 - .length on List # Subtest: .length on non-Cool 1..3 ok 1 - 'bag(1).length ' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|81808592) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|117984000) ... } ok 33 - .length on non-Cool # Subtest: &length 1..3 ok 1 - 'length 42 ' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82114880) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|113451240) ... } ok 34 - &length # Subtest: error points out only only proto is defined 1..3 ok 1 - code dies ok 2 - right exception type (X::Multi::NoMatch) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82119520) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|113455880) ... } ok 35 - error points out only only proto is defined # Subtest: error points out only only proto is defined (Blob.split) 1..3 ok 1 - code dies ok 2 - right exception type (X::Multi::NoMatch) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82119880) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|113456240) ... } ok 36 - error points out only only proto is defined (Blob.split) # Subtest: error points out only only proto is defined (Blob.splice) 1..3 ok 1 - code dies ok 2 - right exception type (X::Multi::NoMatch) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82120120) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|113456480) ... } ok 37 - error points out only only proto is defined (Blob.splice) # Subtest: a private method of the same name as the public missing method is suggested 1..3 @@ -3083,7 +15506,7 @@ 1..3 ok 1 - ' class GH1758_1 { submethod x { }; }; class B is GH1758_1 {}; B.new._ ' died ok 2 - right exception type (X::Method::NotFound) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|90959304) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|125128760) ... } ok 43 - Ancestor submethods should not be typo-suggested # Subtest: Submethods at the same inheritance level should be typo-suggested 1..3 @@ -3118,7 +15541,7 @@ 1..3 ok 1 - 'Blob[num32].new: 2e0' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|91341224) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|125529192) ... } ok 49 - sane NYI error for num32 Blob # Subtest: callframe.my throws sane NYI error message 1..2 @@ -3131,109 +15554,109 @@ 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406600) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722592) ... } ok 1 - int no args # Subtest: int with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406720) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722712) ... } ok 2 - int with args # Subtest: int8 no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406760) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722752) ... } ok 3 - int8 no args # Subtest: int8 with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406800) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722792) ... } ok 4 - int8 with args # Subtest: int16 no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406840) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722832) ... } ok 5 - int16 no args # Subtest: int16 with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406880) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722872) ... } ok 6 - int16 with args # Subtest: int32 no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406920) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722912) ... } ok 7 - int32 no args # Subtest: int32 with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92406960) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722952) ... } ok 8 - int32 with args # Subtest: int64 no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407000) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121722992) ... } ok 9 - int64 no args # Subtest: int64 with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407040) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723032) ... } ok 10 - int64 with args # Subtest: num no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407080) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723072) ... } ok 11 - num no args # Subtest: num with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407120) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723112) ... } ok 12 - num with args # Subtest: num32 no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407160) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723152) ... } ok 13 - num32 no args # Subtest: num32 with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407200) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723192) ... } ok 14 - num32 with args # Subtest: num64 no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407240) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723232) ... } ok 15 - num64 no args # Subtest: num64 with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407280) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723272) ... } ok 16 - num64 with args # Subtest: str no args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407320) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723312) ... } ok 17 - str no args # Subtest: str with args 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92407360) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|121723352) ... } ok 18 - str with args ok 51 - .new on native types works (deprecated; will die) ok @@ -3268,7 +15691,7 @@ 1..3 ok 1 - code dies ok 2 - right exception type (X::Assignment::RO) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|18375880) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|80000880) ... } ok 6 - Trying to assign to immutable List element gives useful error # Subtest: death in whenevered Supply referenced original location of throw 1..3 @@ -3301,7 +15724,7 @@ 1..3 ok 1 - 'my $x; $x = 50; 42 = $x' died ok 2 - right exception type (X::Assignment::RO) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|71327936) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|80733824) ... } ok 9 - RO assignment indicates value of the thing being assigned into # Subtest: declaring enum with uninitialized hash warns about it 1..3 @@ -3355,14 +15778,14 @@ 1..3 ok 1 - code dies ok 2 - right exception type (X::Multi::Ambiguous) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|2922367440) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3995462528) ... } ok 18 - an ambiguous call includes the arguments in the error message # Subtest: sprintf %d directive with one directive and no corresponding argument throws 1..4 ok 1 - code dies ok 2 - right exception type (X::Str::Sprintf::Directives::Count) - ok 3 - .args-have matches 0 - ok 4 - .args-used matches 1 + ok 3 - .args-used matches 1 + ok 4 - .args-have matches 0 ok 19 - sprintf %d directive with one directive and no corresponding argument throws # Subtest: error message when binding to native int array 1..3 @@ -3558,13 +15981,13 @@ # my @a = 1..200; z(@a, <1>, :x[1..200]) # ' died ok 2 - right exception type (X::Multi::NoMatch) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|2884613192) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|84960608) ... } ok 38 - X::Multi::NoMatch does not dump entire contents of variables # Subtest: X::Assignment::RO does not dump entire contents of variables 1..3 ok 1 - 'Set.new(1..300)<42> = 42' died ok 2 - right exception type (X::Assignment::RO) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77294520) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|84967168) ... } ok 39 - X::Assignment::RO does not dump entire contents of variables # Subtest: cannot use Int type object as an operand 1..14 @@ -3651,7 +16074,7 @@ 1..3 ok 1 - code dies ok 2 - right exception type (X::Assignment::RO) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78835104) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|91401272) ... } ok 42 - Trying to assign to immutable Range element gives useful error # Subtest: optimizer flag gets propagated to EVAL 1..3 @@ -3663,25 +16086,25 @@ 1..3 ok 1 - 'use 6.0;' died ok 2 - right exception type (X::Undeclared::Symbols) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|83842496) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|92938272) ... } ok 44 - suggests to use "use v6;" or "use v6.c;" when "use 6.0" is called # Subtest: suggests to use "use v6;" or "use v6.c;" when "need 6.0" is called 1..3 ok 1 - 'need 6.0;' died ok 2 - right exception type (X::Undeclared::Symbols) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82620512) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|87681920) ... } ok 45 - suggests to use "use v6;" or "use v6.c;" when "need 6.0" is called # Subtest: suggests to use "use v6;" or "use v6.c;" when "need v6.0" is called 1..3 ok 1 - 'need v6.0;' died ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82621272) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|87682680) ... } ok 46 - suggests to use "use v6;" or "use v6.c;" when "need v6.0" is called # Subtest: detached non-alpha method says what the problem is 1..3 ok 1 - '^42 .^methods.say' died ok 2 - right exception type (X::Syntax::Malformed) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82622112) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|91031456) ... } ok 47 - detached non-alpha method says what the problem is ok t/05-messages/03-errors.t ....................................... @@ -3724,25 +16147,25 @@ 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|90700448) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78053208) ... } ok 1 - type only, with wrong type given # Subtest: type + where, with wrong type given 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|90700688) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78053448) ... } ok 2 - type + where, with wrong type given # Subtest: type only, with failing constraint 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|90701448) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78054208) ... } ok 3 - type only, with failing constraint # Subtest: type + where, with failing constraint 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|90701608) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|78054368) ... } ok 4 - type + where, with failing constraint ok 5 - subsets get named in typecheck errors # Subtest: like/unlike failures give useful diagnostics @@ -3764,7 +16187,7 @@ 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94083896) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3994297224) ... } ok 7 - trying to bind Proc::Async to unopened handle gives useful error # Subtest: unclosed hash quote index operator <> message 1..2 @@ -3782,10 +16205,10 @@ 1..3 ok 1 - 'say $<' died ok 2 - right exception type (X::Comp::AdHoc) - not ok 3 - .gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94091136) ... } # TODO remove "expecting any of:" - # Failed test '.gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|94091136) ... }' + not ok 3 - .gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|76266192) ... } # TODO remove "expecting any of:" + # Failed test '.gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|76266192) ... }' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 - # Expected: -> ;; $_? is raw = OUTER::<$_> { #`(Block|94091136) ... } + # Expected: -> ;; $_? is raw = OUTER::<$_> { #`(Block|76266192) ... } # Got: ===SORRY!=== Error while compiling /build/reproducible-path/rakudo-2024.09/EVAL_6 # Unable to parse quote-words subscript; couldn't find '>' (corresponding '<' was at line 1) # at /build/reproducible-path/rakudo-2024.09/EVAL_6:1 @@ -3801,7 +16224,7 @@ 1..3 ok 1 - 'Int:erator:$;' died ok 2 - right exception type (X::InvalidTypeSmiley) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|91689344) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|76267992) ... } ok 9 - Don't report "missing semicolon" when semicolon present with complicated punctuation. # Subtest: non-found module in core namespace is not claimed to be built-in 1..3 @@ -3817,7 +16240,7 @@ # -> Supercalifragilisticexpialidocious {}($x) # ' died ok 2 - right exception type (X::TypeCheck) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|91695224) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|79928160) ... } ok 11 - X::TypeCheck does not prematurely chop off the .raku # Subtest: .polymod with zero divisor does not reference guts in error 1..4 @@ -4026,19 +16449,19 @@ 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|72838888) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|81892648) ... } ok 1 - (1) # Subtest: (2) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|72839648) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|81893408) ... } ok 2 - (2) # Subtest: (3) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77109472) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82962184) ... } ok 3 - (3) ok 1 - .roll # Subtest: .indent @@ -4047,37 +16470,37 @@ 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77112392) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82965104) ... } ok 1 - (1) # Subtest: (2) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77112512) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82965224) ... } ok 2 - (2) # Subtest: (3) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77112632) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82965344) ... } ok 3 - (3) # Subtest: (4) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77116192) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82968904) ... } ok 4 - (4) # Subtest: (5) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77116312) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82969024) ... } ok 5 - (5) # Subtest: (6) 1..3 ok 1 - code dies ok 2 - right exception type (Exception) - ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|77116432) ... } + ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|82969144) ... } ok 6 - (6) ok 2 - .indent ok @@ -10341,16 +22764,16 @@ 1..4 ok 1 - code dies ok 2 - right exception type (X::Phaser::PrePost) - ok 3 - .phaser matches PRE - ok 4 - .message matches Precondition '++$pre' failed + ok 3 - .message matches Precondition '++$pre' failed + ok 4 - .phaser matches PRE ok 14 - Str: PRE phaser throws ok 15 - Raku: did we get a Block # Subtest: Raku: PRE phaser throws 1..4 ok 1 - code dies ok 2 - right exception type (X::Phaser::PrePost) - ok 3 - .phaser matches PRE - ok 4 - .message matches Precondition '++$pre' failed + ok 3 - .message matches Precondition '++$pre' failed + ok 4 - .phaser matches PRE ok 16 - Raku: PRE phaser throws 1..16 ok 27 - Block with PRE phaser thunk @@ -10393,8 +22816,8 @@ 1..4 ok 1 - code dies ok 2 - right exception type (X::Phaser::PrePost) - ok 3 - .phaser matches PRE - ok 4 - .message matches / '++$pre' / + ok 3 - .message matches / '++$pre' / + ok 4 - .phaser matches PRE ok 18 - Raku: PRE phaser throws ok 19 - Raku: PRE actually ran 1..19 @@ -10465,8 +22888,8 @@ 1..4 ok 1 - code dies ok 2 - right exception type (X::Phaser::PrePost) - ok 3 - .phaser matches POST - ok 4 - .message matches / '$post = $_' / + ok 3 - .message matches / '$post = $_' / + ok 4 - .phaser matches POST ok 12 - AST: POST phaser throws ok 13 - AST: POST actually ran ok 14 - Str: did we get a Block @@ -12157,21 +24580,21 @@ 1..4 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) - not ok 3 - .expected matches (Int) # TODO string EVAL produces different error - # Failed test '.expected matches (Int)' + not ok 3 - .got matches 100000 # TODO string EVAL produces different error + # Failed test '.got matches 100000' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 Use of uninitialized value element of type Any in string context. Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 - # Expected: Int + # Expected: 100000e0 # Got: - not ok 4 - .got matches 100000 # TODO string EVAL produces different error - # Failed test '.got matches 100000' + not ok 4 - .expected matches (Int) # TODO string EVAL produces different error + # Failed test '.expected matches (Int)' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 Use of uninitialized value element of type Any in string context. Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 - # Expected: 100000e0 + # Expected: Int # Got: not ok 3 - did we throws-like X::TypeCheck::Assignment? # TODO string EVAL produces different error # Failed test 'did we throws-like X::TypeCheck::Assignment?' @@ -12180,8 +24603,8 @@ 1..4 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) - ok 3 - .got matches 100000 - ok 4 - .expected matches (Int) + ok 3 - .expected matches (Int) + ok 4 - .got matches 100000 ok 4 - did we throws-like X::TypeCheck::Assignment? # state Int $foo; # $foo = 100000e0; @@ -12191,28 +24614,28 @@ 1..4 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) - ok 3 - .expected matches (Int) - ok 4 - .got matches 100000 + ok 3 - .got matches 100000 + ok 4 - .expected matches (Int) ok 6 - did we throws-like X::TypeCheck::Assignment? # Subtest: did we throws-like X::TypeCheck::Assignment? 1..4 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) - not ok 3 - .expected matches (Int) # TODO string EVAL produces different error - # Failed test '.expected matches (Int)' + not ok 3 - .got matches 100000 # TODO string EVAL produces different error + # Failed test '.got matches 100000' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 Use of uninitialized value element of type Any in string context. Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 - # Expected: Int + # Expected: 100000e0 # Got: - not ok 4 - .got matches 100000 # TODO string EVAL produces different error - # Failed test '.got matches 100000' + not ok 4 - .expected matches (Int) # TODO string EVAL produces different error + # Failed test '.expected matches (Int)' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5725 Use of uninitialized value element of type Any in string context. Methods .^name, .raku, .gist, or .say can be used to stringify it to something meaningful. in block at /build/reproducible-path/rakudo-2024.09/lib/Test.rakumod (Test) line 646 - # Expected: 100000e0 + # Expected: Int # Got: not ok 7 - did we throws-like X::TypeCheck::Assignment? # TODO string EVAL produces different error # Failed test 'did we throws-like X::TypeCheck::Assignment?' @@ -12948,7 +25371,7 @@ ------------------- t/12-rakuast/xx-fixed-in-rakuast.rakutest (Wstat: 0 Tests: 37 Failed: 0) TODO passed: 8 -Files=151, Tests=2491, 3337 wallclock secs ( 7.59 usr 1.52 sys + 4114.01 cusr 245.10 csys = 4368.22 CPU) +Files=151, Tests=2491, 1570 wallclock secs ( 2.44 usr 0.60 sys + 1290.50 cusr 53.34 csys = 1346.88 CPU) Result: PASS make[2]: Leaving directory '/build/reproducible-path/rakudo-2024.09' make[1]: Leaving directory '/build/reproducible-path/rakudo-2024.09' @@ -12957,13 +25380,13 @@ debian/rules override_dh_auto_install make[1]: Entering directory '/build/reproducible-path/rakudo-2024.09' dh_auto_install - make -j3 install DESTDIR=/build/reproducible-path/rakudo-2024.09/debian/rakudo AM_UPDATE_INFO_DIR=no "INSTALL=install --strip-program=true" + make -j4 install DESTDIR=/build/reproducible-path/rakudo-2024.09/debian/rakudo AM_UPDATE_INFO_DIR=no "INSTALL=install --strip-program=true" make[2]: Entering directory '/build/reproducible-path/rakudo-2024.09' +++ Creating installation directories +++ Preparing installation +++ Removing old files +++ Installing files - Installed 24 core modules in 316.453053711 seconds! + Installed 24 core modules in 178.066410945 seconds! +++ MOAR BACKEND INSTALLED +++ Installing MOAR launchers +++ Creating Raku executable alias @@ -13018,12 +25441,14 @@ dpkg-buildpackage: info: binary-only upload (no source included) dpkg-genchanges: info: including full source code in upload I: copying local configuration +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/B01_cleanup starting +I: user script /srv/workspace/pbuilder/8797/tmp/hooks/B01_cleanup finished I: unmounting dev/ptmx filesystem I: unmounting dev/pts filesystem I: unmounting dev/shm filesystem I: unmounting proc filesystem I: unmounting sys filesystem I: cleaning the build env -I: removing directory /srv/workspace/pbuilder/17092 and its subdirectories -I: Current time: Thu Nov 7 10:27:59 -12 2024 -I: pbuilder-time-stamp: 1731018479 +I: removing directory /srv/workspace/pbuilder/8797 and its subdirectories +I: Current time: Fri Nov 8 13:46:35 +14 2024 +I: pbuilder-time-stamp: 1731023195