multi plan(Cool:D :skip-all($reason)!)
multi plan($number_of_tests)

plan 15;   # expect to run 15 tests 

plan :skip-all<These tests are only for Windows> unless $*DISTRO.is-win;
plan 1;
ok dir 'C:/'; # this won't get run on non-Windows 

plan 2;
subtest "Some Windows tests" => sub { # <-- note the `sub`; can't use bare block 
    plan :skip-all<We aren't on Windows> unless $*DISTRO.is-win;
    plan 1;
    ok dir 'C:/'; # this won't get run on non-Windows 
}
ok 42; # this will run everywhere and isn't affected by skip-all inside subtest 

sub done-testing()

sub do-stuff {@};
use Test;
ok .is-prime for do-stuff;
done-testing;
# output: 
1..0

sub do-stuff {@};
use Test;
plan 1;
ok .is-prime for do-stuff;
# output: 
1..1
# Looks like you planned 1 test, but ran 0 

multi ok(Mu $cond, $desc = '')

my $response; my $query; ...;
ok $response.success, 'HTTP response was successful';

sub factorial($x) { ... };
ok factorial(6) == 720, 'Factorial - small integer';

multi nok(Mu $cond, $desc = '')

my $response; my $query; ...;
nok $query.error, 'Query completed without error';

multi is(Mu $got, Mu:U $expected, $desc = '')
multi is(Mu $got, Mu:D $expected, $desc = '')

my $pdf-document; sub factorial($x) { ... }; ...;
is $pdf-document.author, "Joe", 'Retrieving the author field';
is factorial(6),         720,   'Factorial - small integer';
my Int $a;
is $a, Int, 'The variable $a is an unassigned Int';

is "foo\tbar", "foo\tbaz";   # expected: 'foo     baz'␤#      got: 'foo   bar' 
is "foo\tbar", "foo    bar"; # expected: "foo    bar"␤#      got: "foo\tbar" 

multi isnt(Mu $got, Mu:U $expected, $desc = '')
multi isnt(Mu $got, Mu:D $expected, $desc = '')

isnt pi, 3, 'The constant π is not equal to 3';
my Int $a = 23;
$a = Nil;
isnt $a, Nil, 'Nil should not survive being put in a container';

multi is_approx(Mu $got, Mu $expected, $desc = '')

multi is-approx(Numeric $got, Numeric $expected, $desc = '')

multi is-approx(Numeric $got, Numeric $expected, Numeric $abs-tol,
                    $desc = '')

multi is-approx(Numeric $got, Numeric $expected, $desc = '',
                    Numeric :$rel-tol is required)

multi is-approx(Numeric $got, Numeric $expected, $desc = '',
                    Numeric :$abs-tol is required)

multi is-approx(Numeric $got, Numeric $expected, $desc = '',
                    Numeric :$rel-tol is required,
                    Numeric :$abs-tol is required)

my Numeric ($value, $expected, $abs-tol, $rel-tol) = ...
 
is-approx $value, $expected;
is-approx $value, $expected, 'test description';
 
is-approx $value, $expected, $abs-tol;
is-approx $value, $expected, $abs-tol, 'test description';
 
is-approx $value, $expected, :$rel-tol;
is-approx $value, $expected, :$rel-tol, 'test description';
 
is-approx $value, $expected, :$abs-tol;
is-approx $value, $expected, :$abs-tol, 'test description';
 
is-approx $value, $expected, :$abs-tol, :$rel-tol;
is-approx $value, $expected, :$abs-tol, :$rel-tol, 'test description';

is-approx 3, 4, 2; # success 
is-approx 3, 6, 2; # fail 
 
is-approx 300, 302, 2; # success 
is-approx 300, 400, 2; # fail 
is-approx 300, 600, 2; # fail 

is-approx 10, 10.5, :rel-tol<0.1>; # success 
is-approx 10, 11.5, :rel-tol<0.1>; # fail 
 
