>>> rakudo: Building community/rakudo 2026.08-r0 (using abuild 3.18.0_rc7-r1) started Wed, 14 Oct 2026 03:43:25 +0000 >>> rakudo: Validating /home/buildozer/aports/community/rakudo/APKBUILD... >>> rakudo: Analyzing dependencies... >>> rakudo: Installing for build: build-base nqp~2026.08 moarvm-dev~2026.08 perl-utils perl-test-harness ( 1/22) Installing libffi (3.8.0-r0) ( 2/22) Installing mimalloc2 (2.2.7-r0) ( 3/22) Installing libuv (1.52.1-r0) ( 4/22) Installing moarvm (2026.08-r0) ( 5/22) Installing nqp (2026.08-r0) ( 6/22) Installing linux-headers (7.2.1-r0) ( 7/22) Installing libffi-dev (3.8.0-r0) ( 8/22) Installing libuv-dev (1.52.1-r0) ( 9/22) Installing mimalloc2-debug (2.2.7-r0) (10/22) Installing mimalloc2-insecure (2.2.7-r0) (11/22) Installing mimalloc2-dev (2.2.7-r0) (12/22) Installing libbz2 (1.0.8-r6) (13/22) Installing perl (5.44.0-r0) (14/22) Installing zstd (1.5.7-r2) (15/22) Installing zstd-dev (1.5.7-r2) (16/22) Installing moarvm-dev (2026.08-r0) (17/22) Installing perl-utils (5.44.0-r0) (18/22) Installing perl-test-harness (3.52-r0) (19/22) Installing .makedepends-rakudo (20261014.034329) (20/22) Installing perl-error (0.17030-r0) (21/22) Installing perl-git (2.56.0-r0) (22/22) Installing git-perl (2.56.0-r0) Executing busybox-1.38.0-r7.trigger OK: 352.7 MiB in 124 packages >>> rakudo: Cleaning up srcdir >>> rakudo: Cleaning up pkgdir >>> rakudo: Cleaning up tmpdir >>> rakudo: Fetching https://distfiles.alpinelinux.org/distfiles/v3.25/rakudo-2026.08.tar.gz Connecting to distfiles.alpinelinux.org (172.105.82.32:443) saving to '/var/cache/distfiles/v3.25/rakudo-2026.08.tar.gz.part' rakudo-2026.08.tar.g 100% |********************************| 8440k 0:00:00 ETA '/var/cache/distfiles/v3.25/rakudo-2026.08.tar.gz.part' saved /var/cache/distfiles/v3.25/rakudo-2026.08.tar.gz: OK /home/buildozer/aports/community/rakudo/telemetry-tests-32bit.patch: OK >>> rakudo: Fetching https://distfiles.alpinelinux.org/distfiles/v3.25/rakudo-2026.08.tar.gz /var/cache/distfiles/v3.25/rakudo-2026.08.tar.gz: OK /home/buildozer/aports/community/rakudo/telemetry-tests-32bit.patch: OK >>> rakudo: Unpacking /var/cache/distfiles/v3.25/rakudo-2026.08.tar.gz... >>> rakudo: telemetry-tests-32bit.patch patching file t/06-telemetry/01-basic.t Using /usr/bin/nqp-m (version 2026.08 / MoarVM 2026.08). Cleaning up ... You can now use 'make' to build Rakudo. After that, 'make test' will run some tests and 'make install' will install Rakudo. +++ Checking for moar NQP version +++ Generating gen/moar/Grammar.nqp +++ Generating gen/moar/World.nqp +++ Generating gen/moar/ModuleLoader.nqp +++ Generating gen/moar/Ops.nqp +++ Compiling dynext/libperl6_ops_moar.so +++ Generating gen/moar/Pod.nqp +++ Generating gen/moar/Actions.nqp +++ Generating gen/moar/RakuGrammar.nqp +++ Generating gen/moar/RakuActions.nqp +++ Generating gen/moar/Compiler.nqp +++ Generating gen/moar/Optimizer.nqp +++ Generating gen/moar/Metamodel.nqp +++ Generating gen/moar/SysConfig.nqp +++ Generating gen/moar/ast.nqp +++ Generating gen/moar/BOOTSTRAP/v6d.nqp +++ Generating gen/moar/BOOTSTRAP/v6e.nqp +++ Compiling inst-rakudo +++ Compiling inst-rakudo-debug +++ Compiling inst-rakudo-m +++ Compiling inst-rakudo-debug-m +++ Compiling inst-perl6 +++ Compiling inst-perl6-debug +++ Compiling inst-perl6-m +++ Compiling inst-perl6-debug-m In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:90, from src/vm/moar/ops/perl6_ops.c:2: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition +++ Expanding gen/moar/main-version.nqp In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:2, from src/vm/moar/runner/main.c:5: /usr/include/moar/gen/config.h:113:9: warning: 'MVM_DO_PTY_OURSELF' redefined 113 | #define MVM_DO_PTY_OURSELF | ^~~~~~~~~~~~~~~~~~ : note: this is the location of the previous definition In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ +++ Compiling blib/Perl6/SysConfig.moarvm In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ In file included from /usr/include/moar/moar.h:90: /usr/include/moar/core/nativecall.h: In function 'MVM_nativecall_find_thread_context': /usr/include/moar/platform/threads.h:19:34: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] 19 | #define MVM_platform_thread_id() (MVMint64)uv_thread_self() | ^ /usr/include/moar/core/nativecall.h:148:19: note: in expansion of macro 'MVM_platform_thread_id' 148 | MVM_platform_thread_id()); | ^~~~~~~~~~~~~~~~~~~~~~ +++ Compiling blib/Perl6/Pod.moarvm +++ Compiling blib/Perl6/ModuleLoader.moarvm +++ Generating gen/moar/rakudo.nqp +++ Generating gen/moar/rakudo-debug.nqp +++ Compiling blib/Perl6/Ops.moarvm +++ Compiling blib/Perl6/Metamodel.moarvm +++ Compiling blib/Perl6/World.moarvm +++ Compiling blib/Perl6/Actions.moarvm +++ Compiling blib/Raku/Actions.moarvm +++ Compiling blib/Perl6/Optimizer.moarvm +++ Compiling blib/Perl6/BOOTSTRAP/v6d.moarvm +++ Compiling blib/Perl6/BOOTSTRAP/v6e.moarvm +++ Compiling blib/Raku/Grammar.moarvm +++ Compiling blib/Perl6/Compiler.moarvm +++ Generating gen/moar/BOOTSTRAP/v6c.nqp +++ Compiling blib/Perl6/BOOTSTRAP/v6c.moarvm +++ Compiling blib/Perl6/Grammar.moarvm +++ Compiling rakudo.moarvm +++ Compiling rakudo-debug.moarvm +++ Generating rakudo-gdb-m +++ Generating rakudo-lldb-m +++ Generating rakudo-valgrind-m +++ Generating perl6-gdb-m +++ Generating perl6-lldb-m +++ Generating perl6-valgrind-m +++ Compiling blib/CORE.c.setting.moarvm The following step can take a long time, please be patient. Stage start : 0.000 Stage parse : 91.365 Stage syntaxcheck: 0.000 Stage ast : 0.000 Stage optimize : 10.634 Stage mast : 21.747 Stage mbc : 3.625 +++ Compiling blib/CORE.d.setting.moarvm The following step can take a long time, please be patient. Stage start : 0.000 Stage parse : 0.544 Stage syntaxcheck: 0.000 Stage ast : 0.000 Stage optimize : 0.039 Stage mast : 0.061 Stage mbc : 0.013 +++ Compiling blib/CORE.e.setting.moarvm The following step can take a long time, please be patient. Stage start : 0.000 Stage parse : 4.533 Stage syntaxcheck: 0.000 Stage ast : 0.000 Stage optimize : 0.465 Stage mast : 0.710 Stage mbc : 0.056 +++ Generating rakudo-m >>> rakudo: Running 48 parallel test jobs 'perl' -I'/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/lib' -I'/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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/13-experimental t/14-smoke t/09-moar t/12-rakuast t/01-sanity/16-eqv.t ............................................ 1..1 ok 1 ok 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/20-defined.t ........................................ 1..3 ok 1 ok 2 ok 3 ok t/01-sanity/09-end-blocks.t ..................................... 1..2 ok 1 ok 2 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/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/13-equal.t .......................................... 1..4 ok 1 ok 2 ok 3 ok 4 ok t/01-sanity/15-sub.t ............................................ 1..4 ok 1 ok 2 ok 3 ok 4 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/12-counter.t ........................................ 1..4 ok 1 ok 2 ok 3 ok 4 ok t/01-sanity/21-try.t ............................................ 1..4 ok 1 ok 2 ok 3 ok 4 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/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/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/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/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/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/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/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/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/02-rakudo/12-proto-location.t ................................. 1..3 ok 1 - an onlystar proto reports the file it was declared in ok 2 - an onlystar proto reports the line it was declared on ok 3 - a junction smartmatched against a definite type autothreads 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/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<4133136264>' # 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<4133136432>' 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/04-settingkeys-6d.t ................................. 1..2 ok 1 - all allowed symbols found ok 2 - No unexpected entries in SETTING:: ok t/02-rakudo/05-range-in-range.t ................................. 1..9 ok 1 - 5 is in range 0 1 2 3 4 5 6 7 8 9 ok 2 - 42 is in range 0..^* ok 3 - Inf is in range *..* ok 4 - -Inf is in range *..* # Subtest: 99 is not in range 0 1 2 3 4 5 6 7 8 9 1..2 ok 1 - code dies ok 2 - right exception type (X::OutOfRange) ok 5 - 99 is not in range 0 1 2 3 4 5 6 7 8 9 # Subtest: Inf is not in range 0..^* 1..2 ok 1 - code dies ok 2 - right exception type (X::OutOfRange) ok 6 - Inf is not in range 0..^* # Subtest: Inf is not in range *^..^* 1..2 ok 1 - code dies ok 2 - right exception type (X::OutOfRange) ok 7 - Inf is not in range *^..^* # Subtest: NaN is not in range *..* 1..2 ok 1 - code dies ok 2 - right exception type (X::OutOfRange) ok 8 - NaN is not in range *..* # Subtest: 0/0 is not in -Inf^..^Inf range 1..3 ok 1 - code dies ok 2 - right exception type (X::OutOfRange) ok 3 - .message matches /'<0/0>' | '⁰/₀' / ok 9 - 0/0 is not in -Inf^..^Inf range ok t/02-rakudo/adverb-on-noncall-infix.t ........................... 1..5 # Subtest: can't adverb a short-circuit infix 1..2 ok 1 - 'my %h; True && %h:exists' died ok 2 - right exception type (X::Syntax::Adverb) ok 1 - can't adverb a short-circuit infix # Subtest: can't adverb a chaining infix 1..2 ok 1 - 'my %h; 1 == %h:exists' died ok 2 - right exception type (X::Syntax::Adverb) ok 2 - can't adverb a chaining infix # Subtest: can't adverb a thunky list infix 1..2 ok 1 - 'my %h; True ^^ %h:exists' died ok 2 - right exception type (X::Syntax::Adverb) ok 3 - can't adverb a thunky list infix ok 4 - an adverb on a subscript still works ok 5 - a loose infix leaves the adverb on the subscript ok t/02-rakudo/23-self-call-loop-modifier.t ........................ 1..2 ok 1 - the method returns its lexical after the modifier loop ok 2 - each iteration passed the lexical to the self-call ok t/02-rakudo/21-trial-bind-generic.t ............................. ok 1 - role body can call a sub with a type-capture argument 1..1 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/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/09-thread-id-after-await.t .......................... 1..1 # original ok 1 - Correct dynamic seen after invokving continuation on different thread ok t/02-rakudo/25-run-main-enum.t .................................. 1..4 ok 1 - positional enum argument dispatches when the enum is not in scope ok 2 - named enum argument dispatches when the enum is not in scope ok 3 - enum argument dispatches alongside a Str argument ok 4 - word that is not an enum key still arrives as a Str ok t/02-rakudo/22-traited-variable-by-name.t ....................... 1..3 ok 1 - the LEAVE phaser of each loop iteration receives that iteration value ok 2 - a LEAVE phaser added by a custom does trait receives the traited variable ok 3 - a will leave phaser receives its variable ok t/02-rakudo/25-regex-unspace.t .................................. 1..12 ok 1 - regex {} with a leading escaped hash matches a literal hash ok 2 - token {} with a leading escaped hash matches a literal hash ok 3 - rule {} with a leading escaped hash matches a literal hash ok 4 - a named regex with a leading escaped hash matches a literal hash ok 5 - an escaped hash after whitespace mid-regex stays an escape ok 6 - an escaped hash after sigspace stays an escape ok 7 - an escaped hash does not comment out the rest of its line ok 8 - a line comment at the start of a regex body still works ok 9 - a multi-line embedded comment at the start of a regex body still works ok 10 - rule {} sigspace still applies between atoms # Subtest: a backslash before whitespace mid-regex reports the no-unspace error 1..2 ok 1 - ' rx/ a \ b / ' died ok 2 - right exception type (X::Syntax::Regex::Unspace) ok 11 - a backslash before whitespace mid-regex reports the no-unspace error # Subtest: a backslash before whitespace in a regex body reports the no-unspace error 1..2 ok 1 - ' my regex r { \ } ' died ok 2 - right exception type (X::Syntax::Regex::Unspace) ok 12 - a backslash before whitespace in a regex body reports the no-unspace error ok t/02-rakudo/20-begin-time-loop-init.t ........................... ok 1 - while body inside a BEGIN-time initializer runs for side effects ok 2 - until body inside a BEGIN-time initializer runs for side effects ok 3 - repeat-while body inside a BEGIN-time initializer runs before checking the condition ok 4 - repeat-until body inside a BEGIN-time initializer runs before checking the condition ok 5 - a constant whose value is the side-effect result of a preceding loop is kept ok 6 - and the accumulated value reflects every iteration of that loop 1..6 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/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/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/21-begin-time-eval-context.t ........................ 1..9 ok 1 - BEGIN-time string EVAL sees the caller $/ ok 2 - BEGIN-time string EVAL sees the caller $! ok 3 - BEGIN-time string EVAL sees the caller $_ ok 4 - BEGIN-time string EVAL writes through to the caller $_ ok 5 - BEGIN-time string EVAL sees a lexical of the calling block ok 6 - BEGIN-time string EVAL sees the caller $?PACKAGE ok 7 - our-scoped variable EVALed at BEGIN time lands in the caller package ok 8 - our-scoped variable EVALed at BEGIN time does not leak into GLOBAL ok 9 - our-scoped sub EVALed at BEGIN time lands in the caller package 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/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/02-rakudo/25-min-max-by-key.t ................................. 1..39 ok 1 - .min with a key function finds the first minimal value ok 2 - .min called the key function once per value ok 3 - .max with a key function finds the first maximal value ok 4 - .max called the key function once per value ok 5 - .min of a single value returns that value ok 6 - .min of a single value called the key function once ok 7 - .min with a key function skips type objects ok 8 - .min never called the key function on a type object ok 9 - .max with a block using the topic finds the maximum ok 10 - .max called the topic block once per value ok 11 - .min with a 2-arg comparator finds the minimum ok 12 - .min called the comparator once per value after the first ok 13 - .max with a 2-arg comparator finds the maximum ok 14 - .max called the comparator once per value after the first ok 15 - .max with a key function keeps the first of tied values ok 16 - .minpairs with a key function keeps all tied values ok 17 - .minpairs called the key function once per value ok 18 - .maxpairs with a key function keeps all maximal values ok 19 - .maxpairs called the key function once per value ok 20 - .min(:k) with a key function returns the keys of the minimal values ok 21 - .min(:k) called the key function once per value ok 22 - .max(:v) with a key function returns the maximal values ok 23 - .max(:v) called the key function once per value ok 24 - .minpairs with a 2-arg comparator keeps all minimal values ok 25 - .minpairs called the comparator once per value after the first ok 26 - .minmax with a key function finds the minimal and maximal values ok 27 - .minmax called the key function once per value ok 28 - .minmax with a key function compares Range values by their endpoints ok 29 - .minmax called the key function once per endpoint and value ok 30 - .minmax with a key function preserves endpoint exclusions ok 31 - .minmax with a key function recurses into Positional values ok 32 - .minmax with a 2-arg comparator finds the minimal and maximal values ok 33 - Supply.min with a key function emits each new minimum ok 34 - Supply.min called the key function once per value ok 35 - Supply.max with a key function emits each new maximum ok 36 - Supply.max called the key function once per value ok 37 - Supply.minmax with a key function emits each widened range ok 38 - Supply.minmax called the key function once per value ok 39 - Supply.min with a 2-arg comparator emits each new minimum 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/anon-method-in-role-invocant.t ...................... 1..5 ok 1 - a named anon method from a role is callable when added to an unrelated class ok 2 - the same anon method works on a different type ok 3 - a my method from a role is callable when added to an unrelated class ok 4 - the anon method invocant is not constrained to the concrete role ok 5 - the my method invocant is not constrained to the concrete role ok t/02-rakudo/attribute-junction-default.t ........................ 1..3 ok 1 - an attribute with a Junction default value constructs ok 2 - the Junction default bound as a Junction ok 3 - a default value referencing self still works ok t/02-rakudo/attr-default-nil-typed.t ............................ 1..3 ok 1 - `has TypedClass $.x = Nil` compiles and constructs ok 2 - `= Nil` default yields the type object ok 3 - `= Nil` honors `is default(...)` ok t/02-rakudo/anon-decl-hash-literal.t ............................ 1..4 ok 1 - a pair whose value is an anon subset makes a hash ok 2 - the anon-subset value is stored in the hash and still type-checks ok 3 - a pair whose value is an anon enum stays a block ok 4 - a plain pair makes a hash ok t/02-rakudo/attributive-param-in-nested-sub.t ................... 1..4 ok 1 - a $!attr parameter in a sub nested in a method binds the attribute ok 2 - a $!attr parameter in a Proxy STORE sub binds and reads back ok 3 - plain $!attr access in a sub nested in a method still works # Subtest: a $!attr parameter in a sub with no enclosing method is rejected 1..2 ok 1 - 'sub f($!x) { }' died ok 2 - right exception type (X::Syntax::NoSelf) ok 4 - a $!attr parameter in a sub with no enclosing method is rejected ok t/02-rakudo/anon-subset.t ....................................... 1..6 ok 1 - an anon subset carries its declared name ok 2 - an anon subset accepts a matching value ok 3 - an anon subset rejects a non-matching value # Subtest: an anon subset does not install its name 1..2 ok 1 - 'anon subset Foo of Int where * < 5; Foo' died ok 2 - right exception type (X::Undeclared::Symbols) ok 4 - an anon subset does not install its name # Subtest: an anon enum does not install its name 1..2 ok 1 - 'anon enum Bar ; Bar' died ok 2 - right exception type (X::Undeclared::Symbols) ok 5 - an anon enum does not install its name ok 6 - a my-scoped subset still installs and type-checks ok t/02-rakudo/12-proto-arity-count.t .............................. 1..345 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 - `&gist`'s proto's .count and .arity are good ok 76 - `&goto`'s proto's .count and .arity are good ok 77 - `&grep`'s proto's .count and .arity are good ok 78 - `&hash`'s proto's .count and .arity are good ok 79 - `&index`'s proto's .count and .arity are good ok 80 - `&indices`'s proto's .count and .arity are good ok 81 - `&indir`'s proto's .count and .arity are good ok 82 - `&infix:<^^>`'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 - # SKIP `infix:«(<+)»` is not a multi ok 94 - `&infix:«(>=)»`'s proto's .count and .arity are good ok 95 - `&infix:«(>)»`'s proto's .count and .arity are good ok 96 - # SKIP `infix:«(>+)»` is not a multi ok 97 - `&infix:<=~=>`'s proto's .count and .arity are good 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:<(cont)>`'s proto's .count and .arity are good ok 139 - `&infix:<∌>`'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 - # SKIP `infix:<≼>` is not a multi ok 145 - # SKIP `infix:<≽>` is not a multi ok 146 - `&infix:<⚛-=>`'s proto's .count and .arity are good 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:<(cont)>`'s proto's .count and .arity are good ok 164 - `&infix:
`'s proto's .count and .arity are good ok 165 - `&infix:`'s proto's .count and .arity are good ok 166 - `&infix:<(elem)>`'s proto's .count and .arity are good ok 167 - `&infix:`'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 - `&is-prime`'s proto's .count and .arity are good ok 192 - `&item`'s proto's .count and .arity are good ok 193 - `&join`'s proto's .count and .arity are good ok 194 - `&keys`'s proto's .count and .arity are good ok 195 - `&kv`'s proto's .count and .arity are good ok 196 - `&last`'s proto's .count and .arity are good ok 197 - `&lc`'s proto's .count and .arity are good ok 198 - `&lines`'s proto's .count and .arity are good ok 199 - `&link`'s proto's .count and .arity are good ok 200 - `&list`'s proto's .count and .arity are good ok 201 - `&log`'s proto's .count and .arity are good ok 202 - `&log10`'s proto's .count and .arity are good ok 203 - `&log2`'s proto's .count and .arity are good ok 204 - `&lsb`'s proto's .count and .arity are good ok 205 - # SKIP `make` is not a multi ok 206 - `&map`'s proto's .count and .arity are good ok 207 - `&max`'s proto's .count and .arity are good ok 208 - `&min`'s proto's .count and .arity are good ok 209 - `&minmax`'s proto's .count and .arity are good ok 210 - `&mix`'s proto's .count and .arity are good ok 211 - `&mkdir`'s proto's .count and .arity are good ok 212 - `&move`'s proto's .count and .arity are good ok 213 - `&msb`'s proto's .count and .arity are good ok 214 - `&next`'s proto's .count and .arity are good ok 215 - `&nodemap`'s proto's .count and .arity are good ok 216 - `&none`'s proto's .count and .arity are good ok 217 - `¬`'s proto's .count and .arity are good ok 218 - `¬e`'s proto's .count and .arity are good ok 219 - `&one`'s proto's .count and .arity are good ok 220 - `&open`'s proto's .count and .arity are good ok 221 - `&ord`'s proto's .count and .arity are good ok 222 - `&ords`'s proto's .count and .arity are good ok 223 - `&pair`'s proto's .count and .arity are good ok 224 - `&pairs`'s proto's .count and .arity are good ok 225 - `&parse-base`'s proto's .count and .arity are good ok 226 - `&permutations`'s proto's .count and .arity are good ok 227 - `&pick`'s proto's .count and .arity are good ok 228 - `&pop`'s proto's .count and .arity are good ok 229 - `&postcircumfix:<[ ]>`'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 - `&postfix:<-->`'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 - `&prefix:<^>`'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 - `&prepend`'s proto's .count and .arity are good ok 257 - `&print`'s proto's .count and .arity are good ok 258 - `&printf`'s proto's .count and .arity are good ok 259 - `&produce`'s proto's .count and .arity are good ok 260 - `&prompt`'s proto's .count and .arity are good ok 261 - `&push`'s proto's .count and .arity are good ok 262 - `&put`'s proto's .count and .arity are good ok 263 - `&rand`'s proto's .count and .arity are good ok 264 - `&redo`'s proto's .count and .arity are good ok 265 - `&reduce`'s proto's .count and .arity are good ok 266 - `&rename`'s proto's .count and .arity are good ok 267 - `&repeated`'s proto's .count and .arity are good ok 268 - `&return`'s proto's .count and .arity are good ok 269 - `&return-rw`'s proto's .count and .arity are good ok 270 - `&reverse`'s proto's .count and .arity are good ok 271 - `&rindex`'s proto's .count and .arity are good ok 272 - `&rmdir`'s proto's .count and .arity are good ok 273 - `&roll`'s proto's .count and .arity are good ok 274 - `&roots`'s proto's .count and .arity are good ok 275 - `&rotate`'s proto's .count and .arity are good ok 276 - `&round`'s proto's .count and .arity are good ok 277 - `&roundrobin`'s proto's .count and .arity are good ok 278 - `&run`'s proto's .count and .arity are good ok 279 - `&samecase`'s proto's .count and .arity are good ok 280 - `&samemark`'s proto's .count and .arity are good ok 281 - `&say`'s proto's .count and .arity are good ok 282 - `&sec`'s proto's .count and .arity are good ok 283 - `&sech`'s proto's .count and .arity are good ok 284 - `&set`'s proto's .count and .arity are good ok 285 - `&shell`'s proto's .count and .arity are good ok 286 - `&shift`'s proto's .count and .arity are good ok 287 - `&sign`'s proto's .count and .arity are good ok 288 - `&signal`'s proto's .count and .arity are good ok 289 - `&sin`'s proto's .count and .arity are good ok 290 - `&sinh`'s proto's .count and .arity are good ok 291 - `&sleep`'s proto's .count and .arity are good ok 292 - `&sleep-timer`'s proto's .count and .arity are good ok 293 - `&sleep-until`'s proto's .count and .arity are good ok 294 - `&slip`'s proto's .count and .arity are good ok 295 - `&so`'s proto's .count and .arity are good ok 296 - `&sort`'s proto's .count and .arity are good ok 297 - `&splice`'s proto's .count and .arity are good ok 298 - `&split`'s proto's .count and .arity are good ok 299 - `&sprintf`'s proto's .count and .arity are good ok 300 - `&sqrt`'s proto's .count and .arity are good ok 301 - `&squish`'s proto's .count and .arity are good ok 302 - `&srand`'s proto's .count and .arity are good ok 303 - `&subbuf-rw`'s proto's .count and .arity are good ok 304 - `&substr`'s proto's .count and .arity are good ok 305 - `&substr-rw`'s proto's .count and .arity are good ok 306 - `&succeed`'s proto's .count and .arity are good ok 307 - `&sum`'s proto's .count and .arity are good ok 308 - `&symlink`'s proto's .count and .arity are good ok 309 - `&take`'s proto's .count and .arity are good ok 310 - `&take-rw`'s proto's .count and .arity are good ok 311 - `&tan`'s proto's .count and .arity are good ok 312 - `&tanh`'s proto's .count and .arity are good ok 313 - `&tc`'s proto's .count and .arity are good ok 314 - `&tclc`'s proto's .count and .arity are good ok 315 - `&trait_mod:`'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 - `&trim`'s proto's .count and .arity are good ok 324 - `&trim-leading`'s proto's .count and .arity are good ok 325 - `&trim-trailing`'s proto's .count and .arity are good ok 326 - `&truncate`'s proto's .count and .arity are good ok 327 - `&uc`'s proto's .count and .arity are good ok 328 - `&UNBASE`'s proto's .count and .arity are good ok 329 - `&undefine`'s proto's .count and .arity are good ok 330 - `&unimatch`'s proto's .count and .arity are good ok 331 - `&uniname`'s proto's .count and .arity are good ok 332 - `&uninames`'s proto's .count and .arity are good ok 333 - `&uniparse`'s proto's .count and .arity are good ok 334 - `&uniprop`'s proto's .count and .arity are good ok 335 - `&uniprops`'s proto's .count and .arity are good ok 336 - `&unique`'s proto's .count and .arity are good ok 337 - `&unival`'s proto's .count and .arity are good ok 338 - `&univals`'s proto's .count and .arity are good ok 339 - `&unlink`'s proto's .count and .arity are good ok 340 - `&unpolar`'s proto's .count and .arity are good ok 341 - `&unshift`'s proto's .count and .arity are good ok 342 - `&values`'s proto's .count and .arity are good ok 343 - `&warn`'s proto's .count and .arity are good ok 344 - `&wordcase`'s proto's .count and .arity are good ok 345 - `&words`'s proto's .count and .arity are good ok t/02-rakudo/attr-default-code-value.t ........................... 1..6 ok 1 - a list default holding a block constructs and keeps one element ok 2 - the stored block is callable with its own arity ok 3 - a public list attribute stores a zero-arity block as a value ok 4 - a scalar default naming a setting sub stores the sub itself ok 5 - a bare block default still stores the block ok 6 - a plain literal default still initializes directly ok t/02-rakudo/bare-block-topic-signature.t ........................ 1..11 ok 1 - bare block signature renders its implicit topic as raw with an outer default ok 2 - the implicit topic parameter is raw ok 3 - the implicit topic parameter is optional ok 4 - the implicit topic parameter is typed Mu ok 5 - ACCEPTS on a bare block signature does not die ok 6 - a one-argument capture matches a bare block signature ok 7 - an empty capture matches a bare block signature ok 8 - cando finds a bare block callable with one argument ok 9 - two bare blocks do not share one signature object ok 10 - the implicit topic still aliases the iterated containers ok 11 - ACCEPTS works on the implicit topic signature of a with block ok t/02-rakudo/attributive-param-nested-alias.t .................... 1..4 ok 1 - a private array attributive parameter binds under the full binder ok 2 - a scalar attributive parameter binds under the full binder ok 3 - an attributive parameter in a composed role binds to the pun ok 4 - the inline bindings path is unaffected ok t/02-rakudo/24-qualified-our-anchor.t ........................... 1..6 ok 1 - a qualified our variable declared in a class body anchors at GLOBAL ok 2 - a qualified our sub declared in a class body anchors at GLOBAL ok 3 - a qualified our variable anchors at a lexically visible package ok 4 - the lexically visible package stash holds the variable ok 5 - a qualified our variable from a used module is visible ok 6 - a qualified our sub from a used module updates the shared variable ok t/02-rakudo/19-begin-time-eval-sub.t ............................ ok 1 - precompiling a module returning a string-EVAL Sub from BEGIN works 1..1 ok t/02-rakudo/begin-clone-wrap.t .................................. 1..5 ok 1 - the body of a BEGIN-wrapped sub reaches the runtime lexical ok 2 - a clone made at BEGIN reaches the runtime lexical when called ok 3 - the original still reaches it after the clone ran ok 4 - memoized results are correct ok 5 - memoization via a BEGIN-time wrap caches the body call ok t/02-rakudo/begin-is-container-store.t .......................... 1..3 ok 1 - my %h is Map initialized in a BEGIN ok 2 - my %h is Set initialized in a BEGIN ok 3 - my %h is Map initialized outside a BEGIN ok t/02-rakudo/20-begin-time-eval-frame-leak.t ..................... ok 1 - BEGIN block with non-serializable lexicals before EVAL does not leak the BEGIN lexpad through the EVAL Sub 1..1 ok t/02-rakudo/begin-attr-before-declaration.t ..................... 1..7 ok 1 - a BEGIN-built method can read an attribute declared after the BEGIN ok 2 - a BEGIN-built method reads a later scalar attribute default ok 3 - a BEGIN-built method can assign a later scalar attribute ok 4 - a BEGIN-built method assigns a later untyped scalar attribute ok 5 - a BEGIN-built method steps a later Int attribute ok 6 - a BEGIN-built method binds a later untyped scalar attribute # Subtest: an attribute never declared in the class is still rejected 1..2 ok 1 - 'class C { my $m = BEGIN method () { $!nope }; }' died ok 2 - right exception type (X::Attribute::Undeclared) ok 7 - an attribute never declared in the class is still rejected ok t/02-rakudo/begin-native-var.t .................................. 1..10 ok 1 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 2 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 3 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 4 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 5 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 6 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 7 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 8 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 9 - # SKIP native scalars in BEGIN-time code are NYI on the legacy frontend ok 10 - a BEGIN-time push to a native int array is visible at runtime ok t/02-rakudo/begin-time-attributive-param-method.t ............... 1..5 ok 1 - a method after a BEGIN-built attributive-param method is still installed ok 2 - a BEGIN-built attributive-param method binds its attribute ok 3 - a BEGIN-built method with a where-clause private call composes and runs ok 4 - the non-BEGIN attributive-param method path still works # Subtest: an undeclared attribute in a BEGIN-built method is still rejected 1..2 ok 1 - 'class C { has $!x; BEGIN my $m = method ($!nope) { } }' died ok 2 - right exception type (X::Attribute::Undeclared) ok 5 - an undeclared attribute in a BEGIN-built method is still rejected ok t/02-rakudo/begin-value-container-precomp.t ..................... 1..3 ok 1 - # SKIP legacy serialization loses the Proxy FETCH closure ok 2 - # SKIP legacy serialization loses the Proxy FETCH closure ok 3 - # SKIP legacy serialization loses the Proxy FETCH closure ok t/02-rakudo/begin-value-container.t ............................. 1..5 ok 1 - each read of a Proxy constant calls its FETCH ok 2 - a Proxy constant binds the Proxy itself ok 3 - each read of a BEGIN Proxy value calls its FETCH ok 4 - a constant bound to an anonymous scalar reads its value ok 5 - a constant bound to an anonymous scalar keeps the container ok t/02-rakudo/04-settingkeys-6e.t ................................. 1..2 ok 1 - all allowed symbols found ok 2 - No unexpected entries in SETTING:: 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/bind-container-foreign-value.t ...................... 1..5 ok 1 - a container-held nqp hash binds a value parameter as Hash ok 2 - the mapped hash still holds its entries ok 3 - a container-held nqp list binds a value parameter ok 4 - a raw parameter still receives the unmapped foreign value ok 5 - a bare foreign value still binds and maps ok t/02-rakudo/begintime-loop-side-effects.t ....................... 1..4 ok 1 - while body runs for side effects in a BEGIN-time do-block ok 2 - until body runs for side effects in a BEGIN-time do-block ok 3 - C-style loop runs for side effects in a BEGIN-time do-block ok 4 - repeat-while body runs for side effects in a BEGIN-time do-block ok t/02-rakudo/attribute-typeobject-default.t ...................... 1..5 ok 1 - untyped attribute whose default is a type object is initialized to that type ok 2 - typed attribute whose default is its own type object holds that object ok 3 - a concrete default still works ok 4 - a default that is a sibling type object is initialized ok 5 - concurrent lock-free enqueue does not fragment the chain ok t/02-rakudo/capture-var-adverb.t ................................ 1..12 ok 1 - sanity match with positional captures ok 2 - $0:exists is True for a matched positional capture ok 3 - $1:exists is True for a matched positional capture ok 4 - $2:exists is False for an unmatched positional capture ok 5 - $0:k yields the key ok 6 - sanity match with named captures ok 7 - $:exists is True for a matched named capture ok 8 - $:exists is False for an absent named capture ok 9 - $:exists matches $/:exists ok 10 - $0:exists matches $/[0]:exists ok 11 - $:kv matches $/:kv ok 12 - $:!exists matches the explicit form ok t/02-rakudo/block-type-capture.t ................................ 1..4 ok 1 - capture in loop block does not leak into enclosing routine capture ok 2 - distinct capture in loop block leaves enclosing capture intact ok 3 - pointy block binds its own type capture to the argument type ok 4 - nested block capture binds to its own argument, shadowing outer ok t/02-rakudo/coercion-sigil-param-dispatch.t ..................... 1..6 ok 1 - a multi with a coercive array parameter dispatches ok 2 - a plain Array selects the unconstrained candidate ok 3 - a Positional[Int] selects the Int() @c candidate ok 4 - a multi with a coercive hash parameter dispatches ok 5 - a multi with a coercive callable parameter dispatches ok 6 - a scalar coercion still coerces ok t/02-rakudo/capture-var-sigil.t ................................. 1..10 ok 1 - sanity: named capture with no subcaptures ok 2 - $ is the raw Match ok 3 - @ of a capture with no positional subcaptures is empty ok 4 - @ matches @($/) ok 5 - sanity: named capture with positional subcaptures ok 6 - @

lists the positional subcaptures ok 7 - sanity: named capture with named subcaptures ok 8 - % hashes the named subcaptures ok 9 - @

:exists drops the adverb and stays the list ok 10 - %:exists drops the adverb and stays the hash ok t/02-rakudo/begin-closure-doc-precomp.t ......................... 1..3 ok 1 - a precompiled BEGIN-built closure can call a setting sub ok 2 - a precompiled BEGIN-built table closure can use the array composer ok 3 - the declarator doc is still reachable through .WHY after precompilation ok t/02-rakudo/charclass-enum-merge.t .............................. 1..6 ok 1 - LTM picks the longer branch of two negated char classes ok 2 - the same with a space in the text ok 3 - \h in a class still matches horizontal space ok 4 - \v in a class still matches vertical space ok 5 - \v merged with a literal in a negated class stops at the literal ok 6 - \h merged with a range in a positive class matches both ok t/02-rakudo/begin-time-call-whatever-arg.t ...................... 1..3 ok 1 - a WhateverCode argument to a parameter trait reaches it as a Callable ok 2 - a WhateverCode argument to a routine trait reaches it as a Callable ok 3 - a WhateverCode argument to a variable trait reaches it as a Callable 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/begin-time-call-regex-arg.t ......................... 1..3 ok 1 - a capturing regex in an attribute trait argument compiles and matches ok 2 - a capturing regex in a BEGIN-evaluated call compiles and matches ok 3 - a named-capture regex in a trait argument compiles and matches ok t/02-rakudo/coercion-subset-value-check.t ....................... 1..19 ok 1 - a value satisfying the subset coerces to itself # Subtest: a value failing the refinement is rejected after one was accepted 1..2 ok 1 - code dies ok 2 - right exception type (X::Coerce::Impossible) ok 2 - a value failing the refinement is rejected after one was accepted ok 3 - a value satisfying the subset is accepted after one was rejected ok 4 - a single call site accepts and rejects by value, not by type ok 5 - a natural number coerces to UInt # Subtest: a negative Int is rejected by UInt after a natural number was accepted 1..2 ok 1 - code dies ok 2 - right exception type (X::Coerce::Impossible) ok 6 - a negative Int is rejected by UInt after a natural number was accepted ok 7 - a Str holding an even number coerces into the subset # Subtest: a Str holding an odd number is rejected after an even one was accepted 1..2 ok 1 - code dies ok 2 - right exception type (X::Coerce::Impossible) ok 8 - a Str holding an odd number is rejected after an even one was accepted ok 9 - a Str holding an even number is accepted after an odd one was rejected ok 10 - a parameter coercing to a subset accepts a satisfying value # Subtest: a parameter coercing to a subset rejects a failing value after accepting one 1..2 ok 1 - code dies ok 2 - right exception type (X::Coerce::Impossible) ok 11 - a parameter coercing to a subset rejects a failing value after accepting one ok 12 - a parameter coercing to a subset accepts a satisfying value after rejecting one ok 13 - a subset constraint on a coercion accepts a satisfying value ok 14 - a subset constraint on a coercion rejects a failing value after accepting one ok 15 - a subset constraint on a coercion accepts a satisfying value after rejecting one ok 16 - a subset of a refined subset accepts a satisfying value # Subtest: a subset of a refined subset rejects a failing value after accepting one 1..2 ok 1 - code dies ok 2 - right exception type (X::Coerce::Impossible) ok 17 - a subset of a refined subset rejects a failing value after accepting one ok 18 - a matching value with no coercion method passes through unchanged ok 19 - a matching value with no coercion method still passes through on a repeated call ok t/02-rakudo/colonpair-smiley-key-value.t ........................ 1..16 ok 1 - :D(1) is the pair D => 1 ok 2 - :U(2) is the pair U => 2 ok 3 - :_(3) is the pair _ => 3 ok 4 - :D[...] takes its value ok 5 - a smiley-keyed pair in a list keeps its value ok 6 - valueless :D is D => True ok 7 - Int:D matches a defined Int ok 8 - Int:D does not match an undefined Int ok 9 - Int:U matches an undefined Int ok 10 - Int:D constraint on a variable works ok 11 - Int:D parameter constraint works ok 12 - Str:D(Numeric) coerces a Num to a defined Str ok 13 - Str:U(Numeric) keeps its undefinedness smiley ok 14 - Str:D(Numeric) used as a value is the coercion type ok 15 - a coercion type as a colonpair value keeps its coercion ok 16 - a coercion type as a named-argument value keeps its coercion ok t/02-rakudo/begin-regex-precomp.t ............................... 1..3 ok 1 - the capture groups of a precompiled BEGIN regex match ok 2 - a code block of a precompiled BEGIN regex runs and makes ok 3 - a nested capture group of a precompiled BEGIN regex matches ok t/02-rakudo/constant-anon-var-value.t ........................... 1..6 ok 1 - anonymous native unsigned variable initialises the constant ok 2 - anonymous native int variable initialises the constant ok 3 - anonymous native num variable initialises the constant ok 4 - anonymous object variable initialises the constant ok 5 - a declaration after the constant is unaffected ok 6 - anonymous native variable in a parameter default works ok t/02-rakudo/compose-operator-precedence.t ....................... 1..2 ok 1 - ∘ binds looser than + ok 2 - o binds looser than + ok t/02-rakudo/constant-assign-metaop.t ............................ 1..2 ok 1 - =%= constant produces a Map from its right operand ok 2 - separate =%= constants get separate anonymous state vars ok t/02-rakudo/begin-indirect-lexical-6e.t ......................... 1..6 ok 1 - a 6.e BEGIN indirect lookup finds a sub declared in the compiling unit ok 2 - 6.e LEXICAL:: at BEGIN time knows a sub declared in the compiling unit ok 3 - 6.e LEXICAL:: at BEGIN time reaches the sub itself ok 4 - 6.e OUTERS:: at BEGIN time knows a sub declared in the compiling unit ok 5 - 6.e LEXICAL:: at BEGIN time still reports an undeclared name as absent ok 6 - an imported sub cannot see the calling 6.e unit through LEXICAL:: at BEGIN time ok t/02-rakudo/cmp-collections.t ................................... 1..28 ok 1 - Seq cmp Seq compares element by element ok 2 - List cmp Seq compares element by element ok 3 - Seq cmp List compares element by element ok 4 - Seq comparison no longer coincides with the stringification ok 5 - equal Seqs compare Same ok 6 - shorter Seq with equal prefix is Less ok 7 - first comparison of the same Seq ok 8 - second comparison of the same Seq ok 9 - Seq still has its values after comparisons ok 10 - Seq cmp itself is Same ok 11 - sorting a list of Seqs works ok 12 - lazy Seq cmp List ok 13 - infinite Seq cmp finite List ok 14 - multi-key Hash cmp by content is Less ok 15 - multi-key Hash cmp by content is More ok 16 - equal Hashes compare Same ok 17 - Hash cmp compares values as values ok 18 - sort of multi-key Hashes orders them by content ok 19 - Map cmp ignores insertion order ok 20 - Set cmp compares sorted elements ok 21 - equal Sets compare Same ok 22 - Bag cmp compares sorted pairs ok 23 - Mix with more elements is More ok 24 - sort of Sets orders them by content ok 25 - List cmp List still compares element by element ok 26 - List cmp Str still compares stringifications ok 27 - Range cmp Range still works ok 28 - Junctions still autothread ok t/02-rakudo/container-definite-base.t ........................... 1..5 ok 1 - a `is List:D` array holds its values ok 2 - a `is List:D` array is built as a List ok 3 - a `is Map:D` hash holds its values ok 4 - a `is Map:D` hash is built as a Map ok 5 - a `is Array` array is still an Array ok t/02-rakudo/constant-nonconstant-lexical.t ...................... 1..7 ok 1 - a constant referencing a non-constant my-\ lexical compiles ok 2 - the unbound lexical resolves to its undefined value at the constant BEGIN ok 3 - a non-constant sigilless lexical yields Mu when held as the bare value ok 4 - a non-constant scalar lexical yields its Any default ok 5 - a non-constant array lexical yields its empty default ok 6 - a constant referencing a constant still binds its value ok 7 - a constant referencing an outer-scope constant inlines it ok t/02-rakudo/constant-gather.t ................................... 1..6 ok 1 - a %-constant from gather holds the gathered pairs ok 2 - a %-constant from gather has all the pairs ok 3 - an @-constant from gather holds the gathered values ok 4 - a $-constant from gather holds the gathered sequence ok 5 - a &-constant from a block still binds the block ok 6 - a $-constant from start runs and holds the promise ok t/02-rakudo/contextualizer-6c-topic.t ........................... 1..4 ok 1 - $() yields the matched string when $/ has no made value ok 2 - $() yields the made value of $/ ok 3 - @() yields the positional captures of $/ ok 4 - %() yields the named captures of $/ 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/curried-role-instantiation.t ........................ 1..5 ok 1 - named curry arg survives generic instantiation ok 2 - class composing a curry with a named arg typechecks against the role group ok 3 - value curry arg survives generic instantiation ok 4 - class composing a curry with a value arg typechecks against the parameterization ok 5 - pun repr of the role group reaches a curry instantiated from a generic ok t/02-rakudo/constant-from-gather-precomp.t ...................... 1..3 ok 1 - a precompiled %-constant from gather holds the gathered pairs ok 2 - a precompiled %-constant from gather has all the pairs ok 3 - a precompiled %-constant from gather is reusable across access ok t/02-rakudo/constant-native-dispatch.t .......................... 1..8 ok 1 - # SKIP native-typed constant dispatch is NYI on the legacy frontend ok 2 - # SKIP native-typed constant dispatch is NYI on the legacy frontend ok 3 - # SKIP native-typed constant dispatch is NYI on the legacy frontend ok 4 - # SKIP native-typed constant dispatch is NYI on the legacy frontend ok 5 - a native int constant reads back its value ok 6 - a native int constant boxes to Int in object context ok 7 - a native int constant works in arithmetic ok 8 - a non-native constant still selects the boxed candidate ok t/02-rakudo/04-settingkeys-6c.t ................................. 1..2 ok 1 - all allowed symbols found ok 2 - No unexpected entries in SETTING:: ok t/02-rakudo/03-corekeys-6c.t .................................... 1..1 # Subtest: Symbols in 6.c CORE:: 1..2 ok 1 - No unexpected entries ok 2 - No missing entries ok 1 - Symbols in 6.c CORE:: ok t/02-rakudo/dot-assign-var-method.t ............................. 1..4 ok 1 - $n .= &double mutates $n with the result of double($n) ok 2 - $blob .= &head1 mutates $blob to the trimmed Blob result ok 3 - $x.&f standalone calls f($x) ok 4 - chained $x .= &f compositions apply each routine in order 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/03-corekeys-6e.t .................................... 1..1 # Subtest: Symbols in 6.e CORE:: 1..2 ok 1 - No unexpected entries ok 2 - No missing entries ok 1 - Symbols in 6.e CORE:: ok t/02-rakudo/enum-numeric-key.t .................................. 1..4 ok 1 - enum value with a numeric-literal key is reachable by its string key ok 2 - a sunk enum declaration with a numeric-literal key composes ok 3 - enum declared then discarded inside a do block composes ok 4 - an enum with identifier keys is unaffected ok t/02-rakudo/enum-variable-nyi.t ................................. 1..3 # Subtest: enum with a variable name panics NYI 1..2 ok 1 - 'enum $foo ' died ok 2 - right exception type (X::Comp::NYI) ok 1 - enum with a variable name panics NYI ok 2 - a named enum still composes ok 3 - an anonymous enum still composes ok t/02-rakudo/03-corekeys-6d.t .................................... 1..1 # Subtest: Symbols in 6.d CORE:: 1..2 ok 1 - No unexpected entries ok 2 - No missing entries ok 1 - Symbols in 6.d CORE:: ok t/02-rakudo/compiler-frontend-id.t .............................. 1..3 ok 1 - RakuAST frontend compiler id is a 40 digit hex digest ok 2 - legacy frontend compiler id is a 40 digit hex digest ok 3 - the two frontends have distinct compiler ids ok t/02-rakudo/fatal-sorry-no-worries.t ............................ 1..1 # Subtest: a sorry under fatal with no accompanying worry reports the sorry 1..3 ok 1 - 'use fatal; sub f($a?, $b) { }' died ok 2 - right exception type (X::Comp) ok 3 - .message matches /'required parameter'/ ok 1 - a sorry under fatal with no accompanying worry reports the sorry ok t/02-rakudo/03-corekeys.t ....................................... 1..3 # Subtest: Symbols in CORE::v6c 1..2 ok 1 - No unexpected entries ok 2 - No missing entries ok 1 - Symbols in CORE::v6c # Subtest: Symbols in CORE::v6d 1..2 ok 1 - No unexpected entries ok 2 - No missing entries ok 2 - Symbols in CORE::v6d # Subtest: Symbols in CORE::v6e 1..2 ok 1 - No unexpected entries ok 2 - No missing entries ok 3 - Symbols in CORE::v6e ok t/02-rakudo/deparse-will-trait.t ................................ 1..4 ok 1 - a will trait deparses with its phase ok 2 - the deparsed source reparses to the same deparse ok 3 - a will trait produces .raku without referencing missing attributes ok 4 - the .raku reconstruction names the trait with its phase ok t/02-rakudo/fatal-flatten-arg.t ................................. 1..4 ok 1 - use fatal: flattening an empty hash argument ok 2 - use fatal: flattening an array argument ok 3 - use fatal: flattening an array and a hash argument together ok 4 - use fatal: a Failure flattened into a call still throws 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/forward-sub-lookup.t ................................ 1..5 ok 1 - a forward call resolves to a same-scope `sub` shadowing CORE ok 2 - a forward call resolves to a same-scope `sub` with no CORE name in play ok 3 - a sub-form call with no same-scope `sub` shadow still resolves through CORE ok 4 - a forward call resolves to a same-scope `multi sub` ok 5 - a forward call resolves to a same-scope `our sub` ok t/02-rakudo/enum-nested-in-same-name-package.t .................. 1..4 ok 1 - the nested enum type is reachable as Gender::Gender in the consumer ok 2 - an enum value is reachable through the fully qualified name ok 3 - the short name resolves to the same type as the fully qualified name ok 4 - the upgraded top level name is the package nested under the module ok t/02-rakudo/gather-take-lazy-value.t ............................ 1..5 ok 1 - a lazy Seq taken as a sunk for-loop body survives ok 2 - each taken lazy Seq keeps its own values ok 3 - the value returned by take is still usable ok 4 - take-rw still yields a writable container ok 5 - a user routine named take is sunk like any other call ok t/02-rakudo/for-scalar-slip.t ................................... 1..8 ok 1 - a statement-modifier for flattens a scalar-held Slip ok 2 - a block for flattens a scalar-held Slip ok 3 - the topic is bound to each flattened element ok 4 - a scalar-held plain value is one item ok 5 - a scalar-held list is one item ok 6 - a bare Slip iterates its elements ok 7 - a plain list iterates its elements ok 8 - an empty scalar-held Slip iterates nothing 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/flattened-param-bind.t .............................. 1..23 ok 1 - an itemized element stays a single hash key inside the loop body ok 2 - the loop parameter reports a Scalar container via .VAR ok 3 - assigning to the read-only loop parameter dies ok 4 - the source element is untouched after an assignment attempt # Subtest: binding a value that is not Positional to an @ loop parameter dies 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 5 - binding a value that is not Positional to an @ loop parameter dies # Subtest: binding a value that is not Associative to a % loop parameter dies 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 6 - binding a value that is not Associative to a % loop parameter dies # Subtest: binding a value that is not Callable to an & loop parameter dies 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 7 - binding a value that is not Callable to an & loop parameter dies ok 8 - an @ loop parameter binds Positional values ok 9 - an @ loop parameter binds the source array itself, not a copy ok 10 - a % loop parameter binds Associative values ok 11 - an & loop parameter binds Callable values and is callable in the body ok 12 - an itemized Seq element binds to an @ loop parameter ok 13 - the parameter holds the cached List of the Seq element ok 14 - an itemized Seq given topic binds to an @ parameter ok 15 - a Seq eigenstate binds through its cached List ok 16 - a Junction element autothreads over its eigenstates, depth first ok 17 - eigenstates before a failing one still run the body ok 18 - a failing eigenstate reports the binder error for the parameter ok 19 - an itemized given topic stays a single hash key # Subtest: binding a value that is not Positional to an @ given parameter dies 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 20 - binding a value that is not Positional to an @ given parameter dies ok 21 - a Junction given topic autothreads through an @ parameter ok 22 - a value producing given with an @ parameter returns the body value ok 23 - a value producing given with a scalar parameter returns the body value 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/format-string-literal.t ............................. 1..7 ok 1 - Format.new populates .directives ok 2 - .directives is also populated on a Formatter cache hit ok 3 - # SKIP format string literals require the RakuAST frontend ok 4 - # SKIP format string literals require the RakuAST frontend ok 5 - # SKIP format string literals require the RakuAST frontend ok 6 - # SKIP format string literals require the RakuAST frontend ok 7 - # SKIP format string literals require the RakuAST frontend ok t/02-rakudo/double-closure-and-xx-sink.t ........................ 1..3 # Subtest: `where { *.so }` is rejected as a double closure 1..3 ok 1 - code dies ok 2 - right exception type (X::Syntax::Malformed) ok 3 - .message matches /:i 'double closure' / ok 1 - `where { *.so }` is rejected as a double closure ok 2 - WhateverCode inside a method call argument inside a where clause compiles # Subtest: `xx` in sink context emits no compile-time warning 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - `xx` in sink context emits no compile-time warning ok t/02-rakudo/declarator-signature-param-traits.t ................. 1..14 ok 1 - a declarator signature accepts is rw and the variable assigns ok 2 - a declarator signature accepts is copy and the variable assigns ok 3 - a declarator signature accepts is readonly and the variable assigns ok 4 - a declarator signature accepts is raw and the variable assigns ok 5 - a declarator signature accepts is required and the variable assigns ok 6 - a declarator signature accepts is onearg and the variable assigns # Subtest: an is item trait in a declarator signature reports as a parameter trait 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /"Cannot use 'is item' on parameter"/ ok 7 - an is item trait in a declarator signature reports as a parameter trait ok 8 - a declarator signature accepts is rw on a native int variable ok 9 - a declarator signature accepts is copy on a native int variable ok 10 - a parameter trait beside a variable trait leaves both accepted ok 11 - an our declarator signature accepts is rw and the variable assigns ok 12 - a state declarator signature accepts is copy and the variable persists # Subtest: a binding declarator signature still binds through the parameter 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /'unpack or Capture'/ ok 13 - a binding declarator signature still binds through the parameter # Subtest: a declarator signature inside sub MAIN earns no dispatch advice 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 14 - a declarator signature inside sub MAIN earns no dispatch advice ok t/02-rakudo/04-diag.t ........................................... 1..2 # Subtest: diag at the start of file shows up in non-verbose prove run 1..2 ok 1 - STDOUT ok 2 - STDERR ok 1 - diag at the start of file shows up in non-verbose prove run # Subtest: using diag in the middle of TODO tests does not interfere 1..3 ok 1 - STDOUT has TODO ok 2 - diag message is not in STDOUT ok 3 - diag message is in STDERR ok 2 - using diag in the middle of TODO tests does not interfere ok t/02-rakudo/for-statement-iterator-protocol.t ................... 1..12 ok 1 - statement for with a pointy block iterates via the iterator ok 2 - statement for with a pointy block does not call a user map override ok 3 - statement for with a bare block iterates via the iterator ok 4 - statement for with a bare block does not call a user map override ok 5 - last works in a directly iterated for loop ok 6 - a labeled next reaches the outer directly iterated for loop ok 7 - modifier for iterates via the iterator ok 8 - modifier for does not call a user map override ok 9 - block modifier for iterates via the iterator ok 10 - block modifier for does not call a user map override ok 11 - an expression do-for still collects its values ok 12 - an expression do-for still dispatches to a user map override ok t/02-rakudo/constant-native-value.t ............................. 1..4 ok 1 - an imported native-valued constant is the boxed value ok 2 - package-qualified access to a native-valued constant gives the boxed value ok 3 - method calls work on a package-qualified native-valued constant ok 4 - the constant has the same value when reached through the diamond ok t/02-rakudo/file-variable.t ..................................... 1..4 # Subtest: `$?FILE` of a -e one-liner is -e 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - `$?FILE` of a -e one-liner is -e ok 2 - `$?FILE` in a source file is an absolute path ok 3 - `$?FILE` names the file being compiled ok 4 - `$?FILE` does not leak into SETTING:: from the CORE build ok t/02-rakudo/grammar-6e-parse-sanity.t ........................... 1..3 # Subtest: a TOP returning a non-Match is reported by name 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /"'TOP' returned a Int object (42) rather than a Match object"/ ok 1 - a TOP returning a non-Match is reported by name # Subtest: a named rule returning a non-Match is reported by name 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /"'custom' returned a Str object (oops) rather than a Match object"/ ok 2 - a named rule returning a non-Match is reported by name ok 3 - a rule returning a Match still parses ok t/02-rakudo/heredoc-attribute-default.t ......................... 1..3 ok 1 - a heredoc attribute default holds its whole body ok 2 - the body content is present, not the terminator ok 3 - the default is not the heredoc terminator word ok t/02-rakudo/for-range-native-loop.t ............................. 1..39 ok 1 - an inclusive .. range produces its values ok 2 - a ..^ range excludes its right endpoint ok 3 - a ^.. range excludes its left endpoint ok 4 - a ^..^ range excludes both endpoints ok 5 - a ^N range counts from zero ok 6 - a reversed range counts down ok 7 - a range with negative bounds produces its values ok 8 - a range with start past end runs zero times ok 9 - a modifier for over a range produces its values ok 10 - a native int variable works as a range bound ok 11 - a range with bounds past 32 bits still produces its values ok 12 - a lexically redefined range constructor is honored ok 13 - last works in a range for loop ok 14 - next works in a range for loop ok 15 - an ascending sequence produces its values ok 16 - a descending sequence produces its values ok 17 - a single element sequence produces its value ok 18 - a sequence to zero descends rather than staying empty ok 19 - a reversed sequence produces its values backward ok 20 - a sequence loop binds a native int parameter ok 21 - a variable bound keeps the sequence values ok 22 - a stepped sequence keeps its values ok 23 - a string sequence keeps its values ok 24 - last works in a sequence for loop ok 25 - next works in a sequence for loop ok 26 - a lexically redefined sequence constructor is honored ok 27 - a reversed descending sequence counts up ok 28 - last leaves a sequence with no end bound ok 29 - a sequence with bounds past 32 bits still produces its values ok 30 - a sequence with a negative start produces its values ok 31 - a sequence descending past zero produces its values ok 32 - redo repeats a sequence loop iteration once ok 33 - a modifier for over a sequence produces its values ok 34 - a non sunk for over a sequence keeps its result values ok 35 - last with a label leaves a sequence loop ok 36 - a Bool sequence stops at its single Bool element ok 37 - an enum sequence produces enum elements ok 38 - a sparse enum sequence steps by enum succession ok 39 - an allomorph start keeps its own type ok t/02-rakudo/grammar-6e-subparse-actions.t ....................... 1..3 ok 1 - subparse accepts Mu as the actions ok 2 - parse accepts Mu as the actions ok 3 - subparse still runs a real actions class ok t/02-rakudo/has-list-declaration.t .............................. 1..18 ok 1 - a scalar attribute declared in a has list starts undefined ok 2 - an @-sigil attribute declared in a has list gets an Array container ok 3 - a %-sigil attribute declared in a has list gets a Hash container # Subtest: assigning to a whole has list is a compile time error 1..3 ok 1 - 'class GH4522-Assign { has ($.a) = 1 }' died ok 2 - right exception type (X::Comp) ok 3 - .message matches /"Cannot assign to a list of 'has' scoped declarations"/ ok 4 - assigning to a whole has list is a compile time error ok 5 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 6 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 7 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 8 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 9 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 10 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 11 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 12 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 13 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 14 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 15 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 16 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 17 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok 18 - # SKIP has list attribute traits and defaults are NYI on the legacy frontend ok t/02-rakudo/generic-copy-param.t ................................ 1..23 ok 1 - a role method can assign to a generic copy param via the pun ok 2 - a role method composed into a class can assign to a generic copy param ok 3 - the Int instantiation of a role accepts an Int assignment ok 4 - the Str instantiation of the same role accepts a Str assignment # Subtest: the Str instantiation of the same role rejects an Int assignment 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 5 - the Str instantiation of the same role rejects an Int assignment ok 6 - a sub can assign to a copy param typed by a capture in the same signature ok 7 - a T:D copy param accepts assignment after instantiation ok 8 - a coercive generic copy param coerces its argument and accepts assignment ok 9 - a ::?CLASS copy param accepts assignment in a composing class ok 10 - a named generic copy param accepts assignment ok 11 - an omitted generic copy param assigns over its default ok 12 - a passed generic copy param with a default accepts assignment ok 13 - a multi sub can assign to a generic copy param ok 14 - a role multi method can assign to a generic copy param ok 15 - a generic copy param inside a sub-signature accepts assignment # Subtest: the instantiated copy container still rejects a wrongly typed assignment 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 16 - the instantiated copy container still rejects a wrongly typed assignment ok 17 - the copy container of a generic copy param reports the instantiated type ok 18 - assigning Nil to a generic copy param restores the instantiated default ok 19 - assigning to a generic copy param leaves the argument untouched ok 20 - a constrained generic copy param accepts assignment ok 21 - a non-generic typed copy param still accepts assignment ok 22 - a non-generic typed copy param still rejects a wrongly typed argument ok 23 - an untyped copy param still accepts any assignment ok t/02-rakudo/indirect-package-trailing-empty.t ................... 1..7 ok 1 - a trailing :: on a variable gives the package stash ok 2 - the package designated by $p:: is the value of $p ok 3 - subscripting the package designated by $p:: works ok 4 - an indirect name lookup ::($n) still resolves ok 5 - a leading :: qualified lookup still resolves ok 6 - a leading :: package search designates the package ok 7 - a leading :: GLOBAL lookup sees the runtime GLOBAL ok t/02-rakudo/heredoc-phaser-scope.t .............................. 1..7 ok 1 - BEGIN assignment of a heredoc reaches the outer lexical ok 2 - BEGIN assignment of a heredoc within an expression reaches the outer lexical ok 3 - CHECK assignment of a heredoc reaches the outer lexical ok 4 - a gather over a BEGIN-set heredoc lexical sees the value ok 5 - the gather processed every line of the heredoc ok 6 - a phaser after a heredoc phaser still resolves the outer lexical ok 7 - a heredoc BEGIN reading a BEGIN-set outer lexical observes its value ok t/02-rakudo/exporthow-my-scope.t ................................ 1..4 ok 1 - a module with a bare `package EXPORTHOW` loads without a GLOBAL clash ok 2 - the bare EXPORTHOW override composes classes with its own HOW ok 3 - a subset still parses after using a module that used an EXPORTHOW module not ok 4 - the class declarator override does not travel transitively # TODO the legacy frontend hands a used module's declarator overrides on to consumers # Failed test 'the class declarator override does not travel transitively' # at t/02-rakudo/exporthow-my-scope.t line 33 # expected: 'clean' # got: 'leaked' ok t/02-rakudo/generic-class-parameter-type.t ...................... 1..19 ok 1 - Array[T] parameter instantiates to Array[Int] for an Int argument pair ok 2 - Array[T] parameter binds the passed array contents ok 3 - Array[T] parameter instantiates to Array[Str] for a Str argument pair # Subtest: Array[T] parameter rejects an array whose type does not match the instantiated T 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 4 - Array[T] parameter rejects an array whose type does not match the instantiated T ok 5 - Hash[T] parameter instantiates to Hash[Int] for an Int argument pair ok 6 - Hash[T] parameter binds the passed hash contents # Subtest: Hash[T] parameter rejects a hash whose type does not match the instantiated T 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 7 - Hash[T] parameter rejects a hash whose type does not match the instantiated T ok 8 - Positional[T] parameter still binds an Array[Int] argument ok 9 - plain T parameter still binds a value of the captured type # Subtest: plain T parameter still rejects a value outside the captured type 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 10 - plain T parameter still rejects a value outside the captured type ok 11 - Array[T] parameter on a role method binds after concretization # Subtest: Array[T] parameter on a role method rejects a mismatched array after concretization 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 12 - Array[T] parameter on a role method rejects a mismatched array after concretization ok 13 - Positional[T] parameter on a role method binds after concretization ok 14 - plain T parameter on a role method still binds after concretization ok 15 - multi dispatch picks the Array[T] candidate for a matching argument pair ok 16 - multi dispatch falls back when the array type does not match T # Subtest: multi dispatch reports no match when the only candidate has a mismatched Array[T] parameter 1..2 ok 1 - code dies ok 2 - right exception type (X::Multi::NoMatch) ok 17 - multi dispatch reports no match when the only candidate has a mismatched Array[T] parameter ok 18 - multi method on a role picks the Array[T] candidate after concretization ok 19 - multi method on a role falls back for a non-array argument ok t/02-rakudo/hexfloat-literals.t ................................. 1..20 ok 1 - basic hexfloat with fraction ok 2 - hexfloat without fraction ok 3 - negative exponent ok 4 - hexfloat without integer part ok 5 - capital P exponent, no sign ok 6 - full-precision mantissa ok 7 - multi-digit parts ok 8 - negated hexfloat ok 9 - largest double ok 10 - smallest normal ok 11 - smallest subnormal ok 12 - subnormal tie rounds to even ok 13 - exponent overflow gives Inf ok 14 - exponent underflow gives 0 ok 15 - underscores in mantissa ok 16 - underscore in exponent ok 17 - negative zero survives ok 18 - plain hex integer literal is still an Int ok 19 - method call on hex integer literal still works # Subtest: hexfloat without p exponent is still an error 1..2 ok 1 - code dies ok 2 - right exception type (Exception) ok 20 - hexfloat without p exponent is still an error ok t/02-rakudo/generic-stash-lookup.t .............................. 1..5 ok 1 - T::{$key} in a method resolves in the bound type stash ok 2 - the resolved value is the bound type member ok 3 - T::{$key} in a lexical sub resolves in the bound type stash ok 4 - T::{"literal"} resolves in the bound type stash ok 5 - a missing key resolves to an undefined value ok t/02-rakudo/is-container-shadowed-quanthash.t ................... 1..2 ok 1 - a user type named Set is built with .new, not bare-created ok 2 - the core Set keeps its empty sentinel ok t/02-rakudo/indirect-name-dynamic.t ............................. 1..6 ok 1 - indirect lookup through a dynamic variable ok 2 - indirect lookup through a dynamic-variable expression ok 3 - indirect lookup of a bare dynamic variable ok 4 - indirect lookup through a literal string # Subtest: an empty indirect name has no symbol 1..2 ok 1 - code dies ok 2 - right exception type (X::NoSuchSymbol) ok 5 - an empty indirect name has no symbol ok 6 - require of an indirect name with a dynamic-variable expression ok t/02-rakudo/labels.t ............................................ 1..1 ok 1 - a labeled block with an unreferenced label compiles and yields its value ok t/02-rakudo/18-pseudostash.t .................................... 1..10 # 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 4 - did not hang ok 5 - indirect lookup through a runtime lexical type with a hash-index key ok 6 - indirect lookup through a runtime lexical type with a literal key ok 7 - call qualified by a runtime lexical package ok 8 - CALLERS in the right operand of //= starts at the routine's caller ok 9 - $?CALLER::PACKAGE compiles and resolves through the CALLER pseudo-package ok 10 - $?PACKAGE through an unknown package is Any ok t/02-rakudo/grammar-named-as-core-type-precomp.t ................ 1..3 ok 1 - a precompiled grammar named like a setting builtin loads and parses ok 2 - and it is a distinct type shadowing the builtin, not the builtin itself ok 3 - its nested our-scoped package precompiled and is reachable ok t/02-rakudo/compose-added-method-precomp.t ...................... 1..2 ok 1 - a precompiled class from a compose-extending metaclass works ok 2 - the method added during compose is callable and sees its closure ok t/02-rakudo/leading-pseudo-package-error.t ...................... 1..4 # Subtest: a leading CORE in a declared name reports cleanly 1..2 ok 1 - 'class CORE::Foo { }' died ok 2 - right exception type (X::PseudoPackage::InDeclaration) ok 1 - a leading CORE in a declared name reports cleanly # Subtest: a bare CORE declaration reports cleanly 1..2 ok 1 - 'class CORE { }' died ok 2 - right exception type (X::PseudoPackage::InDeclaration) ok 2 - a bare CORE declaration reports cleanly # Subtest: a bare GLOBAL declaration reports cleanly 1..3 ok 1 - 'class GLOBAL { }' died ok 2 - right exception type (Exception) ok 3 - .message matches /'package GLOBAL'/ ok 3 - a bare GLOBAL declaration reports cleanly ok 4 - a CORE pseudo-stash lookup still resolves ok t/02-rakudo/maybe-method-call.t ................................. 1..5 ok 1 - a maybe-method call invokes a method that exists ok 2 - a maybe-method call yields Nil when the method is absent ok 3 - a maybe-method call on a non-Mu object does not throw ok 4 - a maybe-method call on a non-Mu object without the method yields Nil ok 5 - a maybe-method call with a computed name still works ok t/02-rakudo/label-source-location.t ............................. 1..4 ok 1 - a label reports the source line of its declaration ok 2 - a label reports its name ok 3 - a label gist includes the text following the label name ok 4 - distinct labels report distinct source lines ok t/02-rakudo/init-phaser-decont.t ................................ 1..8 ok 1 - INIT of a container yields the value, not a container ok 2 - the INIT value is correct ok 3 - the INIT value is usable as a value ok 4 - a method call reaches the value captured through INIT ok 5 - INIT of a dynamic variable yields its value ok 6 - the INIT block form also yields the value ok 7 - INIT of a not-yet-bound variable yields Mu, not a VMNull ok 8 - a constant from INIT is Mu at BEGIN, not the block ok t/02-rakudo/keyed-hash-explicit-base.t .......................... 1..8 ok 1 - a keyed `is Hash` hash keeps its key type ok 2 - a keyed `is Hash` hash stores object keys ok 3 - a keyed `is Hash` hash retrieves by object key ok 4 - a typed keyed `is Hash` hash keeps both types ok 5 - a typed keyed `is Hash` hash stores and retrieves ok 6 - a keyed hash parameterizes a parameterized base ok 7 - a keyed `is Hash` attribute keeps its key type ok 8 - a keyed hash without a base trait still keeps its key type ok t/02-rakudo/is-indirect-parent.t ................................ 1..4 ok 1 - role inheriting from a same-named outer type via ::Name composes ok 2 - the consuming class is-a the outer type ok 3 - a class inheriting an existing type via ::Name has its real MRO ok 4 - a signature ::Name capture still binds to the argument type ok t/02-rakudo/enum-value-redeclaration.t .......................... 1..4 # Subtest: a duplicate enum value warns 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - a duplicate enum value warns # Subtest: a value clashing with an earlier enum warns 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - a value clashing with an earlier enum warns # Subtest: a value clashing only with a nested package stays silent 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - a value clashing only with a nested package stays silent # Subtest: a well-formed enum warns nothing 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 4 - a well-formed enum warns nothing ok t/02-rakudo/begin-indirect-lexical.t ............................ 1..32 ok 1 - a BEGIN indirect lookup finds a sub declared in the compiling unit ok 2 - a BEGIN indirect lookup still finds a setting sub ok 3 - a BEGIN indirect lookup finds a class declared in the compiling unit ok 4 - a BEGIN indirect lookup of a scalar reaches its container, unassigned so far ok 5 - a constant initialized from an indirect lookup holds the unit-local sub ok 6 - a run time indirect lookup of a unit-local sub keeps working ok 7 - a BEGIN indirect lookup built from a computed string finds a unit-local sub ok 8 - an indirect lookup in a sub the BEGIN calls finds a unit-local sub ok 9 - a LEXICAL:: lookup in a sub the BEGIN calls finds a unit-local sub ok 10 - assigning through a BEGIN indirect lookup reaches the unit variable ok 11 - a BEGIN indirect lookup of an undeclared name still comes up empty ok 12 - LEXICAL:: at BEGIN time still reports an undeclared name as absent ok 13 - a BEGIN indirect lookup built from a computed string finds a unit-local class ok 14 - a precompiled module constant holds a sub the module itself declared ok 15 - a precompiled module constant holds a sub the module imported ok 16 - a precompiled module constant holds a setting sub ok 17 - a precompiled module constant holds a class the module itself declared ok 18 - a precompiled module constant holds a sub found through a computed string ok 19 - a precompiled module constant holds the handled miss of an undeclared name ok 20 - a loaded unit does not reach the loading unit through an indirect lookup ok 21 - an imported sub called at BEGIN time does not reach the calling unit ok 22 - an imported trait handler does not reach the unit applying the trait ok 23 - # SKIP the legacy frontend cannot invoke a precompiled BEGIN-made closure ok 24 - LEXICAL:: at BEGIN time knows a sub declared in the compiling unit ok 25 - LEXICAL:: at BEGIN time reaches the sub itself ok 26 - an imported sub cannot see the calling unit through LEXICAL:: at BEGIN time ok 27 - DYNAMIC:: at BEGIN time reaches a unit sub through its static-chain path ok 28 - OUTERS:: at BEGIN time reaches a sub declared in the compiling unit ok 29 - DYNAMIC:: at BEGIN time knows a sub declared in the compiling unit ok 30 - OUTERS:: at BEGIN time knows a sub declared in the compiling unit ok 31 - an imported sub cannot see the calling unit through DYNAMIC:: at BEGIN time ok 32 - an imported sub cannot see the calling unit through OUTERS:: at BEGIN time ok t/02-rakudo/lexical-list-declaration.t .......................... 1..13 ok 1 - list assignment to a my list still distributes values ok 2 - a := initializer keeps parameter defaults as binding semantics ok 3 - a := initializer keeps named parameters as binding semantics ok 4 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 5 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 6 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 7 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 8 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 9 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 10 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 11 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 12 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok 13 - # SKIP my list variable traits and defaults are NYI on the legacy frontend ok t/02-rakudo/generic-native-precomp.t ............................ 1..3 ok 1 - a precompiled class steps a generic attribute instantiated with int ok 2 - a precompiled class constructs a generic attribute instantiated with int ok 3 - a precompiled int instantiated generic attribute reports Int as its type ok t/02-rakudo/literalize-fallback.t ............................... 1..2 # Subtest: indirect package name from a runtime expression is reported as not compile-time known 1..3 ok 1 - 'my $*x; class ::($*x ?? "A" !! "B") { }' died ok 2 - right exception type (Exception) ok 3 - .message matches /'not compile-time known'/ ok 1 - indirect package name from a runtime expression is reported as not compile-time known ok 2 - literalize of a node with no specific candidate returns an undefined sentinel ok t/02-rakudo/hexfloat-formatter.t ................................ 1..31 ok 1 - %a ok 2 - %A ok 3 - %a of Int drops radix point ok 4 - %a of 3e0 ok 5 - %a of negative value ok 6 - %a of +0e0 ok 7 - %a of -0e0 ok 8 - %a of max double ok 9 - %a of min subnormal is normalized ok 10 - %.0a rounds the mantissa ok 11 - %.3a rounds the mantissa ok 12 - %.13a is the exact mantissa ok 13 - %.16a pads with zeroes ok 14 - %.3a of zero fills up to precision ok 15 - rounding carries into the leading digit ok 16 - rounding carries through all digits ok 17 - tie rounds to even (up) ok 18 - tie 0x1.18 rounds to even (up) ok 19 - tie 0x1.28 rounds to even (down) ok 20 - %a with plus flag ok 21 - %a with space flag ok 22 - %a with hash flag keeps radix point ok 23 - right-justified %a ok 24 - left-justified %a ok 25 - 0-padding goes after the 0x prefix ok 26 - 0-padding of negative value ok 27 - star width and precision ok 28 - positional parameters ok 29 - %a of Inf ok 30 - %a of -Inf ok 31 - %a of NaN is padded with spaces ok t/02-rakudo/loop-next-phaser.t .................................. 1..8 ok 1 - NEXT runs each iteration of a value-producing C-style loop ok 2 - the C-style loop still yields its values ok 3 - NEXT runs on an explicit next as well ok 4 - the skipped value is omitted ok 5 - NEXT runs when the C-style increment slot is empty ok 6 - NEXT runs each iteration of a value-producing while loop ok 7 - NEXT runs each iteration of a value-producing repeat loop ok 8 - NEXT runs each iteration of a value-producing bare loop ok t/02-rakudo/metaop-assign-concat-blob.t ......................... 1..5 ok 1 - undefined variable ~= a Blob stringifies the Blob ok 2 - undefined Str-typed variable ~= a Blob stringifies the Blob ok 3 - the indirect &infix:<~=> call form stringifies the Blob ok 4 - defined variable ~= a Blob still concatenates ok 5 - undefined variable ~= a Str still works ok t/02-rakudo/my-package-export.t ................................. 1..2 ok 1 - the declared EXPORT package carries its OUR:: symbols ok 2 - EXPORT resolves to the user-declared package ok t/02-rakudo/hyper-race-loop-control.t ........................... 1..21 ok 1 - last in a hyper map keeps exactly the values before the control ok 2 - last in the final batch of a hyper map truncates that batch ok 3 - next in a hyper map skips the value ok 4 - redo in a hyper map reruns the block for the value ok 5 - the redone block ran exactly one extra time ok 6 - last ends a sunk hyper for loop early ok 7 - last ends a sunk race for loop early ok 8 - a labeled last ends a sunk hyper for loop early ok 9 - a labeled next in a hyper for loop compiles and runs ok 10 - the labeled next ran the body for every value ok 11 - last in a nested serial loop does not end the hyper loop ok 12 - last in a race map ends the iteration early ok 13 - a race map stopped by last still emits every value before the last ok 14 - last in a hyper grep keeps exactly the matches before the control ok 15 - next in a hyper grep excludes the value ok 16 - redo in a hyper grep re-evaluates the value ok 17 - the redone matcher ran exactly one extra time ok 18 - last in a race grep ends the iteration early ok 19 - a hyper map without loop controls produces all values in order ok 20 - a race map without loop controls produces all values # Subtest: an exception in a hyper for loop still reaches the caller 1..2 ok 1 - code dies ok 2 - right exception type (X::HyperRace::Died) ok 21 - an exception in a hyper for loop still reaches the caller ok t/02-rakudo/method-literal-package.t ............................ 1..4 ok 1 - a method literal records its enclosing package ok 2 - a top-level anon method records GLOBAL ok 3 - a custom gist added via add_method works when nested ok 4 - the default .raku still works on the inner value ok t/02-rakudo/generic-native-parameters.t ......................... 1..27 ok 1 - a generic parameter instantiated with int accepts an Int argument ok 2 - a generic parameter instantiated with int accepts a native int argument # Subtest: a generic parameter instantiated with int rejects a Str argument 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 3 - a generic parameter instantiated with int rejects a Str argument ok 4 - a multi with a generic parameter instantiated with int dispatches ok 5 - an Int argument picks the generic candidate instantiated with int ok 6 - a Str argument picks the Str candidate beside an int instantiated one ok 7 - a native int argument picks the generic candidate instantiated with int ok 8 - a generic parameter instantiated with int:D accepts a value # Subtest: a generic parameter instantiated with int:D rejects a type object 1..2 ok 1 - code dies ok 2 - right exception type (Exception) ok 9 - a generic parameter instantiated with int:D rejects a type object ok 10 - a generic return type instantiated with int passes an Int return # Subtest: a generic return type instantiated with int rejects a Str return 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Return) ok 11 - a generic return type instantiated with int rejects a Str return ok 12 - a definite generic return type instantiated with int passes a value # Subtest: a definite generic return type instantiated with int rejects a type object 1..2 ok 1 - code dies ok 2 - right exception type (Exception) ok 13 - a definite generic return type instantiated with int rejects a type object # Subtest: a definite generic return type instantiated with int rejects a Str value 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Return) ok 14 - a definite generic return type instantiated with int rejects a Str value ok 15 - a generic parameter instantiated with int16 accepts an Int argument # Subtest: a generic parameter instantiated with int16 rejects a Str argument 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 16 - a generic parameter instantiated with int16 rejects a Str argument ok 17 - a generic parameter instantiated with num32 accepts a Num argument ok 18 - a generic parameter instantiated with uint8 accepts an Int argument ok 19 - a definite generic parameter instantiated with int accepts a value # Subtest: a definite generic parameter instantiated with int rejects a type object 1..2 ok 1 - code dies ok 2 - right exception type (X::Parameter::InvalidConcreteness) ok 20 - a definite generic parameter instantiated with int rejects a type object ok 21 - an undefined generic parameter instantiated with int accepts the box type object ok 22 - a generic parameter instantiated with num accepts a Num argument ok 23 - a generic parameter instantiated with str accepts a Str argument ok 24 - an int instantiated generic parameter reports Int as its type ok 25 - a generic parameter instantiated with Int still binds ok 26 - an Int instantiated generic parameter reports Int as its type ok 27 - a role method parameter declared int still binds a native argument ok t/02-rakudo/multi-coercion-comparable.t ......................... 1..2 ok 1 - distinct coercion types on a multi parameter are not a redeclaration ok 2 - a coercion inside a sub-signature is not a redeclaration ok t/02-rakudo/ltm-before-assertion.t .............................. 1..6 ok 1 - a parenthesized subexpression followed by an infix parses ok 2 - LTM picked the infix chain over the shorter circumfix branch ok 3 - an infix between two parenthesized subexpressions parses ok 4 - the spelling also parses the expression ok 5 - the spelling also picks the infix chain ok 6 - still rejects at a position its argument matches ok t/02-rakudo/import-shadows-setting-type.t ....................... 1..6 ok 1 - the imported same-named subclass shadows the setting type ok 2 - the shadowing import is the module class, not the setting type ok 3 - without the export tag the setting type is untouched ok 4 - the default exports of the module still import ok 5 - a package nested under a setting name is reachable in the consumer ok 6 - the consumer can declare its own class under the setting name the module nested under ok t/02-rakudo/native-arg-compile-errors.t ......................... 1..12 ok 1 - a string argument to an int parameter is refused at compile time ok 2 - a string argument to a num parameter is refused at compile time ok 3 - a string argument to an Int parameter is refused at compile time ok 4 - a string argument to a str parameter still binds ok 5 - an interpolated string argument is not refused at compile time ok 6 - a word-quoted argument with a val processor is not refused at compile time ok 7 - a string argument to all-native multi candidates is refused at compile time ok 8 - a string argument to a mixed multi still picks the Str candidate ok 9 - assigning a Rat literal to a native int variable names the variable ok 10 - assigning a Rat literal to a native int variable names the native type ok 11 - assigning a Rat literal to a native int variable suggests the Real type ok 12 - a Rat literal initializer on a native int declaration names the native variable ok t/02-rakudo/exporthow-after-load.t .............................. 1..2 ok 1 - a declarator from a directly used module declares a class ok 2 - a declarator declared after loading another module that carries an EXPORTHOW survives ok t/02-rakudo/native-copy-param.t ................................. 1..18 ok 1 - an int:D copy parameter accepts assignment of a boxed Int ok 2 - a uint:D copy parameter accepts assignment of a boxed Int ok 3 - a num:D copy parameter accepts assignment of a boxed Num ok 4 - a str:D copy parameter accepts assignment of a boxed Str ok 5 - an int:D copy parameter steps with postfix increment ok 6 - an int copy parameter steps with postfix and prefix forms ok 7 - a num copy parameter steps with postfix increment ok 8 - an int copy parameter compound-steps from a parameter operand through the metaop ok 9 - an int copy parameter compound-steps from a native lexical operand ok 10 - a num copy parameter compound-steps from a float literal ok 11 - a narrow native copy parameter steps through the routine ok 12 - an int copy parameter with a default steps from the default ok 13 - assignment to an int copy parameter leaves the caller variable alone ok 14 - an int:D rw parameter still writes back to the caller ok 15 - an increment of an int rw parameter writes back to the caller ok 16 - a type object argument to an int:D copy parameter is rejected ok 17 - postfix increment on a read-only native parameter still reports immutability ok 18 - a plain int:D parameter still binds a boxed Int ok t/02-rakudo/colonpair-use-import.t .............................. 1..3 ok 1 - use Module :$tag imports the variable exported under that tag ok 2 - use Module :Opaque imports the constant under that tag # Subtest: no Pragma :$foo parses the colonpair as a selector, not a lexical read 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - no Pragma :$foo parses the colonpair as a selector, not a lexical read ok t/02-rakudo/generic-native-attributes.t ......................... 1..46 ok 1 - postfix increment works on a generic attribute instantiated with int ok 2 - postfix decrement works on a generic attribute instantiated with int ok 3 - prefix increment works on a generic attribute instantiated with int ok 4 - assignment works on a generic attribute instantiated with int ok 5 - compound assignment works on a generic attribute instantiated with int ok 6 - a read returns the stored value ok 7 - a read of an int instantiated generic attribute returns an Int ok 8 - postfix increment works on a generic attribute instantiated with num ok 9 - assignment and concatenation work on a generic attribute instantiated with str ok 10 - postfix increment works on a generic attribute instantiated with uint ok 11 - compound assignment works on a generic attribute instantiated with int8 ok 12 - an int instantiated generic attribute reports Int as its type ok 13 - an untouched int instantiated generic attribute reads as the Int type object # Subtest: assigning a non-numeric value to an int instantiated generic attribute dies 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck) ok 14 - assigning a non-numeric value to an int instantiated generic attribute dies ok 15 - assigning Nil resets an int instantiated generic attribute to Int ok 16 - a definite generic attribute instantiated with int steps ok 17 - a definite int instantiated generic attribute reports Int:D as its type # Subtest: a definite int instantiated generic attribute rejects a type object 1..2 ok 1 - code dies ok 2 - right exception type (Exception) ok 18 - a definite int instantiated generic attribute rejects a type object ok 19 - a default value initializes an int instantiated generic attribute ok 20 - a named constructor argument initializes an int instantiated generic attribute ok 21 - the generated rw accessor writes an int instantiated generic attribute ok 22 - each object steps its own copy of an int instantiated generic attribute ok 23 - stepping one object does not disturb another ok 24 - a role attribute declared int keeps its native type ok 25 - postfix increment works on a role attribute declared int ok 26 - a generic attribute survives a role to role generic pass through instantiated with int ok 27 - a method in the outer role reaches the passed through generic attribute ok 28 - a generic attribute instantiated with int inside an intermediate role steps ok 29 - a method in the consuming role reaches the instantiated generic attribute ok 30 - a punned role steps a generic attribute instantiated with int ok 31 - a punned role constructs a generic attribute instantiated with int ok 32 - an untouched generic attribute on a pun reads as the Int type object ok 33 - a runtime does mixin steps a generic attribute instantiated with int ok 34 - a runtime but mixin steps a generic attribute instantiated with int ok 35 - postfix increment works on a generic attribute instantiated with int16 ok 36 - compound assignment works on a generic attribute instantiated with num32 ok 37 - an undefined generic attribute instantiated with int stores the box type object # Subtest: an undefined generic attribute instantiated with int rejects a concrete value 1..2 ok 1 - code dies ok 2 - right exception type (Exception) ok 38 - an undefined generic attribute instantiated with int rejects a concrete value ok 39 - a method ahead of a native attribute declaration steps it ok 40 - a method ahead of a native num attribute declaration compound assigns it ok 41 - a method ahead of a native str attribute declaration concatenates onto it ok 42 - a method ahead of a native uint8 attribute declaration steps it ok 43 - a class body method steps a native attribute supplied by a role ok 44 - a class body method steps a generic role attribute instantiated with int ok 45 - postfix increment works on a generic attribute instantiated with Int ok 46 - an Int instantiated generic attribute reports Int as its type ok t/02-rakudo/optimize-operator-late-decl.t ....................... 1..4 ok 1 - a native int increment honors a postfix:<++> declared later in the block ok 2 - the later-declared postfix:<++> was called ok 3 - a range for loop honors an infix:<..> declared later in the block ok 4 - a modifier for loop honors a prefix:<^> declared later in the block ok t/02-rakudo/native-rw-param-writeback.t ......................... 1..16 ok 1 - a for loop over a native int array writes back through <-> int ok 2 - a for loop over a native uint array writes back through <-> uint ok 3 - a for loop over a native num array writes back through <-> num ok 4 - a for loop over a native str array writes back through <-> str ok 5 - a for loop taking two <-> int parameters writes back through both ok 6 - calling a <-> block with a native int variable writes back ok 7 - a native parameter of a <-> block introspects as rw ok 8 - an is copy native parameter of a <-> block still writes back ok 9 - an is copy ordinary parameter of a <-> block still writes back ok 10 - a sub with a native int is rw parameter writes back ok 11 - a sub with a native int is copy parameter does not write back ok 12 - a for loop over an ordinary array writes back through a <-> parameter ok 13 - a native int declared in a declarator signature accepts assignment ok 14 - a native num declared in a declarator signature accepts assignment ok 15 - a declarator signature holding one native int takes its initializer # Subtest: a for loop over a range of values rejects a <-> int parameter 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /'modifiable native int'/ ok 16 - a for loop over a range of values rejects a <-> int parameter ok t/02-rakudo/native-array-generic-parameterize.t ................. 1..12 ok 1 - role with array[T] attribute compiles ok 2 - attribute type instantiates to array[int] ok 3 - attribute holds an array[int] after instantiation with int ok 4 - attribute contents survive as native ints ok 5 - attribute type instantiates to array[num] for a num role instance ok 6 - attribute type instantiates to array[str] for a str role instance ok 7 - attribute type instantiates to array[uint8] for a sized native type ok 8 - attribute default array[T].new produces an array[int] ok 9 - defaulted attribute stores native ints ok 10 - a generic parameterization names itself array[T] # Subtest: instantiating with a non-native type dies with the native-type error 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /'Can only parameterize array with a native type'/ ok 11 - instantiating with a non-native type dies with the native-type error # Subtest: directly parameterizing with a non-native type still dies 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /'Can only parameterize array with a native type'/ ok 12 - directly parameterizing with a non-native type still dies ok t/02-rakudo/once-in-phasers.t ................................... 1..8 ok 1 - ENTER once in a sub fires on the first entry only ok 2 - a once inside an ENTER block fires on the first entry only ok 3 - state in an ENTER block persists across entries ok 4 - an ENTER body reads the current entry's arguments ok 5 - ENTER once in a loop body fires on the first iteration only ok 6 - a once as the body of start runs ok 7 - a plain once in a sub still fires once ok 8 - a once inside gather fires on the first iteration only ok t/02-rakudo/indirect-name-constant.t ............................ 1..11 ok 1 - the required module EXPORT::DEFAULT is visible through ::("EXPORT") ok 2 - the required module exports are read from ::("EXPORT") ok 3 - the re-read exported sub is callable ok 4 - a require-injected class shadows a same-named lexical class in ::("...") ok 5 - a multi-part ::("...") walks the require-injected package at run time ok 6 - a parameter default holding ::("...") looks the symbol up per call ok 7 - a ::("...") interpolated in a string runs the symbolic lookup ok 8 - a .&::("...") call runs the symbolic lookup that sees require-injected subs ok 9 - a hyper .&::($name) call resolves the routine at run time ok 10 - a constant initialized from an indirect lookup evaluates it at BEGIN time ok 11 - a direct name still resolves to the lexical class ok t/02-rakudo/multi-redeclaration-accepts.t ....................... 1..1 # Subtest: the duplicate-multi check does not run a parameter type ACCEPTS at compile time 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - the duplicate-multi check does not run a parameter type ACCEPTS at compile time ok t/02-rakudo/inherit-same-name-setting-package.t ................. 1..4 ok 1 - the class declared inside the same-named unit package inherits the qualified parent ok 2 - a method from the inherited parent works on the child ok 3 - a method of the child itself works ok 4 - the used package namespace carries the nested class ok t/02-rakudo/core-pseudo-package-precomp.t ....................... 1..1 # Subtest: a compile-time CORE:: reference in a precompiled module loads 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - a compile-time CORE:: reference in a precompiled module loads ok t/02-rakudo/once-in-role-sub.t .................................. 1..5 ok 1 - once in a role sub returns its value ok 2 - once in a role sub does not re-run on a later call ok 3 - the once body ran exactly once ok 4 - once with an expression in a role sub returns its value ok 5 - once in an exported sub in a role works ok t/02-rakudo/our-constant-shadow.t ............................... 1..4 ok 1 - a nested-block constant shadows the outer one of the same name ok 2 - the outer constant is unchanged lexically outside the block ok 3 - the nested constant overwrites the package entry # Subtest: a same-scope constant redeclaration still fails 1..2 ok 1 - code dies ok 2 - right exception type (X::Redeclaration) ok 4 - a same-scope constant redeclaration still fails ok t/02-rakudo/native-return-coercion.t ............................ 1..23 ok 1 - native-return sub widens to num on assignment ok 2 - native-return multi widens to num on assignment ok 3 - int * int widens to num on assignment ok 4 - int + int widens to num on assignment ok 5 - nested native int operators widen to num ok 6 - literal and native int mix computes the boxed result ok 7 - boxed Int operand keeps the result boxed ok 8 - parenthesized native results widen to num ok 9 - a parenthesized loop modifier stays an Iterable ok 10 - chained native multiply widens to num ok 11 - native prefix result participates in native dispatch ok 12 - all-native exponentiation widens to num ok 13 - native prefix negate widens to num ok 14 - num + num narrows to int on assignment ok 15 - native str return assigns to str ok 16 - rw routine with native return stays an lvalue ok 17 - boxed Int to native num still requires explicit coercion ok 18 - boxed Int return to native num still requires coercion ok 19 - subset return to native num still requires coercion ok 20 - div by a native zero throws ok 21 - Failure from a native-return multi flows through // ok 22 - Failure from a native-return sub stays soft in object context ok 23 - a named argument still lets the declared native return widen ok t/02-rakudo/private-method-trait-wrapper.t ...................... 1..2 ok 1 - a trait wrapper resolves the class private method at runtime # Subtest: a private-method typo in a composed class still fails to compile 1..2 ok 1 - 'class D { method !real() {}; method go() { self!bogus() } }' died ok 2 - right exception type (X::Comp) ok 2 - a private-method typo in a composed class still fails to compile ok t/02-rakudo/doc-param-declarator-once.t ......................... 1..2 # Subtest: a parameter declarator doc renders once under --doc 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - a parameter declarator doc renders once under --doc # Subtest: a method parameter declarator doc renders once under --doc 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - a method parameter declarator doc renders once under --doc ok t/02-rakudo/prefix-tilde-blob.t ................................. 1..8 ok 1 - prefix ~ on a utf8 decodes ok 2 - prefix ~ on a utf8 gives a Str ok 3 - prefix ~ on a utf16 decodes # Subtest: prefix ~ on a Buf still throws, naming the ~ operator 1..3 ok 1 - code dies ok 2 - right exception type (X::Buf::AsStr) ok 3 - .message matches rx/"'~'"/ ok 4 - prefix ~ on a Buf still throws, naming the ~ operator # Subtest: concatenating a Buf throws, naming the ~ operator 1..3 ok 1 - code dies ok 2 - right exception type (X::Buf::AsStr) ok 3 - .message matches rx/"'~'"/ ok 5 - concatenating a Buf throws, naming the ~ operator # Subtest: the error still suggests decode 1..3 ok 1 - code dies ok 2 - right exception type (X::Buf::AsStr) ok 3 - .message matches rx/decode/ ok 6 - the error still suggests decode # Subtest: prefix ~ on a Blob still throws 1..2 ok 1 - code dies ok 2 - right exception type (X::Buf::AsStr) ok 7 - prefix ~ on a Blob still throws ok 8 - infix ~ with a utf8 still concatenates ok t/02-rakudo/my-role-group-in-package.t .......................... 1..6 ok 1 - three my-role variants in a class body form a group ok 2 - my-role variants join the group inside a role body too ok 3 - group dispatches to the single-arg variant ok 4 - group dispatches to the two-arg variant ok 5 - a my-role group inside a package shadows an outer lexical of the same name # Subtest: redeclaring the group name as a class is still an error 1..2 ok 1 - 'class F { # my role R[Str $c] { } # my class R { } # } # ' died ok 2 - right exception type (X::Redeclaration) ok 6 - redeclaring the group name as a class is still an error ok t/02-rakudo/native-literal-dispatch.t ........................... 1..24 ok 1 - a literal beside a native int reaches the native candidate ok 2 - a literal on the left adopts the native context too ok 3 - the native candidate answers whether or not its body can inline ok 4 - a lone literal dispatches as the boxed value it is ok 5 - a native variable reaches the native candidate ok 6 - a parameter read provides the native context through its declared type ok 7 - a literal among three positionals has no single native context ok 8 - a named argument leaves a literal boxed ok 9 - a method call argument stays the boxed value ok 10 - an int literal does not adopt a num context ok 11 - a num literal beside a native num reaches the native candidate ok 12 - a str literal beside a native str reaches the native candidate ok 13 - a constant heredoc pairs like a str literal ok 14 - a literal above the small-Int storage limit still has its native form ok 15 - the largest native int literal has its native form ok 16 - a literal too wide for a native int stays boxed ok 17 - native arithmetic on a wide literal computes the right value ok 18 - a literal paired with a native int computes a native result that widens to num ok 19 - div by a literal zero throws like div by a native zero ok 20 - native addition of a literal wraps like native variables do ok 21 - a lone literal rules out a native rw candidate at compile time ok 22 - a paired literal rules out a native rw candidate at compile time ok 23 - a settled native-return multi with a paired literal widens to num ok 24 - an indirect call passes a paired literal natively ok t/02-rakudo/phaser-once-state.t ................................. 1..4 ok 1 - INIT once runs its body ok 2 - BEGIN once runs its body ok 3 - INIT once yields its value ok 4 - INIT once runs a multi-statement body ok t/02-rakudo/pseudo-package-nested.t ............................. 1..3 ok 1 - CORE nested in a declared package name is allowed ok 2 - another pseudo-package nested in a declared name is allowed # Subtest: a leading pseudo-package in a declared name is still rejected 1..2 ok 1 - 'class MY::Foo { }' died ok 2 - right exception type (X::PseudoPackage::InDeclaration) ok 3 - a leading pseudo-package in a declared name is still rejected ok t/02-rakudo/postfix-hyper.t ..................................... 1..10 ok 1 - a hyper power postfix applies element-wise ok 2 - a hyper meta-method call acts on the operand itself ok 3 - a hyper meta-method call on a type object resolves ok 4 - a hyper unqualified private method call applies element-wise ok 5 - a hyper method call applies element-wise ok 6 - a hyper postcircumfix index applies element-wise ok 7 - a hyper empty-index zen slice yields each element unchanged ok 8 - a hyper zen slice preserves nested elements ok 9 - a hyper zen slice on a single element yields that element ok 10 - a hyper `<>` hash zen slice errors, not selects nothing ok t/02-rakudo/12-multi-revision-gated.t ........................... 1..8 # Subtest: is revision-gated("6.c") candidate called for 'use v6.c;' 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - is revision-gated("6.c") candidate called for 'use v6.c;' # Subtest: is revision-gated("6.d") candidate called for 'use v6.d;' 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - is revision-gated("6.d") candidate called for 'use v6.d;' # Subtest: is revision-gated("6.e") candidate called for 'use v6.e;' 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - is revision-gated("6.e") candidate called for 'use v6.e;' # Subtest: candidates differing in parameter name only supersede (6.c caller) 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 4 - candidates differing in parameter name only supersede (6.c caller) # Subtest: candidates differing in parameter name only supersede (6.e caller) 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 5 - candidates differing in parameter name only supersede (6.e caller) # Subtest: same-revision equivalent candidates dispatch to one candidate 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 6 - same-revision equivalent candidates dispatch to one candidate ok 7 - # SKIP the redeclaration worry needs the RakuAST frontend ok 8 - # SKIP the redeclaration worry needs the RakuAST frontend ok t/02-rakudo/package-adopts-imported-stub-who.t .................. 1..2 ok 1 - a symbol from the imported stub package is visible via the class ok 2 - the class adopts the imported stub package WHO rather than copying its symbols ok t/02-rakudo/param-arg-compile-errors.t .......................... 1..19 ok 1 - a call through a read-only parameter that can never bind is refused at compile time ok 2 - a call through a copy parameter that can never bind is refused at compile time ok 3 - a call through an rw parameter that can never bind is refused at compile time ok 4 - a call through a raw parameter that can never bind is refused at compile time ok 5 - an untyped parameter argument is not judged at compile time ok 6 - a parameter argument that can bind compiles ok 7 - a definite Mu variable argument is not refused ok 8 - a definite Mu parameter argument is not refused ok 9 - a definite Mu parameter argument still passes its value ok 10 - a subset parameter argument is judged by its refinee ok 11 - a subset parameter argument binds where its refinee binds ok 12 - a subset of a definite type strips to its nominal foundation ok 13 - a definite typed parameter argument is judged by its base type ok 14 - a parameter argument no multi candidate can bind is refused at compile time ok 15 - refusing a multi call renders the candidate list ok 16 - the candidate list names each signature ok 17 - a coercion typed parameter argument is not judged at compile time ok 18 - a definite typed parameter argument binds where its base type binds ok 19 - # SKIP the legacy frontend does not judge definite typed variable arguments ok t/02-rakudo/qualified-method-call-unresolved.t .................. 1..4 ok 1 - a qualified call to a not-in-scope qualifier compiles ok 2 - a qualified call to an in-scope type dispatches to its method # Subtest: a qualifier that resolves to nothing reports an invalid qualifier at runtime 1..2 ok 1 - code dies ok 2 - right exception type (X::Method::InvalidQualifier) ok 3 - a qualifier that resolves to nothing reports an invalid qualifier at runtime ok 4 - a hyper qualified call dispatches to the qualifier type ok t/02-rakudo/rakudoc-unit-package.t .............................. 1..1 ok 1 - # SKIP $=rakudoc requires the RakuAST frontend ok t/02-rakudo/quit-phaser-succeed.t ............................... 1..5 ok 1 - a default in a whenever QUIT handles the quit and react completes ok 2 - a default in a supply-block whenever QUIT handles the quit # Subtest: a QUIT with no matching when rethrows and the react block dies 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /boom/ ok 3 - a QUIT with no matching when rethrows and the react block dies ok 4 - the non-matching when clause did not run ok 5 - a QUIT phaser returns Nil after its default succeeds ok t/02-rakudo/proc-async-spawn-failure.t .......................... 1..3 # Subtest: The merged Supply of an async process that does not exist quits with the spawn error 1..3 ok 1 - code dies ok 2 - right exception type (X::AdHoc) ok 3 - .message matches /'does-not-exist-cabbage-mooncake-unicycle'/ ok 1 - The merged Supply of an async process that does not exist quits with the spawn error ok 2 - Promise for an async process that does not exist is broken when its merged Supply is tapped ok 3 - Promise for a pty process that does not exist is broken ok t/02-rakudo/rakuast-trailing-declarator-doc.t ................... 1..7 ok 1 - trailing \#= attaches to a parameterless sub ok 2 - trailing \#= attaches to a sub past its signature ok 3 - trailing \#= attaches correctly to a chain of subs ok 4 - trailing \#= between signature and body still works ok 5 - plain trailing ` \#` comment does not produce a declarator doc ok 6 - leading \#| declarator doc still works ok 7 - mid-signature trailing \#= stays on the parameter, not on the routine ok t/02-rakudo/rakuast-whatever-paren-postfix.t .................... 1..9 ok 1 - (5 ~~ *).WHAT returns the WhateverCode type object ok 2 - (*+1).WHAT returns the WhateverCode type object ok 3 - ("- " ~ *).chars produces a WhateverCode ok 4 - ... a concrete curried instance ok 5 - ... that runs ("- " ~ $_).chars ok 6 - *.Str (no parens) curries to WhateverCode ok 7 - *.Str produces a concrete curried instance ok 8 - *.Str curried thunk runs with arg ok 9 - *+1 (no parens) still curries and runs ok t/02-rakudo/regex-crlf-grapheme.t ............................... 1..9 ok 1 - a regex \r\n matches a combined CR LF grapheme ok 2 - splitting on /\r\n/ breaks at each CR LF grapheme ok 3 - a /\r\n/ match consumes exactly the one combined grapheme ok 4 - a regex \r\n\r\n matches a blank-line header terminator ok 5 - a negated \R followed by \n does not fuse and still matches ok 6 - a \r followed by a negated \N does not fuse ok 7 - a lone \n still matches a CR LF grapheme via the newline class ok 8 - a \x0D codepoint escape does not fuse with \n ok 9 - a \r followed by a quantified \n+ does not fuse into a \r\n literal 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/regex-token-arg-backtrack.t ......................... 1..6 ok 1 - backtracking an alternation of argument tokens tries the next branch ok 2 - exhausting both branches fails cleanly instead of erroring ok 3 - sequential alternation of argument tokens backtracks too ok 4 - a single argument token call still matches ok 5 - backtracking argumentless tokens is unaffected ok 6 - a regex (non-ratchet) with an argument can still be backtracked into ok t/02-rakudo/regex-group-named-capture.t ......................... 1..8 ok 1 - named capture of a group with a quantified atom spans the run ok 2 - and binds a single Match, not a list of repetitions ok 3 - named capture of a group containing a subrule ok 4 - the group capture does not adopt the subrule inner captures ok 5 - the subrule captures under its own name ok 6 - a quantified bare subrule alias captures per repetition ok 7 - named capture of a quantified group spans the whole run ok 8 - a backtrack-modified group capture does not adopt inner captures ok t/02-rakudo/return-method-in-sunk-for.t ......................... 1..5 ok 1 - .return in a sunk for loop returns from the routine ok 2 - .return in a sunk .map(...).sink returns from the routine ok 3 - .return of a value matching the return type works # Subtest: .return still honors a literal return constraint 1..3 ok 1 - code dies ok 2 - right exception type (X::AdHoc) ok 3 - .message matches /'return value 42'/ ok 4 - .return still honors a literal return constraint # Subtest: a type-constrained .return in a sunk for reports the routine type-check error 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Return) ok 5 - a type-constrained .return in a sunk for reports the routine type-check error ok t/02-rakudo/regex-expr-sym.t .................................... 1..7 ok 1 - a :sym(EXPR) candidate matches the evaluated sym value ok 2 - the token captures the evaluated sym value ok 3 - input not matching the evaluated sym falls through to the other candidate ok 4 - a literal :sym<...> candidate still matches its sym ok 5 - a literal :sym<...> proto still falls through to another candidate ok 6 - a constant-foldable expression sym evaluates and matches ok 7 - a sym computed by a BEGIN-time call evaluates and matches ok t/02-rakudo/regex-vspace-class-crlf.t ........................... 1..8 ok 1 - the CR LF grapheme is not a member of <[\v]> ok 2 - nor when \v is merged with a literal in a class ok 3 - so <-[\v]> matches the CR LF grapheme ok 4 - and <[\V]> matches it ok 5 - while a standalone \v still matches it ok 6 - <[\v]> matches a line feed ok 7 - <[\v]> matches a carriage return ok 8 - <[\v]> does not match a non-space character ok t/02-rakudo/repr-trait-after-pod.t .............................. 1..6 ok 1 - is repr(...) after a pod block sets the representation ok 2 - is repr(...) after several pod blocks still sets the representation ok 3 - is repr(...) with a double-quoted value works after a pod block ok 4 - is repr(...) without a pod block is unchanged ok 5 - the pod block before an is repr(...) class still reaches $=pod ok 6 - the preserved pod keeps its content ok t/02-rakudo/regex-constant-interpolation.t ...................... 1..4 ok 1 - a constant array interpolates as an alternation ok 2 - a constant integer interpolates by its string value ok 3 - a constant string is still matched as a literal ok 4 - a constant array interpolates in a grammar token under :i ok t/02-rakudo/role-group-under-core-package.t ..................... 1..5 ok 1 - the first variant of a role group under a setting-named package resolves ok 2 - the second variant of that role group resolves, not a redeclaration ok 3 - a role group under a plain compound name still resolves its first variant ok 4 - a role group under a plain compound name resolves its second variant # Subtest: redeclaring a class under a setting-named package is still an error 1..2 ok 1 - 'class Hash::Dup { }; class Hash::Dup { }' died ok 2 - right exception type (X::Redeclaration) ok 5 - redeclaring a class under a setting-named package is still an error ok t/02-rakudo/99-misc.t ........................................... 1..14 # 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 # Subtest: Temporal not ok 1 - .from-posix-nanos vs .from-posix # TODO Needs more time or expertise # Failed test '.from-posix-nanos vs .from-posix' # at t/02-rakudo/99-misc.t line 155 # expected: 'Instant:915148832.999999999' # got: 'Instant:915148800.999999999' 1..1 ok 11 - Temporal # Subtest: DOC use loads only when compiling documentation 1..2 # Subtest: a DOC-prefixed use is inert without --doc 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - a DOC-prefixed use is inert without --doc # Subtest: a DOC-prefixed use loads the module under --doc 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - a DOC-prefixed use loads the module under --doc ok 12 - DOC use loads only when compiling documentation # Subtest: trailing paren declarator doc directly after a block 1..1 ok 1 - the doc attaches without a separating semicolon ok 13 - trailing paren declarator doc directly after a block # Subtest: a stash reference used as a compile-time value is the stash 1..4 ok 1 - a trailing :: on a class name gives its stash ok 2 - the stash holds the nested package ok 3 - a trailing :: on GLOBAL gives a stash ok 4 - a name without a trailing :: keeps its own value ok 14 - a stash reference used as a compile-time value is the stash Saw 1 occurrence of deprecated code. ================================================================================ Method perl (from Mu) seen at: t/02-rakudo/99-misc.t, line 150 Please use raku instead. -------------------------------------------------------------------------------- Please contact the author to have these occurrences of deprecated code adapted, so that this message will disappear! ok t/02-rakudo/precomp-declarator-block-or-hash.t .................. 1..1 # Subtest: precomp of `{ :pair }` block-or-hash inside a #|-documented sub does not orphan a stub 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - precomp of `{ :pair }` block-or-hash inside a \#|-documented sub does not orphan a stub ok t/02-rakudo/role-forward-lexical-default.t ...................... 1..8 ok 1 - a forward sub reference in a role method parameter default resolves ok 2 - a forward sub reference in a role attribute default resolves ok 3 - a forward sub reference in a role method body resolves ok 4 - a forward reference to a method-local sub in a role resolves ok 5 - a forward sub reference inside a package nested in a role resolves ok 6 - a reference to a later outer sub, in scope by consumption, resolves ok 7 - a backward sub reference in a role still resolves ok 8 - a role-local sub wins over an outer sub of the same name ok t/02-rakudo/our-twigil-package-key.t ............................ 1..2 ok 1 - the `our @.operations` accessor returns its bound value ok 2 - the `our %.table` accessor returns its bound value ok t/02-rakudo/role-shadows-setting-type.t ......................... 1..6 ok 1 - a role can shadow a setting class of the same compound name ok 2 - a role can shadow a setting class of the same simple name ok 3 - a role shadows a setting role of the same name instead of joining it # Subtest: a role redeclaring a same-scope class is rejected 1..2 ok 1 - 'class Foo { }; role Foo { }' died ok 2 - right exception type (X::Redeclaration) ok 4 - a role redeclaring a same-scope class is rejected # Subtest: a role redeclaring an enclosing-scope class is rejected 1..2 ok 1 - 'class Outer { }; { role Outer { } }' died ok 2 - right exception type (X::Redeclaration) ok 5 - a role redeclaring an enclosing-scope class is rejected ok 6 - same-named roles still form a role group ok t/02-rakudo/parameter-sub-signature.t ........................... 1..19 ok 1 - trait_mod multi with named array sub signature on attribute compiles ok 2 - named array sub signature destructure binds ok 3 - positional sub signature destructure binds ok 4 - multi candidate with sub signature dispatches and binds ok 5 - nested sub signature destructure binds ok 6 - trait_mod multi with named array sub signature on class compiles ok 7 - slurpy positional with sub signature destructure binds ok 8 - hash sub signature destructure binds ok 9 - sub signature parameter default thunk runs ok 10 - parametric role with sub signature param accepts inline array ok 11 - parametric role with named sub signature param accepts inline array via named arg ok 12 - role parameterization with self outside object dies cleanly ok 13 - unfilled named sub signature parameter binds to Any ok 14 - unfilled positional sub signature parameter binds to Any ok 15 - unfilled sub signature value resolves to an Any candidate ok 16 - where after a sub signature binds the destructure and accepts a valid value # Subtest: where after a sub signature rejects a value failing the constraint 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 17 - where after a sub signature rejects a value failing the constraint ok 18 - every where clause on a parameter is enforced ok 19 - where-guarded scalar trait candidate does not shadow the named sub signature candidate ok t/02-rakudo/role-method-generic-invocant.t ...................... 1..10 ok 1 - a role private method called on an object of another class binds its invocant ok 2 - a concretized private method accepts an invocant of another class doing the role ok 3 - the concretized private method still advertises the class as its invocant type ok 4 - a concretized public method accepts an invocant of another class doing the role ok 5 - an untyped explicit invocant binds an object of another class # Subtest: an explicitly ::?CLASS-typed invocant still rejects another class 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 6 - an explicitly ::?CLASS-typed invocant still rejects another class ok 7 - a role type-capture parameter still binds a matching argument # Subtest: a role type-capture parameter still rejects a mismatched argument 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 8 - a role type-capture parameter still rejects a mismatched argument # Subtest: a sub-signature method rejects a cross-class invocant in the full binder 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 9 - a sub-signature method rejects a cross-class invocant in the full binder # Subtest: a class method still rejects an invocant of an unrelated class 1..2 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 10 - a class method still rejects an invocant of an unrelated class ok t/02-rakudo/signature-array-elem-definedness.t .................. 1..2 ok 1 - Str:D :@alpha = Array[Str] default binds ok 2 - Str:D @alpha parameter stores Positional[Str], not Positional[Str:D] ok t/02-rakudo/rule-quantifier-whitespace-backtrack.t .............. 1..10 ok 1 - a default subrule quantifier in a rule backtracks across inserted whitespace ok 2 - the same rule still matches when the optional subrule is present ok 3 - the same shape in a token does not backtrack (ratchet, no whitespace) ok 4 - DEFAULT FALSE parses: the optional name gives FALSE back to the value ok 5 - DEFAULT with an explicit name still parses ok 6 - an explicit ratchet quantifier (?:) in a rule does not backtrack ok 7 - a %%-separated quantifier in a rule gives an iteration back ok 8 - a ** {..} block-range quantifier in a rule backtracks ok 9 - a quantifier inside a capture group in a token stays ratcheted ok 10 - a token alternation can still be re-entered for its other branch ok t/02-rakudo/siglist-decl-rvalue.t ............................... 1..7 ok 1 - first sigilless target aliases the first declared container ok 2 - second sigilless target aliases the second declared container ok 3 - assigning through the aliases writes the underlying containers ok 4 - a no-initializer list declaration used as an rvalue yields its containers ok 5 - a plain sunk list declaration statement still works ok 6 - list assignment still binds each element ok 7 - list bind to a literal list still works ok t/02-rakudo/signature-literal-declaration.t ..................... 1..5 ok 1 - my :(...) := list binds positionally ok 2 - my :(...) := capture binds named arguments ok 3 - our :(...) := binds # Subtest: assignment to a signature literal declaration is rejected 1..2 ok 1 - code dies ok 2 - right exception type (X::Syntax::Variable::SignatureAssignment) ok 4 - assignment to a signature literal declaration is rejected # Subtest: signature literal declaration without an initializer is rejected 1..2 ok 1 - code dies ok 2 - right exception type (X::Syntax::Variable::SignatureWithoutInitializer) ok 5 - signature literal declaration without an initializer is rejected ok t/02-rakudo/role-parameterization-hash-pair-args.t .............. 1..8 ok 1 - role parameterized with a %(...) hash ok 2 - role parameterized with an empty %() ok 3 - role parameterized with a => pair ok 4 - role parameterized with a { } hash composer ok 5 - role parameterized with an @(...) list ok 6 - role parameterized with an empty @() ok 7 - role parameterized with a $(...) item ok 8 - role parameterized with a mixed-value %(...), as Cro does ok t/02-rakudo/slurpy-callable-param.t ............................. 1..4 ok 1 - a `*&` parameter binds and calls a single Callable ok 2 - a `*&` parameter is not actually slurpy ok 3 - a `*&` parameter keeps its callable sigil ok 4 - a `*&` parameter still takes a single argument, not many ok t/02-rakudo/rakuast-code-assuming.t ............................. 1..9 ok 1 - assuming over a sub with an externally-defined typed parameter ok 2 - assuming from a BUILD submethod, currying a typed named arg ok 3 - assuming over a pointy block with an externally-defined typed parameter ok 4 - plain positional assuming still works ok 5 - assuming a containerized positional declared at the call site ok 6 - is raw curried call sees initial container value ok 7 - is raw curried call sees mutated container value ok 8 - subset-typed Whatever-passthrough, currying Int ok 9 - subset-typed Whatever-passthrough, currying Str ok t/02-rakudo/routine-overrides-imported-stub.t ................... 1..4 ok 1 - a stub sub reports .yada ok 2 - a non-stub sub does not report .yada ok 3 - a real routine overrides an imported stub of the same name # Subtest: overriding a non-stub imported routine is rejected 1..2 ok 1 - 'use SubsStubHelper; sub real-export() { 0 }' died ok 2 - right exception type (X::Redeclaration) ok 4 - overriding a non-stub imported routine is rejected ok t/02-rakudo/role-typed-hash-attr-hang.t ......................... 1..8 ok 1 - Issue 6071 golf: role with generic hash value, composed into class ok 2 - role with generic hash value, parameterized and instantiated ok 3 - role with `has %h{Int} of T` (the issue 6071 attribute shape) ok 4 - PR 6073 golf: user `::TValue` colliding with Array::Typed `::TValue` ok 5 - user `::TValue` colliding with Hash::Typed `::TValue` ok 6 - user `::TDefault` colliding with Hash::Typed `::TDefault` ok 7 - collision-named capture still resolves the array element type ok 8 - collision-named capture still resolves the hash value type ok t/02-rakudo/qualified-lookup-parent-package-sc.t ................ 1..1 ok 1 - a constant naming a symbol through the unit own parent package compiles ok t/02-rakudo/smartmatch-topic-rhs.t .............................. 1..5 ok 1 - a bare $_ on the smartmatch RHS matches against the outer topic, not the LHS ok 2 - a bare $_ on the smartmatch RHS that equals the LHS still matches ok 3 - reusing the topic on the smartmatch RHS does not consume the LHS ok 4 - a Seq LHS against the topic RHS does not throw ok 5 - a block on the smartmatch RHS still binds $_ to the LHS ok t/02-rakudo/self-in-regex.t ..................................... 1..7 ok 1 - self in a regex code block in a role compiles ok 2 - self in a regex predicate assertion in a role compiles ok 3 - self in a role regex calls the right method ok 4 - self in a class/grammar regex still works ok 5 - self with no available object still fails at compile time ok 6 - self in a non-method regex in a role still fails at compile time ok 7 - self in a role body mainline still fails at compile time ok t/02-rakudo/smartmatch-match-matcher.t .......................... 1..9 ok 1 - smartmatch against a Match returns a Match ok 2 - the matcher itself is the result ok 3 - negated smartmatch against a successful Match ok 4 - a constructed Match is returned as-is too ok 5 - a constructed Match is truthy, so its negated smartmatch is False ok 6 - Junction topic against a Match collapses to Bool ok 7 - any-Junction against a successful Match ok 8 - none-Junction against a successful Match ok 9 - negated all-Junction against a successful Match ok t/02-rakudo/sink-postfix-call-failure.t ......................... 1..6 ok 1 - a Failure reached through a sunk postfix call throws ok 2 - sinking a postfix call returning a Failure throws ok 3 - sinking an is-rw routine call result does not sink its container ok 4 - sinking an is-rw container return does not sink its contents ok 5 - binding a block call result preserves its container ok 6 - sinking a non-Failure postfix call result lives ok t/02-rakudo/n-flag-mainline-scope.t ............................. 1..5 # Subtest: a BEGIN-declared variable persists across -n lines 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - a BEGIN-declared variable persists across -n lines # Subtest: a plain my assigned in BEGIN persists across -n lines 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - a plain my assigned in BEGIN persists across -n lines # Subtest: a plain my = 0 resets each line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - a plain my = 0 resets each line # Subtest: separate BEGIN-declared variables both persist 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 4 - separate BEGIN-declared variables both persist # Subtest: -p modifies the topic each line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 5 - -p modifies the topic each line ok t/02-rakudo/superscript-power-macron.t .......................... 1..5 ok 1 - 10 with a macron-signed negative exponent ok 2 - 10 with a high-minus negative exponent ok 3 - macron and high-minus exponents agree ok 4 - macron negative exponent on a small base ok 5 - positive superscript exponent ok t/02-rakudo/our-operator-var-container.t ........................ 1..6 ok 1 - the package entry holds the value assigned to the operator ok 2 - the assigned operator works when used ok 3 - a prefix operator variable also reaches its package entry ok 4 - the assigned prefix operator works ok 5 - an exported operator variable exports the assigned routine, not the empty container ok 6 - the exported operator is invocable ok t/02-rakudo/split-trans-capture-markers.t ....................... 1..16 ok 1 - .split honors both capture markers ok 2 - .split honors a <( marker without )> ok 3 - .split honors a )> marker without <( ok 4 - .split without capture markers is unaffected ok 5 - .split honors capture markers on repeated matches ok 6 - .split with a limit honors capture markers ok 7 - .split with :skip-empty honors capture markers ok 8 - .split with a needle list honors capture markers ok 9 - .split with :v produces parts according to capture markers ok 10 - .split with :v produces the marked extent as the separator Match ok 11 - .split with :v produces a Match with the marked extent ok 12 - .trans with a string replacement honors capture markers ok 13 - .trans with a callable replacement honors capture markers ok 14 - .trans with needle and replacement lists honors capture markers ok 15 - .split and .subst agree on the extent of a marker regex ok 16 - .split does not apply capture markers of an interpolated regex ok t/02-rakudo/smartmatch-user-accepts.t ........................... 1..10 ok 1 - a type object with a user ACCEPTS runs it for a smartmatch ok 2 - the user ACCEPTS ran once ok 3 - a role-supplied ACCEPTS on a but-mixed type object is called ok 4 - the role ACCEPTS ran once ok 5 - a :D-only ACCEPTS does not run for a type-object right side ok 6 - so the type check applies and the ACCEPTS is not called ok 7 - a negated smartmatch runs the user ACCEPTS and inverts it ok 8 - the user ACCEPTS ran once for the negated form ok 9 - a setting type still type checks, a match ok 10 - a setting type still type checks, a non-match ok t/02-rakudo/proc-async-merge-stream-close.t ..................... 1..10 ok 1 - Merged output includes stderr output produced before stdout closed ok 2 - Merged output includes stderr output produced after stdout closed ok 3 - Every merged chunk is defined after stdout closed early ok 4 - Merged Supply completes when stderr ends after stdout closed early ok 5 - Merged output includes stdout output produced before stderr closed ok 6 - Merged output includes stdout output produced after stderr closed ok 7 - Every merged chunk is defined after stderr closed early ok 8 - Merged Supply completes when stdout ends after stderr closed early ok 9 - A merged child that writes nothing produces no output ok 10 - Merged Supply completes for a child that writes nothing ok t/02-rakudo/sub-signature-special-var.t ......................... 1..5 ok 1 - $_ in a for-loop destructuring sub-signature binds the value ok 2 - $_ in a positional sub-signature binds the destructured value ok 3 - $/ in a sub-signature binds without a redeclaration ok 4 - $! in a sub-signature binds without a redeclaration ok 5 - $! in a for-loop sub-signature binds without a redeclaration ok t/02-rakudo/rakuast-anon-container-freshness.t .................. 1..3 ok 1 - a hash composer in a hot loop keeps per-iteration literal values ok 2 - a hash composer in a hot loop allocates a distinct hash per iteration not ok 3 - a BEGIN-invoked sub returns a fresh anonymous hash per call in a hot loop # TODO BEGIN-compiled routines keep unlowered containers under the legacy frontend # Failed test 'a BEGIN-invoked sub returns a fresh anonymous hash per call in a hot loop' # at t/02-rakudo/rakuast-anon-container-freshness.t line 82 # expected: '-1' # got: '137' ok t/02-rakudo/smartmatch-junction-topic.t ......................... 1..31 ok 1 - all-Junction against a Hash, every key present ok 2 - all-Junction against a Hash, a key missing ok 3 - any-Junction against a Hash, one key present ok 4 - none-Junction against a Hash, no key present ok 5 - none-Junction against a Hash, a key present ok 6 - one-Junction against a Hash, exactly one key present ok 7 - all-Junction against a Hash constant ok 8 - negated all-Junction against a Hash, every key present ok 9 - negated all-Junction against a Hash, no key present ok 10 - any-Junction against a type held in a variable ok 11 - Junction on both sides of a smartmatch ok 12 - a regex held in a variable returns a Match ok 13 - a regex held in a variable sets $/ ok 14 - negated smartmatch against a matching regex variable ok 15 - the negated smartmatch still sets $/ ok 16 - subset where-clause threading all() over a Map accepts a member ok 17 - subset where-clause rejects a non-member ok 18 - a matcher with its own Junction ACCEPTS candidate decides the match ok 19 - that ACCEPTS candidate received the whole Junction ok 20 - negated smartmatch defers to the custom ACCEPTS too ok 21 - a non-multi custom ACCEPTS decides the match ok 22 - a non-multi custom ACCEPTS received the whole Junction ok 23 - Junction topic against a regex variable returns a Junction ok 24 - the match Junction collapses to True when an eigenstate matches ok 25 - the match Junction collapses to False when no eigenstate matches ok 26 - negated smartmatch of a Junction against a regex variable ok 27 - all-Junction against a complex expression yielding a Map ok 28 - a custom ACCEPTS matcher from a complex expression decides the match ok 29 - that matcher received the whole Junction ok 30 - a regex from a complex expression returns a Match ok 31 - a regex from a complex expression sets $/ ok t/02-rakudo/subsig-nominal-type.t ............................... 1..6 ok 1 - a typed anonymous sub-signature binds and destructures a plain Array ok 2 - an untyped anonymous sub-signature still binds a plain Array ok 3 - a typed sub-signature parameter is a bare Positional, not Positional[Int] ok 4 - a real typed array parameter still parameterises Positional by its element type ok 5 - a real typed array parameter still binds a matching Positional ok 6 - a real typed array with a sub-signature keeps Positional[Int] ok t/02-rakudo/lexical-declarator-doc.t ............................ 1..8 # Subtest: a trailing declarator doc on a lexical does not warn about a missing declarand 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - a trailing declarator doc on a lexical does not warn about a missing declarand # Subtest: trailing declarator docs on our and state declarations do not warn either 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - trailing declarator docs on our and state declarations do not warn either # Subtest: leading declarator doc before a lexical falls through to the next declarand 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - leading declarator doc before a lexical falls through to the next declarand # Subtest: a trailing declarator doc on a typed lexical does not become the WHY of its type 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 4 - a trailing declarator doc on a typed lexical does not become the WHY of its type # Subtest: a trailing declarator doc on a typed lexical does not replace the class doc 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 5 - a trailing declarator doc on a typed lexical does not replace the class doc # Subtest: a documented lexical does not leave a hole in $=pod 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 6 - a documented lexical does not leave a hole in $=pod # Subtest: a trailing declarator doc attaches to a HAS attribute without warning 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 7 - a trailing declarator doc attaches to a HAS attribute without warning ok 8 - # SKIP the $=rakudoc variable requires the RakuAST frontend ok t/02-rakudo/term-self-reference.t ............................... 1..5 ok 1 - a term is visible inside its own initializer ok 2 - a term self-reference drives a recursive lazy sequence ok 3 - a term may reference an earlier term ok 4 - a typed term binding still works ok 5 - a term with no self-reference is unaffected ok t/02-rakudo/native-argument-snapshot.t .......................... 1..9 ok 1 - a native lexical as a pair value is snapshotted at construction ok 2 - a native attribute as a pair value is snapshotted at construction ok 3 - a native argument stored by a sub through a raw parameter is a snapshot ok 4 - a native argument stored by a prefix through a raw parameter is a snapshot ok 5 - a native argument stored by a postfix through a raw parameter is a snapshot ok 6 - a native argument to an rw parameter still writes back ok 7 - a native argument to an infix with an rw parameter stays writable ok 8 - a native argument after a named argument still binds rw to its parameter ok 9 - a native argument after a flattened argument still binds rw to its parameter ok t/02-rakudo/supply-one-emit.t ................................... 1..6 ok 1 - a single-emit supply statement emits its value ok 2 - a single-emit supply block emits its value ok 3 - a Failure from the emitted expression quits the supply ok 4 - the Failure was not emitted as a value ok 5 - a two-emit supply block emits both values ok 6 - a single emit with a statement modifier emits its value ok t/02-rakudo/object-hash-default-value-type.t .................... 1..6 # Subtest: 6.d default: my %h{Mu} defaults value type to Any 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - 6.d default: my %h{Mu} defaults value type to Any # Subtest: 6.e: my %h{Mu} defaults value type to Mu 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 2 - 6.e: my %h{Mu} defaults value type to Mu # Subtest: 6.d default: my %h{Str} defaults value type to Any 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 3 - 6.d default: my %h{Str} defaults value type to Any # Subtest: 6.e: my %h{Str} defaults value type to Mu 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 4 - 6.e: my %h{Str} defaults value type to Mu # Subtest: my Int %h{Str} keeps the explicit value type on either revision 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 5 - my Int %h{Str} keeps the explicit value type on either revision # Subtest: my %h without shape stays the generic Hash on either revision 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 6 - my %h without shape stays the generic Hash on either revision 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; .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|4142490128) ... } 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|3852720480) ... } 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|3852723080) ... } 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|3852723200) ... } 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|3852723240) ... } 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|3852723280) ... } 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|3852723320) ... } 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|3852723360) ... } 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|3852723400) ... } 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|3852723440) ... } 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|3852723480) ... } 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|3852723520) ... } 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|3852723560) ... } 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|3852723600) ... } 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|3852723640) ... } 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|3852723680) ... } 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|3852723720) ... } 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|3852723760) ... } 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|3852723800) ... } 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|3852723840) ... } ok 18 - str with args ok 51 - .new on native types works (deprecated; will die) 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/08-performance/21-rakuast-unused-implicits.t .................. 1..53 ok 1 - a sub that never touches the topic declares no fresh $_ ok 2 - # SKIP shapes specific to the RakuAST frontend ok 3 - # SKIP shapes specific to the RakuAST frontend ok 4 - # SKIP shapes specific to the RakuAST frontend ok 5 - assigning and reading the topic in a sub behaves unchanged ok 6 - a sub sees its own fresh topic, not the enclosing one ok 7 - given topicalizes ok 8 - the enclosing topic survives a given ok 9 - a for loop binds its topic per iteration ok 10 - smartmatch in a sub with a kept topic works ok 11 - a closure taking the topic as its argument still receives it ok 12 - # SKIP the %_ shapes are specific to the RakuAST frontend ok 13 - # SKIP the %_ shapes are specific to the RakuAST frontend ok 14 - a method with an unused %_ still accepts and discards stray nameds ok 15 - flattening %_ into another call still works ok 16 - a method that never touches &?ROUTINE does not bind it ok 17 - a method using &?ROUTINE keeps its binding ok 18 - &?ROUTINE in a method names the method ok 19 - &?ROUTINE in a sub names the sub ok 20 - &?ROUTINE reached from a nested block names the enclosing method ok 21 - samewith in a method redispatches through its kept binding ok 22 - # SKIP legacy never installs &?ROUTINE for an EVAL-only use ok 23 - # SKIP the accessor shape is specific to the RakuAST frontend ok 24 - an accessor still absorbs stray named arguments ok 25 - a native rw accessor still writes and reads through its reference ok 26 - a scalar rw accessor still writes and reads its container ok 27 - an accessor composed from a role still reads its attribute ok 28 - # SKIP the accessor block shape is specific to the RakuAST frontend ok 29 - # SKIP the legacy invocant name leaks from the first composed package ok 30 - # SKIP the legacy invocant name leaks from the first composed package ok 31 - accessors of one package share one signature ok 32 - an accessor invoked on the type object still dies ok 33 - an accessor found through the MOP still invokes ok 34 - an accessor rejects an extra positional argument ok 35 - callsame from an overriding method reaches the accessor ok 36 - a wrapped accessor runs its wrapper around the raw block ok 37 - an unwrapped accessor reads directly again ok 38 - an accessor still reads through a mixin instance ok 39 - the shared accessor signature compiles ok 40 - the shared accessor signature loads from the precompilation store ok 41 - a method of raw ops declares no fresh match or error variable ok 42 - a call inside a nested block keeps the method fresh containers ok 43 - string interpolation counts as a call, keeping both containers ok 44 - a method that tries keeps both fresh containers ok 45 - a method that makes a call keeps both fresh containers ok 46 - # SKIP the call counting shapes are specific to the RakuAST frontend ok 47 - # SKIP the call counting shapes are specific to the RakuAST frontend ok 48 - a nested callee writing its caller match variable cannot reach the mainline one ok 49 - a nested callee reading its caller match variable sees a fresh one ok 50 - a method calling match reads the result through its own match variable ok 51 - a method that matches keeps its own match variable ok 52 - a method that tries keeps its own error variable ok 53 - a match in a method still binds its result 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/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/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/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/08-performance/31-rakuast-constant-terms.t .................... 1..19 ok 1 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 2 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 3 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 4 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 5 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 6 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 7 - # SKIP the constant term shapes are specific to the RakuAST frontend ok 8 - the compiled value keeps the identity of the setting constant ok 9 - a folded True is still true ok 10 - a folded False is still false ok 11 - a folded enum value compares to itself ok 12 - a folded enum value keeps its value ok 13 - a folded unit constant computes ok 14 - the outer constant reads its own value ok 15 - the shadowing constant reads its own value ok 16 - the outer constant reads unchanged after the block ok 17 - a constant holding a type object reads the very type object ok 18 - the folded constants compiles ok 19 - the folded constants loads from the precompilation store 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/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/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/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/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/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/02-rakudo/sink-warnings-legacy-parity.t ....................... 1..23 ok 1 - `,` is not a useless-use subject for `1, 2, 3;` ok 2 - the constant integer operand of `1, 2, 3;` is still a useless-use subject ok 3 - `...` is not a useless-use subject for a stubbed method body ok 4 - `???` is not a useless-use subject for a stubbed method body ok 5 - `!!!` is not a useless-use subject for a stubbed method body ok 6 - `rand` is not a useless-use subject at statement level ok 7 - `*` is not a useless-use subject at statement level ok 8 - `**` is not a useless-use subject at statement level ok 9 - `temp` is not a useless-use subject in sink context ok 10 - `let` is not a useless-use subject in sink context ok 11 - a user-defined prefix without `is pure` is not a useless-use subject ok 12 - a user-defined infix without `is pure` is not a useless-use subject ok 13 - a user-defined prefix declared `is pure` is a useless-use subject ok 14 - a user-defined infix declared `is pure` is a useless-use subject ok 15 - `{*}` is not a useless-use subject in a non-tail proto body ok 16 - `Z=` produces no useless-use subjects in sink context ok 17 - `X=` produces no useless-use subjects in sink context ok 18 - `R=` produces no useless-use subjects in sink context ok 19 - `Z+` of a pure operator is still a useless-use subject in sink context ok 20 - the operands of a sunk `Z+` are not useless-use subjects ok 21 - sunk `Z=` assigned zipwise ok 22 - sunk `X=` assigned each element ok 23 - sunk `R=` assigned to its right operand ok t/12-rakuast/enum.rakutest ...................................... 1..7 # Subtest: Simple enum # enum foo ok 1 - deparse ok 2 - AST: did it produce the right Map ok 3 - AST: was the enum installed ok 4 - AST: first enum element ok 5 - AST: second enum element # TODO keys are not yet installed in OUR:: ok 6 - AST: third enum element # TODO keys are not yet installed in OUR:: 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 ok 14 - Raku: first enum element ok 15 - Raku: second enum element # TODO keys are not yet installed in OUR:: ok 16 - Raku: third enum element # TODO keys are not yet installed in OUR:: 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 ok 4 - AST: first enum element ok 5 - AST: second enum element # TODO keys are not yet installed in OUR:: ok 6 - AST: third enum element # TODO keys are not yet installed in OUR:: 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 ok 14 - Raku: first enum element ok 15 - Raku: second enum element # TODO keys are not yet installed in OUR:: ok 16 - Raku: third enum element # TODO keys are not yet installed in OUR:: 1..16 ok 3 - Enum with preset values # Subtest: BEGIN-wrapped enum with term # BEGIN enum foo ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 4 - BEGIN-wrapped enum with term # Subtest: BEGIN-wrapped enum with colon-pair term # BEGIN enum foo (:0a, :1b, :2c) ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 5 - BEGIN-wrapped enum with colon-pair term # Subtest: CHECK-wrapped enum with term # CHECK enum foo ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 6 - CHECK-wrapped enum with term # Subtest: Anonymous enum (enum ::) ok 1 - AST two-Empty: deparse uses :: placeholder ok 2 - AST two-Empty: enum AST evaluates to expected Map ok 3 - Source: anonymous enum compiles outside a role ok 4 - Source: anonymous enum yields expected Map 1..4 ok 7 - Anonymous enum (enum ::) ok t/12-rakuast/meta-operators.rakutest ............................ 1..14 # 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 # Subtest: Zip+Assign meta-op assigns elementwise to LHS # @a Z+= (10, 20, 30) ok 1 - deparse ok 2 - AST: did mutate the array ok 3 - Str: did mutate the array ok 4 - Raku: did mutate the array 1..4 ok 12 - Zip+Assign meta-op assigns elementwise to LHS # Subtest: Cross+Assign meta-op assigns the cross to LHS # @a X+= (10, 20) ok 1 - deparse ok 2 - AST: did mutate the array 1..2 ok 13 - Cross+Assign meta-op assigns the cross to LHS # Subtest: Hyper+Assign meta-op assigns elementwise to LHS # @a <<+>>= (10, 20, 30) ok 1 - deparse ok 2 - AST: did mutate the array ok 3 - Str: did mutate the array ok 4 - Raku: did mutate the array 1..4 ok 14 - Hyper+Assign meta-op assigns elementwise to LHS ok t/13-experimental/macros-opaque-ast.rakutest .................... 1..3 ok 1 - macro returning quasi ok 2 - Macros can return noops ok 3 - lexical vars in macros are not visible to the AST vars ok t/08-performance/18-rakuast-callstatic.t ........................ 1..40 ok 1 - a call to a setting routine compiles to a static callee lookup ok 2 - a setting routine whose value is used compiles to a static callee lookup ok 3 - a call to a nested user routine keeps the plain callee lookup ok 4 - a call to a sub declared in the outermost scope compiles to a static callee lookup ok 5 - a call to a multi declared in the outermost scope compiles to a static callee lookup ok 6 - the outer call to a recursive sub compiles to a static callee lookup ok 7 - a call to an imported routine compiles to a static callee lookup ok 8 - a call through a routine variable keeps the plain callee lookup WARNINGS for /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/t/08-performance/18-rakuast-callstatic.t: Useless use of "==" in expression "$a == $b" in sink context (line 2) ok 9 - a comparison against a setting operator compiles to a static callee lookup ok 10 - a chained comparison against a setting operator compiles to static chain links ok 11 - a comparison against a nested user operator keeps the plain lookup ok 12 - a setting infix that does not chain compiles to a static callee lookup ok 13 - a setting prefix compiles to a static callee lookup ok 14 - a setting postfix compiles to a static callee lookup ok 15 - a nested user prefix keeps the plain callee lookup ok 16 - a nested user infix keeps the plain callee lookup ok 17 - a prefix bound through an operator variable keeps the plain callee lookup ok 18 - # SKIP the soft shape is specific to the RakuAST frontend ok 19 - a setting routine called by name returns its value ok 20 - return unwinds through a static callee lookup ok 21 - take reaches the enclosing gather through a static callee lookup ok 22 - fail produces a Failure through a static callee lookup ok 23 - a multi setting routine called by name returns its value ok 24 - a setting routine still runs under the soft pragma ok 25 - a recursive outermost-scope sub computes through static lookups ok 26 - a multi called with an Int picks the Int candidate ok 27 - a multi called with a Str picks the Str candidate ok 28 - an outermost-scope sub closing over a mainline lexical reads it ok 29 - a true chained comparison holds through static links ok 30 - a false chained comparison fails through static links ok 31 - a chained comparison with a call in the middle holds ok 32 - the middle operand of a chained comparison runs once ok 33 - a Junction autothreads through a static comparison ok 34 - a setting prefix called through a static lookup returns its value ok 35 - a postfix increment through a static lookup yields the original value ok 36 - a postfix increment through a static lookup steps the variable ok 37 - a user infix declared in the outermost scope computes through a static lookup ok 38 - a wrapped prefix in the outermost scope runs its wrapper through a static lookup ok 39 - use fatal respects defined through a static callee lookup ok 40 - use fatal promotes a Failure from a static callee lookup ok t/13-experimental/macros-errors.rakutest ........................ 1..2 ok 1 - macro returning AST.new doesn't blow up ok 2 - die-ing inside a macro dies normally. ok t/13-experimental/macros-advent2012-day23.rakutest .............. 1..2 ok 1 - checkpoint example ok 2 - LOG macro ok t/09-moar/Line_Break__LineBreak.t ............................... ok 1 - Property: Line_Break=ID from file: LineBreak.txt (Correct: 115049 Wrong: 57512). Todo'd if < 62579 failures. # TODO Expecting 62579 failures from Line_Break=ID ok 2 - Property: Line_Break=PR from file: LineBreak.txt (Correct: 53 Wrong: 14). Todo'd if < 15 failures. # TODO Expecting 15 failures from Line_Break=PR 1..2 ok t/13-experimental/macros.rakutest ............................... 1..6 # Subtest: Macro 1..8 ok 1 - I like numbers before - contents ok 2 - I like numbers before - WHEREFORE ok 3 - I like numbers before - leading ok 4 - I like numbers before - no trailing ok 5 - I like numbers before - stringifies correctly ok 6 - $=pod I like numbers before - WHEREFORE ok 7 - $=pod I like numbers before ok 8 - a macro does Callable ok 1 - Macro # Subtest: Macro 1..8 ok 1 - I like numbers after - contents ok 2 - I like numbers after - WHEREFORE ok 3 - I like numbers after - trailing ok 4 - I like numbers after - no leading ok 5 - I like numbers after - stringifies correctly ok 6 - $=pod I like numbers after - WHEREFORE ok 7 - $=pod I like numbers after ok 8 - a macro does Callable ok 2 - Macro # Subtest: Macro 1..8 ok 1 - I like numbers before - contents ok 2 - I like numbers before - WHEREFORE ok 3 - I like numbers before - leading ok 4 - I like numbers before - no trailing ok 5 - I like numbers before - stringifies correctly ok 6 - $=pod I like numbers before - WHEREFORE ok 7 - $=pod I like numbers before ok 8 - a macro does Callable ok 3 - Macro # Subtest: Macro 1..8 ok 1 - I like numbers after - contents ok 2 - I like numbers after - WHEREFORE ok 3 - I like numbers after - trailing ok 4 - I like numbers after - no leading ok 5 - I like numbers after - stringifies correctly ok 6 - $=pod I like numbers after - WHEREFORE ok 7 - $=pod I like numbers after ok 8 - a macro does Callable ok 4 - Macro # Subtest: Macro 1..8 ok 1 - I like\nnumbers - contents ok 2 - I like\nnumbers - WHEREFORE ok 3 - I like\nnumbers - trailing ok 4 - I like\nnumbers - trailing ok 5 - I like\nnumbers - stringifies correctly ok 6 - $=pod I like\nnumbers - WHEREFORE ok 7 - $=pod I like\nnumbers ok 8 - a macro does Callable ok 5 - Macro # Subtest: did we throws-like X::Role::Parametric::NoSuchCandidate? 1..3 ok 1 - 'role popo { macro marco { $^a but popo }; marco popo; }' died ok 2 - right exception type (X::Role::Parametric::NoSuchCandidate) ok 3 - .role matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3845654120) ... } ok 6 - did we throws-like X::Role::Parametric::NoSuchCandidate? ok t/14-smoke/optimizations.rakutest ............................... 1..1 ok 1 - \#6109 - makefile template broke windows optimization path for smartmatch ok t/12-rakuast/stubs.rakutest ..................................... 1..6 # Subtest: can make a simple ... stub # ... ok 1 - deparse ok 2 - AST: did we get return? ok 3 - AST: did we get a Failure ok 4 - AST: did we get right exception ok 5 - AST: payload ok ok 6 - Str: did we get return? ok 7 - Str: did we get a Failure ok 8 - Str: did we get right exception ok 9 - Str: payload ok ok 10 - Raku: did we get return? ok 11 - Raku: did we get a Failure ok 12 - Raku: did we get right exception ok 13 - Raku: payload ok 1..13 ok 1 - can make a simple ... stub # Subtest: can make a ... stub with info # ... "foobar" ok 1 - deparse ok 2 - AST: did we get return? ok 3 - AST: did we get a Failure ok 4 - AST: did we get right exception ok 5 - AST: payload ok ok 6 - Str: did we get return? ok 7 - Str: did we get a Failure ok 8 - Str: did we get right exception ok 9 - Str: payload ok ok 10 - Raku: did we get return? ok 11 - Raku: did we get a Failure ok 12 - Raku: did we get right exception ok 13 - Raku: payload ok 1..13 ok 2 - can make a ... stub with info # Subtest: can make a simple !!! stub # !!! ok 1 - deparse # Subtest: did we throws-like X::StubCode? 1..3 ok 1 - code dies ok 2 - right exception type (X::StubCode) ok 3 - .message matches Stub code executed ok 2 - did we throws-like X::StubCode? # Subtest: did we throws-like X::StubCode? 1..3 ok 1 - code dies ok 2 - right exception type (X::StubCode) ok 3 - .message matches Stub code executed ok 3 - did we throws-like X::StubCode? # Subtest: did we throws-like X::StubCode? 1..3 ok 1 - code dies ok 2 - right exception type (X::StubCode) ok 3 - .message matches Stub code executed ok 4 - did we throws-like X::StubCode? 1..4 ok 3 - can make a simple !!! stub # Subtest: can make a !!! stub with info # !!! "foobar" ok 1 - deparse # Subtest: did we throws-like X::StubCode? 1..3 ok 1 - code dies ok 2 - right exception type (X::StubCode) ok 3 - .message matches foobar ok 2 - did we throws-like X::StubCode? # Subtest: did we throws-like X::StubCode? 1..3 ok 1 - code dies ok 2 - right exception type (X::StubCode) ok 3 - .message matches foobar ok 3 - did we throws-like X::StubCode? # Subtest: did we throws-like X::StubCode? 1..3 ok 1 - code dies ok 2 - right exception type (X::StubCode) ok 3 - .message matches foobar ok 4 - did we throws-like X::StubCode? 1..4 ok 4 - can make a !!! stub with info # Subtest: can make a simple ??? stub # ??? ok 1 - deparse ok 2 - AST: did we get a warning? ok 3 - AST: the right warning ok 4 - Str: did we get a warning? ok 5 - Str: the right warning ok 6 - Raku: did we get a warning? ok 7 - Raku: the right warning 1..7 ok 5 - can make a simple ??? stub # Subtest: can make a ??? stub with info # ??? "foobar" ok 1 - deparse ok 2 - AST: did we get a warning? ok 3 - AST: the right warning ok 4 - Str: did we get a warning? ok 5 - Str: the right warning ok 6 - Raku: did we get a warning? ok 7 - Raku: the right warning 1..7 ok 6 - can make a ??? stub with info 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/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 - Str: role gets correct name ok 3 - Str: does the role auto-pun (1) ok 4 - Str: did the attribute get initialized (1) ok 5 - Str: does the role auto-pun (2) ok 6 - Str: did the attribute get initialized (2) 1..6 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 - Str: role gets correct name ok 3 - Str: can we see the roles it does ok 4 - Str: does the role auto-pun (1) ok 5 - Str: did the default value get set ok 6 - Str: does the role auto-pun (2) ok 7 - Str: did the value get set 1..7 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 - Str: role gets correct name ok 3 - Str: can we see the roles it does ok 4 - Str: does the role auto-pun (1) ok 5 - Str: value returned (1) ok 6 - Str: does uninstantiated type die (1) # TODO :D not yet being applied in type check ok 7 - Str: does incorrect type die (1) ok 8 - Str: does the role auto-pun (2) ok 9 - Str: value returned (2) ok 10 - Str: does uninstantiated type die (2) # TODO :D not yet being applied in type check ok 11 - Str: does incorrect type die (2) 1..11 ok 6 - creating a parameterized role with a type capture ok t/12-rakuast/eval.rakutest ...................................... 1..7 # Subtest: precompiling a module returning a Str.AST.EVAL Sub from BEGIN works 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - precompiling a module returning a Str.AST.EVAL Sub from BEGIN works ok 2 - multis declared inside .AST.EVAL dispatch ok 3 - an .AST tree declaring a multi EVALs ok 4 - the same .AST tree EVALs a second time ok 5 - require inside .AST.EVAL works ok 6 - require with import inside .AST.EVAL works # Subtest: precompiling a module returning a Str.AST.EVAL multi from BEGIN works 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 7 - precompiling a module returning a Str.AST.EVAL multi from BEGIN works ok t/05-messages/03-errors.t ....................................... 1..30 # 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|3811494480) ... } 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|3811494720) ... } 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|3811495480) ... } 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|3811495640) ... } 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|3811436040) ... } 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 (Exception) 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|3811373000) ... } # TODO remove "expecting any of:" # Failed test '.gist matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3811373000) ... }' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5974 # Expected: -> ;; $_? is raw = OUTER::<$_> { #`(Block|3811373000) ... } # Got: ===SORRY!=== Error while compiling /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_6 # Unable to parse quote-words subscript; couldn't find '>' (corresponding '<' was at line 1) # at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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|3811374840) ... } 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|3811378960) ... } 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 # Subtest: attribute declaration in the mainline is a compile time error 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 27 - attribute declaration in the mainline is a compile time error # Subtest: signature attribute declaration in the mainline is a compile time error 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 28 - signature attribute declaration in the mainline is a compile time error # Subtest: an unknown compiler variable is reported with suggestions 1..3 ok 1 - 'my $FILA = 1; say $?FILA' died ok 2 - right exception type (X::Undeclared) ok 3 - .message matches WhateverCode.new ok 29 - an unknown compiler variable is reported with suggestions # Subtest: constraint failure on an unpassed optional parameter explains the implicit default 1..5 # Subtest: an unpassed named parameter with a subset type mentions the implicit default 1..4 ok 1 - 'my subset NonEmpty of Str where *.so; sub foo(NonEmpty :$name) { }; foo()' died ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 3 - .omitted matches WhateverCode.new ok 4 - .message matches WhateverCode.new ok 1 - an unpassed named parameter with a subset type mentions the implicit default # Subtest: an unpassed optional positional parameter with a subset type mentions the implicit default 1..3 ok 1 - 'my subset NonEmpty of Str where *.so; sub foo(NonEmpty $name?) { }; foo()' died ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 3 - .message matches WhateverCode.new ok 2 - an unpassed optional positional parameter with a subset type mentions the implicit default # Subtest: an unpassed named parameter with a where clause mentions the implicit default 1..3 ok 1 - 'sub foo(Str :$name where *.so) { }; foo()' died ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 3 - .message matches WhateverCode.new ok 3 - an unpassed named parameter with a where clause mentions the implicit default # Subtest: a passed value failing the constraint does not claim the parameter was not passed 1..3 ok 1 - 'my subset NonEmpty of Str where *.so; sub foo(NonEmpty :$name) { }; foo(name => "")' died ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3860378504) ... } ok 4 - a passed value failing the constraint does not claim the parameter was not passed # Subtest: an explicit default failing the constraint does not claim the parameter has none 1..3 ok 1 - 'my subset NonEmpty of Str where *.so; sub foo(NonEmpty :$name = "".lc) { }; foo()' died ok 2 - right exception type (X::TypeCheck::Binding::Parameter) ok 3 - .message matches -> ;; $_? is raw = OUTER::<$_> { \#`(Block|3860381384) ... } ok 5 - an explicit default failing the constraint does not claim the parameter has none ok 30 - constraint failure on an unpassed optional parameter explains the implicit default ok t/08-performance/28-rakuast-metaop-hoist.t ...................... 1..55 ok 1 - # SKIP the formation shapes are specific to the RakuAST frontend ok 2 - # SKIP the formation shapes are specific to the RakuAST frontend ok 3 - # SKIP the formation shapes are specific to the RakuAST frontend ok 4 - # SKIP the formation shapes are specific to the RakuAST frontend ok 5 - # SKIP the formation shapes are specific to the RakuAST frontend ok 6 - # SKIP the formation shapes are specific to the RakuAST frontend ok 7 - # SKIP the formation shapes are specific to the RakuAST frontend ok 8 - # SKIP the formation shapes are specific to the RakuAST frontend ok 9 - # SKIP the formation shapes are specific to the RakuAST frontend ok 10 - # SKIP the formation shapes are specific to the RakuAST frontend ok 11 - # SKIP the formation shapes are specific to the RakuAST frontend ok 12 - a zip of a setting operator computes through its constant meta-op ok 13 - a cross of a setting operator computes through its constant meta-op ok 14 - a hyper of a setting operator computes through its constant meta-op ok 15 - a negated setting comparison holds through its constant meta-op ok 16 - a negated setting comparison fails where the comparison holds ok 17 - a chain of negated comparisons holds through its links ok 18 - a chain of negated comparisons fails on a failing link ok 19 - a chain mixing negated and plain comparisons holds ok 20 - a negated comparison autothreads a Junction argument ok 21 - a negated comparison over an all Junction collapses correctly ok 22 - a negated ordering comparison fails where the ordering holds ok 23 - a negated chain with a call in the middle holds ok 24 - the middle operand of a negated chain runs once ok 25 - a negated user chaining operator holds where the comparison fails ok 26 - a curried negated comparison fails on the negated value ok 27 - a curried negated comparison holds elsewhere ok 28 - # SKIP the legacy frontend chains through a parenthesized negation ok 29 - a chain reduce of a negated comparison fails on a failing link ok 30 - a smartmatch of a type declines to collapse over a negated link ok 31 - a negated smartmatch of a type declines to collapse over a negated link ok 32 - a smartmatch of a literal declines to collapse over a negated link ok 33 - a smartmatch of a pair declines to collapse over a negated link ok 34 - # SKIP the sequenced comparison does not run under the legacy frontend ok 35 - # SKIP the sequenced comparison does not run under the legacy frontend ok 36 - a reversed setting operator swaps its operands ok 37 - a zip building pairs computes through its constant meta-op ok 38 - a reversed comma builds its list through its constant meta-op ok 39 - a zip of a lexical operator computes through its formed meta-op ok 40 - a right dwim hyper extends the shorter side through its constant meta-op ok 41 - a left dwim hyper truncates to the fixed side through its constant meta-op ok 42 - a non dwim hyper still dies on lists of different lengths ok 43 - a zip of a reversal computes through its constant reversal ok 44 - a reversal of a negation compares correctly ok 45 - a zip assign computes through its constant operator ok 46 - a max assign computes through its constant operator ok 47 - a wrap of a setting operator shows through its constant meta-op ok 48 - an unwrap of a setting operator shows through its constant meta-op ok 49 - a zip of a thunky operator computes through its constant meta-op ok 50 - # SKIP the callable meta-op forms do not compile under the legacy frontend ok 51 - # SKIP the callable meta-op forms do not compile under the legacy frontend ok 52 - # SKIP the callable meta-op forms do not compile under the legacy frontend ok 53 - # SKIP the callable meta-op forms do not compile under the legacy frontend ok 54 - a module using constant meta-ops compiles ok 55 - a module using constant meta-ops loads from the precompilation store ok t/13-experimental/pack.rakutest ................................. 1..43 ok 1 - H* works ok 2 - H* works ok 3 - H works on odd-length strings ok 4 - H works on odd-length strings ok 5 - A11 A28 A8 A* works ok 6 - A11 A28 A8 A* works ok 7 - C S L n N v V work ok 8 - C S L n N v V work ok 9 - x by itself works ok 10 - x by itself works ok 11 - x4 & amount works ok 12 - x4 & amount works ok 13 - x* & amount works: does nothing ok 14 - x* & amount works: does nothing ok 15 - H* works ok 16 - H* works ok 17 - field 1 (A11) works ok 18 - field 2 (A28) works ok 19 - field 3 (A8) works ok 20 - field 4 (A*) works ok 21 - field 1 (A11) works ok 22 - field 2 (A28) works ok 23 - field 3 (A8) works ok 24 - field 4 (A*) works ok 25 - C works ok 26 - S works ok 27 - L works ok 28 - n works ok 29 - N works ok 30 - v works ok 31 - V works ok 32 - C works ok 33 - S works ok 34 - L works ok 35 - n works ok 36 - N works ok 37 - v works ok 38 - V works # Subtest: did we throws-like X::Buf::AsStr? 1..2 ok 1 - code dies ok 2 - right exception type (X::Buf::AsStr) ok 39 - did we throws-like X::Buf::AsStr? # Subtest: did we throws-like X::Buf::Pack? 1..3 ok 1 - code dies ok 2 - right exception type (X::Buf::Pack) ok 3 - .directive matches B ok 40 - did we throws-like X::Buf::Pack? # Subtest: did we throws-like X::Buf::Pack? 1..3 ok 1 - code dies ok 2 - right exception type (X::Buf::Pack) ok 3 - .directive matches B ok 41 - did we throws-like X::Buf::Pack? # Subtest: did we throws-like X::Buf::Pack::NonASCII? 1..3 ok 1 - code dies ok 2 - right exception type (X::Buf::Pack::NonASCII) ok 3 - .char matches Ä ok 42 - did we throws-like X::Buf::Pack::NonASCII? ok 43 - is "use experimental :pack" visible? 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/subset.rakutest .................................... 1..8 # 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: Anonymous subset (subset ::) ok 1 - AST two-Empty: deparse uses :: placeholder ok 2 - AST two-Empty: anonymous name ok 3 - AST single-Empty: anonymous name ok 4 - Source: anonymous subset as hash typed-key constraint compiles ok 5 - Source: anonymous subset inside role compiles ok 6 - class :: .^name uses HOW anon default ok 7 - role :: .^name uses HOW anon default ok 8 - module :: .^name uses HOW anon default ok 9 - grammar :: .^name uses HOW anon default # Subtest: our sub :: in role throws (exemption is PackageInstaller-only) 1..2 ok 1 - code dies ok 2 - right exception type (X::Declaration::OurScopeInRole) ok 10 - our sub :: in role throws (exemption is PackageInstaller-only) 1..10 ok 7 - Anonymous subset (subset ::) # 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 8 - Subset with a where regex ok t/13-experimental/macros-unquoting.rakutest ..................... WARNINGS for /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/t/13-experimental/macros-unquoting.rakutest: Useless use of $cookies in sink context (line 73) 1..5 ok 1 - spliced code runs at parse time ok 2 - can build ASTs incrementally ok 3 - unquotes retain their lexical context # Subtest: did we throws-like X::TypeCheck::Splice? 1..6 ok 1 - 'macro bohm() { quasi { {{{"not an AST"}}} } }; bohm' died ok 2 - right exception type (X::TypeCheck::Splice) ok 3 - .expected matches (AST) ok 4 - .line matches 1 ok 5 - .action matches unquote evaluation ok 6 - .got matches (Str) ok 4 - did we throws-like X::TypeCheck::Splice? # Subtest: did we throws-like Exception? 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches Null check failed for $cookies ok 5 - did we throws-like Exception? 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/09-moar/01-profilers.t ........................................ 1..12 # Subtest: can launch with profiling requested 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 1 - can launch with profiling requested ok 2 - profiler html output file exists on disk ok 3 - profiler html output file isn't tiny # Subtest: can launch with profiling requested 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 4 - can launch with profiling requested ok 5 - profiler json output file exists on disk ok 6 - profiler json output file isn't tiny # Subtest: can launch with profiling requested 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 7 - can launch with profiling requested ok 8 - profiler sql output file exists on disk ok 9 - profiler sql output file isn't tiny # Subtest: can launch with profiling requested 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 10 - can launch with profiling requested ok 11 - profiler heap output file exists on disk ok 12 - profiler heap output file isn't tiny ok t/13-experimental/macros-quasi-blocks.rakutest .................. WARNINGS for /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/t/13-experimental/macros-quasi-blocks.rakutest: Useless use of constant integer 2 in sink context (line 64) Useless use of constant string "motor oil" in sink context (line 73) Useless use of constant string "grasshopper" in sink context (line 73) Useless use of constant integer 1 in sink context (line 64) 1..12 ok 1 - calls to macro are at parse time ok 2 - macro call with arguments works ok 3 - macro calls without parens work ok 4 - macro call with arguments works ok 5 - can define an entirely new operator ok 6 - can shadow an existing operator ok 7 - lexical lookup from quasi to macro works ok 8 - lexical lookup from quasi to macro params works ok 9 - macro can return its param ok 10 - Nil from an empty block turns into no code ok 11 - addition of two quasis with arithmetical expressions works (1) ok 12 - addition of two quasis with arithmetical expressions works (2) 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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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/13-experimental/will-complain.rakutest ........................ 1..8 # Subtest: Enum 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - 'my FOO $foo; $foo = 0;' died ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /'need something FOO-ish, got 0'/ ok 2 - activated upon failed type check ok 1 - Enum # Subtest: Custom class 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - 'my Bar $bar; $bar = 0;' died ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /'need something Bar-like, got 0'/ ok 2 - activated upon failed type check ok 2 - Custom class # Subtest: Parameter 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Binding) ok 3 - .message matches /"the first argument must be a string with 'foo'"/ ok 2 - activated upon failed type check ok 3 - Parameter # Subtest: Subset 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /'only non-zero positive integers, not -1'/ ok 2 - activated upon failed type check ok 4 - Subset # Subtest: Variable 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /'gimme a string, not Int'/ ok 2 - activated upon failed type check ok 5 - Variable # Subtest: Attribute 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /"you offer me 4.2, but with all the respect: an integer, please!"/ ok 2 - activated upon failed type check ok 6 - Attribute # Subtest: Hash 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /'hash values are to be strings, not Num'/ ok 2 - activated upon failed type check ok 7 - Hash # Subtest: Array 1..2 ok 1 - doesn't fire when there is no error # Subtest: activated upon failed type check 1..3 ok 1 - code dies ok 2 - right exception type (X::TypeCheck::Assignment) ok 3 - .message matches /'this array is all about integers, not Num'/ ok 2 - activated upon failed type check ok 8 - Array ok t/12-rakuast/class.rakutest ..................................... 1..15 # 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 method as accessor # my class TestClassMethodAsAccessor { # method looks-like-accessor ($a, $b) { # $a + $b # } # method foo { # $.looks-like-accessor(42, 666) # } # } ok 1 - deparse ok 2 - AST: Class with method as accessor evaluates to a type object ok 3 - AST: Correct class name ok 4 - AST: accessor compiles correctly ok 5 - Str: Class with method as accessor evaluates to a type object ok 6 - Str: Correct class name ok 7 - Str: accessor compiles correctly ok 8 - Raku: Class with method as accessor evaluates to a type object ok 9 - Raku: Correct class name ok 10 - Raku: accessor compiles correctly 1..10 ok 10 - class with method as accessor # 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 11 - 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 12 - 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 13 - 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 14 - unit scoped class # Subtest: Multi-part class name matching enclosing package does not redeclare (rakudo#5854) # module GH5854AST::Outer { # class GH5854AST::Outer { # method x { # 42 # } # } # } ok 1 - deparse ok 2 - AST: enclosing module is not overwritten ok 3 - AST: inner class is installed with full nested name ok 4 - AST: inner class method is callable # module GH5854Str::Outer { # class GH5854Str::Outer { # method x { # 42 # } # } # } ok 5 - deparse ok 6 - Str: enclosing module is not overwritten ok 7 - Str: inner class is installed with full nested name ok 8 - Str: inner class method is callable # module GH5854Raku::Outer { # class GH5854Raku::Outer { # method x { # 42 # } # } # } ok 9 - deparse ok 10 - Raku: enclosing module is not overwritten ok 11 - Raku: inner class is installed with full nested name ok 12 - Raku: inner class method is callable 1..12 ok 15 - Multi-part class name matching enclosing package does not redeclare (rakudo \#5854) ok t/09-moar/NAME__UnicodeData.t ................................... ok 1 - Property: NAME from file: UnicodeData.txt (Correct: 288145 Wrong: 0) 1..1 ok t/12-rakuast/strings.rakutest ................................... 1..14 # 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 quotewords and val processor # <<1 "2" 3.5>> ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 13 - Using the quotewords and val processor # 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 14 - Using the exec processor alone gives expected result ok t/05-messages/10-warnings.t ..................................... 1..18 # 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 # Subtest: has-scoped method in mainline warns with file and line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 10 - has-scoped method in mainline warns with file and line # Subtest: has-scoped method in a package warns with file and line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 11 - has-scoped method in a package warns with file and line # Subtest: use fatal promotes the useless method declaration worry to an error 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 12 - use fatal promotes the useless method declaration worry to an error ok 13 - # SKIP legacy frontend does not warn on a dangling leading declarator doc # Subtest: duplicate trait warns with file and line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 14 - duplicate trait warns with file and line # Subtest: accessor generation outside a package warns with file and line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 15 - accessor generation outside a package warns with file and line # Subtest: class replacing a same-named enclosing package warns with file and line 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 16 - class replacing a same-named enclosing package warns with file and line # Subtest: use fatal promotes the same-named enclosing package worry to an error 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 17 - use fatal promotes the same-named enclosing package worry to an error # Subtest: the last statement of a when block in value position stays wanted 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 18 - the last statement of a when block in value position stays wanted ok t/12-rakuast/terms.rakutest ..................................... 1..14 # 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: Topic call can be bound to # given %(:a(1)) { # . := .; # $_ # } ok 1 - AST ok 2 - Str ok 3 - Raku 1..3 ok 3 - Topic call can be bound to # Subtest: now named term can be called # now ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 4 - 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 5 - rand term works # Subtest: Empty set term works # ∅ ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 6 - 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 7 - 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 8 - 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 9 - Whatever term works # Subtest: Hyperwhatever term works # ** ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 ok 10 - 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 11 - 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 12 - 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 13 - 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 14 - Radix number term with multiple args ok t/09-moar/General_Category__extracted-DerivedGeneralCategory.t .. ok 1 - Property: General_Category=Cn from file: extracted/DerivedGeneralCategory.txt (Correct: 814708 Wrong: 22). Todo'd if < 22 failures. 1..1 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/signature.rakutest ................................. 1..15 # Subtest: Default type for block and routine # sub ($param) { } ok 1 - deparse not ok 2 - AST: Default type of param # TODO Returns Mu instead of Any # Failed test 'AST: Default type of param' # at t/12-rakuast/signature.rakutest line 32 ok 3 - Str: Default type of param # TODO Returns Mu instead of Any not ok 4 - Raku: Default type of param # TODO Returns Mu instead of Any # Failed test 'Raku: Default type of param' # at t/12-rakuast/signature.rakutest line 32 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 # Subtest: Parameter with sub-signature destructure # sub ($pair ($k, $v)) { # "$k|$v" # } ok 1 - AST: positional sub-signature destructure binds ok 2 - Str: positional sub-signature destructure binds ok 3 - Raku: positional sub-signature destructure binds 1..3 ok 14 - Parameter with sub-signature destructure # Subtest: set-sub-signature mutator on a Parameter ok 1 - mutator path: destructure binds 1..1 ok 15 - set-sub-signature mutator on a Parameter ok t/13-experimental/is-cached.rakutest ............................ 1..41 ok 1 - does fib(9) work ok 2 - did we call them all (1) ok 3 - does fib(10) work ok 4 - did we call them all (2) ok 5 - does fib(10) work ok 6 - did we call them all (3) ok 7 - no args case(1) ok 8 - did we run (1) ok 9 - no args case (2) ok 10 - did we run (2) ok 11 - foo arg case (1) ok 12 - did we run (3) ok 13 - foo arg case (2) ok 14 - did we run (4) ok 15 - bar arg case (1) ok 16 - did we run (5) ok 17 - bar arg case (2) ok 18 - did we run (6) ok 19 - foo,bar arg case (1) ok 20 - did we run (7) ok 21 - foo,bar arg case (2) ok 22 - did we run (8) ok 23 - foo,bar case(1) ok 24 - did we run (1) ok 25 - foo,bar case(2) ok 26 - did we run (2) ok 27 - foo,bar,baz case(1) ok 28 - did we run (3) ok 29 - foo,bar,baz case(2) ok 30 - did we run (4) ok 31 - did we get the value back (1) ok 32 - was the code done (1) ok 33 - did we get the value back (2) ok 34 - was the code done (2) ok 35 - did we get the value back (3) ok 36 - was the code done (3) ok 37 - did we get the value back (4) ok 38 - was the code done (4) ok 39 - was the call successful ok 40 - did it produce the right output ok 41 - no error output ok 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/09-moar/General_Category__UnicodeData__2.t .................... ok 1 - Property: General_Category from file: UnicodeData.txt (Correct: 40575 Wrong: 0) 1..1 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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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/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/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/highlight.rakutest ................................. 1..31 # 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 Potential difficulties: Redeclaration of symbol '$a'. at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_6:12 ------> my Frobnicate $a .= new; ok 1 - using default Potential difficulties: Redeclaration of symbol '$a'. at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_7:12 ------> my Frobnicate $a .= new; ok 2 - using mapping ok 6 - class and attributes # Subtest: vars, if and say 1..2 Potential difficulties: Redeclaration of symbol '$a'. at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_8:2 ------> my Int $a = 42; Redeclaration of symbol '$b'. at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_8:3 ------> my str $b = "foo"; ok 1 - using default Potential difficulties: Redeclaration of symbol '$a'. at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_9:2 ------> my Int $a = 42; Redeclaration of symbol '$b'. at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/EVAL_9:3 ------> my str $b = "foo"; 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: abbreviated visual table 1..2 ok 1 - using default ok 2 - using mapping ok 27 - abbreviated visual table # Subtest: for visual table 1..2 ok 1 - using default ok 2 - using mapping ok 28 - for visual table # Subtest: visual table 1..2 ok 1 - using default ok 2 - using mapping ok 29 - visual table # Subtest: use v6 (1) 1..2 ok 1 - using default ok 2 - using mapping ok 30 - use v6 (1) # Subtest: use v6 (2) 1..2 ok 1 - using default ok 2 - using mapping ok 31 - use v6 (2) ok t/08-performance/11-rakuast-constant-folding.t .................. WARNINGS for /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/t/08-performance/11-rakuast-constant-folding.t: Useless use of "zdie" in expression "1 zdie 2" in sink context (line 83) 1..47 ok 1 - integer arithmetic folds ok 2 - nested operators fold up the chain ok 3 - mixed precedence folds ok 4 - a negated literal folds ok 5 - a bitwise operator folds ok 6 - string concatenation folds ok 7 - a list-associative operator folds ok 8 - the folded list-associative operator is gone from the tree ok 9 - a junction constructor folds to a junction ok 10 - a prefix on an enumeration value folds ok 11 - a negative power folds to a Rat ok 12 - integer division folds to a Rat ok 13 - a folded division still produces a Rat at runtime ok 14 - a method call invocant folds ok 15 - a pair value folds ok 16 - a block final value folds ok 17 - a statement modifier condition folds ok 18 - array composer elements fold ok 19 - an index expression folds ok 20 - a parameter default folds ok 21 - parenthesized constants fold into the enclosing expression ok 22 - nested grouping parentheses fold ok 23 - a native int initializer folds ok 24 - a folded native int initializer widens correctly ok 25 - a variable operand keeps the runtime computation ok 26 - a chained comparison is not mis-folded as binary operations ok 27 - list parentheses are not mistaken for a foldable value ok 28 - a small string repetition folds ok 29 - an enormous string repetition is left for runtime ok 30 - division by zero folds to a zero-denominator Rat ok 31 - using a folded zero-denominator Rat throws # Subtest: a declined Failure does not warn at compile time 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 32 - a declined Failure does not warn at compile time ok 33 - a throwing pure operator is left to throw at runtime ok 34 - an operator bound to a lexical variable is left for runtime ok 35 - an unmarked user-defined operator gives the right value ok 36 - an unmarked user-defined operator runs at runtime ok 37 - an is pure operator on literals is evaluated at compile time ok 38 - a pure prefix operator with an adverb keeps its adverb ok 39 - a constant folds as an operand ok 40 - a sigiled constant folds as an operand ok 41 - a constant folds up a nested chain ok 42 - a string constant folds as an operand ok 43 - a folded constant operand computes the same value ok 44 - a runtime variable keeps the operator ok 45 - a stash reference keeps the operator ok 46 - the unoptimized tree keeps the operator ok 47 - an imported our-scoped variable reassigned at runtime computes with the new value 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/02-rakudo/reproducible-builds.t ............................... ok 1 - Both precompilation runs resulted in the same checksum 1..1 ok t/12-rakuast/regex.rakutest ..................................... 1..56 # 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 # Subtest: Match with a dba name # /:dba("digits") \d+/ ok 1 - deparse # Subtest: matches 1..3 ok 1 - AST: EVAL is not ok 2 - Str: EVAL is # TODO the legacy frontend breaks matching on :dba # Failed test 'Str: EVAL is' # at t/12-rakuast/regex.rakutest line 774 # expected: '42' # got: (Nil) ok 3 - Raku: EVAL is not ok 2 - matches # TODO the legacy frontend breaks matching on :dba # Failed test 'matches' # at t/12-rakuast/regex.rakutest line 774 1..2 ok 56 - Match with a dba name ok t/12-rakuast/statement-phaser.rakutest .......................... 1..36 # Subtest: BEGIN phaser producing a literal expression works # BEGIN 12 ok 1 - deparse ok 2 - AST ok 3 - Str ok 4 - Raku 1..4 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_17 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 1052 # 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 1053 # 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 981 # 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 1149 # 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 1059 # 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 1321 # 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 1321 # 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 1321 # 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 1374 # 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 not ok 3 - AST: QUIT phaser returns Nil # TODO Old implementation returns expression # Failed test 'AST: QUIT phaser returns Nil' # at t/12-rakuast/statement-phaser.rakutest line 1430 # expected: Nil # got: X::AdHoc.new(payload => "foo") 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 1430 # expected: Nil # got: X::AdHoc.new(payload => "foo") ok 7 - Str: QUIT actually ran ok 8 - Raku: did we get a Block not ok 9 - Raku: QUIT phaser returns Nil # TODO Old implementation returns expression # Failed test 'Raku: QUIT phaser returns Nil' # at t/12-rakuast/statement-phaser.rakutest line 1430 # expected: Nil # got: X::AdHoc.new(payload => "foo") 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 - .phaser matches PRE ok 4 - .message matches Precondition '++$pre' failed 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 - .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 # 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 - .phaser matches PRE ok 4 - .message 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 - .phaser matches PRE ok 4 - .message 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 - .phaser matches POST ok 4 - .message 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/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|3844857640) ... } 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|3810723976) ... } 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 MEOWS` suggests mistake and offers `=begin MEOWS` 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 11 - error with `=end MEOWS` suggests mistake and offers `=begin MEOWS` # Subtest: error for `=for` suggests it might be a mistake 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 12 - error for `=for` suggests it might be a 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|3853664336) ... } 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-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 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|3853704600) ... } 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|3853676624) ... } 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|4142398032) ... } 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|4142401632) ... } 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|4142401792) ... } 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|4142402592) ... } 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|4142403432) ... } ok 47 - detached non-alpha method says what the problem is 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: "/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/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 - .got matches 100000 ok 4 - .expected matches (Int) 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 5974 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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/lib/Test.rakumod (Test) line 673 # 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 5974 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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/lib/Test.rakumod (Test) line 673 # 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 - .expected matches (Int) ok 4 - .got matches 100000 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 - .expected matches (Int) # TODO string EVAL produces different error # Failed test '.expected matches (Int)' # at SETTING::src/core.c/Rakudo/Iterator.rakumod line 5974 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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/lib/Test.rakumod (Test) line 673 # 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 5974 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 /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/lib/Test.rakumod (Test) line 673 # Expected: 100000e0 # 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 ok 2 - AST: did it produce an Instant 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 ok 8 - Raku: did it produce an Instant 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/02-rakudo/15-gh_1202.t ........................................ 1..2 ok 1 - shell output ok 2 - all runs completed ok t/02-rakudo/repl.t .............................................. 1..49 # Subtest: sanity check; load without tweaking line editor 1..3 ok 1 - result of code is on STDOUT ok 2 - no STDERR output ok 3 - successful exit code ok 1 - sanity check; load without tweaking line editor # Subtest: can use native typed variable on subsequent lines (1) 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 2 - can use native typed variable on subsequent lines (1) # Subtest: indented code parses correctly 1..4 # Subtest: uncuddled else is parsed correctly 1..2 not ok 1 - stdout is correct # TODO indent styles don't parse right # Failed test 'stdout is correct' # at t/02-rakudo/repl.t line 42 # expected: ':) # ' # got: '[1] > * * ===SORRY!=== Error while compiling: # Undeclared routine: # else used at line 1 # # ' ok 2 - stderr is correct not ok 1 - uncuddled else is parsed correctly # TODO indent styles don't parse right # Failed test 'uncuddled else is parsed correctly' # at t/02-rakudo/repl.t line 42 # Subtest: open brace on next line is parsed correctly 1..2 not ok 1 - stdout is correct # TODO indent styles don't parse right # Failed test 'stdout is correct' # at t/02-rakudo/repl.t line 52 # expected: ':) # ' # got: '[1] > ===SORRY!=== Error while compiling: # Undeclared routine: # else used at line 1 # # :) # ' ok 2 - stderr is correct not ok 2 - open brace on next line is parsed correctly # TODO indent styles don't parse right # Failed test 'open brace on next line is parsed correctly' # at t/02-rakudo/repl.t line 52 # Subtest: partially-cuddled else is parsed correctly 1..2 not ok 1 - stdout is correct # TODO indent styles don't parse right # Failed test 'stdout is correct' # at t/02-rakudo/repl.t line 64 # expected: ':) # ' # got: '[1] > ===SORRY!=== Error while compiling: # Undeclared routine: # else used at line 1 # # ' ok 2 - stderr is correct not ok 3 - partially-cuddled else is parsed correctly # TODO indent styles don't parse right # Failed test 'partially-cuddled else is parsed correctly' # at t/02-rakudo/repl.t line 64 # Subtest: cuddled else 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 4 - cuddled else ok 3 - indented code parses correctly # Subtest: multi-line sub decl 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 4 - multi-line sub decl # Subtest: single-line sub declaration works 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 5 - single-line sub declaration works # Subtest: assignment maintains values on subsequent lines 1..4 # Subtest: Scalar 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 1 - Scalar # Subtest: Array 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 2 - Array # Subtest: Hash 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 3 - Hash # Subtest: sigilless value 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 4 - sigilless value ok 6 - assignment maintains values on subsequent lines ok 7 - # SKIP Different result on OSX # Subtest: an empty string gives back one blank line 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 8 - an empty string gives back one blank line # Subtest: syntax error gives a compile-time error 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 9 - syntax error gives a compile-time error # Subtest: syntax error clears on further input 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 10 - syntax error clears on further input # Subtest: undeclared routines give compile time errors 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 11 - undeclared routines give compile time errors # Subtest: undeclared routines inside another routine give compile time errors 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 12 - undeclared routines inside another routine give compile time errors # Subtest: run-time error error gives the expected error 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 13 - run-time error error gives the expected error # Subtest: raises error when you run control flow command 'return' in top level 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 14 - raises error when you run control flow command 'return' in top level # Subtest: raises error when you run control flow command 'redo' in top level 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 15 - raises error when you run control flow command 'redo' in top level # Subtest: raises error when you run control flow command 'next' in top level 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 16 - raises error when you run control flow command 'next' in top level # Subtest: raises error when you run control flow command 'last' in top level 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 17 - raises error when you run control flow command 'last' in top level # Subtest: raises error when you run control flow command 'proceed' in top level 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 18 - raises error when you run control flow command 'proceed' in top level # Subtest: raises error when you run control flow command 'succeed' in top level 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 19 - raises error when you run control flow command 'succeed' in top level # Subtest: `emit` errors usefully 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 20 - `emit` errors usefully # Subtest: `take` errors usefully 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 21 - `take` errors usefully # Subtest: warn() shows warnings 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 22 - warn() shows warnings # Subtest: previous output does not silence exceptions 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 23 - previous output does not silence exceptions # Subtest: previous output prevents output of handled failures 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 24 - previous output prevents output of handled failures # Subtest: previous output prevents output of unthrown exceptions 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 25 - previous output prevents output of unthrown exceptions # Subtest: previous output does not prevent output of unthrown exceptions 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 26 - previous output does not prevent output of unthrown exceptions # Subtest: can't trick REPL into thinking an exception was thrown 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 27 - can't trick REPL into thinking an exception was thrown # Subtest: REPL outputs Nil as a Nil 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 28 - REPL outputs Nil as a Nil ok 29 - # SKIP Result differs on OSX # Subtest: prefix 0 on invalid octal warns in REPL 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 30 - prefix 0 on invalid octal warns in REPL # Subtest: prefix 0 on valid octal warns in REPL 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 31 - prefix 0 on valid octal warns in REPL ok 32 - # SKIP Result differs on OSX # Subtest: exceptions from lazy-evaluated things do not crash REPL 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 33 - exceptions from lazy-evaluated things do not crash REPL # Subtest: Using native numeric types does not break REPL 1..2 not ok 1 - stdout is correct # TODO https://github.com/rakudo/rakudo/issues/4161 # Failed test 'stdout is correct' # at t/02-rakudo/repl.t line 229 # expected a match with: /'(1 2 3 4 5 6 7 8 9 10)' .* 'test is good'/ # got: "(1 2 3 4 5 6 7 8 9 10)\nUnhandled lexical type 'num32' in lexprimspec\n in any

