Assert-Conditional
view release on metacpan or search on metacpan
t/asserts.t view on Meta::CPAN
#!/usr/bin/env perl
use strict;
use warnings;
use v5.10;
use utf8;
use charnames qw(:full);
#use Carp::Always;
use Cwd qw(abs_path);
use FindBin qw($Bin);
$| = 1;
use lib abs_path("$Bin/../lib");
use Config qw(%Config); # because it's tied
use Math::BigInt; # for overloads
use Env qw($PATH @PATH); # because they're tied
use Test::More;
use Test2::Tools::Exception qw(dies lives);
use IO::File;
use IO::Handle;
use Hash::Util qw(lock_keys unlock_keys);
use Assert::Conditional qw(:all -if 1);
use Assert::Conditional::Utils qw(:list);
my($junk, @junk) ;
my $undef;
my $zero = 0;
my $true = 1;
my $one = 1;
my $two = 2;
my $minus_two = -2;
my $float = 3.14;
my $string = "string";
my @empty = ();
my %empty;
my @stuff = ("a" .. "z");
my @ten = (1 .. 10);
my $class = "IO::File";
my $obj = $class->new();
my @primary_colors = qw(red green blue);
my @all_colors = (@primary_colors, qw(orange yellow cyan violet));
my @not_colors = qw(black white pink purple);
my %primary_color = map { $_ => 1 } @primary_colors;
my $primary_color_ref = \%primary_color;
my %locked_hash = %primary_color;
my $locked_hashref = \%locked_hash;
lock_keys %locked_hash;
my %unlocked_hash = %primary_color;
my $unlocked_hashref = \%unlocked_hash;
my %hash_of_hashes = (
LOCKED => $locked_hashref,
UNLOCKED => $unlocked_hashref,
);
my $hashref_of_hashes = \%hash_of_hashes;
my $ref_of_hashref_of_hashes = \\%hash_of_hashes;
my $bignum = Math::BigInt->new("1000");
my $tied_object = do {
no warnings "once";
tie *Tied_FH, "TieOut";
};
sub void_context { assert_void_context() }
sub nonvoid_context { assert_nonvoid_context() }
sub list_context { assert_list_context() }
sub nonlist_context { assert_nonlist_context() }
sub scalar_context { assert_scalar_context() }
my @good_tests = (
q{assert_defined(1) },
q{assert_defined_value(1) },
q{assert_undefined(undef) },
q{assert_defined("string") },
q{assert_defined_value("string") },
q{assert_defined_variable($true) },
q{@junk = list_context() },
q{$junk = nonlist_context() },
q{@junk = nonvoid_context() },
q{nonlist_context(); 0 },
q{void_context(); 1 },
q{$junk = nonvoid_context() },
q{$junk = scalar_context() },
q{@junk = list_context() },
q{assert_false(!1) },
q{assert_false(0) },
q{assert_false(q()) },
q{assert_false(undef) },
q{assert_true('0 but true') },
q{assert_true(1) },
q{assert_is($one, $one)},
q{assert_is($float, $float)},
q{assert_is(@stuff, @stuff)},
q{assert_isnt($one, $two)},
t/asserts.t view on Meta::CPAN
q{assert_multi_line("one\rtwo\f")},
q{assert_multi_line("abc\x{000A} ")},
q{assert_multi_line("abc\x{000B} ")},
q{assert_multi_line("abc\x{000C} ")},
q{assert_multi_line("abc\x{000D} ")},
q{assert_multi_line("abc\x{0085} ")},
q{assert_multi_line("abc\x{2028} ")},
q{assert_multi_line("abc\x{2029} ")},
q{assert_single_paragraph("one")},
q{assert_single_paragraph("one\f")},
q{assert_single_paragraph("one\r\n")},
q{assert_single_paragraph("one\n\n\f")},
q{assert_bytes("abc")},
q{assert_bytes("\xA0")},
q{assert_nonbytes("\x{223}")},
q{assert_wide_characters("\x{223}")},
q{assert_nonascii("\x{223}")},
q{assert_ascii("zzz")},
q{assert_alphabetic("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_nonalphabetic("~!")},
q{assert_alnum("abc39sd")},
q{assert_digits("12349120")},
q{assert_uppercased("THIS OLD MAN!")},
q{assert_lowercased("this old man!")},
q{assert_unicode_ident("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_simple_perl_ident("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_full_perl_ident("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_qualified_ident("main::ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_ascii_ident("nino")},
q{assert_regex(qr/foo/)},
q{assert_like("foo", qr/f/)},
q{assert_unlike("foo", qr/z/)},
q{assert_latin1("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_latinish("Henry \N{ROMAN NUMERAL EIGHT}")},
q{assert_astral("\x{012345}")},
q{assert_nonastral("fred")},
q{assert_bmp("ni\x{223}o")},
q{assert_nfc("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_nfd("nin\x{303}o")},
q{assert_nfkc("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_nfkd("nin\x{303}o")},
q{assert_eq("ni\N{LATIN SMALL LETTER N WITH TILDE}o", "nin\x{303}o")},
q{assert_eq_letters("----one, two", "ONE, TWO")},
q{assert_eq_letters("one, two", "ONE, TWO")},
q{assert_eq_letters("one, two", "ONE TWO")},
q{assert_eq_letters("one two", "ONE TWO")},
q{assert_eq_letters("one two", "ONE, TWO")},
q{assert_in_list("red", qw(one fish two fish red fish blue fish))},
q{assert_in_list(5, 1 .. 10)},
q{assert_in_list(5, 1, 3, undef, [], 5, 10)},
q{assert_in_list(\@ARGV, 1, 3, undef, \@ARGV, 5, 10)},
q{assert_in_list(undef, 1 .. 10, undef)},
q{assert_in_list(undef, undef)},
q{assert_not_in_list("red", qw(one fish two fish fish blue fish))},
q{assert_not_in_list(5, 6 .. 10)},
q{assert_not_in_list(1, 20 .. 30)},
q{assert_not_in_list(5, 1, 3, undef, [], 10)},
q{assert_not_in_list(undef, 1 .. 10)},
q{assert_not_in_list(undef)},
q{assert_list_nonempty( 1..10 )},
q{assert_array_nonempty( @stuff )},
q{assert_arrayref_nonempty( \@stuff )},
q{assert_arrayref_nonempty( [1..5] )},
q{assert_array_length(@ten)},
q{assert_array_length(@ten, 10)},
q{assert_array_length_min(@ten, 5)},
q{assert_array_length_max(@ten, 10)},
q{assert_array_length_minmax(@ten, 5, 20)},
q{ no warnings 'redefine'; sub fn0 { assert_argc_min(5) } fn0(localtime()) },
q{ no warnings 'redefine'; sub fn1($) { assert_argc(1) } fn1(localtime()) },
q{ no warnings 'redefine'; sub fn2 { assert_argc(3) } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_max(3) } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_max(5) } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_minmax(1,5) } fn2(1, 2, 3) },
q{assert_hash_nonempty(%primary_color)},
q{assert_hashref_nonempty(\%primary_color)},
q{assert_hash_keys(%primary_color, qw<red blue green>)},
q{assert_hashref_keys(\%primary_color, qw<red blue green>)},
q{assert_hash_keys_required(%primary_color, qw<red blue green>)},
q{assert_hash_keys_allowed(%primary_color, qw<red blue green>)},
q{assert_hash_keys_required_and_allowed(%primary_color, ["red"], [qw<red blue green>])},
q{assert_hashref_keys_required_and_allowed(\\%primary_color, ["red"], [qw<red blue green>])},
q{assert_hashref_keys_required_and_allowed($primary_color_ref, ["red"], [qw<red blue green>])},
q{assert_hash_keys_allowed_and_required(%primary_color, [qw<red blue green>], ["red"])},
q{assert_hashref_keys_allowed_and_required(\\%primary_color, [qw<red blue green>], ["red"])},
q{assert_hashref_keys_allowed_and_required($primary_color_ref, [qw<red blue green>], ["red"])},
q{assert_hashref_keys_required(\\%primary_color, qw<red blue green>)},
q{assert_hashref_keys_allowed(\\%primary_color, qw<red blue green>)},
q{assert_hashref_keys_required($primary_color_ref, qw<red blue green>)},
q{assert_hashref_keys_allowed($primary_color_ref, qw<red blue green>)},
q{assert_keys(%primary_color, qw<red blue green>)},
q{assert_keys(%primary_color, @primary_colors)},
q{assert_keys($primary_color_ref, qw<red blue green>)},
q{assert_keys($primary_color_ref, @primary_colors)},
q{assert_min_keys(%primary_color, qw<red blue green>)},
q{assert_min_keys(%primary_color, @primary_colors)},
q{assert_min_keys($primary_color_ref, qw<red blue green>)},
q{assert_min_keys($primary_color_ref, @primary_colors)},
q{assert_max_keys(%primary_color, qw<red orange yellow green blue violet>)},
q{assert_max_keys(%primary_color, @all_colors)},
q{assert_max_keys($primary_color_ref, qw<red orange yellow green blue violet>)},
q{assert_max_keys($primary_color_ref, @all_colors)},
q{assert_minmax_keys(%primary_color, @primary_colors, @all_colors)},
q{assert_minmax_keys($primary_color_ref, @primary_colors, @all_colors)},
t/asserts.t view on Meta::CPAN
q{assert_coderef()},
q{assert_defined()},
q{assert_defined_value()},
q{assert_defined_variable()},
q{assert_digits()},
q{assert_directory()},
q{assert_does()},
q{assert_doesnt()},
q{assert_empty()},
q{assert_eq()},
q{assert_eq_letters()},
q{assert_even_number()},
q{assert_false()},
q{assert_fractional()},
q{assert_fractional($one)},
q{assert_full_perl_ident()},
q{assert_globref()},
q{assert_happy_code()},
q{assert_hash_keys()},
q{assert_hash_nonempty()},
q{assert_hashref()},
q{assert_hashref_keys()},
q{assert_hashref_nonempty()},
q{assert_hex_number()},
q{assert_in_list()},
q{assert_in_numeric_range()},
q{assert_integer()},
q{assert_ioref()},
q{assert_is()},
q{assert_isa()},
q{assert_isnt()},
q{assert_known_package()},
q{assert_latin1()},
q{assert_latinish()},
q{assert_like()},
q{assert_list_nonempty()},
q{assert_lowercased()},
q{assert_multi_line()},
q{assert_natural_number()},
q{assert_negative()},
q{assert_negative_integer()},
q{assert_nfc()},
q{assert_nfd()},
q{assert_nfkc()},
q{assert_nfkd()},
q{assert_nonalphabetic()},
q{assert_nonascii()},
q{assert_nonastral()},
q{assert_nonblank()},
q{assert_nonblank(" ")},
q{assert_nonbytes()},
q{assert_nonempty()},
q{assert_nonnegative()},
q{assert_nonnegative_integer()},
q{assert_nonnumeric()},
q{assert_nonobject()},
q{assert_nonpositive()},
q{assert_nonpositive_integer()},
q{assert_nonref()},
q{assert_nonzero()},
q{assert_not_in_list()},
q{assert_numeric()},
q{assert_object()},
q{assert_odd_number()},
q{assert_open_handle()},
q{assert_positive()},
q{assert_positive_integer()},
q{assert_qualified_ident()},
q{assert_reftype()},
q{assert_regex()},
q{assert_regular_file()},
q{assert_scalarref()},
q{assert_signed_number()},
q{assert_signed_number(42)},
q{assert_simple_perl_ident()},
q{assert_single_line()},
q{assert_single_paragraph()},
q{assert_text_file()},
q{assert_true()},
q{assert_undefined()},
q{assert_unhappy_code()},
q{assert_unicode_ident()},
q{assert_unlike()},
q{assert_uppercased()},
q{assert_whole_number()},
q{assert_wide_characters()},
q{assert_zero()},
q{assert_is($one, $two)},
q{assert_is($one, $undef)},
q{assert_defined(undef) },
q{assert_defined($undef) },
q{assert_defined_value(undef) },
q{assert_defined_variable($undef) },
q{assert_undefined(1) },
q{assert_defined_variable(!1) },
q{assert_undefined({}) },
q{assert_undefined_value({}) },
q{$junk = list_context() },
q{assert_defined($undef) },
q{$junk = list_context() },
q{@junk = scalar_context() },
q{@junk = void_context() },
q{list_context(); 1 },
q{nonvoid_context(); 1 },
q{scalar_context(); 1 },
q{$junk = void_context() },
q{@junk = nonlist_context() },
q{assert_true(!1) },
q{assert_true(0) },
q{assert_true(1,1) },
q{assert_true(q()) },
q{assert_true(q(), 4) },
q{assert_true(undef) },
q{assert_true(undef, undef) },
q{assert_false('0 but true') },
q{assert_false(1) },
q{assert_false(1,1) },
q{assert_numeric($string)},
q{assert_nonnumeric(42)},
q{assert_nonnumeric($one)},
q{assert_nonnumeric($float)},
t/asserts.t view on Meta::CPAN
q{assert_wide_characters("x")},
q{assert_nonascii("223")},
q{assert_ascii("\xa0")},
q{assert_nonalphabetic("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_alphabetic("~!")},
q{assert_alnum("abc%39sd")},
q{assert_digits("1234asbc9120")},
q{assert_lowercased("THIS OLD MAN!")},
q{assert_uppercased("this old man!")},
q{assert_uppercased("BA\N{LATIN SMALL LETTER SHARP S}")},
q{assert_unicode_ident("_ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_simple_perl_ident("ni\xa2o")},
q{assert_full_perl_ident("ni\xa2o")},
q{assert_qualified_ident("main::ni\xa2o")},
q{assert_qualified_ident("main")},
q{assert_ascii_ident("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_regex(q/foo/)},
q{assert_like("foo", q/f/)},
q{assert_like("foo", qr/z/)},
q{assert_unlike("foo", qr/f/)},
q{assert_latin1("\x{189}")},
q{assert_latin1("Henry \x{2167}")},
q{assert_latinish("\x{F0FF}")},
q{assert_astral("\x{F0FF}")},
q{assert_nonastral("\x{12345}")},
q{assert_bmp("ni\x{12223}o")},
q{assert_nfc("\x{212A}")}, # Singleton
q{assert_nfd("\x{212A}")},
q{assert_nfkc("\x{212A}")},
q{assert_nfkd("\x{212A}")},
q{assert_nfd("ni\N{LATIN SMALL LETTER N WITH TILDE}o")},
q{assert_nfc("nin\x{303}o")},
q{assert_nfkc("\x{a0}")},
q{assert_nfkd("\x{a0}")},
q{assert_nfkd("\x{bc}")},
q{assert_eq("ni\N{LATIN SMALL LETTER N WITH TILDE}o", "nin\x{304}o")},
q{assert_eq_letters("one, tow", "ONE")},
q{assert_isnt($one, $one)},
q{assert_isnt($bignum, $bignum)},
q{assert_isnt($tied_object, $tied_object)},
q{ no warnings 'redefine'; sub fn0 { assert_argc_min(15) } fn0(localtime()) },
q{ no warnings 'redefine'; sub fn1($) { assert_argc(0) } fn1(localtime()) },
q{ no warnings 'redefine'; sub fn2 { assert_argc(2) } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc } fn2() },
q{ no warnings 'redefine'; sub fn2 { assert_argc_max(2) } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_max(2) } fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_minmax(10,25) }fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_minmax(2,1) }fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_minmax(25,10) }fn2(1, 2, 3) },
q{ no warnings 'redefine'; sub fn2 { assert_argc_minmax(1,2) }fn2(1, 2, 3) },
q{assert_in_list("red", qw(one fish two fish fish blue fish))},
q{assert_in_list(5, 6 .. 10)},
q{assert_in_list(1, 20 .. 30)},
q{assert_in_list(5, 1, 3, undef, [], 10)},
q{assert_in_list(undef, 1 .. 10)},
q{assert_in_list(undef)},
q{assert_not_in_list("red", qw(one fish two fish red fish blue fish))},
q{assert_not_in_list(5, 1 .. 10)},
q{assert_not_in_list(5, 1, 3, undef, [], 5, 10)},
q{assert_not_in_list(\@ARGV, 1, 3, undef, \@ARGV, 5, 10)},
q{assert_not_in_list(undef, 1 .. 10, undef)},
q{assert_not_in_list(undef, undef)},
q{assert_list_nonempty( () )},
q{assert_array_nonempty( @some::thing )},
q{assert_arrayref_nonempty( \@some::thing )},
q{assert_arrayref_nonempty( [ ] )},
q{assert_array_length(@empty)},
q{assert_array_length(@empty, 10)},
q{assert_array_length_min(@empty, 5)},
q{assert_array_length_max(@primary_colors, 1)},
q{assert_array_length_minmax(@empty, 5, 20)},
q{assert_array_length_minmax(@empty, -5, -2)},
q{assert_array_length_minmax(@empty, -5, 20)},
q{assert_array_length_minmax(@empty, 25, 5)},
q{assert_array_length_minmax(@primary_colors, 1, 2)},
q{assert_hash_nonempty(%empty)},
q{assert_hashref_nonempty(\%empty)},
q{assert_hash_keys(%empty, qw<HOME PATH USER>)},
q{assert_hashref_keys(\%empty, qw<HOME PATH USER>)},
q{assert_hash_keys_required(@junk, qw<yellow violet cyan>)},
q{assert_hash_keys_required(%primary_color, @empty)},
q{assert_hash_keys_required(%primary_color, qw<yellow violet cyan>)},
q{assert_hash_keys_required(%primary_color, qw<pink purple>)},
q{assert_hash_keys_allowed(%primary_color, qw<yellow violet cyan>)},
q{assert_hash_keys_allowed(%primary_color, qw<pink purple>)},
q{assert_hash_keys_allowed(%primary_color, qw<red>)},
q{assert_hash_keys_allowed(%primary_color, @empty)},
q{assert_hashref_keys_required(%primary_color, qw<yellow violet cyan>)},
q{assert_hashref_keys_allowed(%primary_color, qw<yellow violet cyan>)},
q{assert_hashref_keys_required(\%primary_color, qw<yellow violet cyan>)},
q{assert_hashref_keys_allowed(\%primary_color, qw<yellow violet cyan>)},
q{assert_hash_keys_required_and_allowed(%primary_color, [qw<red blue green>], ["red"])},
q{assert_hash_keys_required_and_allowed(%primary_color, [qw<red blue green>], [])},
q{assert_hash_keys_required_and_allowed(%primary_color, [], [])},
q{assert_hashref_keys_required_and_allowed(\\%primary_color, [qw<red blue green>], ["red"])},
q{assert_hashref_keys_required_and_allowed($primary_color_ref, [qw<red blue green>], ["red"])},
q{assert_hash_keys_allowed_and_required(%primary_color, ["red"], [qw<red blue green>])},
q{assert_hash_keys_allowed_and_required(%primary_color, [], [qw<red blue green>])},
q{assert_hash_keys_allowed_and_required(%primary_color, [], [])},
q{assert_hashref_keys_allowed_and_required(\\%primary_color,, ["red"] [qw<red blue green>])},
q{assert_hashref_keys_allowed_and_required($primary_color_ref, ["red"], [qw<red blue green>])},
q{assert_hashref_keys_required(\\%primary_color, qw<red pink green>)},
q{assert_hashref_keys_allowed(\\%primary_color, qw<red pink green>)},
q{assert_hashref_keys_required($primary_color_ref, qw<red pink green>)},
q{assert_hashref_keys_allowed($primary_color_ref, qw<red pink green>)},
q{assert_keys(%primary_color, qw<red pink green>)},
q{assert_keys(%primary_color, @all_colors)},
q{assert_keys(%primary_color, @not_colors)},
q{assert_keys(%primary_color, @empty)},
q{assert_keys($primary_color_ref, qw<red pink green>)},
q{assert_keys($primary_color_ref, @all_colors)},
q{assert_keys($primary_color_ref, @not_colors)},
q{assert_keys($primary_color_ref, @empty)},
q{assert_min_keys(%primary_color, qw<red pink green>)},
q{assert_min_keys(%primary_color, @empty)},
q{assert_min_keys(%primary_color, @all_colors)},
q{assert_min_keys(%primary_color, @not_colors)},
q{assert_min_keys($primary_color_ref, qw<red pink green>)},
q{assert_min_keys($primary_color_ref, @all_colors)},
q{assert_min_keys($primary_color_ref, @not_colors)},
q{assert_max_keys(%primary_color, qw<orange yellow violet>)},
q{assert_max_keys(%primary_color, @not_colors)},
q{assert_max_keys(%primary_color, @empty)},
q{assert_max_keys($primary_color_ref, qw<orange yellow violet>)},
q{assert_max_keys($primary_color_ref, @not_colors)},
q{assert_minmax_keys(%primary_color, @all_colors, @primary_color)},
q{assert_minmax_keys($primary_color_ref, @all_colors, @primary_colors)},
q{assert_minmax_keys(%primary_color, @empty, @empty)},
q{assert_minmax_keys($primary_color_ref, @empty, @empty)},
q{assert_unlocked(%locked_hash)},
q{assert_unlocked($locked_hashref)},
q{assert_unlocked($hash_of_hashes{LOCKED})},
q{assert_unlocked($hashref_of_hashes->{LOCKED})},
q{assert_unlocked($$ref_of_hashref_of_hashes->{LOCKED})},
q{assert_locked(%unlocked_hash)},
q{assert_locked($unlocked_hashref)},
q{assert_locked($$ref_of_hashref_of_hashes)},
q{assert_locked($hash_of_hashes{UNLOCKED})},
q{assert_locked($hashref_of_hashes->{UNLOCKED})},
q{assert_locked($$ref_of_hashref_of_hashes->{UNLOCKED})},
q{assert_anyref( "string" )},
q{assert_anyref( 0 )},
q{assert_anyref( $0 )},
q{assert_anyref( *0 )},
q{assert_anyref( @ARGV )},
q{assert_anyref( )},
q{assert_anyref( %ENV )},
q{assert_anyref( defined &lives )},
q{assert_anyref( time() )},
q{assert_anyref( localtime() )},
q{assert_anyref( *STDIN )},
q{assert_anyref( @{ *ARGV{ARRAY} } )},
q{assert_anyref( @{ *{$main::{ARGV}}{ARRAY} } )},
q{assert_reftype( ARRAY => \"string" )},
q{assert_reftype( ARRAY => \0 )},
q{assert_reftype( ARRAY => \$0 )},
q{assert_reftype( ARRAY => *0{SCALAR} )},
q{assert_reftype( REFREF => \\\$0 )},
q{assert_reftype( SCALAR => \@ARGV )},
q{assert_reftype( ARRAY => \\\\\@ARGV )},
q{assert_reftype( STRING => [ ] )},
q{assert_reftype( CODE => \%ENV )},
q{assert_reftype( CODE => { } )},
q{assert_reftype( ARRAY => sub { } )},
q{assert_reftype( CODE => time() )},
q{assert_reftype( IO => \time() )},
q{assert_reftype( HASH => \*ENV )},
q{assert_reftype( "IO::Handle" => *STDIN{IO} )},
q{assert_reftype( GLOB => *ARGV{ARRAY} )},
q{assert_reftype( HASH => *{$main::{ARGV}}{ARRAY} )},
q{assert_hashref( \"string" )},
q{assert_hashref( \0 )},
q{assert_hashref( \$0 )},
q{assert_hashref( *0{SCALAR} )},
q{assert_scalarref( \\\$0 )},
q{assert_arrayref( \\\\\\@ARGV )},
q{assert_hashref( \@ARGV )},
q{assert_hashref( [ ] )},
q{assert_arrayref( \%ENV )},
( run in 0.675 second using v1.01-cache-2.11-cpan-39bf76dae61 )