is-approx 100, 105, :rel-tol<0.1>; # success 
is-approx 100, 115, :rel-tol<0.1>; # fail 

              |value - expected|
⁣rel-diff = ────────────────────────
           max(|value|, |expected|)

is-approx $value, $expected, :rel-tol<.5>, :abs-tol<10>;

sub is-approx-calculate($got, $expected, $abs-tol where { !.defined or $_ >= 0 },
                        $rel-tol where { !.defined or $_ >= 0 }, $desc)

multi is-deeply(Seq:D $got, Seq:D $expected, $reason = '')
multi is-deeply(Seq:D $got, Mu $expected, $reason = '')
multi is-deeply(Mu $got, Seq:D $expected, $reason = '')
multi is-deeply(Mu $got, Mu $expected, $reason = '')

use Test;
plan 1;
 
sub string-info(Str() $_) {
    Map.new: (
      length  =>  .chars,
      char-counts => Bag.new-from-pairs: (
          letters => +.comb(/<:letter>/),
          digits  => +.comb(/<:digit>/),
          other   => +.comb(/<.-:letter-:digit>/),
    ))
}
 
is-deeply string-info('42 Butterflies ♥ Raku'), Map.new((
    :21length,
    char-counts => Bag.new-from-pairs: ( :15letters, :2digits, :4other, )
)), 'string-info gives right info';

multi cmp-ok(Mu $got is raw, $op, Mu $expected is raw, $desc = '')

cmp-ok 'my spelling is apperling', '~~', /perl/, "bad speller";

cmp-ok <a b c>, &[!eqv], <b d e>, 'not equal';

sub my-comp { $^a / $^b  < rand };
cmp-ok 1, &my-comp, 2, 'the dice giveth and the dice taketh away'
cmp-ok 2, -> $a, $b { $a.is-prime and $b.is-prime and $a < $b }, 7,
    'we got primes, one larger than the other!';

multi isa-ok(Mu $var, Mu $type, $desc = "The object is-a '$type.raku()'")

class Womble {}
class GreatUncleBulgaria is Womble {}
my $womble = GreatUncleBulgaria.new;
 
isa-ok $womble, Womble, "Great Uncle Bulgaria is a womble";
isa-ok $womble, 'Womble';     # equivalent 

say 42.isa(Numeric); # OUTPUT: «False␤» 
isa-ok 42, Numeric;  # OUTPUT: «ok 1 - The object is-a 'Numeric'␤» 

multi can-ok(Mu $var, Str $meth, $desc = "..." )

class Womble {
    method collect-rubbish { ... }
}
my $womble = Womble.new;
 
# with automatically generated test description 
can-ok $womble, 'collect-rubbish';
#  => An object of type 'Womble' can do the method 'collect-rubbish' 
 
# with human-generated test description 
can-ok $womble, 'collect-rubbish', "Wombles can collect rubbish";
#  => Wombles can collect rubbish 

multi does-ok(Mu $var, Mu $type, $desc = "...")

# create a Womble who can invent 
role Invent {
    method brainstorm { say "Aha!" }
}
class Womble {}
class Tobermory is Womble does Invent {}
 
# ... and later in the tests 
use Test;
 
my $tobermory = Tobermory.new;
 
# with automatically generated test description 
does-ok $tobermory, Invent;
#  => The object does role Type 
 
does-ok $tobermory, Invent, "Tobermory can invent";
#  => Tobermory can invent 

sub like(Str() $got, Regex:D $expected, $desc = "text matches $expected.raku()")

like 'foo', /fo/, 'foo looks like fo';

multi unlike(Str() $got, Regex:D $expected, $desc = "text does not match $expected.raku()")

unlike 'foo', /bar/, 'foo does not look like bar';

multi use-ok(Str $code, $desc = "$code module can be use-d ok")

use-ok 'Full::Qualified::ModuleName';

use-ok 'Full::Qualified::ModuleName :my-argument';

multi dies-ok(Callable $code, $reason = '')