at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/rakudo.moarvm line 1\n in any at /home/buildozer/aports/community/rakudo/src/rakudo-2026.08/rakudo.moarvm line 1\n\n" ok 2 - stderr is correct not ok 34 - Using native numeric types does not break REPL # TODO https://github.com/rakudo/rakudo/issues/4161 # Failed test 'Using native numeric types does not break REPL' # at t/02-rakudo/repl.t line 229 # Subtest: REPL with -M with non-existent module does not start 1..3 ok 1 - program did not hang ok 2 - STDOUT ok 3 - STDERR ok 35 - REPL with -M with non-existent module does not start # Subtest: variables persist across multiple lines of input 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 36 - variables persist across multiple lines of input # Subtest: REPL does neither crash nor report True and False for junction 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 37 - REPL does neither crash nor report True and False for junction # Subtest: previously-entered code must not be re-run on every line of input 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 38 - previously-entered code must not be re-run on every line of input # Subtest: no bizzare types returned from redeclared "returns an `of` Array" sub 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 39 - no bizzare types returned from redeclared "returns an `of` Array" sub # Subtest: loop controls do not exit the REPL 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 40 - loop controls do not exit the REPL # Subtest: REPL can handle `Mu` as line's return value 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 41 - REPL can handle `Mu` as line's return value # Subtest: REPL does not explode with none Junction return values 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 42 - REPL does not explode with none Junction return values # Subtest: REPL detects incomplete regex (no NullPointerException) 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 43 - REPL detects incomplete regex (no NullPointerException) # Subtest: no complaints about .message 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 44 - no complaints about .message # Subtest: no sticky $0 values across lines 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 45 - no sticky $0 values across lines # Subtest: REPL can auto-print non-Mu things that lack .WHERE and .gist 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 46 - REPL can auto-print non-Mu things that lack .WHERE and .gist # Subtest: no complaints about failed writing to filehandle when opening a file 1..2 ok 1 - stdout is correct ok 2 - stderr is correct ok 47 - no complaints about failed writing to filehandle when opening a file # Subtest: check with additional CLI arguments 1..3 ok 1 - got the command line arguments ok 2 - no STDERR output ok 3 - successful exit code ok 48 - check with additional CLI arguments # Subtest: check that trying to run a REPL that expects a TTY fails without a TTY 1..2 ok 1 - Cannot start a REPL that wants a TTY without a TTY ok 2 - Exit code (1) reflects expected failure ok 49 - check that trying to run a REPL that expects a TTY fails without a TTY ok t/12-rakuast/xx-fixed-in-rakuast.rakutest ....................... 1..144 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 - *.uc and *.lc are not considered equivalent ok 6 - *.uc and *.uc are considered equivalent ok 7 - equivalence is still correct for more complicated WhateverCodes ok 8 - the :initialize flag is not sent to Set.STORE ok 9 - Pointy blocks are parameterized with return types ok 10 - Pointy blocks can be assigned to a parameterized Callable container ok 11 - creating a constant without a name dies ok 12 - wrapping infix:<|> works ok 13 - wrapping postfix:<++> works under soft ok 14 - Colonpairs with indirect-lookup as variables work ok 15 - Colonpairs with indirect-lookup as variables work (complex) ok 16 - no error messages from code params to regexes (<.&a>) ok 17 - no error messages from code params to regexes (<&a>) ok 18 - eager on parenthesized range works without issue ok 19 - Parametarization with DefiniteHOWs is not ignored in binding ok 20 - Parametarization with DefiniteHOWs works where it should ok 21 - 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 22 - Ambiguous adverb usage results in coherent exception ok 23 - 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 24 - 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 25 - 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 26 - 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 27 - '-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 28 - '-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 29 - topic variable is successfully lowered while using '-n' ok 30 - 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 31 - repl can successfully use and instantiate a class ('Depth') that is shadowed and surpassed by an earlier used class ('Depth::One') # TODO Fails in legacy grammar # 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 32 - no worry of a useless 'useless use' for parenthesized prime expression in where clause not ok 33 - stubbed classes that belong to parent package cause no issues when stubbed and defined within parent package scope # TODO Fails in legacy grammar # Failed test 'stubbed classes that belong to parent package cause no issues when stubbed and defined within parent package scope' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 222 # The following packages were stubbed but not defined: # A::B ok 34 - using the topic inside a 'with' and an embedded code block in a qq string ok 35 - did the code do the right thing not ok 36 - can have constraint on "our" variable # TODO compilation error in legacy grammar # Failed test 'can have constraint on "our" variable' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 237 # expected: 'foo' # got: (Nil) not ok 37 - handled X/= correctly # TODO handling of X/= when sunk # Failed test 'handled X/= correctly' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 248 # expected: $[[1.0, 2.0, 3.0], [1.0, 3.0, 5.0], [1.0, 4.0, 7.0]] # got: $[[1, 2, 3], [2, 6, 10], [3, 12, 21]] ok 38 - dispatch went correctly not ok 39 - did R[||]= work # TODO R[||]= doesn't compile # Failed test 'did R[||]= work' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 265 # expected: '42' # got: (Any) not ok 40 - did R[&&]= work # TODO R[&&]= doesn't compile # Failed test 'did R[&&]= work' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 270 # expected: '666' # got: (Any) not ok 41 - did R[//]= work # TODO R[//]= doesn't compile # Failed test 'did R[//]= work' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 275 # expected: '137' # got: (Any) not ok 42 - signature smartmatch ok # TODO signature smartmatch doesn't compile # Failed test 'signature smartmatch ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 281 # expected: Bool::False # got: Nil not ok 43 - did the object get built # TODO doesn't compile # Failed test 'did the object get built' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 296 # expected: 1 # got: Any not ok 44 - is Set on dynvar works # TODO dies # Failed test 'is Set on dynvar works' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 303 # expected: Set.new("b","a","c") # got: Set # Subtest: use of &?ROUTINE and &?BLOCK 1..14 ok 1 - sub for-sub is ok ok 2 - block inside for-sub is different ok 3 - sub do-sub is ok ok 4 - block inside do-sub is different ok 5 - sub given-sub is ok ok 6 - block inside given-sub is different ok 7 - sub if-sub is ok ok 8 - block inside if-sub is different ok 9 - sub when-sub is ok ok 10 - block inside when-sub is different ok 11 - sub loop-sub is ok ok 12 - block inside loop-sub is different ok 13 - sub while-sub is ok ok 14 - block inside while-sub is different ok 45 - use of &?ROUTINE and &?BLOCK not ok 46 - did post increment int8 return correct value # TODO incorrect value for int8 # Failed test 'did post increment int8 return correct value' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 361 # expected: '127' # got: '-129' ok 47 - did int8 get correct value not ok 48 - did post increment int16 return correct value # TODO incorrect value for int16 # Failed test 'did post increment int16 return correct value' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 365 # expected: '32767' # got: '-32769' ok 49 - did int16 get correct value ok 50 - is the value being bound returned # TODO dies ok 51 - did the value get bound # TODO dies not ok 52 - did the trait get run # TODO dies # Failed test 'did the trait get run' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 391 # expected: Bool::True # got: Any not ok 53 - loop completed successfully # TODO dies # Failed test 'loop completed successfully' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 401 # expected: '7' # got: '0' not ok 54 - did LAST run # TODO dies # Failed test 'did LAST run' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 402 # expected: Bool::True # got: Any Non ast passed to WANTED: NQPMu not ok 55 - was the syntax valid and did it fire # TODO dies # Failed test 'was the syntax valid and did it fire' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 410 # expected: Bool::True # got: Any not ok 56 - Routine name properly codegenned # TODO name is missing # Failed test 'Routine name properly codegenned' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 419 # expected: ${:foobar(${:foo("bar")})} # got: ${:foobar(${"" => "bar"})} not ok 57 - got a random value with state # TODO returned value is Any # Failed test 'got a random value with state' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 427 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 Use of uninitialized value @a of type Any in numeric context in block at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 428 ok 58 - all values the same with state not ok 59 - got a random value with once # TODO returned value is VMNull # Failed test 'got a random value with once' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 432 not ok 60 - all values the same with once # TODO returned value is VMNull # Failed test 'all values the same with once' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 433 # expected: Bool::True # got: Nil not ok 61 - LAST can see the state variable # TODO state variable appears undefined # Failed test 'LAST can see the state variable' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 449 # expected: Bool::True # got: Bool::False not ok 62 - can have a signature as a default for an attribute # TODO dispatch error # Failed test 'can have a signature as a default for an attribute' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 455 # expected: :() # got: Nil not ok 63 - uint ok # TODO becomes signed # Failed test 'uint ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 470 # expected: '18446744073709551615' # got: '-1' not ok 64 - uint64 ok # TODO becomes signed # Failed test 'uint64 ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 471 # expected: '18446744073709551615' # got: '-1' not ok 65 - did the code run and handle the exception # TODO doesn't compile # Failed test 'did the code run and handle the exception' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 486 # expected: '1' # got: '0' not ok 66 - role body only ran once # TODO runs 0 times or 2 times # Failed test 'role body only ran once' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 495 # expected: '1' # got: '0' not ok 67 - was the variable not stale # TODO optimizer stales variable # Failed test 'was the variable not stale' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 504 # expected: '11111111112222222222333333333344444444445555555555' # got: '11111111111111111111111111111111111111111111111111' ok 68 - no worries Regex object coerced to string (please use .gist or .raku to do that) in any metachar at /usr/share/nqp/lib/NQPP6QRegex.moarvm line 1 not ok 69 - regex interpolated ok # TODO doesn't interpolate correctly # Failed test 'regex interpolated ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 514 # expected: '「foo」' # got: '「」' not ok 70 - Do we always get the first value # TODO doesn't return correctly # Failed test 'Do we always get the first value' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 522 # expected: 42 # got: Nil not ok 71 - Do we always get the first value # TODO doesn't return correctly # Failed test 'Do we always get the first value' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 522 # expected: 42 # got: Nil not ok 72 - Do we always get the first value # TODO doesn't return correctly # Failed test 'Do we always get the first value' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 522 # expected: 42 # got: Nil ok 73 - Int:D candidate selected # TODO selects the wrong candidate ok 74 - Int:D candidate selected ok 75 - foo ok 76 - Rfoo ok 77 - bar not ok 78 - Rbar # TODO gets associativity wrong # Failed test 'Rbar' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 547 # expected: "(4,(3,(2,1)))" # got: "(((4,3),2),1)" ok 79 - :foo test 1 ok 80 - :foo test 2 ok 81 - :foo test 3 ok 82 - :foo test 4 not ok 83 - can have andthen as part of an elseif # TODO does not compile # Failed test 'can have andthen as part of an elseif' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 566 # Cannot find method 'blocktype' on object of type QAST::Op ok 84 - can access attribute ok 85 - can add to the attribute # TODO throws error ok 86 - attribute got incremented # TODO did not get updated not ok 87 - dispatch worked ok # TODO dispatch error # Failed test 'dispatch worked ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 592 # expected: 'yes' # got: (Nil) ok 88 - no output not ok 89 - error message is about usage # TODO execution error # Failed test 'error message is about usage' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 601 not ok 90 - val processing kept # TODO no val processing # Failed test 'val processing kept' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 607 # expected: IntStr.new(42, "42\n") # got: "42\n" not ok 91 - should not crash with typecheck error # TODO crashes # Failed test 'should not crash with typecheck error' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 623 not ok 92 - native integers do not require an initializer with variables:D # TODO compilation error # Failed test 'native integers do not require an initializer with variables:D' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 630 # Variable definition of type int:D (implicit :D by pragma) needs to be given an initializer not ok 93 - native integers can be initialized with variables:D # TODO typecheck error # Failed test 'native integers can be initialized with variables:D' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 633 # Type check failed in assignment to $a; expected int:D but got Int (42) not ok 94 - auto generated Callable ok # TODO does not compile # Failed test 'auto generated Callable ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 640 # Actual type: Nil not ok 95 - exits loop as expected # TODO throws execution error # Failed test 'exits loop as expected' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 647 # No such method 'eager' for invocant of type 'VMNull' not ok 96 - name is ok # TODO name empty # Failed test 'name is ok' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 652 # expected: 'z' # got: '' # Subtest: throws an illegal decimal error 1..2 ok 1 - code dies not ok 2 - right exception type (X::Syntax::Number::IllegalDecimal) # TODO throws wrong error # Failed test 'right exception type (X::Syntax::Number::IllegalDecimal)' # at NQP::src/HLL/Compiler.nqp line 534 # Expected: X::Syntax::Number::IllegalDecimal # Got: X::AdHoc # Exception message: Cannot stringify object of type QAST::Want not ok 97 - throws an illegal decimal error # TODO throws wrong error # Failed test 'throws an illegal decimal error' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 660 not ok 98 - interpolation of non-existing @!x # TODO throws compilation error # Failed test 'interpolation of non-existing @!x' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 681 # expected: "\@.x" # got: Nil ok 99 - was $_ set to 0 not ok 100 - Submethods can access attributes # TODO Having a submethod that accesses an attribute dies, even if never called # Failed test 'Submethods can access attributes' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 695 # Error: Virtual method call $.a may not be used on partially constructed object (maybe you mean $!a for direct attribute access here?) not ok 101 - no special quasting for infix:<,>(1) # TODO improper QASTing of infix:<,>(42) to just 42 # Failed test 'no special quasting for infix:<,>(1)' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 710 # expected: "(42,)\n" # got: "42\n" ok 102 - postfix hyper primes properly # TODO ensure that hyper operators prime as expected ok 103 - BEGIN-time EVAL of a parsed RakuAST sub produces a Sub ok 104 - BEGIN-time EVAL of an empty RakuAST statement list lives ok 105 - BEGIN-time EVAL of a RakuAST sub can resolve setting routines and run # Subtest: synthetic RakuAST::Sub calling a setting routine runs at runtime 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 106 - synthetic RakuAST::Sub calling a setting routine runs at runtime # Subtest: precompiling a module returning a synthetic RakuAST Sub from BEGIN works 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 107 - precompiling a module returning a synthetic RakuAST Sub from BEGIN works # Subtest: .assuming in a precompiled module loaded via another module works 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 108 - .assuming in a precompiled module loaded via another module works ok 109 - invoking a Sub returned from BEGIN-time string EVAL works ok 110 - BEGIN-time string-EVAL Sub with setting operator runs ok 111 - a once in a LEAVE body fires once across calls of one clone ok 112 - a once in an UNDO body fires once across calls of one clone ok 113 - each clone of a routine runs its ENTER once independently not ok 114 - a native argument to a multi where no candidate is rw is a snapshot # TODO undecided multi leaks the native reference in legacy grammar # Failed test 'a native argument to a multi where no candidate is rw is a snapshot' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 842 # expected: '5' # got: '8' not ok 115 - a native argument following a named argument is a snapshot # TODO mixed named and positional args leak the native reference in legacy grammar # Failed test 'a native argument following a named argument is a snapshot' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 852 # expected: '5' # got: '8' ok 116 - require loads a module through a satisfiable :ver constraint ok 117 - require loads a module with a bare boolean adverb ok 118 - a require with an adverb used as a block value returns the module ok 119 - a require with an adverb still imports the requested symbol not ok 120 - require fails on an unsatisfiable :ver constraint # TODO the legacy grammar ignores an unsatisfiable :ver on require # Failed test 'require fails on an unsatisfiable :ver constraint' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 885 not ok 121 - require fails on an unsatisfiable :auth constraint # TODO the legacy grammar ignores an unsatisfiable :auth on require # Failed test 'require fails on an unsatisfiable :auth constraint' # at t/12-rakuast/xx-fixed-in-rakuast.rakutest line 888 # Subtest: :dba names the regex region and FAILGOAL receives it 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 122 - :dba names the regex region and FAILGOAL receives it ok 123 - S applies the base operator ok 124 - chained S keeps the base associativity ok 125 - a sequenced operator can be reduced ok 126 - a custom postcircumfix parses a semicolon separated subscript ok 127 - a custom postcircumfix parses an empty subscript ok 128 - a custom postcircumfix passes the operand as the first argument ok 129 - a plain signature literal inside a WhateverCode links its code ok 130 - a where-constrained signature literal inside a WhateverCode links its code # Subtest: the last statement of a CATCH default block also warns as useless 1..3 ok 1 - STDOUT ok 2 - STDERR ok 3 - Exit code ok 131 - the last statement of a CATCH default block also warns as useless ok 132 - a for loop over a sized native array writes back through <-> ok 133 - an is rw trait inside a has declaration list gives a writable accessor ok 134 - an is default trait inside a declaration list reaches the variable # Subtest: an unknown trait inside a declaration list is rejected 1..3 ok 1 - code dies ok 2 - right exception type (Exception) ok 3 - .message matches /'nonesuch'/ ok 135 - an unknown trait inside a declaration list is rejected ok 136 - a BEGIN-built method steps a later declared int attribute ok 137 - a BEGIN-built method assigns a later declared int attribute ok 138 - a BEGIN-built method compound assigns a later declared num attribute ok 139 - a BEGIN-built method concatenates onto a later declared str attribute ok 140 - a BEGIN-built method stores a high uint8 value without sign extension ok 141 - a BEGIN-built method stores a high uint32 value without sign extension ok 142 - a constant return value is returned from a call ok 143 - a constant return value parameterizes Callable with its type ok 144 - subs with different constant return values share their Callable mixin type 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 ok 42 - # SKIP Memory allocation failures on 32-bit architectures ok All tests successful. Test Summary Report ------------------- t/08-performance/22-rakuast-copy-returns.t (Wstat: 0 Tests: 9 Failed: 0) TODO passed: 1-2, 9 t/09-moar/Line_Break__LineBreak.t (Wstat: 0 Tests: 2 Failed: 0) TODO passed: 1-2 t/12-rakuast/xx-fixed-in-rakuast.rakutest (Wstat: 0 Tests: 144 Failed: 0) TODO passed: 31, 50-51, 73, 85-86, 102 Files=426, Tests=5415, 87 wallclock secs ( 4.22 usr 0.97 sys + 1576.84 cusr 124.10 csys = 1706.13 CPU) Result: PASS >>> rakudo: Entering fakeroot... +++ Creating installation directories +++ Preparing installation +++ Removing old files +++ Installing files Installed 24 core modules in 27.408973958 seconds! +++ MOAR BACKEND INSTALLED +++ Installing MOAR launchers +++ Creating Raku executable alias +++ Rakudo installed successfully! '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/perl6' -> 'rakudo' created directory: '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/' created directory: '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo' 'CONTRIBUTING.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/CONTRIBUTING.md' 'CREDITS' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/CREDITS' 'LICENSE' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/LICENSE' 'README.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/README.md' 'VERSION' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/VERSION' 'docs/module_management.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/module_management.md' 'docs/architecture.svg' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/architecture.svg' 'docs/language_versions.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/language_versions.md' 'docs/rakudo-nqp-and-pod-notes.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/rakudo-nqp-and-pod-notes.md' 'docs/running.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/running.pod' 'docs/S26-configure-notes-from-Damian-Conway.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/S26-configure-notes-from-Damian-Conway.md' 'docs/architecture.html' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/architecture.html' 'docs/archive/constants-type-constraints-proposal-2018-02-10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/archive/constants-type-constraints-proposal-2018-02-10.md' 'docs/archive/2017-IO-Grant--Action-Plan.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/archive/2017-IO-Grant--Action-Plan.md' 'docs/archive/2018-03-04--Polishing-Rationals.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/archive/2018-03-04--Polishing-Rationals.md' 'docs/archive/spectest-progress.csv' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/archive/spectest-progress.csv' 'docs/archive' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/archive' 'docs/deprecations' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/deprecations' 'docs/val.pod6' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/val.pod6' 'docs/guide_to_setting.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/guide_to_setting.pod' 'docs/rakuast/rakuast-compilation-phases.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/rakuast/rakuast-compilation-phases.md' 'docs/rakuast' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/rakuast' 'docs/announce/2011.07' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.07' 'docs/announce/2020.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.12.md' 'docs/announce/2024.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.03.md' 'docs/announce/2016.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.08.md' 'docs/announce/2013.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.07.md' 'docs/announce/2013.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.08.md' 'docs/announce/2020.02.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.02.1.md' 'docs/announce/2023.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.05.md' 'docs/announce/2020.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.02.md' 'docs/announce/2021.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.05.md' 'docs/announce/2015.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.08.md' 'docs/announce/2022.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2022.06.md' 'docs/announce/2024.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.07.md' 'docs/announce/2014.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.07.md' 'docs/announce/2022.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2022.03.md' 'docs/announce/2021.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.06.md' 'docs/announce/2021.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.09.md' 'docs/announce/2013.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.10.md' 'docs/announce/2012.07' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.07' 'docs/announce/2014.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.09.md' 'docs/announce/2024.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.12.md' 'docs/announce/2020.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.10.md' 'docs/announce/2017.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.01.md' 'docs/announce/2016.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.05.md' 'docs/announce/2017.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.11.md' 'docs/announce/2016.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.04.md' 'docs/announce/2024.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.05.md' 'docs/announce/2018.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.08.md' 'docs/announce/2025.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.02.md' 'docs/announce/2013.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.06.md' 'docs/announce/2020.08.2.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.08.2.md' 'docs/announce/2017.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.02.md' 'docs/announce/2014.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.05.md' 'docs/announce/2017.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.08.md' 'docs/announce/2013.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.11.md' 'docs/announce/2010.11' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.11' 'docs/announce/2023.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.11.md' 'docs/announce/2016.08.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.08.1.md' 'docs/announce/2021.02.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.02.1.md' 'docs/announce/2024.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.06.md' 'docs/announce/2021.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.12.md' 'docs/announce/2016.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.01.md' 'docs/announce/2010-01' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010-01' 'docs/announce/2012.12' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.12' 'docs/announce/2009-11' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-11' 'docs/announce/2024.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.08.md' 'docs/announce/2011.10' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.10' 'docs/announce/2012.01' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.01' 'docs/announce/2019.03.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2019.03.1.md' 'docs/announce/2015.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.03.md' 'docs/announce/2025.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.03.md' 'docs/announce/2017.04.2.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.04.2.md' 'docs/announce/2021.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.10.md' 'docs/announce/2015.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.04.md' 'docs/announce/2014.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.02.md' 'docs/announce/2017.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.09.md' 'docs/announce/2017.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.07.md' 'docs/announce/2018.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.04.md' 'docs/announce/2009-09' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-09' 'docs/announce/2015.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.05.md' 'docs/announce/2018.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.05.md' 'docs/announce/2026.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.01.md' 'docs/announce/2010.07' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.07' 'docs/announce/2011.04' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.04' 'docs/announce/2018.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.10.md' 'docs/announce/2019.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2019.07.md' 'docs/announce/2024.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.09.md' 'docs/announce/2016.07.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.07.1.md' 'docs/announce/2019.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2019.11.md' 'docs/announce/2016.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.06.md' 'docs/announce/2009-02' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-02' 'docs/announce/2025.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.05.md' 'docs/announce/2021.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.08.md' 'docs/announce/2023.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.08.md' 'docs/announce/2015.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.01.md' 'docs/announce/2021.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.02.md' 'docs/announce/2009-08' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-08' 'docs/announce/2018.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.01.md' 'docs/announce/2017.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.05.md' 'docs/announce/2025.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.04.md' 'docs/announce/2023.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.06.md' 'docs/announce/2013.01' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.01' 'docs/announce/2014.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.08.md' 'docs/announce/2012.05' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.05' 'docs/announce/2013.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.05.md' 'docs/announce/2012.11' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.11' 'docs/announce/2014.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.03.md' 'docs/announce/2018.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.12.md' 'docs/announce/2017.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.03.md' 'docs/announce/2020.05.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.05.1.md' 'docs/announce/2009-05' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-05' 'docs/announce/2026.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.02.md' 'docs/announce/2012.04.1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.04.1' 'docs/announce/2013.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.12.md' 'docs/announce/2011.01' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.01' 'docs/announce/2015.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.02.md' 'docs/announce/2020.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.08.md' 'docs/announce/2022.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2022.04.md' 'docs/announce/2012.10' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.10' 'docs/announce/2017.04.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.04.1.md' 'docs/announce/2023.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.09.md' 'docs/announce/2017.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.12.md' 'docs/announce/2012.06' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.06' 'docs/announce/2026.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.07.md' 'docs/announce/2018.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.11.md' 'docs/announce/2012.08' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.08' 'docs/announce/2015.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.12.md' 'docs/announce/2015.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.06.md' 'docs/announce/2024.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.04.md' 'docs/announce/2021.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.07.md' 'docs/announce/2025.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.10.md' 'docs/announce/2022.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2022.07.md' 'docs/announce/2018.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.09.md' 'docs/announce/2026.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.05.md' 'docs/announce/2013.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.04.md' 'docs/announce/2012.02' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.02' 'docs/announce/2025.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.08.md' 'docs/announce/2017.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.10.md' 'docs/announce/2014.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.10.md' 'docs/announce/2015.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.07.md' 'docs/announce/2023.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.02.md' 'docs/announce/2026.08.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.08.md' 'docs/announce/2011.03' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.03' 'docs/announce/2010.06' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.06' 'docs/announce/2015.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.11.md' 'docs/announce/2010.12' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.12' 'docs/announce/2021.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.03.md' 'docs/announce/2018.04.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.04.1.md' 'docs/announce/2025.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.11.md' 'docs/announce/2018.02.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.02.1.md' 'docs/announce/2026.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.03.md' 'docs/announce/2015.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.10.md' 'docs/announce/2016.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.11.md' 'docs/announce/2016.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.07.md' 'docs/announce/2010.10' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.10' 'docs/announce/2026.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.04.md' 'docs/announce/2020.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.09.md' 'docs/announce/2020.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.06.md' 'docs/announce/2011.06' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.06' 'docs/announce/2018.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.02.md' 'docs/announce/2023.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.04.md' 'docs/announce/2018.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.06.md' 'docs/announce/2014.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.11.md' 'docs/announce/2009-10' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-10' 'docs/announce/2010.02' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.02' 'docs/announce/2025.06.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.06.1.md' 'docs/announce/2009-04' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-04' 'docs/announce/2016.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.02.md' 'docs/announce/2017.04.3.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.04.3.md' 'docs/announce/2026.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2026.06.md' 'docs/announce/2009-12' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-12' 'docs/announce/2020.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.01.md' 'docs/announce/2010.04' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.04' 'docs/announce/2013.02' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.02' 'docs/announce/2016.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.12.md' 'docs/announce/2024.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.01.md' 'docs/announce/2020.08.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.08.1.md' 'docs/announce/2013.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.03.md' 'docs/announce/2011.09' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.09' 'docs/announce/2012.04' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.04' 'docs/announce/2011.05' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.05' 'docs/announce/2019.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2019.03.md' 'docs/announce/2014.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.12.md' 'docs/announce/2024.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.10.md' 'docs/announce/2022.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2022.02.md' 'docs/announce/2013.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2013.09.md' 'docs/announce/2021.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2021.04.md' 'docs/announce/2012.09' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.09' 'docs/announce/2011.11' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.11' 'docs/announce/2016.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.03.md' 'docs/announce/2009-07' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-07' 'docs/announce/2014.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.06.md' 'docs/announce/2020.07.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.07.md' 'docs/announce/2009-06' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-06' 'docs/announce/2020.11.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.11.md' 'docs/announce/2017.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.06.md' 'docs/announce/2010.08' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.08' 'docs/announce/2019.07.1.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2019.07.1.md' 'docs/announce/2018.03.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2018.03.md' 'docs/announce/2011.02' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.02' 'docs/announce/2023.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.10.md' 'docs/announce/2025.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.01.md' 'docs/announce/2012.03' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.03' 'docs/announce/2023.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2023.12.md' 'docs/announce/2022.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2022.12.md' 'docs/announce/2024.02.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2024.02.md' 'docs/announce/2014.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.04.md' 'docs/announce/2009-03' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2009-03' 'docs/announce/2010.03' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.03' 'docs/announce/2016.10.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.10.md' 'docs/announce/2025.06.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.06.md' 'docs/announce/2025.12.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2025.12.md' 'docs/announce/2016.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2016.09.md' 'docs/announce/2017.04.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2017.04.md' 'docs/announce/2014.01.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2014.01.md' 'docs/announce/2010.05' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.05' 'docs/announce/2011.12' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2011.12' 'docs/announce/2015.09.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2015.09.md' 'docs/announce/2010.09' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2010.09' 'docs/announce/2012.09.1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2012.09.1' 'docs/announce/2020.05.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce/2020.05.md' 'docs/announce' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/announce' 'docs/declarator_block_expectations.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/declarator_block_expectations.raku' 'docs/articles/2016-02 Proposed Perl 6 Versioning And Compatibility Guidelines.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/articles/2016-02 Proposed Perl 6 Versioning And Compatibility Guidelines.md' 'docs/articles' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/articles' 'docs/S26-declarator-block-notes-from-Damian-Conway.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/S26-declarator-block-notes-from-Damian-Conway.md' 'docs/metaobject-api.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/metaobject-api.pod' 'docs/compiler_overview.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/compiler_overview.pod' 'docs/S11-Modules-proposal.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/S11-Modules-proposal.pod' 'docs/ChangeLog' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/ChangeLog' 'docs/ROADMAP' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/ROADMAP' 'docs/dispatchers.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/dispatchers.md' 'docs/metamodel.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/metamodel.pod' 'docs/line-editor.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/line-editor.pod' 'docs/ops.markdown' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/ops.markdown' 'docs/release_guide.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/release_guide.pod' 'docs/Building-Rakudo.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/Building-Rakudo.md' 'docs/release-guide-binary.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/release-guide-binary.md' 'docs/windows.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/windows.md' 'docs/roast.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/roast.md' 'docs/obtaining-a-commit-bit.pod' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs/obtaining-a-commit-bit.pod' 'docs' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo/usr/share/doc/rakudo/docs' >>> rakudo-dev*: Running split function dev... 'usr/bin/perl6-debug' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/perl6-debug' 'usr/bin/perl6-debug-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/perl6-debug-m' 'usr/bin/perl6-gdb-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/perl6-gdb-m' 'usr/bin/perl6-lldb-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/perl6-lldb-m' 'usr/bin/perl6-valgrind-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/perl6-valgrind-m' 'usr/bin/rakudo-debug' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/rakudo-debug' 'usr/bin/rakudo-debug-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/rakudo-debug-m' 'usr/bin/rakudo-gdb-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/rakudo-gdb-m' 'usr/bin/rakudo-lldb-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/rakudo-lldb-m' 'usr/bin/rakudo-valgrind-m' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/rakudo-valgrind-m' 'usr/bin/raku-debug' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/bin/raku-debug' created directory: '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/' created directory: '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/nuke-precomps.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/nuke-precomps.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/lib/NQP/Config/Rakudo.pm' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/lib/NQP/Config/Rakudo.pm' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/lib/NQP/Config' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/lib/NQP/Config' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/lib/NQP' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/lib/NQP' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/lib' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/lib' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/add-leap-second.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/add-leap-second.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/install-dist.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/install-dist.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/benchmark.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/benchmark.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/releasable/Akefile' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/releasable/Akefile' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/releasable/github-release' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/releasable/github-release' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/releasable' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/releasable' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeUNIPROP.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeUNIPROP.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeMAGIC_INC_DEC.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeMAGIC_INC_DEC.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeNATIVE_SHAPED1_CANDIDATES.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeNATIVE_SHAPED1_CANDIDATES.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/raku-ast-compiler.nqp' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/raku-ast-compiler.nqp' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeNATIVE_SHAPED_ARRAY.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeNATIVE_SHAPED_ARRAY.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/monitor-process.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/monitor-process.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/clean-target-files.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/clean-target-files.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/wrapper-compiler-helper.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/wrapper-compiler-helper.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/checkout-repos-for-test.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/checkout-repos-for-test.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/create-jvm-runner.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/create-jvm-runner.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeNATIVE_ARRAY.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeNATIVE_ARRAY.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/build-macos.sh' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/build-macos.sh' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/build-debian.sh' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/build-debian.sh' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/build-containers/Dockerfile' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/build-containers/Dockerfile' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/build-containers' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/build-containers' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/build-linux.sh' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/build-linux.sh' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows/README.txt' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows/README.txt' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows/scripts/set-env-cmd-helper.ps1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows/scripts/set-env-cmd-helper.ps1' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows/scripts/set-env.ps1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows/scripts/set-env.ps1' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows/scripts/vs_build_tools_install_assistant.ps1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows/scripts/vs_build_tools_install_assistant.ps1' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows/scripts/set-env.bat' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows/scripts/set-env.bat' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows/scripts' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows/scripts' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Windows' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Windows' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Linux/scripts/set-env.sh' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Linux/scripts/set-env.sh' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Linux/scripts' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Linux/scripts' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Linux/README.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Linux/README.md' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/Linux' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/Linux' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/MacOS/scripts/set-env.sh' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/MacOS/scripts/set-env.sh' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/MacOS/scripts' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/MacOS/scripts' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/MacOS/README.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/MacOS/README.md' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets/MacOS' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets/MacOS' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/assets' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/assets' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/.gitattributes' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/.gitattributes' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/.gitignore' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/.gitignore' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/build-msi.ps1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/build-msi.ps1' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/assets/README.txt' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/assets/README.txt' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/assets/scripts/rakudo_repl.ps1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/assets/scripts/rakudo_repl.ps1' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/assets/scripts' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/assets/scripts' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/assets/rakudo_icon.ico' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/assets/rakudo_icon.ico' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/assets/camelia_icon.ico' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/assets/camelia_icon.ico' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/assets' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/assets' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/README.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/README.md' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/installer-assets/banner.bmp' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/installer-assets/banner.bmp' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/installer-assets/License.rtf' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/installer-assets/License.rtf' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/installer-assets/dialog.bmp' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/installer-assets/dialog.bmp' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/installer-assets' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/installer-assets' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi/rakudo.wxs' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi/rakudo.wxs' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/msi' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/msi' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/build-windows.ps1' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/build-windows.ps1' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release/README.md' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release/README.md' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/binary-release' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/binary-release' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/create-js-runner.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/create-js-runner.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeBLOB_ROLES.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeBLOB_ROLES.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeBUF_ROLES.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeBUF_ROLES.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeARRAY_SLICE_ASSIGN.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeARRAY_SLICE_ASSIGN.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/install-core-dist.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/install-core-dist.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeNATIVE_SORTING.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeNATIVE_SORTING.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/upgrade-repository.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/upgrade-repository.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/nqp-jvm-rr.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/nqp-jvm-rr.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeNATIVE_CANDIDATES.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeNATIVE_CANDIDATES.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/update-submodules.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/update-submodules.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/ln_s.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/ln_s.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeSLICE.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeSLICE.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeHTML-ENTITIES.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeHTML-ENTITIES.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/check-nqp-version.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/check-nqp-version.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeARRAY_SLICE_ACCESS.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeARRAY_SLICE_ACCESS.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/clean-precomps.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/clean-precomps.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/makeARRAY_SLICE_BIND.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/makeARRAY_SLICE_BIND.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build/gen-cat.nqp' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build/gen-cat.nqp' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/CREDITS.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/CREDITS.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/rakudo-limited.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/rakudo-limited.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.c/bootstrap_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.c/bootstrap_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.c/core_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.c/core_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.c' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.c' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/Makefile.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/Makefile.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/js/Makefile.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/js/Makefile.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/js/main-version.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/js/main-version.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/js/rakudo-js-build.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/js/rakudo-js-build.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/js/core_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/js/core_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/js' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/js' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.d/bootstrap_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.d/bootstrap_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.d/core_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.d/core_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.d' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.d' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/Makefile-backend-common.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/Makefile-backend-common.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/sh-prelude' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/sh-prelude' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/main-version-common.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/main-version-common.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/NQP_REVISION' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/NQP_REVISION' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/raku_ast_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/raku_ast_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-debug-notice.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-debug-notice.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/Makefile.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/Makefile.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/main-version.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/main-version.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/Makefile-install.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/Makefile-install.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/Makefile-gen-c-runner.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/Makefile-gen-c-runner.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-m-build.c.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-m-build.c.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-gdb-m.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-gdb-m.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-m-early-build.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-m-early-build.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/Makefile-runner_opts.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/Makefile-runner_opts.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-m-build.c.windows' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-m-build.c.windows' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-lldb-m.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-lldb-m.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/rakudo-valgrind-m.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/rakudo-valgrind-m.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar/moar_includes' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar/moar_includes' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/moar' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/moar' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/common_metamodel_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/common_metamodel_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/Makefile-common-macros.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/Makefile-common-macros.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/Makefile-common-rules.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/Makefile-common-rules.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/common_test_dirs' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/common_test_dirs' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.e/bootstrap_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.e/bootstrap_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.e/core_sources' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.e/core_sources' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/6.e' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/6.e' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/jvm/Makefile.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/jvm/Makefile.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/jvm/main-version.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/jvm/main-version.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/jvm/rakudo-j-build.in' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/jvm/rakudo-j-build.in' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/jvm' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/jvm' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates/RAKU_SPECS' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates/RAKU_SPECS' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/templates' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/templates' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/speedup.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/speedup.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/create-release-announcement.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/create-release-announcement.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/autounfudge.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/autounfudge.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/contributors.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/contributors.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/release-dates.raku' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/release-dates.raku' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/update-passing-test-data.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/update-passing-test-data.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/rakudo-swarm.config' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/rakudo-swarm.config' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools/build-localtest.pl' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools/build-localtest.pl' '/home/buildozer/aports/community/rakudo/src/rakudo-2026.08/tools' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-dev/usr/share/rakudo/tools' >>> rakudo-dev*: Preparing subpackage rakudo-dev... >>> rakudo-dev*: Stripping binaries >>> rakudo-dev*: Running postcheck for rakudo-dev >>> rakudo-doc*: Running split function doc... 'usr/share/doc' -> '/home/buildozer/aports/community/rakudo/pkg/rakudo-doc/usr/share/doc' >>> rakudo-doc*: Preparing subpackage rakudo-doc... >>> rakudo-doc*: Running postcheck for rakudo-doc >>> rakudo*: Running postcheck for rakudo >>> rakudo*: Preparing package rakudo... >>> rakudo*: Stripping binaries >>> rakudo*: Scanning shared objects >>> rakudo-dev*: Scanning shared objects >>> rakudo*: Tracing dependencies... nqp~2026.08 so:libc.musl-x86.so.1 so:libmoar.so >>> rakudo*: Package size: 63.7 MB >>> rakudo*: Compressing data... >>> rakudo*: Create checksum... >>> rakudo*: Create rakudo-2026.08-r0.apk >>> rakudo-dev*: Tracing dependencies... so:libc.musl-x86.so.1 so:libmoar.so >>> rakudo-dev*: Package size: 1.1 MB >>> rakudo-dev*: Compressing data... >>> rakudo-dev*: Create checksum... >>> rakudo-dev*: Create rakudo-dev-2026.08-r0.apk >>> rakudo-doc*: Tracing dependencies... >>> rakudo-doc*: Package size: 1.9 MB >>> rakudo-doc*: Compressing data... >>> rakudo-doc*: Create checksum... >>> rakudo-doc*: Create rakudo-doc-2026.08-r0.apk >>> rakudo: Build complete at Wed, 14 Oct 2026 03:48:49 +0000 elapsed time 0h 5m 24s >>> rakudo: Cleaning up srcdir >>> rakudo: Cleaning up pkgdir >>> rakudo: Cleaning up tmpdir >>> rakudo: Uninstalling dependencies... ( 1/22) Purging .makedepends-rakudo (20261014.034329) ( 2/22) Purging nqp (2026.08-r0) ( 3/22) Purging moarvm-dev (2026.08-r0) ( 4/22) Purging moarvm (2026.08-r0) ( 5/22) Purging libffi-dev (3.8.0-r0) ( 6/22) Purging linux-headers (7.2.1-r0) ( 7/22) Purging libffi (3.8.0-r0) ( 8/22) Purging libuv-dev (1.52.1-r0) ( 9/22) Purging libuv (1.52.1-r0) (10/22) Purging mimalloc2-dev (2.2.7-r0) (11/22) Purging mimalloc2-debug (2.2.7-r0) (12/22) Purging mimalloc2-insecure (2.2.7-r0) (13/22) Purging mimalloc2 (2.2.7-r0) (14/22) Purging zstd-dev (1.5.7-r2) (15/22) Purging zstd (1.5.7-r2) (16/22) Purging perl-utils (5.44.0-r0) (17/22) Purging perl-test-harness (3.52-r0) (18/22) Purging git-perl (2.56.0-r0) (19/22) Purging perl-git (2.56.0-r0) (20/22) Purging perl-error (0.17030-r0) (21/22) Purging perl (5.44.0-r0) (22/22) Purging libbz2 (1.0.8-r6) Executing busybox-1.38.0-r7.trigger OK: 294.3 MiB in 102 packages >>> rakudo: Updating the community/x86 repository index... >>> rakudo: Signing the index...