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 Test2::Util::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¶

strict is turned on for you. You can disable this with the "-no_strict" or "-no_pragmas" import arguments:

    use Test2::V0 -no_strict => 1;

WARNINGS¶

warnings are turned on for you. You can disable this with the "-no_warnings" or "-no_pragmas" import arguments:

    use Test2::V0 -no_warnings => 1;

UTF8¶

This is actually done via the Test2::Plugin::UTF8 plugin, see the "PLUGINS" section for details.

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

SRAND¶

See Test2::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;

You can also disable this behavior:

    use Test2::V0 -no_srand => 1;

Note When srand is on (default) it can cause problems with things like File::Temp which will end up attempting the same "random" filenames for every test process started on a given day (or sharing the same seed).

UTF8¶

See Test2::Plugin::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¶

See Test2::Plugin::ExitSummary.

This plugin has no configuration.

TARGET¶

See Test2::Tools::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¶

See Test2::Tools::Defer.

def $func => @args;

do_def()

BASIC¶

See Test2::Tools::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¶

See Test2::Tools::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 = bool($bool)

$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¶

See Test2::Tools::ClassicCompare.

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

SUBTEST¶

See Test2::Tools::Subtest.

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

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

CLASS¶

See Test2::Tools::Class.

can_ok($thing, @methods)

isa_ok($thing, @classes)

DOES_ok($thing, @roles)

ENCODING¶

See Test2::Tools::Encoding.

set_encoding($encoding)

EXPORTS¶

See Test2::Tools::Exports.

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

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

REF¶

See Test2::Tools::Ref.

ref_ok($ref, $type)

ref_is($got, $want)

ref_is_not($got, $do_not_want)

See Test2::Tools::Refcount.

is_refcount($ref, $count, $description)

is_oneref($ref, $description)

$count = refcount($ref)

MOCK¶

See Test2::Tools::Mock.

$control = mock ...

$bool = mocked($thing)

EXCEPTION¶

See Test2::Tools::Exception.

$exception = dies { ... }

$bool = lives { ... }

$bool = try_ok { ... }

WARNINGS¶

See Test2::Tools::Warnings.

$count = warns { ... }

$warning = warning { ... }

$warnings_ref = warnings { ... }

$bool = no_warnings { ... }