sub saruman(Bool :$ents-destroy-isengard) {
    die "Killed by Wormtongue" if $ents-destroy-isengard;
}
 
dies-ok { saruman(ents-destroy-isengard => True) }, "Saruman dies";

multi lives-ok(Callable $code, $reason = '')

sub frodo(Bool :$destroys-ring) {
    die "Oops, that wasn't supposed to happen" unless $destroys-ring;
}
 
lives-ok { frodo(destroys-ring => True) }, "Frodo survives";

multi eval-dies-ok(Str $code, $reason = '')

eval-dies-ok q[my $joffrey = "nasty";
               die "bye bye Ned" if $joffrey ~~ /nasty/],
    "Ned Stark dies";

multi eval-lives-ok(Str $code, $reason = '')

eval-lives-ok q[my $daenerys-burns = False;
                die "Oops, Khaleesi now ashes" if $daenerys-burns],
    "Dany is blood of the dragon";

sub throws-like($code, $ex_type, $reason?, *%matcher)

sub frodo(Bool :$destroys-ring) {
    fail "Oops. Frodo dies" unless $destroys-ring
};
throws-like { frodo }, Exception, message => /dies/;

sub fails-not-throws { +"a" }
# test passes, even though it's just a Failure and would not always throw: 
throws-like { fails-not-throws }, Exception;
 
# test detects nothing thrown, because our Failure wasn't sunk or made fatal: 
throws-like { no fatal; my $ = fails-not-throws; Nil }, Exception;

throws-like { EVAL q[ fac("foo") ] }, X::TypeCheck::Argument;

sub fails-like ( \test where Callable:D|Str:D, $ex-type, $reason?, *%matcher)

fails-like { +"a" }, X::Str::Numeric,
    :message(/'Cannot convert string to number'/),
    'converting non-numeric string to number fails';

multi subtest(Pair $what)
multi subtest($desc, &subtests)
multi subtest(&subtests, $desc = '')

class Womble {}
 
class GreatUncleBulgaria is Womble {
    has $.location = "Wimbledon Common";
    has $.spectacles = True;
}
 
subtest {
    my $womble = GreatUncleBulgaria.new;
 
    isa-ok $womble,            Womble,             "Correct type";
    is     $womble.location,   "Wimbledon Common", "Correct location";
    ok     $womble.spectacles,                     "Correct eyewear";
 
}, "Check Great Uncle Bulgaria";

subtest 'A bunch of tests', {
    plan 42;
    ...
    ...
}
 
subtest 'Another bunch of tests' => {
    plan 72;
    ...
    ...
}

multi todo($reason, $count = 1)

sub my-custom-pi { 3 };
 
todo 'not yet precise enough';         # Mark the test as TODO. 
is my-custom-pi(), pi, 'my-custom-pi'; # Run the test, but don't report 
                                       # failure in test harness. 

not ok 1 - my-custom-pi # TODO not yet precise enough
# Failed test 'my-custom-pi'
# at test-todo.rakutest line 7
# expected: '3.14159265358979'
#      got: '3'

multi skip()
multi skip($reason, $count = 1)

sub num-forward-slashes($arg) { ... } ;
 
if $*KERNEL ~~ 'linux' {
    is num-forward-slashes("/a/b"),             2;
    is num-forward-slashes("/a//b".IO.cleanup), 2;
}
else {
    skip "Can't use forward slashes on Windows", 2;
}

sub skip-rest($reason = '<unknown>')

my $location; sub womble { ... }; ...;
unless $location ~~ "Wimbledon Common" {
    skip-rest "We can't womble, the remaining tests will fail";
    exit;
}
 
# tests requiring functional wombling 
ok womble();
# ... 

sub bail-out ($desc?)

my $has-db-connection;
...
$has-db-connection  or bail-out 'Must have database connection for testing';

multi pass($desc = '')

pass "Actually, this test has passed";
flunk "But this one hasn't passed";

multi flunk($reason = '')

sub diag($message)

diag "Yay!  The tests got to here!";