Assert-Conditional
view release on metacpan or search on metacpan
lib/Assert/Conditional.pm view on Meta::CPAN
sub assert_nonblank ( $ ) ;
sub assert_nonbytes ( $ ) ;
sub assert_nonempty ( $ ) ;
sub assert_nonlist_context ( ) ;
sub assert_nonnegative ( $ ) ;
sub assert_nonnegative_integer ( $ ) ;
sub assert_nonnumeric ( $ ) ;
sub assert_nonobject ( $ ) ;
sub assert_nonpositive ( $ ) ;
sub assert_nonpositive_integer ( $ ) ;
sub assert_nonref ( $ ) ;
sub assert_nonvoid_context ( ) ;
sub assert_nonzero ( $ ) ;
sub assert_not_in_list ( $@ ) ;
sub assert_numeric ( $ ) ;
sub assert_object ( $ ) ;
sub assert_object_ainta ( $@ ) ;
sub assert_object_boolifies ( $ ) ;
sub assert_object_can ( $@ ) ;
sub assert_object_cant ( $@ ) ;
sub assert_object_isa ( $@ ) ;
sub assert_object_method ( ) ;
sub assert_object_nummifies ( $ ) ;
sub assert_object_overloads ( $@ ) ;
sub assert_object_stringifies ( $ ) ;
sub assert_odd_number ( $ ) ;
sub assert_open_handle ( $ ) ;
sub assert_positive ( $ ) ;
sub assert_positive_integer ( $ ) ;
sub assert_private_method ( ) ;
sub assert_protected_method ( ) ;
sub assert_public_method ( ) ;
sub assert_qualified_ident ( $ ) ;
sub assert_refref ( $ ) ;
sub assert_reftype ( $$ ) ;
sub assert_regex ( $ ) ;
sub assert_regular_file ( $ ) ;
sub assert_sad_exit ( ;$ ) ;
sub assert_scalar_context ( ) ;
sub assert_scalarref ( $ ) ;
sub assert_signalled ( ;$ ) ;
sub assert_signed_number ( $ ) ;
sub assert_simple_perl_ident ( $ ) ;
sub assert_single_line ( $ ) ;
sub assert_single_paragraph ( $ ) ;
sub assert_text_file ( $ ) ;
sub assert_tied ( \[$@%*] ) ;
sub assert_tied_array ( \@ ) ;
sub assert_tied_arrayref ( $ ) ;
sub assert_tied_glob ( \* ) ;
sub assert_tied_globref ( $ ) ;
sub assert_tied_hash ( \% ) ;
sub assert_tied_hashref ( $ ) ;
sub assert_tied_referent ( $ ) ;
sub assert_tied_scalar ( \$ ) ;
sub assert_tied_scalarref ( $ ) ;
sub assert_true ( $ ) ;
sub assert_unblessed_ref ( $ ) ;
sub assert_undefined ( $ ) ;
sub assert_unhappy_code ( & ) ;
sub assert_unicode_ident ( $ ) ;
sub assert_unlike ( $$ ) ;
sub assert_unlocked ( \[%$] @ ) ;
sub assert_unsignalled ( ;$ ) ;
sub assert_untied ( \[$@%*] ) ;
sub assert_untied_array ( \@ ) ;
sub assert_untied_arrayref ( $ ) ;
sub assert_untied_glob ( \* ) ;
sub assert_untied_globref ( $ ) ;
sub assert_untied_hash ( \% ) ;
sub assert_untied_hashref ( $ ) ;
sub assert_untied_referent ( $ ) ;
sub assert_untied_scalar ( \$ ) ;
sub assert_untied_scalarref ( $ ) ;
sub assert_uppercased ( $ ) ;
sub assert_void_context ( ) ;
sub assert_whole_number ( $ ) ;
sub assert_wide_characters ( $ ) ;
sub assert_zero ( $ ) ;
############################################################
sub import {
my ($package, @conditional_imports) = @_;
my @normal_imports = $package->_strip_import_conditions(@conditional_imports);
if ($Assert_Never) { $package->SUPER::import(@normal_imports, -if => 0) }
elsif ($Assert_Always) { $package->SUPER::import(@normal_imports, -if => 1) }
else { $package->SUPER::import(@conditional_imports ) }
$package->_reimport_nulled_code_protos();
}
# This is just pretty extreme, but it's also about the only way to
# make the Exporter shut up about things we sometimes need to do in
# this module.
#
# Well, not quite the only way: there's always local *SIG. :)
#
# Otherwise it dribbles all over your screen when you try more than one
# import, like importing a set and then reneging on a few of them.
#
# Newer versions of Carp appear not to need these heroics.
sub export_to_level {
my($package, $level, @export_args) = @_;
state $old_carp = \&Carp::carp;
state $filters = [
qr/^Constant subroutine \S+ redefined/,
qr/^Subroutine \S+ redefined/,
qr/^Prototype mismatch:/,
];
no warnings "redefine";
local *Carp::carp = sub {
my($text) = @_;
$text =~ $_ && return for @$filters;
local $Carp::CarpInternal{"Exporter::Heavy"} = 1;
$old_carp->($text);
};
$package->SUPER::export_to_level($level+2, @export_args);
}
lib/Assert/Conditional.pm view on Meta::CPAN
sub assert_nonascii($)
:Assert( qw[string regex] )
{
local($_) = @_;
/\P{ascii}/x || botch "expected non-ASCII in string";
}
sub assert_ascii($)
:Assert( qw[string regex] )
{
local($_) = @_;
/^ \p{ASCII} + \z/x || botch "expected only ASCII in string";
}
sub assert_alphabetic($)
:Assert( qw[string regex] )
{
local($_) = @_;
/^ \p{alphabetic} + \z/x || botch "expected only alphabetics in string";
}
sub assert_nonalphabetic($)
:Assert( qw[string regex] )
{
local($_) = @_;
/^ \P{alphabetic} + \z/x || botch "expected only non-alphabetics in string";
}
sub assert_alnum($)
:Assert( qw[regex] )
{
local($_) = @_;
/^ \p{alnum} + \z/x || botch "expected only alphanumerics in string";
}
sub assert_digits($)
:Assert( qw[regex number] )
{
local($_) = @_;
/^ [0-9] + \z/x || botch "expected only ASCII digits in string";
}
sub assert_uppercased($)
:Assert( qw[case regex] )
{
local($_) = @_;
($] >= 5.014
? ! /\p{Changes_When_Uppercased}/
: $_ eq uc ) || botch "changes case when uppercased";
}
sub assert_lowercased($)
:Assert( qw[case regex] )
{
local($_) = @_;
($] >= 5.014
? ! /\p{Changes_When_Lowercased}/
: $_ eq lc ) || botch "changes case when lowercased";
}
sub assert_unicode_ident($)
:Assert( qw[regex] )
{
local($_) = @_;
/^ \p{XID_Start} \p{XID_Continue}* \z/x
|| botch "invalid identifier $_";
}
# This is a lie.
my $perl_simple_ident_rx = qr{
\b
[\p{gc=Connector_Punctuation}\p{XID_Start}]
\p{XID_Continue} *+
\b
}x;
my $perl_qualified_ident_rx = qr{
(?: $perl_simple_ident_rx
| (?: :: | ' )
) +
}x;
sub assert_simple_perl_ident($)
:Assert( qw[regex ident] )
{
local($_) = @_;
/^ $perl_simple_ident_rx \z/x
|| botch "invalid simple perl identifier $_";
}
sub assert_full_perl_ident($)
:Assert( qw[regex ident] )
{
local($_) = @_;
/^ $perl_qualified_ident_rx \z/x
|| botch "invalid qualified perl identifier $_";
}
sub assert_qualified_ident($)
:Assert( qw[regex ident] )
{
&assert_full_perl_ident;
local($_) = @_;
/(?: ' | :: ) /x || botch "no package separators in $_";
}
sub assert_ascii_ident($)
:Assert( qw[regex ident] )
{
local($_) = @_;
/^ (?= \p{ASCII}+ \z) (?! \d) \w+ \z/x
|| botch q(expected only ASCII \\w characters in string);
}
sub assert_regex($)
:Assert( qw[regex] )
{
my($pattern) = @_;
assert_isa($pattern, "Regexp");
}
sub assert_like($$)
:Assert( qw[regex] )
{
my($string, $pattern) = @_;
assert_defined($string);
assert_nonref($string);
assert_regex($pattern);
$string =~ $pattern || botch "'$string' did not match $pattern";
}
sub assert_unlike($$)
:Assert( qw[regex] )
{
my($string, $pattern) = @_;
assert_defined($string);
assert_nonref($string);
assert_regex($pattern);
$string !~ $pattern || botch "'$string' should not match $pattern";
}
sub assert_latin1($)
:Assert( qw[string unicode] )
{
&assert_bytes;
}
sub assert_latinish($)
:Assert( qw[unicode] )
{
local($_) = @_;
/^[\p{Latin}\p{Common}\p{Inherited}]+/
|| botch "expected only Latinish characters in string";
}
sub assert_astral($)
:Assert( qw[unicode] )
{
local($_) = @_;
no warnings "utf8"; # early versions of perl complain of illegal for interchange on FFFF
/[^\x00-\x{FFFF}]/x || botch "expected non-BMP characters in string";
}
sub assert_nonastral($)
:Assert( qw[unicode] )
{
local($_) = @_;
no warnings "utf8"; # early versions of perl complain of illegal for interchange on FFFF
/^ [\x00-\x{FFFF}] * \z/x || botch "unexpected non-BMP characters in string";
}
sub assert_bmp($)
:Assert( qw[unicode] )
{
&assert_nonastral;
}
sub assert_nfc($)
:Assert( qw[unicode] )
{
my($str) = @_;
checkNFC($str) // $str eq NFC($str)
|| botch "string not in NFC form";
}
sub assert_nfkc($)
:Assert( qw[unicode] )
{
my($str) = @_;
checkNFKC($str) // $str eq NFKC($str)
|| botch "string not in NFKC form";
}
sub assert_nfd($)
:Assert( qw[unicode] )
{
my($str) = @_;
checkNFD($str) || botch "string not in NFD form";
}
sub assert_nfkd($)
:Assert( qw[unicode] )
{
my($str) = @_;
checkNFKD($str) || botch "string not in NFKD form";
}
sub assert_eq($$)
:Assert( qw[string unicode] )
{
my($this, $that) = @_;
NFC($this) eq NFC($that) || botch "'$this' and '$that' are not equivalent Unicode strings";
}
sub assert_eq_letters($$)
:Assert( qw[string unicode] )
{
my($this, $that) = @_;
UCA1($this) eq UCA1($that) || botch "'$this' and '$that' do not equivalent letters"
}
sub assert_in_list($@)
:Assert( qw[list] )
{
my($needle, @haystack) = @_;
#assert_nonref($needle);
my $undef_needle = !defined($needle);
for my $straw (@haystack) {
#assert_nonref($straw);
return if $undef_needle
? !defined($straw)
: ("$needle" eq (defined($straw) && "$straw"))
}
$needle = "undef" unless defined $needle;
botch "couldn't find $needle in " . join(", " => map { defined() ? $_ : "undef" } @haystack);
}
sub assert_not_in_list($@)
:Assert( qw[list] )
{
my($needle, @haystack) = @_;
my $found = 0;
for my $straw (@haystack) {
if (defined $needle) {
next if !defined $straw;
if ("$needle" eq "$straw") {
$found = 1;
last;
}
} else {
next if defined $straw;
$found = 1;
last;
}
}
return unless $found;
$needle = "undef" unless defined $needle;
botch "found $needle in forbidden list";
}
sub assert_list_nonempty( @ )
:Assert( qw[list array] )
{
@_ || botch "list is empty";
}
sub assert_array_nonempty( \@ )
:Assert( qw[array] )
{
&assert_arrayref_nonempty;
}
sub assert_arrayref_nonempty( $ )
:Assert( qw[array] )
{
&assert_array_length;
lib/Assert/Conditional.pm view on Meta::CPAN
assert_nonblank ( $ ) ;
assert_nonbytes ( $ ) ;
assert_nonempty ( $ ) ;
assert_nonlist_context ( ) ;
assert_nonnegative ( $ ) ;
assert_nonnegative_integer ( $ ) ;
assert_nonnumeric ( $ ) ;
assert_nonobject ( $ ) ;
assert_nonpositive ( $ ) ;
assert_nonpositive_integer ( $ ) ;
assert_nonref ( $ ) ;
assert_nonvoid_context ( ) ;
assert_nonzero ( $ ) ;
assert_not_in_list ( $@ ) ;
assert_numeric ( $ ) ;
assert_object ( $ ) ;
assert_object_ainta ( $@ ) ;
assert_object_boolifies ( $ ) ;
assert_object_can ( $@ ) ;
assert_object_cant ( $@ ) ;
assert_object_isa ( $@ ) ;
assert_object_method ( ) ;
assert_object_nummifies ( $ ) ;
assert_object_overloads ( $@ ) ;
assert_object_stringifies ( $ ) ;
assert_odd_number ( $ ) ;
assert_open_handle ( $ ) ;
assert_positive ( $ ) ;
assert_positive_integer ( $ ) ;
assert_private_method ( ) ;
assert_protected_method ( ) ;
assert_public_method ( ) ;
assert_qualified_ident ( $ ) ;
assert_refref ( $ ) ;
assert_reftype ( $$ ) ;
assert_regex ( $ ) ;
assert_regular_file ( $ ) ;
assert_sad_exit ( ;$ ) ;
assert_scalar_context ( ) ;
assert_scalarref ( $ ) ;
assert_signalled ( ;$ ) ;
assert_signed_number ( $ ) ;
assert_simple_perl_ident ( $ ) ;
assert_single_line ( $ ) ;
assert_single_paragraph ( $ ) ;
assert_text_file ( $ ) ;
assert_tied ( \[$@*] ) ;
assert_tied_array ( \@ ) ;
assert_tied_arrayref ( $ ) ;
assert_tied_glob ( \* ) ;
assert_tied_globref ( $ ) ;
assert_tied_hash ( \% ) ;
assert_tied_hashref ( $ ) ;
assert_tied_referent ( $ ) ;
assert_tied_scalar ( \$ ) ;
assert_tied_scalarref ( $ ) ;
assert_true ( $ ) ;
assert_unblessed_ref ( $ ) ;
assert_undefined ( $ ) ;
assert_unhappy_code ( & ) ;
assert_unicode_ident ( $ ) ;
assert_unlike ( $$ ) ;
assert_unlocked ( \[%$] @ ) ;
assert_unsignalled ( ;$ ) ;
assert_untied ( \[$@%*] ) ;
assert_untied_array ( \@ ) ;
assert_untied_arrayref ( $ ) ;
assert_untied_glob ( \* ) ;
assert_untied_globref ( $ ) ;
assert_untied_hash ( \% ) ;
assert_untied_hashref ( $ ) ;
assert_untied_referent ( $ ) ;
assert_untied_scalar ( \$ ) ;
assert_untied_scalarref ( $ ) ;
assert_uppercased ( $ ) ;
assert_void_context ( ) ;
assert_whole_number ( $ ) ;
assert_wide_characters ( $ ) ;
assert_zero ( $ ) ;
All assertions have function prototypes; this helps you use them correctly,
and in some cases casts the argument into scalar context, adds backslashes
to pass things by reference, so you don't have to.
=head2 Export Tags
You may import all assertions or just some of them. When importing only
some of them, you may wish to use an export tag to import a set of related
assertions. Here is what each tag imports:
=over
=item C<:all>
L</assert_ainta>, L</assert_alnum>, L</assert_alphabetic>,
L</assert_anyref>, L</assert_argc>, L</assert_argc_max>,
L</assert_argc_min>, L</assert_argc_minmax>, L</assert_array_length>,
L</assert_array_length_max>, L</assert_array_length_min>,
L</assert_array_length_minmax>, L</assert_array_nonempty>,
L</assert_arrayref>, L</assert_arrayref_nonempty>, L</assert_ascii>,
L</assert_ascii_ident>, L</assert_astral>, L</assert_blank>,
L</assert_bmp>, L</assert_box_number>, L</assert_bytes>, L</assert_can>,
L</assert_cant>, L</assert_class_ainta>, L</assert_class_can>,
L</assert_class_cant>, L</assert_class_isa>, L</assert_class_method>,
L</assert_coderef>, L</assert_defined>, L</assert_defined_value>,
L</assert_defined_variable>, L</assert_digits>, L</assert_directory>,
L</assert_does>, L</assert_doesnt>, L</assert_dumped_core>,
L</assert_empty>, L</assert_eq>, L</assert_eq_letters>,
L</assert_even_number>, L</assert_exited>, L</assert_false>,
L</assert_fractional>, L</assert_full_perl_ident>, L</assert_globref>,
L</assert_happy_code>, L</assert_happy_exit>, L</assert_hash_keys>,
L</assert_hash_keys_allowed>, L</assert_hash_keys_allowed_and_required>,
L</assert_hash_keys_required>, L</assert_hash_keys_required_and_allowed>,
L</assert_hash_nonempty>, L</assert_hashref>, L</assert_hashref_keys>,
L</assert_hashref_keys_allowed>,
L</assert_hashref_keys_allowed_and_required>,
L</assert_hashref_keys_required>,
L</assert_hashref_keys_required_and_allowed>, L</assert_hashref_nonempty>,
L</assert_hex_number>, L</assert_in_list>, L</assert_in_numeric_range>,
L</assert_integer>, L</assert_ioref>, L</assert_is>, L</assert_isa>,
L</assert_isnt>, L</assert_keys>, L</assert_known_package>,
L</assert_latin1>, L</assert_latinish>, L</assert_legal_exit_status>,
L</assert_like>, L</assert_list_context>, L</assert_list_nonempty>,
L</assert_locked>, L</assert_lowercased>, L</assert_max_keys>,
L</assert_method>, L</assert_min_keys>, L</assert_minmax_keys>,
L</assert_multi_line>, L</assert_natural_number>, L</assert_negative>,
L</assert_negative_integer>, L</assert_nfc>, L</assert_nfd>,
L</assert_nfkc>, L</assert_nfkd>, L</assert_no_coredump>,
L</assert_nonalphabetic>, L</assert_nonascii>, L</assert_nonastral>,
L</assert_nonblank>, L</assert_nonbytes>, L</assert_nonempty>,
L</assert_nonlist_context>, L</assert_nonnegative>,
L</assert_nonnegative_integer>, L</assert_nonnumeric>,
L</assert_nonobject>, L</assert_nonpositive>,
L</assert_nonpositive_integer>, L</assert_nonref>,
L</assert_nonvoid_context>, L</assert_nonzero>, L</assert_not_in_list>,
L</assert_numeric>, L</assert_object>, L</assert_object_ainta>,
L</assert_object_boolifies>, L</assert_object_can>, L</assert_object_cant>,
L</assert_object_isa>, L</assert_object_method>,
L</assert_object_nummifies>, L</assert_object_overloads>,
L</assert_object_stringifies>, L</assert_odd_number>,
L</assert_open_handle>, L</assert_positive>, L</assert_positive_integer>,
L</assert_private_method>, L</assert_protected_method>,
L</assert_public_method>, L</assert_qualified_ident>, L</assert_refref>,
L</assert_reftype>, L</assert_regex>, L</assert_regular_file>,
L</assert_sad_exit>, L</assert_scalar_context>, L</assert_scalarref>,
L</assert_signalled>, L</assert_signed_number>,
L</assert_simple_perl_ident>, L</assert_single_line>,
L</assert_single_paragraph>, L</assert_text_file>, L</assert_tied>,
L</assert_tied_array>, L</assert_tied_arrayref>, L</assert_tied_glob>,
L</assert_tied_globref>, L</assert_tied_hash>, L</assert_tied_hashref>,
L</assert_tied_referent>, L</assert_tied_scalar>,
L</assert_tied_scalarref>, L</assert_true>, L</assert_unblessed_ref>,
L</assert_undefined>, L</assert_unhappy_code>, L</assert_unicode_ident>,
L</assert_unlike>, L</assert_unlocked>, L</assert_unsignalled>,
L</assert_untied>, L</assert_untied_array>, L</assert_untied_arrayref>,
L</assert_untied_glob>, L</assert_untied_globref>, L</assert_untied_hash>,
L</assert_untied_hashref>, L</assert_untied_referent>,
L</assert_untied_scalar>, L</assert_untied_scalarref>,
L</assert_uppercased>, L</assert_void_context>, L</assert_whole_number>,
L</assert_wide_characters>, and L</assert_zero>.
=item C<:argc>
L</assert_argc>, L</assert_argc_max>, L</assert_argc_min>, and
L</assert_argc_minmax>.
=item C<:array>
L</assert_array_length>, L</assert_array_length_max>,
L</assert_array_length_min>, L</assert_array_length_minmax>,
L</assert_array_nonempty>, L</assert_arrayref>,
L</assert_arrayref_nonempty>, L</assert_list_nonempty>,
L</assert_tied_array>, L</assert_tied_arrayref>, L</assert_untied_array>,
and L</assert_untied_arrayref>.
=item C<:boolean>
L</assert_false>, L</assert_happy_code>, L</assert_true>, and
L</assert_unhappy_code>.
=item C<:case>
L</assert_lowercased> and L</assert_uppercased>.
=item C<:code>
L</assert_coderef>, L</assert_happy_code>, and L</assert_unhappy_code>.
=item C<:context>
L</assert_list_context>, L</assert_nonlist_context>,
L</assert_nonvoid_context>, L</assert_scalar_context>, and
L</assert_void_context>.
=item C<:file>
L</assert_directory>, L</assert_open_handle>, L</assert_regular_file>,
and L</assert_text_file>.
=item C<:glob>
L</assert_globref>, L</assert_tied_glob>, L</assert_tied_globref>,
L</assert_untied_glob>, and L</assert_untied_globref>.
=item C<:hash>
L</assert_hash_keys>, L</assert_hash_keys_allowed>,
L</assert_hash_keys_allowed_and_required>, L</assert_hash_keys_required>,
L</assert_hash_keys_required_and_allowed>, L</assert_hash_nonempty>,
L</assert_hashref>, L</assert_hashref_keys>,
L</assert_hashref_keys_allowed>,
L</assert_hashref_keys_allowed_and_required>,
L</assert_hashref_keys_required>,
lib/Assert/Conditional.pm view on Meta::CPAN
L</assert_in_list>, L</assert_list_nonempty>, and L</assert_not_in_list>.
=item C<:number>
L</assert_box_number>, L</assert_digits>, L</assert_even_number>,
L</assert_fractional>, L</assert_hex_number>, L</assert_in_numeric_range>,
L</assert_integer>, L</assert_natural_number>, L</assert_negative>,
L</assert_negative_integer>, L</assert_nonnegative>,
L</assert_nonnegative_integer>, L</assert_nonnumeric>,
L</assert_nonpositive>, L</assert_nonpositive_integer>, L</assert_nonzero>,
L</assert_numeric>, L</assert_odd_number>, L</assert_positive>,
L</assert_positive_integer>, L</assert_signed_number>,
L</assert_whole_number>, and L</assert_zero>.
=item C<:object>
L</assert_ainta>, L</assert_can>, L</assert_cant>, L</assert_class_ainta>,
L</assert_class_can>, L</assert_class_cant>, L</assert_class_isa>,
L</assert_class_method>, L</assert_does>, L</assert_doesnt>,
L</assert_isa>, L</assert_known_package>, L</assert_method>,
L</assert_nonobject>, L</assert_object>, L</assert_object_ainta>,
L</assert_object_boolifies>, L</assert_object_can>, L</assert_object_cant>,
L</assert_object_isa>, L</assert_object_method>,
L</assert_object_nummifies>, L</assert_object_overloads>,
L</assert_object_stringifies>, L</assert_private_method>,
L</assert_protected_method>, L</assert_public_method>, L</assert_reftype>,
and L</assert_unblessed_ref>.
=item C<:overload>
L</assert_object_boolifies>, L</assert_object_nummifies>,
L</assert_object_overloads>, and L</assert_object_stringifies>.
=item C<:process>
L</assert_dumped_core>, L</assert_exited>, L</assert_happy_exit>,
L</assert_legal_exit_status>, L</assert_no_coredump>, L</assert_sad_exit>,
L</assert_signalled>, and L</assert_unsignalled>.
=item C<:ref>
L</assert_anyref>, L</assert_arrayref>, L</assert_coderef>,
L</assert_globref>, L</assert_hashref>, L</assert_ioref>,
L</assert_nonref>, L</assert_refref>, L</assert_reftype>,
L</assert_scalarref>, L</assert_tied_arrayref>, L</assert_tied_globref>,
L</assert_tied_hashref>, L</assert_tied_referent>,
L</assert_tied_scalarref>, L</assert_unblessed_ref>,
L</assert_untied_arrayref>, L</assert_untied_globref>,
L</assert_untied_hashref>, L</assert_untied_referent>, and
L</assert_untied_scalarref>.
=item C<:regex>
L</assert_alnum>, L</assert_alphabetic>, L</assert_ascii>,
L</assert_ascii_ident>, L</assert_blank>, L</assert_digits>,
L</assert_full_perl_ident>, L</assert_hex_number>, L</assert_like>,
L</assert_lowercased>, L</assert_multi_line>, L</assert_nonalphabetic>,
L</assert_nonascii>, L</assert_nonblank>, L</assert_qualified_ident>,
L</assert_regex>, L</assert_simple_perl_ident>, L</assert_single_line>,
L</assert_single_paragraph>, L</assert_unicode_ident>, L</assert_unlike>,
and L</assert_uppercased>.
=item C<:scalar>
L</assert_defined>, L</assert_defined_value>, L</assert_defined_variable>,
L</assert_false>, L</assert_scalarref>, L</assert_tied_scalar>,
L</assert_tied_scalarref>, L</assert_true>, L</assert_undefined>,
L</assert_untied_scalar>, and L</assert_untied_scalarref>.
=item C<:string>
L</assert_alphabetic>, L</assert_ascii>, L</assert_blank>,
L</assert_bytes>, L</assert_empty>, L</assert_eq>, L</assert_eq_letters>,
L</assert_is>, L</assert_isnt>, L</assert_latin1>, L</assert_multi_line>,
L</assert_nonalphabetic>, L</assert_nonascii>, L</assert_nonblank>,
L</assert_nonbytes>, L</assert_nonempty>, L</assert_single_line>,
L</assert_single_paragraph>, and L</assert_wide_characters>.
=item C<:tie>
L</assert_tied>, L</assert_tied_array>, L</assert_tied_arrayref>,
L</assert_tied_glob>, L</assert_tied_globref>, L</assert_tied_hash>,
L</assert_tied_hashref>, L</assert_tied_referent>, L</assert_tied_scalar>,
L</assert_tied_scalarref>, L</assert_untied>, L</assert_untied_array>,
L</assert_untied_arrayref>, L</assert_untied_glob>,
L</assert_untied_globref>, L</assert_untied_hash>,
L</assert_untied_hashref>, L</assert_untied_referent>,
L</assert_untied_scalar>, and L</assert_untied_scalarref>.
=item C<:unicode>
L</assert_astral>, L</assert_bmp>, L</assert_eq>, L</assert_eq_letters>,
L</assert_latin1>, L</assert_latinish>, L</assert_nfc>, L</assert_nfd>,
L</assert_nfkc>, L</assert_nfkd>, and L</assert_nonastral>.
=back
=head2 Assertions about Calling Context
These assertions inspect their immediate caller’s C<wantarray>.
=over
=item assert_list_context()
Current function was called in list context.
=item assert_nonlist_context()
Current function was I<not> called in list context.
=item assert_scalar_context()
Current function was called in scalar context.
=item assert_void_context()
Current function was called in void context.
=item assert_nonvoid_context()
Current function was I<not> called in void context.
=back
=head2 Assertions about Scalars
These assertions don't pay any special attention to objects, so the normal
effects of evaluating an object where a regular scalar is expected apply.
=over
=item assert_true(I<EXPR>)
The scalar expression I<EXPR> is true according to Perl's sense of Boolean
logic, the sort of thing you would put in an C<if (...)> condition to have
its block run.
If this assertion fails, it will not report the original expression. You
should therefore strongly consider using L</assert_happy_code> instead for
more descriptive error messages because L</assert_happy_code> will show the
literal expression that was expected to be true but which unexpectedly
evaluated to false.
=item assert_false(I<EXPR>)
The scalar expression I<EXPR> is true according to Perl's sense of Boolean
logic, the sort of thing you would put in an C<unless>) condition to have
its block run.
lib/Assert/Conditional.pm view on Meta::CPAN
Non-empty string argument has at any number of linebreak graphemes
at the very end only. It is disqualified if it has linebreaks
anywhere shy of the end, but does not care how many are there.
=item assert_bytes(I<EXPR>)
Argument contains only code points between 0x00 and 0xFF.
Such data is suitable for writing out as binary bytes.
=item assert_nonbytes(I<EXPR>)
Argument contains code points greater than 0xFF.
Such data must first be encoded when written.
=item assert_wide_characters(I<EXPR>)
The same thing as saying that it contains non-bytes.
=back
=head2 Assertions about Regexes
=over
=item assert_nonascii(I<EXPR>)
Argument contains at least one code point larger that 127.
=item assert_ascii(I<EXPR>)
Argument contains only code points less than 128.
=item assert_alphabetic(I<EXPR>)
Argument contains only alphabetic code points,
but not necessarily ASCII ones.
=item assert_nonalphabetic(I<EXPR>)
Argument contains only non-alphabetic code points,
but not necessarily ASCII ones.
=item assert_alnum(I<EXPR>)
Argument contains only alphabetic or numeric code points,
but not necessarily ASCII ones.
=item assert_digits(I<EXPR>)
Argument contains only ASCII digits.
=item assert_uppercased(I<EXPR>)
Argument will not change if uppercased.
=item assert_lowercased(I<EXPR>)
Argument will not change if lowercased.
=item assert_unicode_ident(I<EXPR>)
Argument is a legal Unicode identifier, so one beginning with an (X)ID Start
code point and having any number of (X)ID Continue code points following.
Note that Perl identifiers are somewhat different from this.
=item assert_simple_perl_ident(I<EXPR>)
Like a Unicode identifier but which may also start
with connector punctuation like underscores. No package
separators are allowed, however. Sigils do not count.
Also, special variables like C<$.> or C<${^PREMATCH}>
will not work either, since passing this function
strings like C<.> and C<{> and C<^> are
all beyond the pale.
=item assert_full_perl_ident(I<EXPR>)
Like a simple Perl identifier but which also
allows for optional package separators,
either C<::> or C<'>.
=item assert_qualified_ident(I<EXPR>)
Like a full Perl identifier but with
mandatory package separators, either C<::> or C<'>.
=item assert_ascii_ident(I<EXPR>)
What most people think of as an identifier,
one with only ASCII letter, digits, and underscores,
and which cannot begin with a digit.
=item assert_regex(I<ARG>)
The argument must be a compile Regexp object.
=item assert_like(I<STRING>, I<REGEX>)
The string, which must be a defined non-reference,
matches the pattern, which must be a compiled Regexp object
produces by the C<qr> operator.
=item assert_unlike(I<STRING>, I<REGEX>)
The string, which must be a defined non-reference,
cannot match the pattern, which must be a compiled Regexp object
produces by the C<qr> operator.
=back
=head2 Assertions about Unicode
=over
=item assert_latin1(I<ARG>)
The argument contains only code points
from U+0000 through U+00FF.
( run in 0.869 second using v1.01-cache-2.11-cpan-cdf2f3d4e48 )