TAGS

:DEFAULT

The following are both identical:

    use Test2::V0;

    use Test2::V0 ':DEFAULT';
    

RENAMING ON IMPORT

    use Test2::V0 ':DEFAULT', '!ok', ok => {-as => 'my_ok'};

This bundle uses Importer for exporting, as such you can use any arguments it accepts.

Explanation:

'!ok'

Do not export "ok()"

ok => {-as => 'my_ok'}

Actually, go ahead and import "ok()" but under the name "my_ok()".

If you did not add the '!ok' argument then you would have both "ok()" and "my_ok()"

STRICT

    use Test2::V0 -no_strict => 1;

WARNINGS

    use Test2::V0 -no_warnings => 1;

UTF8

Note: "-no_pragmas => 1" will turn off the entire plugin.

SRAND

This will set the random seed to today's date. You can provide an alternate seed with the "-srand" import option:

    use Test2::V0 -srand => 1234;

UTF8

This will set the file, and all output handles (including formatter handles), to utf8. This will turn on the utf8 pragma for the current scope.

This can be disabled using the "-no_utf8 => 1" or "-no_pragmas => 1" import arguments.

    use Test2::V0 -no_utf8 => 1;

EXIT SUMMARY

This plugin has no configuration.

TARGET

You can specify a target class with the "-target" import argument. If you do not provide a target then $CLASS and "CLASS()" will not be imported.

    use Test2::V0 -target => 'My::Class';

    print $CLASS;  # My::Class
    print CLASS(); # My::Class

Or you can specify names:

    use Test2::V0 -target => { pkg => 'Some::Package' };

    pkg()->xxx; # Call 'xxx' on Some::Package
    $pkg->xxx;  # Same

$CLASS

Package variable that contains the target class name.

$class = CLASS()

Constant function that returns the target class name.

DEFER

def $func => @args;

do_def()

BASIC

ok($bool, $name)

ok($bool, $name, @diag)

pass($name)

pass($name, @diag)

fail($name)

fail($name, @diag)

diag($message)

note($message)

$todo = todo($reason)

todo $reason => sub { ... }

skip($reason, $count)

plan($count)

skip_all($reason)

done_testing()

bail_out($reason)

COMPARE

is($got, $want, $name)

isnt($got, $do_not_want, $name)

like($got, qr/match/, $name)

unlike($got, qr/mismatch/, $name)

$check = match(qr/pattern/)

$check = mismatch(qr/pattern/)

$check = validator(sub { return $bool })

$check = hash { ... }

$check = array { ... }

$check = bag { ... }

$check = object { ... }

$check = meta { ... }

$check = number($num)

$check = string($str)

$check = check_isa($class_name)

$check = in_set(@things)

$check = not_in_set(@things)

$check = check_set(@things)

$check = item($thing)

$check = item($idx => $thing)

$check = field($name => $val)

$check = call($method => $expect)

$check = call_list($method => $expect)

$check = call_hash($method => $expect)

$check = prop($name => $expect)

$check = check($thing)

$check = T()

$check = F()

$check = D()

$check = DF()

$check = E()

$check = DNE()

$check = FDNE()

$check = U()

$check = L()

$check = exact_ref($ref)

end()

etc()

filter_items { grep { ... } @_ }

$check = event $type => ...

@checks = fail_events $type => ...

CLASSIC COMPARE

cmp_ok($got, $op, $want, $name)

SUBTEST

subtest $name => sub { ... };

(Note: This is called "subtest_buffered()" in the Tools module.)

CLASS

can_ok($thing, @methods)

isa_ok($thing, @classes)

DOES_ok($thing, @roles)

ENCODING

set_encoding($encoding)

EXPORTS

imported_ok('function', '$scalar', ...)

not_imported_ok('function', '$scalar', ...)

REF

ref_ok($ref, $type)

ref_is($got, $want)

ref_is_not($got, $do_not_want)

MOCK

$control = mock ...

$bool = mocked($thing)

EXCEPTION

$exception = dies { ... }

$bool = lives { ... }

$bool = try_ok { ... }

WARNINGS

$count = warns { ... }

$warning = warning { ... }

$warnings_ref = warnings { ... }

$bool = no_warnings { ... }