Also checking in the tool I used to do the conversion.
--- /dev/null
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+use File::Slurp qw( write_file );
+use PPI;
+
+rewrite_doc($_) for grep { -w } @ARGV;
+
+sub rewrite_doc {
+ my $file = shift;
+
+ my $doc = PPI::Document->new($file);
+
+ return unless $doc =~ /Test::Exception/;
+
+ print $file, "\n";
+
+ my $pattern = sub {
+ my $elt = $_[1];
+
+ return 1
+ if $elt->isa('PPI::Statement')
+ && $elt->content()
+ =~ /^\s*(?:::)?(?:lives_|throws_|dies_)(?:ok|and)/;
+
+ return 0;
+ };
+
+ for my $elt ( @{ $doc->find($pattern) || [] } ) {
+ transform_statement($elt);
+ }
+
+ my $content = $doc->content();
+ $content =~ s/Test::Exception/Test::Fatal/g;
+
+ write_file( $file, $content );
+}
+
+sub transform_statement {
+ my $stmt = shift;
+
+ my @children = $stmt->schildren;
+
+ my $func = shift @children;
+
+ my $colons = $func =~ /^::/ ? '::' : q{};
+
+ my $code;
+ if ( $func =~ /lives_/ ) {
+ $code = function(
+ $colons . 'is',
+ $children[0],
+ 'undef',
+ $children[1]
+ );
+ }
+ elsif ( $func =~ /dies_/ ) {
+ $code = function(
+ $colons . 'isnt',
+ $children[0],
+ 'undef',
+ $children[1]
+ );
+ }
+ elsif ( $func =~ /throws_/ ) {
+
+ # $children[2] is always a comma if it exists
+ if ( $children[1]->isa('PPI::Token::QuoteLike::Regexp') ) {
+ $code = function(
+ $colons . 'like',
+ $children[0],
+ $children[1],
+ $children[3]
+ );
+ }
+ else {
+ $code = function(
+ $colons . 'is',
+ $children[0],
+ $children[1],
+ $children[3]
+ );
+ }
+ }
+
+ $stmt->insert_before($code);
+ $stmt->remove;
+}
+
+sub function {
+ my $func = shift;
+ my $exception = shift;
+ my $expect = shift;
+ my $desc = shift;
+
+ my $exc_func = $func =~ /^::/ ? '::exception' : 'exception';
+
+ my @code;
+
+ push @code,
+ PPI::Token::Word->new($func),
+ PPI::Token::Structure->new('('),
+ PPI::Token::Whitespace->new(q{ }),
+ PPI::Token::Word->new($exc_func),
+ PPI::Token::Whitespace->new(q{ }),
+ $exception->clone,
+ PPI::Token::Operator->new(','),
+ PPI::Token::Whitespace->new(q{ }),
+ ( ref $expect ? $expect->clone : PPI::Token::Word->new($expect) );
+
+ if ( $desc && $desc->isa('PPI::Token::Quote') ) {
+ push @code, PPI::Token::Operator->new(','),
+ PPI::Token::Whitespace->new(q{ }),
+ $desc->clone;
+ }
+
+ push @code,
+ PPI::Token::Whitespace->new(q{ }),
+ PPI::Token::Structure->new(')'),
+ PPI::Token::Structure->new(';');
+
+ my $stmt = PPI::Statement->new;
+ $stmt->add_element($_) for @code;
+
+ return $stmt;
+}
my $base = $self->SUPER::process(@_);
- $base =~ s/(\$\| = 1;)/use Test::Exception;\n$1/;
+ $base =~ s/(\$\| = 1;)/use Test::Fatal;\n$1/;
return $base;
}
$point->y(10);
is( $point->y, 10, '... got the right (changed) value for y' );
-dies_ok {
- $point->y('Foo');
-}
-'... cannot assign a non-Int to y';
+isnt(
+ exception {
+ $point->y('Foo');
+ },
+ undef,
+ '... cannot assign a non-Int to y'
+);
-dies_ok {
- Point->new();
-}
-'... must provide required attributes to new';
+isnt(
+ exception {
+ Point->new();
+ },
+ undef,
+ '... must provide required attributes to new'
+);
$point->clear();
# check the type constraints on the constructor
-lives_ok {
- Point->new( x => 0, y => 0 );
-}
-'... can assign a 0 to x and y';
+is(
+ exception {
+ Point->new( x => 0, y => 0 );
+ },
+ undef,
+ '... can assign a 0 to x and y'
+);
-dies_ok {
- Point->new( x => 10, y => 'Foo' );
-}
-'... cannot assign a non-Int to y';
+isnt(
+ exception {
+ Point->new( x => 10, y => 'Foo' );
+ },
+ undef,
+ '... cannot assign a non-Int to y'
+);
-dies_ok {
- Point->new( x => 'Foo', y => 10 );
-}
-'... cannot assign a non-Int to x';
+isnt(
+ exception {
+ Point->new( x => 'Foo', y => 10 );
+ },
+ undef,
+ '... cannot assign a non-Int to x'
+);
# Point3D
is( $point3d->y, 0, '... got the right (cleared) value for y' );
is( $point3d->z, 0, '... got the right (cleared) value for z' );
-dies_ok {
- Point3D->new( x => 10, y => 'Foo', z => 3 );
-}
-'... cannot assign a non-Int to y';
+isnt(
+ exception {
+ Point3D->new( x => 10, y => 'Foo', z => 3 );
+ },
+ undef,
+ '... cannot assign a non-Int to y'
+);
-dies_ok {
- Point3D->new( x => 'Foo', y => 10, z => 3 );
-}
-'... cannot assign a non-Int to x';
+isnt(
+ exception {
+ Point3D->new( x => 'Foo', y => 10, z => 3 );
+ },
+ undef,
+ '... cannot assign a non-Int to x'
+);
-dies_ok {
- Point3D->new( x => 0, y => 10, z => 'Bar' );
-}
-'... cannot assign a non-Int to z';
+isnt(
+ exception {
+ Point3D->new( x => 0, y => 10, z => 'Bar' );
+ },
+ undef,
+ '... cannot assign a non-Int to z'
+);
-dies_ok {
- Point3D->new( x => 10, y => 3 );
-}
-'... z is a required attribute for Point3D';
+isnt(
+ exception {
+ Point3D->new( x => 10, y => 3 );
+ },
+ undef,
+ '... z is a required attribute for Point3D'
+);
# test some class introspection
can_ok( 'Point3D', 'meta' );
isa_ok( Point3D->meta, 'Moose::Meta::Class' );
-isnt( Point->meta, Point3D->meta,
- '... they are different metaclasses as well' );
+isnt(
+ Point->meta, Point3D->meta,
+ '... they are different metaclasses as well'
+);
# poke at Point
isa_ok( $savings_account, 'BankAccount' );
is( $savings_account->balance, 250, '... got the right savings balance' );
- lives_ok {
- $savings_account->withdraw(50);
- }
- '... withdrew from savings successfully';
+ is(
+ exception {
+ $savings_account->withdraw(50);
+ },
+ undef,
+ '... withdrew from savings successfully'
+ );
is( $savings_account->balance, 200,
'... got the right savings balance after withdrawl' );
is( $checking_account->balance, 100,
'... got the right checkings balance' );
- lives_ok {
- $checking_account->withdraw(50);
- }
- '... withdrew from checking successfully';
+ is(
+ exception {
+ $checking_account->withdraw(50);
+ },
+ undef,
+ '... withdrew from checking successfully'
+ );
is( $checking_account->balance, 50,
'... got the right checkings balance after withdrawl' );
is( $savings_account->balance, 350,
'... got the right savings balance after checking withdrawl (no overdraft)'
);
- lives_ok {
- $checking_account->withdraw(200);
- }
- '... withdrew from checking successfully';
+ is(
+ exception {
+ $checking_account->withdraw(200);
+ },
+ undef,
+ '... withdrew from checking successfully'
+ );
is( $checking_account->balance, 0,
'... got the right checkings balance after withdrawl' );
is( $savings_account->balance, 200,
is( $checking_account->balance, 100,
'... got the right checkings balance' );
- lives_ok {
- $checking_account->withdraw(50);
- }
- '... withdrew from checking successfully';
+ is(
+ exception {
+ $checking_account->withdraw(50);
+ },
+ undef,
+ '... withdrew from checking successfully'
+ );
is( $checking_account->balance, 50,
'... got the right checkings balance after withdrawl' );
- dies_ok {
- $checking_account->withdraw(200);
- }
- '... withdrawl failed due to attempted overdraft';
+ isnt(
+ exception {
+ $checking_account->withdraw(200);
+ },
+ undef,
+ '... withdrawal failed due to attempted overdraft'
+ );
is( $checking_account->balance, 50,
'... got the right checkings balance after withdrawl failure' );
}
is($left->node, undef, '... left has got no node value');
-lives_ok {
- $left->node('left')
-} '... assign to lefts node';
+is(
+ exception {
+ $left->node('left');
+ },
+ undef,
+ '... assign to lefts node'
+);
is($left->node, 'left', '... left now has a node value');
my $right = $root->right;
isa_ok($right, 'BinaryTree');
-lives_ok {
- $right->node('right')
-} '... assign to rights node';
+is(
+ exception {
+ $right->node('right');
+ },
+ undef,
+ '... assign to rights node'
+);
is($right->node, 'right', '... left now has a node value');
my $left_right = BinaryTree->new;
isa_ok($left_right, 'BinaryTree');
-lives_ok {
- $left->right($left_right)
-} '... assign to rights node';
+is(
+ exception {
+ $left->right($left_right);
+ },
+ undef,
+ '... assign to rights node'
+);
ok($left_right->has_parent, '... left does have a parent');
# and check the error
-dies_ok {
- $left_right->right($left_left)
-} '... cant assign a node which already has a parent';
+isnt(
+ exception {
+ $left_right->right($left_left);
+ },
+ undef,
+ '... cannot assign a node which already has a parent'
+);
=end testing
use Scalar::Util 'isweak';
my $ii;
-lives_ok {
- $ii = Company->new(
- {
- name => 'Infinity Interactive',
- address => Address->new(
- street => '565 Plandome Rd., Suite 307',
- city => 'Manhasset',
- state => 'NY',
- zip_code => '11030'
- ),
- employees => [
- Employee->new(
- first_name => 'Jeremy',
- last_name => 'Shao',
- title => 'President / Senior Consultant',
- address =>
- Address->new( city => 'Manhasset', state => 'NY' )
+is(
+ exception {
+ $ii = Company->new(
+ {
+ name => 'Infinity Interactive',
+ address => Address->new(
+ street => '565 Plandome Rd., Suite 307',
+ city => 'Manhasset',
+ state => 'NY',
+ zip_code => '11030'
),
- Employee->new(
- first_name => 'Tommy',
- last_name => 'Lee',
- title => 'Vice President / Senior Developer',
- address =>
- Address->new( city => 'New York', state => 'NY' )
- ),
- Employee->new(
- first_name => 'Stevan',
- middle_initial => 'C',
- last_name => 'Little',
- title => 'Senior Developer',
- address =>
- Address->new( city => 'Madison', state => 'CT' )
- ),
- ]
- }
- );
-}
-'... created the entire company successfully';
+ employees => [
+ Employee->new(
+ first_name => 'Jeremy',
+ last_name => 'Shao',
+ title => 'President / Senior Consultant',
+ address => Address->new(
+ city => 'Manhasset', state => 'NY'
+ )
+ ),
+ Employee->new(
+ first_name => 'Tommy',
+ last_name => 'Lee',
+ title => 'Vice President / Senior Developer',
+ address =>
+ Address->new( city => 'New York', state => 'NY' )
+ ),
+ Employee->new(
+ first_name => 'Stevan',
+ middle_initial => 'C',
+ last_name => 'Little',
+ title => 'Senior Developer',
+ address =>
+ Address->new( city => 'Madison', state => 'CT' )
+ ),
+ ]
+ }
+ );
+ },
+ undef,
+ '... created the entire company successfully'
+);
+
isa_ok( $ii, 'Company' );
is( $ii->name, 'Infinity Interactive',
## check some error conditions for the subtypes
-dies_ok {
- Address->new( street => {} ),;
-}
-'... we die correctly with bad args';
-
-dies_ok {
- Address->new( city => {} ),;
-}
-'... we die correctly with bad args';
-
-dies_ok {
- Address->new( state => 'British Columbia' ),;
-}
-'... we die correctly with bad args';
-
-lives_ok {
- Address->new( state => 'Connecticut' ),;
-}
-'... we live correctly with good args';
-
-dies_ok {
- Address->new( zip_code => 'AF5J6$' ),;
-}
-'... we die correctly with bad args';
-
-lives_ok {
- Address->new( zip_code => '06443' ),;
-}
-'... we live correctly with good args';
-
-dies_ok {
- Company->new(),;
-}
-'... we die correctly without good args';
-
-lives_ok {
- Company->new( name => 'Foo' ),;
-}
-'... we live correctly without good args';
-
-dies_ok {
- Company->new( name => 'Foo', employees => [ Person->new ] ),;
-}
-'... we die correctly with good args';
-
-lives_ok {
- Company->new( name => 'Foo', employees => [] ),;
-}
-'... we live correctly with good args';
+isnt(
+ exception {
+ Address->new( street => {} ),;
+ },
+ undef,
+ '... we die correctly with bad args'
+);
+
+isnt(
+ exception {
+ Address->new( city => {} ),;
+ },
+ undef,
+ '... we die correctly with bad args'
+);
+
+isnt(
+ exception {
+ Address->new( state => 'British Columbia' ),;
+ },
+ undef,
+ '... we die correctly with bad args'
+);
+
+is(
+ exception {
+ Address->new( state => 'Connecticut' ),;
+ },
+ undef,
+ '... we live correctly with good args'
+);
+
+isnt(
+ exception {
+ Address->new( zip_code => 'AF5J6$' ),;
+ },
+ undef,
+ '... we die correctly with bad args'
+);
+
+is(
+ exception {
+ Address->new( zip_code => '06443' ),;
+ },
+ undef,
+ '... we live correctly with good args'
+);
+
+isnt(
+ exception {
+ Company->new(),;
+ },
+ undef,
+ '... we die correctly without good args'
+);
+
+is(
+ exception {
+ Company->new( name => 'Foo' ),;
+ },
+ undef,
+ '... we live correctly without good args'
+);
+
+isnt(
+ exception {
+ Company->new( name => 'Foo', employees => [ Person->new ] ),;
+ },
+ undef,
+ '... we die correctly with good args'
+);
+
+is(
+ exception {
+ Company->new( name => 'Foo', employees => [] ),;
+ },
+ undef,
+ '... we live correctly with good args'
+);
=end testing
is( $header4->content_type, 'application/pdf',
'... got the right content type in the header' );
- dies_ok {
- $r->headers('Foo');
- }
- '... dies when it gets bad params';
+ isnt(
+ exception {
+ $r->headers('Foo');
+ },
+ undef,
+ '... dies when it gets bad params'
+ );
}
{
is( $r->protocol, undef, '... got nothing by default' );
- lives_ok {
- $r->protocol('HTTP/1.0');
- }
- '... set the protocol correctly';
+ is(
+ exception {
+ $r->protocol('HTTP/1.0');
+ },
+ undef,
+ '... set the protocol correctly'
+ );
+
is( $r->protocol, 'HTTP/1.0', '... got nothing by default' );
- dies_ok {
- $r->protocol('http/1.0');
- }
- '... the protocol died with bar params correctly';
+ isnt(
+ exception {
+ $r->protocol('http/1.0');
+ },
+ undef,
+ '... the protocol died with bar params correctly'
+ );
}
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
ok(Foo->meta->has_method('meta'), '... we got the &meta method');
ok(Foo->isa('Moose::Object'), '... Foo is automagically a Moose::Object');
-dies_ok {
+isnt( exception {
Foo->meta->has_method()
-} '... has_method requires an arg';
+}, undef, '... has_method requires an arg' );
can_ok('Foo', 'does');
use lib 't/lib', 'lib';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Bar;
use Moose;
- ::lives_ok { extends 'Foo' } 'loaded Foo superclass correctly';
+ ::is( ::exception { extends 'Foo' }, undef, 'loaded Foo superclass correctly' );
}
{
package Baz;
use Moose;
- ::lives_ok { extends 'Bar' } 'loaded (inline) Bar superclass correctly';
+ ::is( ::exception { extends 'Bar' }, undef, 'loaded (inline) Bar superclass correctly' );
}
{
package Foo::Bar;
use Moose;
- ::lives_ok { extends 'Foo', 'Bar' }
- 'loaded Foo and (inline) Bar superclass correctly';
+ ::is( ::exception { extends 'Foo', 'Bar' }, undef, 'loaded Foo and (inline) Bar superclass correctly' );
}
{
package Bling;
use Moose;
- ::throws_ok { extends 'No::Class' }
- qr{Can't locate No/Class\.pm in \@INC},
- 'correct error when superclass could not be found';
+ ::like( ::exception { extends 'No::Class' }, qr{Can't locate No/Class\.pm in \@INC}, 'correct error when superclass could not be found' );
}
{
package Tiger;
use Moose;
- ::lives_ok { extends 'Foo', Affe => { -version => 13 } }
- 'extends with version requirement';
+ ::is( ::exception { extends 'Foo', Affe => { -version => 13 } }, undef, 'extends with version requirement' );
}
{
package Birne;
use Moose;
- ::throws_ok { extends 'Foo', Affe => { -version => 42 } }
- qr/Affe version 42 required--this is only version 23/,
- 'extends with unsatisfied version requirement';
+ ::like( ::exception { extends 'Foo', Affe => { -version => 42 } }, qr/Affe version 42 required--this is only version 23/, 'extends with unsatisfied version requirement' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
sub bling { 'Bling::bling' }
- ::dies_ok {
+ ::isnt( ::exception {
override 'bling' => sub {};
- } '... cannot override a method which has a local equivalent';
+ }, undef, '... cannot override a method which has a local equivalent' );
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
sub bling { 'Bling::bling' }
- ::dies_ok {
+ ::isnt( ::exception {
augment 'bling' => sub {};
- } '... cannot augment a method which has a local equivalent';
+ }, undef, '... cannot augment a method which has a local equivalent' );
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Dog::Role;
use Moose::Role;
- ::dies_ok {
+ ::isnt( ::exception {
before qr/bark.*/ => sub {};
- } '... this is not currently supported';
+ }, undef, '... this is not currently supported' );
- ::dies_ok {
+ ::isnt( ::exception {
around qr/bark.*/ => sub {};
- } '... this is not currently supported';
+ }, undef, '... this is not currently supported' );
- ::dies_ok {
+ ::isnt( ::exception {
after qr/bark.*/ => sub {};
- } '... this is not currently supported';
+ }, undef, '... this is not currently supported' );
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util::TypeConstraints;
my $bar = Bar->new;
isa_ok($bar, 'Bar');
-lives_ok {
+is( exception {
$bar->foo('Foo');
-} '... checked the type constraint correctly';
+}, undef, '... checked the type constraint correctly' );
-dies_ok {
+isnt( exception {
$bar->foo(Foo->new);
-} '... checked the type constraint correctly';
+}, undef, '... checked the type constraint correctly' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util 'blessed';
use Moose::Util::TypeConstraints;
is(blessed($foo), 'Parent', 'Parent->new gives a Parent object');
is($foo->name, undef, 'No name yet');
is($foo->lazy_classname, 'Parent', "lazy attribute initialized");
-lives_ok { $foo->type_constrained(10.5) } "Num type constraint for now..";
+is( exception { $foo->type_constrained(10.5) }, undef, "Num type constraint for now.." );
# try to rebless, except it will fail due to Child's stricter type constraint
-throws_ok { Child->meta->rebless_instance($foo) }
-qr/^Attribute \(type_constrained\) does not pass the type constraint because\: Validation failed for 'Int' with value 10\.5/,
-'... this failed cause of type check';
-throws_ok { Child->meta->rebless_instance($bar) }
-qr/^Attribute \(type_constrained\) does not pass the type constraint because\: Validation failed for 'Int' with value 5\.5/,
-'... this failed cause of type check';
+like( exception { Child->meta->rebless_instance($foo) }, qr/^Attribute \(type_constrained\) does not pass the type constraint because\: Validation failed for 'Int' with value 10\.5/, '... this failed cause of type check' );
+like( exception { Child->meta->rebless_instance($bar) }, qr/^Attribute \(type_constrained\) does not pass the type constraint because\: Validation failed for 'Int' with value 5\.5/, '... this failed cause of type check' );
$foo->type_constrained(10);
$bar->type_constrained(5);
is($foo->lazy_classname, 'Parent', "lazy attribute was already initialized");
is($bar->lazy_classname, 'Child', "lazy attribute just now initialized");
-throws_ok { $foo->type_constrained(10.5) }
-qr/^Attribute \(type_constrained\) does not pass the type constraint because\: Validation failed for 'Int' with value 10\.5/,
-'... this failed cause of type check';
+like( exception { $foo->type_constrained(10.5) }, qr/^Attribute \(type_constrained\) does not pass the type constraint because\: Validation failed for 'Int' with value 10\.5/, '... this failed cause of type check' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Class;
my $new_class;
-lives_ok {
+is( exception {
$new_class = Moose::Meta::Class->create(
'Class::WithFoo',
superclasses => ['Class'],
roles => ['Foo'],
);
-} 'creating lives';
+}, undef, 'creating lives' );
ok $new_class;
my $with_foo = Class::WithFoo->new;
ok $with_foo->foo_role_applied;
isa_ok $with_foo, 'Class', '$with_foo';
-throws_ok {
+like( exception {
Moose::Meta::Class->create(
'Made::Of::Fail',
superclasses => ['Class'],
roles => 'Foo', # "oops"
);
-} qr/You must pass an ARRAY ref of roles/;
+}, qr/You must pass an ARRAY ref of roles/ );
ok !Made::Of::Fail->isa('UNIVERSAL'), "did not create Made::Of::Fail";
-dies_ok {
+isnt( exception {
Moose::Meta::Class->create(
'Continuing::To::Fail',
superclasses => ['Class'],
roles => ['Foo', 'Conflicts::With::Foo'],
);
-} 'conflicting roles == death';
+}, undef, 'conflicting roles == death' );
# XXX: Continuing::To::Fail gets created anyway
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
-lives_ok {
+is( exception {
eval 'use Moose';
-} "export to main";
+}, undef, "export to main" );
isa_ok( main->meta, "Moose::Meta::Class" );
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
# This tests the error handling in Moose::Object only
use Moose;
}
-throws_ok { Foo->new('bad') } qr/^\QSingle parameters to new() must be a HASH ref/,
- 'A single non-hashref arg to a constructor throws an error';
-throws_ok { Foo->new(undef) } qr/^\QSingle parameters to new() must be a HASH ref/,
- 'A single non-hashref arg to a constructor throws an error';
+like( exception { Foo->new('bad') }, qr/^\QSingle parameters to new() must be a HASH ref/, 'A single non-hashref arg to a constructor throws an error' );
+like( exception { Foo->new(undef) }, qr/^\QSingle parameters to new() must be a HASH ref/, 'A single non-hashref arg to a constructor throws an error' );
-throws_ok { Foo->does() } qr/^\QYou must supply a role name to does()/,
- 'Cannot call does() without a role name';
+like( exception { Foo->does() }, qr/^\QYou must supply a role name to does()/, 'Cannot call does() without a role name' );
done_testing;
use strict;
use warnings;
-use Test::Exception;
+use Test::Fatal;
use Test::More;
use Test::Moose qw( with_immutable );
}
with_immutable {
- lives_and {
+ is( exception {
stderr_like { Baz->new( x => 42, 'y' ) }
qr{\QThe new() method for Baz expects a hash reference or a key/value list. You passed an odd number of arguments at t/010_basics/022_buildargs_warning.t line \E\d+},
'warning when passing an odd number of args to new()';
stderr_is { Baz->new( { x => 42 } ) }
q{},
'we handle a single hashref to new without errors';
- };
+ }, undef );
}
'Baz';
use strict;
use warnings;
-use Test::Exception;
+use Test::Fatal;
use Test::More;
use Test::Requires {
use Moose;
- ::lives_and(
+ ::is( ::exception (
sub {
::stderr_like{ has foo => (
traits => ['String'],
'thing2 method is created as alias in role application'
);
}
- );
+ ), undef );
}
{
use Moose;
- ::lives_and(
+ ::is( ::exception (
sub {
::stderr_is{ has foo => (
traits => ['String'],
::stderr_is{ Pack1->new->_bar } q{},
'Providing a reader for a String trait avoids default is warning';
}
- );
+ ), undef );
sub _build_foo { q{} }
}
use Moose;
- ::lives_and(
+ ::is( ::exception (
sub {
::stderr_is{ has foo => (
traits => ['String'],
q{},
'Providing a writer for a String trait avoids default is warning';
}
- );
+ ), undef );
}
{
use Moose;
- ::lives_and(
+ ::is( ::exception (
sub {
::stderr_is{ has foo => (
traits => ['String'],
q{},
'Providing a accessor for a String trait avoids default is warning';
}
- );
+ ), undef );
sub _build_foo { q{} }
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
can_ok($foo, 'get_foo');
is($foo->get_foo(), undef, '... got an undefined value');
- dies_ok {
+ isnt( exception {
$foo->get_foo(100);
- } '... get_foo is a read-only';
+ }, undef, '... get_foo is a read-only' );
ok(!exists($foo->{lazy_foo}), '... no value in get_lazy_foo slot');
can_ok($foo, 'get_lazy_foo');
is($foo->get_lazy_foo(), 10, '... got an deferred value');
- dies_ok {
+ isnt( exception {
$foo->get_lazy_foo(100);
- } '... get_lazy_foo is a read-only';
+ }, undef, '... get_lazy_foo is a read-only' );
}
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util 'isweak';
can_ok($foo, 'set_foo');
is($foo->get_foo(), undef, '... got an unset value');
- lives_ok {
+ is( exception {
$foo->set_foo(100);
- } '... set_foo wrote successfully';
+ }, undef, '... set_foo wrote successfully' );
is($foo->get_foo(), 100, '... got the correct set value');
ok(!isweak($foo->{foo}), '... it is not a weak reference');
# required writer
- dies_ok {
+ isnt( exception {
Foo->new;
- } '... cannot create without the required attribute';
+ }, undef, '... cannot create without the required attribute' );
can_ok($foo, 'set_foo_required');
is($foo->get_foo_required(), 'required', '... got an unset value');
- lives_ok {
+ is( exception {
$foo->set_foo_required(100);
- } '... set_foo_required wrote successfully';
+ }, undef, '... set_foo_required wrote successfully' );
is($foo->get_foo_required(), 100, '... got the correct set value');
- dies_ok {
+ isnt( exception {
$foo->set_foo_required();
- } '... set_foo_required died successfully with no value';
+ }, undef, '... set_foo_required died successfully with no value' );
- lives_ok {
+ is( exception {
$foo->set_foo_required(undef);
- } '... set_foo_required did accept undef';
+ }, undef, '... set_foo_required did accept undef' );
ok(!isweak($foo->{foo_required}), '... it is not a weak reference');
can_ok($foo, 'set_foo_int');
is($foo->get_foo_int(), undef, '... got an unset value');
- lives_ok {
+ is( exception {
$foo->set_foo_int(100);
- } '... set_foo_int wrote successfully';
+ }, undef, '... set_foo_int wrote successfully' );
is($foo->get_foo_int(), 100, '... got the correct set value');
- dies_ok {
+ isnt( exception {
$foo->set_foo_int("Foo");
- } '... set_foo_int died successfully';
+ }, undef, '... set_foo_int died successfully' );
ok(!isweak($foo->{foo_int}), '... it is not a weak reference');
can_ok($foo, 'set_foo_weak');
is($foo->get_foo_weak(), undef, '... got an unset value');
- lives_ok {
+ is( exception {
$foo->set_foo_weak($test);
- } '... set_foo_weak wrote successfully';
+ }, undef, '... set_foo_weak wrote successfully' );
is($foo->get_foo_weak(), $test, '... got the correct set value');
ok(isweak($foo->{foo_weak}), '... it is a weak reference');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util 'isweak';
can_ok($foo, 'foo');
is($foo->foo(), undef, '... got an unset value');
- lives_ok {
+ is( exception {
$foo->foo(100);
- } '... foo wrote successfully';
+ }, undef, '... foo wrote successfully' );
is($foo->foo(), 100, '... got the correct set value');
ok(!isweak($foo->{foo}), '... it is not a weak reference');
# required writer
- dies_ok {
+ isnt( exception {
Foo->new;
- } '... cannot create without the required attribute';
+ }, undef, '... cannot create without the required attribute' );
can_ok($foo, 'foo_required');
is($foo->foo_required(), 'required', '... got an unset value');
- lives_ok {
+ is( exception {
$foo->foo_required(100);
- } '... foo_required wrote successfully';
+ }, undef, '... foo_required wrote successfully' );
is($foo->foo_required(), 100, '... got the correct set value');
- lives_ok {
+ is( exception {
$foo->foo_required(undef);
- } '... foo_required did not die with undef';
+ }, undef, '... foo_required did not die with undef' );
is($foo->foo_required, undef, "value is undef");
can_ok($foo, 'foo_int');
is($foo->foo_int(), undef, '... got an unset value');
- lives_ok {
+ is( exception {
$foo->foo_int(100);
- } '... foo_int wrote successfully';
+ }, undef, '... foo_int wrote successfully' );
is($foo->foo_int(), 100, '... got the correct set value');
- dies_ok {
+ isnt( exception {
$foo->foo_int("Foo");
- } '... foo_int died successfully';
+ }, undef, '... foo_int died successfully' );
ok(!isweak($foo->{foo_int}), '... it is not a weak reference');
can_ok($foo, 'foo_weak');
is($foo->foo_weak(), undef, '... got an unset value');
- lives_ok {
+ is( exception {
$foo->foo_weak($test);
- } '... foo_weak wrote successfully';
+ }, undef, '... foo_weak wrote successfully' );
is($foo->foo_weak(), $test, '... got the correct set value');
ok(isweak($foo->{foo_weak}), '... it is a weak reference');
can_ok( $foo, 'foo_deref');
is_deeply( [$foo->foo_deref()], [], '... default default value');
my @list;
- lives_ok {
+ is( exception {
@list = $foo->foo_deref();
- } "... doesn't deref undef value";
+ }, undef, "... doesn't deref undef value" );
is_deeply( \@list, [], "returns empty list in list context");
- lives_ok {
+ is( exception {
$foo->foo_deref( [ qw/foo bar gorch/ ] );
- } '... foo_deref wrote successfully';
+ }, undef, '... foo_deref wrote successfully' );
is( Scalar::Util::reftype( scalar $foo->foo_deref() ), "ARRAY", "returns an array reference in scalar context" );
is_deeply( scalar($foo->foo_deref()), [ qw/foo bar gorch/ ], "correct array" );
can_ok( $foo, 'foo_deref' );
is_deeply( [$foo->foo_deref_ro()], [], "... default default value" );
- dies_ok {
+ isnt( exception {
$foo->foo_deref_ro( [] );
- } "... read only";
+ }, undef, "... read only" );
$foo->{foo_deref_ro} = [qw/la la la/];
is_deeply( { $foo->foo_deref_hash() }, {}, "... default default value" );
my %hash;
- lives_ok {
+ is( exception {
%hash = $foo->foo_deref_hash();
- } "... doesn't deref undef value";
+ }, undef, "... doesn't deref undef value" );
is_deeply( \%hash, {}, "returns empty list in list context");
- lives_ok {
+ is( exception {
$foo->foo_deref_hash( { foo => 1, bar => 2 } );
- } '... foo_deref_hash wrote successfully';
+ }, undef, '... foo_deref_hash wrote successfully' );
is_deeply( scalar($foo->foo_deref_hash), { foo => 1, bar => 2 }, "scalar context" );
use Scalar::Util 'isweak';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
my $baz = Baz->new;
isa_ok($baz, 'Baz');
- lives_ok {
+ is( exception {
$foo->bar($bar);
- } '... did not die setting bar';
+ }, undef, '... did not die setting bar' );
is($foo->bar, $bar, '... set the value foo.bar correctly');
is($bar->foo, $foo, '... which in turn set the value bar.foo correctly');
ok(isweak($bar->{foo}), '... bar.foo is a weak reference');
- lives_ok {
+ is( exception {
$foo->bar(undef);
- } '... did not die un-setting bar';
+ }, undef, '... did not die un-setting bar' );
is($foo->bar, undef, '... set the value foo.bar correctly');
is($bar->foo, $foo, '... which in turn set the value bar.foo correctly');
# test the writer
- lives_ok {
+ is( exception {
$foo->set_baz($baz);
- } '... did not die setting baz';
+ }, undef, '... did not die setting baz' );
is($foo->get_baz, $baz, '... set the value foo.baz correctly');
is($baz->foo, $foo, '... which in turn set the value baz.foo correctly');
package Bling;
use Moose;
- ::dies_ok {
+ ::isnt( ::exception {
has('bling' => (is => 'rw', trigger => 'Fail'));
- } '... a trigger must be a CODE ref';
+ }, undef, '... a trigger must be a CODE ref' );
- ::dies_ok {
+ ::isnt( ::exception {
has('bling' => (is => 'rw', trigger => []));
- } '... a trigger must be a CODE ref';
+ }, undef, '... a trigger must be a CODE ref' );
}
# Triggers do not fire on built values
{
my $blarg;
- lives_ok { $blarg = Blarg->new; } 'Blarg->new() lives';
+ is( exception { $blarg = Blarg->new; }, undef, 'Blarg->new() lives' );
ok($blarg, 'Have a $blarg');
foreach my $attr (qw/foo bar baz/) {
is($blarg->$attr(), "default $attr value", "$attr has default value");
is_deeply(\%Blarg::trigger_calls, { map { $_ => 1 } qw/foo bar baz/ }, 'All triggers fired once on assign');
is_deeply(\%Blarg::trigger_vals, { map { $_ => "Different $_ value" } qw/foo bar baz/ }, 'All triggers given assigned values');
- lives_ok { $blarg => Blarg->new( map { $_ => "Yet another $_ value" } qw/foo bar baz/ ) } '->new() with parameters';
+ is( exception { $blarg => Blarg->new( map { $_ => "Yet another $_ value" } qw/foo bar baz/ ) }, undef, '->new() with parameters' );
is_deeply(\%Blarg::trigger_calls, { map { $_ => 2 } qw/foo bar baz/ }, 'All triggers fired once on construct');
is_deeply(\%Blarg::trigger_vals, { map { $_ => "Yet another $_ value" } qw/foo bar baz/ }, 'All triggers given assigned values');
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
my $bar = Bar::Class->new;
isa_ok($bar, 'Bar::Class');
-lives_ok {
+is( exception {
$foo->bar($bar);
-} '... bar passed the type constraint okay';
+}, undef, '... bar passed the type constraint okay' );
-dies_ok {
+isnt( exception {
$foo->bar($foo);
-} '... foo did not pass the type constraint okay';
+}, undef, '... foo did not pass the type constraint okay' );
-lives_ok {
+is( exception {
$foo->baz($bar);
-} '... baz passed the type constraint okay';
+}, undef, '... baz passed the type constraint okay' );
-dies_ok {
+isnt( exception {
$foo->baz($foo);
-} '... foo did not pass the type constraint okay';
+}, undef, '... foo did not pass the type constraint okay' );
-lives_ok {
+is( exception {
$bar->foo($foo);
-} '... foo passed the type constraint okay';
+}, undef, '... foo passed the type constraint okay' );
# if isa and does appear together, then see if Class->does(Role)
# if it does not,.. we have a conflict... so we die loudly
- ::dies_ok {
+ ::isnt( ::exception {
has 'foo' => (isa => 'Foo::Class', does => 'Bar::Class');
- } '... cannot have a does() which is not done by the isa()';
+ }, undef, '... cannot have a does() which is not done by the isa()' );
}
{
# if isa and does appear together, then see if Class->does(Role)
# if it does not,.. we have a conflict... so we die loudly
- ::dies_ok {
+ ::isnt( ::exception {
has 'foo' => (isa => 'Bling', does => 'Bar::Class');
- } '... cannot have a isa() which is cannot does()';
+ }, undef, '... cannot have a isa() which is cannot does()' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
# Foo->new(bar => 10, boo => undef);
#} qr/^Attribute \(boo\) is required and cannot be undef/, '... must supply all the required attribute';
-lives_ok {
+is( exception {
Foo->new(bar => 10, baz => undef);
-} '... undef is a valid attribute value';
+}, undef, '... undef is a valid attribute value' );
-lives_ok {
+is( exception {
Foo->new(bar => 10, boo => undef);
-} '... undef is a valid attribute value';
+}, undef, '... undef is a valid attribute value' );
-throws_ok {
+like( exception {
Foo->new;
-} qr/^Attribute \(bar\) is required/, '... must supply all the required attribute';
+}, qr/^Attribute \(bar\) is required/, '... must supply all the required attribute' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Bar;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has 'bar' => (metaclass => 'Bar::Meta::Attribute');
- } '... the attribute metaclass need not be a Moose::Meta::Attribute as long as it behaves';
+ }, undef, '... the attribute metaclass need not be a Moose::Meta::Attribute as long as it behaves' );
}
{
package Another::Foo;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has 'foo' => (metaclass => 'Foo');
- } '... the attribute metaclass alias worked correctly';
+ }, undef, '... the attribute metaclass alias worked correctly' );
- ::lives_ok {
+ ::is( ::exception {
has 'bar' => (metaclass => 'Bar', is => 'bare');
- } '... the attribute metaclass alias worked correctly';
+ }, undef, '... the attribute metaclass alias worked correctly' );
}
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
my $foo = Foo->new;
isa_ok($foo, 'Foo');
-lives_ok {
+is( exception {
$foo->bar([])
-} '... set bar successfully with an ARRAY ref';
+}, undef, '... set bar successfully with an ARRAY ref' );
-lives_ok {
+is( exception {
$foo->bar({})
-} '... set bar successfully with a HASH ref';
+}, undef, '... set bar successfully with a HASH ref' );
-dies_ok {
+isnt( exception {
$foo->bar(100)
-} '... couldnt set bar successfully with a number';
+}, undef, '... couldnt set bar successfully with a number' );
-dies_ok {
+isnt( exception {
$foo->bar(sub {})
-} '... couldnt set bar successfully with a CODE ref';
+}, undef, '... couldnt set bar successfully with a CODE ref' );
# check the constructor
-lives_ok {
+is( exception {
Foo->new(bar => [])
-} '... created new Foo with bar successfully set with an ARRAY ref';
+}, undef, '... created new Foo with bar successfully set with an ARRAY ref' );
-lives_ok {
+is( exception {
Foo->new(bar => {})
-} '... created new Foo with bar successfully set with a HASH ref';
+}, undef, '... created new Foo with bar successfully set with a HASH ref' );
-dies_ok {
+isnt( exception {
Foo->new(bar => 50)
-} '... didnt create a new Foo with bar as a number';
+}, undef, '... didnt create a new Foo with bar as a number' );
-dies_ok {
+isnt( exception {
Foo->new(bar => sub {})
-} '... didnt create a new Foo with bar as a CODE ref';
+}, undef, '... didnt create a new Foo with bar as a CODE ref' );
{
package Bar;
my $bar = Bar->new;
isa_ok($bar, 'Bar');
-lives_ok {
+is( exception {
$bar->baz('a string')
-} '... set baz successfully with a string';
+}, undef, '... set baz successfully with a string' );
-lives_ok {
+is( exception {
$bar->baz(sub { 'a sub' })
-} '... set baz successfully with a CODE ref';
+}, undef, '... set baz successfully with a CODE ref' );
-dies_ok {
+isnt( exception {
$bar->baz(\(my $var1))
-} '... couldnt set baz successfully with a SCALAR ref';
+}, undef, '... couldnt set baz successfully with a SCALAR ref' );
-dies_ok {
+isnt( exception {
$bar->baz({})
-} '... couldnt set bar successfully with a HASH ref';
+}, undef, '... couldnt set bar successfully with a HASH ref' );
# check the constructor
-lives_ok {
+is( exception {
Bar->new(baz => 'a string')
-} '... created new Bar with baz successfully set with a string';
+}, undef, '... created new Bar with baz successfully set with a string' );
-lives_ok {
+is( exception {
Bar->new(baz => sub { 'a sub' })
-} '... created new Bar with baz successfully set with a CODE ref';
+}, undef, '... created new Bar with baz successfully set with a CODE ref' );
-dies_ok {
+isnt( exception {
Bar->new(baz => \(my $var2))
-} '... didnt create a new Bar with baz as a number';
+}, undef, '... didnt create a new Bar with baz as a number' );
-dies_ok {
+isnt( exception {
Bar->new(baz => {})
-} '... didnt create a new Bar with baz as a HASH ref';
+}, undef, '... didnt create a new Bar with baz as a HASH ref' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
extends 'Foo';
- ::lives_ok {
+ ::is( ::exception {
has '+bar' => (default => 'Bar::bar');
- } '... we can change the default attribute option';
+ }, undef, '... we can change the default attribute option' );
- ::lives_ok {
+ ::is( ::exception {
has '+baz' => (isa => 'ArrayRef');
- } '... we can add change the isa as long as it is a subtype';
+ }, undef, '... we can add change the isa as long as it is a subtype' );
- ::lives_ok {
+ ::is( ::exception {
has '+foo' => (coerce => 1);
- } '... we can change/add coerce as an attribute option';
+ }, undef, '... we can change/add coerce as an attribute option' );
- ::lives_ok {
+ ::is( ::exception {
has '+gorch' => (required => 1);
- } '... we can change/add required as an attribute option';
+ }, undef, '... we can change/add required as an attribute option' );
- ::lives_ok {
+ ::is( ::exception {
has '+gloum' => (lazy => 1);
- } '... we can change/add lazy as an attribute option';
+ }, undef, '... we can change/add lazy as an attribute option' );
- ::lives_ok {
+ ::is( ::exception {
has '+fleem' => (lazy_build => 1);
- } '... we can add lazy_build as an attribute option';
+ }, undef, '... we can add lazy_build as an attribute option' );
- ::lives_ok {
+ ::is( ::exception {
has '+bunch_of_stuff' => (isa => 'ArrayRef[Int]');
- } '... extend an attribute with parameterized type';
+ }, undef, '... extend an attribute with parameterized type' );
- ::lives_ok {
+ ::is( ::exception {
has '+one_last_one' => (isa => subtype('Ref', where { blessed $_ eq 'CODE' }));
- } '... extend an attribute with anon-subtype';
+ }, undef, '... extend an attribute with anon-subtype' );
- ::lives_ok {
+ ::is( ::exception {
has '+one_last_one' => (isa => 'Value');
- } '... now can extend an attribute with a non-subtype';
+ }, undef, '... now can extend an attribute with a non-subtype' );
- ::lives_ok {
+ ::is( ::exception {
has '+fleem' => (weak_ref => 1);
- } '... now allowed to add the weak_ref option via inheritance';
+ }, undef, '... now allowed to add the weak_ref option via inheritance' );
- ::lives_ok {
+ ::is( ::exception {
has '+bling' => (handles => ['hello']);
- } '... we can add the handles attribute option';
+ }, undef, '... we can add the handles attribute option' );
# this one will *not* work here ....
- ::dies_ok {
+ ::isnt( ::exception {
has '+blang' => (handles => ['hello']);
- } '... we can not alter the handles attribute option';
- ::lives_ok {
+ }, undef, '... we can not alter the handles attribute option' );
+ ::is( ::exception {
has '+fail' => (isa => 'Ref');
- } '... can now create an attribute with an improper subtype relation';
- ::dies_ok {
+ }, undef, '... can now create an attribute with an improper subtype relation' );
+ ::isnt( ::exception {
has '+other_fail' => (trigger => sub {});
- } '... cannot create an attribute with an illegal option';
- ::throws_ok {
+ }, undef, '... cannot create an attribute with an illegal option' );
+ ::like( ::exception {
has '+does_not_exist' => (isa => 'Str');
- } qr/in Bar/, '... cannot extend a non-existing attribute';
+ }, qr/in Bar/, '... cannot extend a non-existing attribute' );
}
my $foo = Foo->new;
isa_ok($foo, 'Foo');
is($foo->foo, undef, '... got the right undef default value');
-lives_ok { $foo->foo('FooString') } '... assigned foo correctly';
+is( exception { $foo->foo('FooString') }, undef, '... assigned foo correctly' );
is($foo->foo, 'FooString', '... got the right value for foo');
-dies_ok { $foo->foo([]) } '... foo is not coercing (as expected)';
+isnt( exception { $foo->foo([]) }, undef, '... foo is not coercing (as expected)' );
is($foo->bar, 'Foo::bar', '... got the right default value');
-dies_ok { $foo->bar(10) } '... Foo::bar is a read/only attr';
+isnt( exception { $foo->bar(10) }, undef, '... Foo::bar is a read/only attr' );
is($foo->baz, undef, '... got the right undef default value');
{
my $hash_ref = {};
- lives_ok { $foo->baz($hash_ref) } '... Foo::baz accepts hash refs';
+ is( exception { $foo->baz($hash_ref) }, undef, '... Foo::baz accepts hash refs' );
is($foo->baz, $hash_ref, '... got the right value assigned to baz');
my $array_ref = [];
- lives_ok { $foo->baz($array_ref) } '... Foo::baz accepts an array ref';
+ is( exception { $foo->baz($array_ref) }, undef, '... Foo::baz accepts an array ref' );
is($foo->baz, $array_ref, '... got the right value assigned to baz');
my $scalar_ref = \(my $var);
- lives_ok { $foo->baz($scalar_ref) } '... Foo::baz accepts scalar ref';
+ is( exception { $foo->baz($scalar_ref) }, undef, '... Foo::baz accepts scalar ref' );
is($foo->baz, $scalar_ref, '... got the right value assigned to baz');
- lives_ok { $foo->bunch_of_stuff([qw[one two three]]) } '... Foo::bunch_of_stuff accepts an array of strings';
+ is( exception { $foo->bunch_of_stuff([qw[one two three]]) }, undef, '... Foo::bunch_of_stuff accepts an array of strings' );
- lives_ok { $foo->one_last_one(sub { 'Hello World'}) } '... Foo::one_last_one accepts a code ref';
+ is( exception { $foo->one_last_one(sub { 'Hello World'}) }, undef, '... Foo::one_last_one accepts a code ref' );
my $code_ref = sub { 1 };
- lives_ok { $foo->baz($code_ref) } '... Foo::baz accepts a code ref';
+ is( exception { $foo->baz($code_ref) }, undef, '... Foo::baz accepts a code ref' );
is($foo->baz, $code_ref, '... got the right value assigned to baz');
}
-dies_ok {
+isnt( exception {
Bar->new;
-} '... cannot create Bar without required gorch param';
+}, undef, '... cannot create Bar without required gorch param' );
my $bar = Bar->new(gorch => 'Bar::gorch');
isa_ok($bar, 'Bar');
isa_ok($bar, 'Foo');
is($bar->foo, undef, '... got the right undef default value');
-lives_ok { $bar->foo('FooString') } '... assigned foo correctly';
+is( exception { $bar->foo('FooString') }, undef, '... assigned foo correctly' );
is($bar->foo, 'FooString', '... got the right value for foo');
-lives_ok { $bar->foo([]) } '... assigned foo correctly';
+is( exception { $bar->foo([]) }, undef, '... assigned foo correctly' );
is($bar->foo, 'FooArrayRef', '... got the right value for foo');
is($bar->gorch, 'Bar::gorch', '... got the right default value');
is($bar->bar, 'Bar::bar', '... got the right default value');
-dies_ok { $bar->bar(10) } '... Bar::bar is a read/only attr';
+isnt( exception { $bar->bar(10) }, undef, '... Bar::bar is a read/only attr' );
is($bar->baz, undef, '... got the right undef default value');
{
my $hash_ref = {};
- dies_ok { $bar->baz($hash_ref) } '... Bar::baz does not accept hash refs';
+ isnt( exception { $bar->baz($hash_ref) }, undef, '... Bar::baz does not accept hash refs' );
my $array_ref = [];
- lives_ok { $bar->baz($array_ref) } '... Bar::baz can accept an array ref';
+ is( exception { $bar->baz($array_ref) }, undef, '... Bar::baz can accept an array ref' );
is($bar->baz, $array_ref, '... got the right value assigned to baz');
my $scalar_ref = \(my $var);
- dies_ok { $bar->baz($scalar_ref) } '... Bar::baz does not accept a scalar ref';
+ isnt( exception { $bar->baz($scalar_ref) }, undef, '... Bar::baz does not accept a scalar ref' );
- lives_ok { $bar->bunch_of_stuff([1, 2, 3]) } '... Bar::bunch_of_stuff accepts an array of ints';
- dies_ok { $bar->bunch_of_stuff([qw[one two three]]) } '... Bar::bunch_of_stuff does not accept an array of strings';
+ is( exception { $bar->bunch_of_stuff([1, 2, 3]) }, undef, '... Bar::bunch_of_stuff accepts an array of ints' );
+ isnt( exception { $bar->bunch_of_stuff([qw[one two three]]) }, undef, '... Bar::bunch_of_stuff does not accept an array of strings' );
my $code_ref = sub { 1 };
- dies_ok { $bar->baz($code_ref) } '... Bar::baz does not accept a code ref';
+ isnt( exception { $bar->baz($code_ref) }, undef, '... Bar::baz does not accept a code ref' );
}
# check some meta-stuff
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
# -------------------------------------------------------------------
is($foo->bar, 25, '... got the right foo->bar');
-lives_ok {
+is( exception {
$bar->foo($foo);
-} '... assigned the new Foo to Bar->foo';
+}, undef, '... assigned the new Foo to Bar->foo' );
is($bar->foo, $foo, '... assigned bar->foo with the new Foo');
package Goorch::Autoloaded;
use Moose;
- ::dies_ok {
+ ::isnt( ::exception {
has 'foo' => (
is => 'rw',
default => sub { Foo::Autoloaded->new },
handles => qr/bar/
);
- } '... you cannot delegate to AUTOLOADED class with regexp';
+ }, undef, '... you cannot delegate to AUTOLOADED class with regexp' );
}
# check HASH based delegation w/ AUTOLOAD
is($foo->bar, 25, '... got the right foo->bar');
- lives_ok {
+ is( exception {
$bar->foo($foo);
- } '... assigned the new Foo to Bar->foo';
+ }, undef, '... assigned the new Foo to Bar->foo' );
is($bar->foo, $foo, '... assigned bar->foo with the new Foo');
is($foo->bar, 25, '... got the right foo->bar');
- lives_ok {
+ is( exception {
$baz->foo($foo);
- } '... assigned the new Foo to Baz->foo';
+ }, undef, '... assigned the new Foo to Baz->foo' );
is($baz->foo, $foo, '... assigned baz->foo with the new Foo');
# not an object
{
my $i = Bar->new(foo => undef);
- throws_ok { $i->foo_bar } qr/is not defined/,
- 'useful error from unblessed reference';
+ like( exception { $i->foo_bar }, qr/is not defined/, 'useful error from unblessed reference' );
my $j = Bar->new(foo => []);
- throws_ok { $j->foo_bar } qr/is not an object \(got 'ARRAY/,
- 'useful error from unblessed reference';
+ like( exception { $j->foo_bar }, qr/is not an object \(got 'ARRAY/, 'useful error from unblessed reference' );
my $k = Bar->new(foo => "Foo");
- lives_ok { $k->foo_baz } "but not for class name";
+ is( exception { $k->foo_baz }, undef, "but not for class name" );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
sub parent_method_1 { "parent_1" }
::can_ok('Parent', 'parent_method_1');
- ::dies_ok {
+ ::isnt( ::exception {
has child_a => (
is => "ro",
default => sub { ChildA->new },
handles => qr/.*/,
);
- } "all_methods requires explicit isa";
+ }, undef, "all_methods requires explicit isa" );
- ::lives_ok {
+ ::is( ::exception {
has child_a => (
isa => "ChildA",
is => "ro",
default => sub { ChildA->new },
handles => qr/.*/,
);
- } "allow all_methods with explicit isa";
+ }, undef, "allow all_methods with explicit isa" );
- ::lives_ok {
+ ::is( ::exception {
has child_b => (
is => 'ro',
default => sub { ChildB->new },
handles => [qw/child_b_method_1/],
);
- } "don't need to declare isa if method list is predefined";
+ }, undef, "don't need to declare isa if method list is predefined" );
- ::lives_ok {
+ ::is( ::exception {
has child_c => (
isa => "ChildC",
is => "ro",
default => sub { ChildC->new },
handles => qr/_la$/,
);
- } "can declare regex collector";
+ }, undef, "can declare regex collector" );
- ::dies_ok {
+ ::isnt( ::exception {
has child_d => (
is => "ro",
default => sub { ChildD->new },
my ( $class, $delegate_class ) = @_;
}
);
- } "can't create attr with generative handles parameter and no isa";
+ }, undef, "can't create attr with generative handles parameter and no isa" );
- ::lives_ok {
+ ::is( ::exception {
has child_d => (
isa => "ChildD",
is => "ro",
return;
}
);
- } "can't create attr with generative handles parameter and no isa";
+ }, undef, "can't create attr with generative handles parameter and no isa" );
- ::lives_ok {
+ ::is( ::exception {
has child_e => (
isa => "ChildE",
is => "ro",
default => sub { ChildE->new },
handles => ["child_e_method_2"],
);
- } "can delegate to non moose class using explicit method list";
+ }, undef, "can delegate to non moose class using explicit method list" );
my $delegate_class;
- ::lives_ok {
+ ::is( ::exception {
has child_f => (
isa => "ChildF",
is => "ro",
return;
},
);
- } "subrefs on non moose class give no meta";
+ }, undef, "subrefs on non moose class give no meta" );
::is( $delegate_class, "ChildF", "plain classes are handed down to subs" );
- ::lives_ok {
+ ::is( ::exception {
has child_g => (
isa => "ChildG",
default => sub { ChildG->new },
handles => ["child_g_method_1"],
);
- } "can delegate to object even without explicit reader";
+ }, undef, "can delegate to object even without explicit reader" );
::can_ok('Parent', 'parent_method_1');
- ::dies_ok {
+ ::isnt( ::exception {
has child_h => (
isa => "ChildH",
is => "ro",
default => sub { ChildH->new },
handles => sub { map { $_, $_ } $_[1]->get_all_method_names },
);
- } "Can't override exisiting class method in delegate";
+ }, undef, "Can't override exisiting class method in delegate" );
::can_ok('Parent', 'parent_method_1');
- ::lives_ok {
+ ::is( ::exception {
has child_i => (
isa => "ChildI",
is => "ro",
$_[1]->get_all_method_names;
},
);
- } "Test handles code ref for skipping predefined methods";
+ }, undef, "Test handles code ref for skipping predefined methods" );
sub parent_method { "p" }
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
my $test = Test::For::Lazy::TypeConstraint->new;
isa_ok($test, 'Test::For::Lazy::TypeConstraint');
- dies_ok {
+ isnt( exception {
$test->bad_lazy_attr;
- } '... this does not work';
+ }, undef, '... this does not work' );
- lives_ok {
+ is( exception {
$test->good_lazy_attr;
- } '... this does not work';
+ }, undef, '... this does not work' );
}
{
}
- dies_ok {
+ isnt( exception {
Test::UndefDefault::Attributes->new;
- } '... default must return a value which passes the type constraint';
+ }, undef, '... default must return a value which passes the type constraint' );
}
is($moose_obj->a_str( 'foobar' ), 'foobar', 'setter took string');
ok($moose_obj, 'this is a *not* a string');
- throws_ok {
+ like( exception {
$moose_obj->a_str( $moose_obj )
- } qr/Attribute \(a_str\) does not pass the type constraint because\: Validation failed for 'Str' with value OverloadedStr=HASH\(0x.+?\)/,
- '... dies without overloading the string';
+ }, qr/Attribute \(a_str\) does not pass the type constraint because\: Validation failed for 'Str' with value OverloadedStr=HASH\(0x.+?\)/, '... dies without overloading the string' );
}
has 'a_num' => ( isa => 'Int' , is => 'rw', default => 7.5 );
}
- throws_ok {
+ like( exception {
OverloadBreaker->new;
- } qr/Attribute \(a_num\) does not pass the type constraint because\: Validation failed for 'Int' with value 7\.5/,
- '... this doesnt trip overload to break anymore ';
+ }, qr/Attribute \(a_num\) does not pass the type constraint because\: Validation failed for 'Int' with value 7\.5/, '... this doesnt trip overload to break anymore ' );
- lives_ok {
+ is( exception {
OverloadBreaker->new(a_num => 5);
- } '... this works fine though';
+ }, undef, '... this works fine though' );
}
has 'foo' => ( required => 1, builder => 'build_foo', is => 'ro');
}
- dies_ok {
+ isnt( exception {
Test::Builder::Attribute::Broken->new;
- } '... no builder, wtf';
+ }, undef, '... no builder, wtf' );
}
ok(!$instance->_has_foo, "noo _foo value yet");
is($instance->foo, 'works', "foo builder works");
is($instance->_foo, 'works too', "foo builder works too");
- throws_ok { $instance->fool }
- qr/Test::LazyBuild::Attribute does not support builder method \'_build_fool\' for attribute \'fool\'/,
- "Correct error when a builder method is not present";
+ like( exception { $instance->fool }, qr/Test::LazyBuild::Attribute does not support builder method \'_build_fool\' for attribute \'fool\'/, "Correct error when a builder method is not present" );
}
use Moose;
}
-lives_ok { OutOfClassTest::has('foo', is => 'bare'); } 'create attr via direct sub call';
-lives_ok { OutOfClassTest->can('has')->('bar', is => 'bare'); } 'create attr via can';
+is( exception { OutOfClassTest::has('foo', is => 'bare'); }, undef, 'create attr via direct sub call' );
+is( exception { OutOfClassTest->can('has')->('bar', is => 'bare'); }, undef, 'create attr via can' );
ok(OutOfClassTest->meta->get_attribute('foo'), 'attr created from sub call');
ok(OutOfClassTest->meta->get_attribute('bar'), 'attr created from can');
package Foo;
use Moose;
- ::throws_ok { has 'foo' => ( 'ro', isa => 'Str' ) }
- qr/^Usage/, 'has throws error with odd number of attribute options';
+ ::like( ::exception { has 'foo' => ( 'ro', isa => 'Str' ) }, qr/^Usage/, 'has throws error with odd number of attribute options' );
}
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
use Moose;
use Moose::Util::TypeConstraints;
- ::lives_ok {
+ ::is( ::exception {
has 'customers' => (
is => 'ro',
isa => subtype('ArrayRef' => where {
(blessed($_) && $_->isa('Customer') || return) for @$_; 1 }),
auto_deref => 1,
);
- } '... successfully created attr';
+ }, undef, '... successfully created attr' );
}
{
{
my $autoderef = AutoDeref->new;
- dies_ok {
+ isnt( exception {
$autoderef->bar(1, 2, 3);
- } '... its auto-de-ref-ing, not auto-en-ref-ing';
+ }, undef, '... its auto-de-ref-ing, not auto-en-ref-ing' );
- lives_ok {
+ is( exception {
$autoderef->bar([ 1, 2, 3 ])
- } '... set the results of bar correctly';
+ }, undef, '... set the results of bar correctly' );
is_deeply [ $autoderef->bar ], [ 1, 2, 3 ], '... auto-dereffed correctly';
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
my $r = Request->new;
isa_ok($r, 'Request');
-lives_ok {
+is( exception {
$r->headers;
-} '... this coerces and passes the type constraint even with lazy';
+}, undef, '... this coerces and passes the type constraint even with lazy' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
__PACKAGE__->meta->make_immutable;
}
-dies_ok {
+isnt( exception {
Fail::Bar->new(foo => 10)
-} '... this fails, because initializer returns a bad type';
+}, undef, '... this fails, because initializer returns a bad type' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
$obj = $class->new();
can_ok($obj, qw/foo _foo/);
-lives_ok {$obj->_foo(1)} "$class->_foo is writer";
+is( exception {$obj->_foo(1)}, undef, "$class->_foo is writer" );
is($obj->foo(), 1, "$class->foo is reader");
-dies_ok {$obj->foo(2)} "$class->foo is not writer"; # this should fail
+isnt( exception {$obj->foo(2)}, undef, "$class->foo is not writer" ); # this should fail
ok(!defined $obj->_foo(), "$class->_foo is not reader");
$class = make_class('ro', 'writer', 'Test::Class::WriterRO');
$obj = $class->new();
can_ok($obj, qw/foo _foo/);
-lives_ok {$obj->_foo(1)} "$class->_foo is writer";
+is( exception {$obj->_foo(1)}, undef, "$class->_foo is writer" );
is($obj->foo(), 1, "$class->foo is reader");
-dies_ok {$obj->foo(1)} "$class->foo is not writer";
+isnt( exception {$obj->foo(1)}, undef, "$class->foo is not writer" );
isnt($obj->_foo(), 1, "$class->_foo is not reader");
$class = make_class('rw', 'accessor', 'Test::Class::AccessorRW');
$obj = $class->new();
can_ok($obj, qw/_foo/);
-lives_ok {$obj->_foo(1)} "$class->_foo is writer";
+is( exception {$obj->_foo(1)}, undef, "$class->_foo is writer" );
is($obj->_foo(), 1, "$class->foo is reader");
-dies_ok { make_class('ro', 'accessor', "Test::Class::AccessorRO"); } "Cant define attr with ro + accessor";
+isnt( exception { make_class('ro', 'accessor', "Test::Class::AccessorRO"); }, undef, "Cant define attr with ro + accessor" );
done_testing;
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Foo;
extends 'Foo';
- ::lives_ok { has '+foo' => (is => 'rw') } "can override is";
- ::throws_ok { has '+foo' => (reader => 'bar') } qr/illegal/, "can't override reader";
- ::lives_ok { has '+foo' => (clearer => 'baz') } "can override unspecified things";
+ ::is( ::exception { has '+foo' => (is => 'rw') }, undef, "can override is" );
+ ::like( ::exception { has '+foo' => (reader => 'bar') }, qr/illegal/, "can't override reader" );
+ ::is( ::exception { has '+foo' => (clearer => 'baz') }, undef, "can override unspecified things" );
- ::throws_ok { has '+bar' => (clearer => 'quux') } qr/illegal/, "can't override clearer";
- ::lives_ok { has '+bar' => (predicate => 'has_bar') } "can override unspecified things";
+ ::like( ::exception { has '+bar' => (clearer => 'quux') }, qr/illegal/, "can't override clearer" );
+ ::is( ::exception { has '+bar' => (predicate => 'has_bar') }, undef, "can override unspecified things" );
}
{
package Bar;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has bar => (
traits => ['Bar::Meta::Attribute'],
my_illegal_option => 'FOO',
is => 'bare',
);
- } "can use illegal options";
+ }, undef, "can use illegal options" );
has baz => (
traits => ['Bar::Meta::Attribute'],
extends 'Bar';
- ::throws_ok { has '+bar' => (my_illegal_option => 'BAR') }
- qr/illegal/,
- "can't override illegal attribute";
- ::lives_ok { has '+baz' => (my_illegal_option => 'BAR') }
- "can add illegal option if superclass doesn't set it";
+ ::like( ::exception { has '+bar' => (my_illegal_option => 'BAR') }, qr/illegal/, "can't override illegal attribute" );
+ ::is( ::exception { has '+baz' => (my_illegal_option => 'BAR') }, undef, "can add illegal option if superclass doesn't set it" );
}
my $bar_attr = Bar->meta->get_attribute('bar');
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
my $exception_regex = qr/You must provide a name for the attribute/;
{
package My::Role;
use Moose::Role;
- ::throws_ok {
+ ::like( ::exception {
has;
- } $exception_regex, 'has; fails';
+ }, $exception_regex, 'has; fails' );
- ::throws_ok {
+ ::like( ::exception {
has undef;
- } $exception_regex, 'has undef; fails';
+ }, $exception_regex, 'has undef; fails' );
- ::lives_ok {
+ ::is( ::exception {
has "" => (
is => 'bare',
);
- } 'has ""; works now';
+ }, undef, 'has ""; works now' );
- ::lives_ok {
+ ::is( ::exception {
has 0 => (
is => 'bare',
);
- } 'has 0; works now';
+ }, undef, 'has 0; works now' );
}
{
package My::Class;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
has;
- } $exception_regex, 'has; fails';
+ }, $exception_regex, 'has; fails' );
- ::throws_ok {
+ ::like( ::exception {
has undef;
- } $exception_regex, 'has undef; fails';
+ }, $exception_regex, 'has undef; fails' );
- ::lives_ok {
+ ::is( ::exception {
has "" => (
is => 'bare',
);
- } 'has ""; works now';
+ }, undef, 'has ""; works now' );
- ::lives_ok {
+ ::is( ::exception {
has 0 => (
is => 'bare',
);
- } 'has 0; works now';
+ }, undef, 'has 0; works now' );
}
done_testing;
use Moose::Util::MetaRole;
use Test::More;
- use Test::Exception;
+ use Test::Fatal;
Moose::Util::MetaRole::apply_metaroles(
for => __PACKAGE__,
class_metaroles => { instance => ['MooseX::SomeAwesomeDBFields'] },
);
- lives_ok {
+ is( exception {
has lazy_attr => (
is => 'ro',
isa => 'Bool',
lazy => 1,
default => sub {0},
);
- }
- "Adding lazy accessor does not use inline_slot_access";
+ }, undef, "Adding lazy accessor does not use inline_slot_access" );
- lives_ok {
+ is( exception {
has rw_attr => (
is => 'rw',
);
- }
- "Adding read-write accessor does not use inline_slot_access";
+ }, undef, "Adding read-write accessor does not use inline_slot_access" );
- lives_ok { __PACKAGE__->meta->make_immutable; }
- "Inling constructor does not use inline_slot_access";
+ is( exception { __PACKAGE__->meta->make_immutable; }, undef, "Inling constructor does not use inline_slot_access" );
done_testing;
}
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
-lives_ok {
+is( exception {
package My::Class;
use Moose;
auto_deref => 1,
);
-} 'class definition';
+}, undef, 'class definition' );
-lives_ok {
+is( exception {
my $o = My::Class->new();
is_deeply [scalar $o->s_rw], [undef], 'uninitialized scalar attribute/rw in scalar context';
is_deeply [scalar $o->h_ro], [undef], 'uninitialized HashRef attribute/ro in scalar context';
is_deeply [$o->h_ro], [], 'uninitialized HashRef attribute/ro in list context';
-} 'testing';
+}, undef, 'testing' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role;
use Moose::Util::TypeConstraints ();
ok(!$foo_role->has_attribute('bar'), '... FooRole does not have the bar attribute');
-lives_ok {
+is( exception {
$foo_role->add_attribute('bar' => (is => 'rw', isa => 'Foo'));
-} '... added the bar attribute okay';
+}, undef, '... added the bar attribute okay' );
is_deeply(
[ $foo_role->get_attribute_list() ],
'bar has a Foo class type'
);
-lives_ok {
+is( exception {
$foo_role->add_attribute('baz' => (is => 'ro'));
-} '... added the baz attribute okay';
+}, undef, '... added the baz attribute okay' );
is_deeply(
[ sort $foo_role->get_attribute_list() ],
is_deeply( $baz->original_options, { is => 'ro' },
'original options for baz attribute' );
-lives_ok {
+is( exception {
$foo_role->remove_attribute('bar');
-} '... removed the bar attribute okay';
+}, undef, '... removed the bar attribute okay' );
is_deeply(
[ $foo_role->get_attribute_list() ],
ok(!$foo_role->has_before_method_modifiers('boo'), '... no boo:before modifier');
my $method = sub { "FooRole::boo:before" };
-lives_ok {
+is( exception {
$foo_role->add_before_method_modifier('boo' => $method);
-} '... added a method modifier okay';
+}, undef, '... added a method modifier okay' );
ok($foo_role->has_before_method_modifiers('boo'), '... now we have a boo:before modifier');
is(($foo_role->get_before_method_modifiers('boo'))[0], $method, '... got the right method back');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
override 'bling' => sub { "FooRole::bling:override" };
override 'fling' => sub { "FooRole::fling:override" };
- ::dies_ok { extends() } '... extends() is not supported';
- ::dies_ok { augment() } '... augment() is not supported';
- ::dies_ok { inner() } '... inner() is not supported';
+ ::isnt( ::exception { extends() }, undef, '... extends() is not supported' );
+ ::isnt( ::exception { augment() }, undef, '... augment() is not supported' );
+ ::isnt( ::exception { inner() }, undef, '... inner() is not supported' );
no Moose::Role;
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package FooRole;
extends 'BarClass';
- ::throws_ok { with 'FooRole' => { -version => 42 } }
- qr/FooRole version 42 required--this is only version 23/,
- 'applying role with unsatisfied version requirement';
+ ::like( ::exception { with 'FooRole' => { -version => 42 } }, qr/FooRole version 42 required--this is only version 23/, 'applying role with unsatisfied version requirement' );
- ::lives_ok { with 'FooRole' => { -version => 13 } }
- 'applying role with satisfied version requirement';
+ ::is( ::exception { with 'FooRole' => { -version => 13 } }, undef, 'applying role with satisfied version requirement' );
sub blau {'FooClass::blau'} # << the role wraps this ...
my $foobar_class_meta = FooBarClass->meta;
isa_ok( $foobar_class_meta, 'Moose::Meta::Class' );
-dies_ok {
+isnt( exception {
$foo_class_meta->does_role();
-}
-'... does_role requires a role name';
+}, undef, '... does_role requires a role name' );
-dies_ok {
+isnt( exception {
$foo_class_meta->add_role();
-}
-'... apply_role requires a role';
+}, undef, '... apply_role requires a role' );
-dies_ok {
+isnt( exception {
$foo_class_meta->add_role( bless( {} => 'Fail' ) );
-}
-'... apply_role requires a role';
+}, undef, '... apply_role requires a role' );
ok( $foo_class_meta->does_role('FooRole'),
'... the FooClass->meta does_role FooRole' );
ok( !defined( $foo->baz ), '... $foo->baz is undefined' );
ok( !defined( $foo->bar ), '... $foo->bar is undefined' );
- dies_ok {
+ isnt( exception {
$foo->baz(1);
- }
- '... baz is a read-only accessor';
+ }, undef, '... baz is a read-only accessor' );
- dies_ok {
+ isnt( exception {
$foo->bar(1);
- }
- '... bar is a read-write accessor with a type constraint';
+ }, undef, '... bar is a read-write accessor with a type constraint' );
my $foo2 = FooClass->new();
isa_ok( $foo2, 'FooClass' );
- lives_ok {
+ is( exception {
$foo->bar($foo2);
- }
- '... bar is a read-write accessor with a type constraint';
+ }, undef, '... bar is a read-write accessor with a type constraint' );
is( $foo->bar, $foo2, '... got the right value for bar now' );
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Foo::Class;
use Moose;
- ::dies_ok { with('Foo::Role') }
- '... no foo method implemented by Foo::Class';
+ ::isnt( ::exception { with('Foo::Role') }, undef, '... no foo method implemented by Foo::Class' );
}
# class which does implement required method
package Bar::Class;
use Moose;
- ::dies_ok { with('Foo::Class') }
- '... cannot consume a class, it must be a role';
- ::lives_ok { with('Foo::Role') }
- '... has a foo method implemented by Bar::Class';
+ ::isnt( ::exception { with('Foo::Class') }, undef, '... cannot consume a class, it must be a role' );
+ ::is( ::exception { with('Foo::Role') }, undef, '... has a foo method implemented by Bar::Class' );
sub foo {'Bar::Class::foo'}
}
package Bar::Role;
use Moose::Role;
- ::lives_ok { with('Foo::Role') }
- '... has a foo method implemented by Bar::Role';
+ ::is( ::exception { with('Foo::Role') }, undef, '... has a foo method implemented by Bar::Role' );
sub foo {'Bar::Role::foo'}
}
package Baz::Role;
use Moose::Role;
- ::lives_ok { with('Foo::Role') }
- '... no foo method implemented by Baz::Role';
+ ::is( ::exception { with('Foo::Role') }, undef, '... no foo method implemented by Baz::Role' );
}
is_deeply(
package Baz::Class;
use Moose;
- ::dies_ok { with('Baz::Role') }
- '... no foo method implemented by Baz::Class2';
+ ::isnt( ::exception { with('Baz::Role') }, undef, '... no foo method implemented by Baz::Class2' );
}
# class which does implement required method
package Baz::Class2;
use Moose;
- ::lives_ok { with('Baz::Role') }
- '... has a foo method implemented by Baz::Class2';
+ ::is( ::exception { with('Baz::Role') }, undef, '... has a foo method implemented by Baz::Class2' );
sub foo {'Baz::Class2::foo'}
}
package Quux::Class;
use Moose;
- ::throws_ok { with('Quux::Role') }
- qr/\Q'Quux::Role' requires the methods 'meth1', 'meth2', 'meth3', and 'meth4' to be implemented by 'Quux::Class'/,
- 'exception mentions all the missing required methods at once';
+ ::like( ::exception { with('Quux::Role') }, qr/\Q'Quux::Role' requires the methods 'meth1', 'meth2', 'meth3', and 'meth4' to be implemented by 'Quux::Class'/, 'exception mentions all the missing required methods at once' );
}
{
sub meth1 { }
- ::throws_ok { with('Quux::Role') }
- qr/'Quux::Role' requires the methods 'meth2', 'meth3', and 'meth4' to be implemented by 'Quux::Class2'/,
- 'exception mentions all the missing required methods at once, but not the one that exists';
+ ::like( ::exception { with('Quux::Role') }, qr/'Quux::Role' requires the methods 'meth2', 'meth3', and 'meth4' to be implemented by 'Quux::Class2'/, 'exception mentions all the missing required methods at once, but not the one that exists' );
}
{
has 'meth1' => ( is => 'ro' );
has 'meth2' => ( is => 'ro' );
- ::throws_ok { with('Quux::Role') }
- qr/'Quux::Role' requires the methods 'meth3' and 'meth4' to be implemented by 'Quux::Class3'/,
- 'exception mentions all the missing methods at once, but not the accessors';
+ ::like( ::exception { with('Quux::Role') }, qr/'Quux::Role' requires the methods 'meth3' and 'meth4' to be implemented by 'Quux::Class3'/, 'exception mentions all the missing methods at once, but not the accessors' );
}
{
sub meth1 { }
has 'meth2' => ( is => 'ro' );
- ::throws_ok { with('Quux::Role') }
- qr/'Quux::Role' requires the methods 'meth3' and 'meth4' to be implemented by 'Quux::Class4'/,
- 'exception mentions all the require methods that are accessors at once, as well as missing methods, but not the one that exists';
+ ::like( ::exception { with('Quux::Role') }, qr/'Quux::Role' requires the methods 'meth3' and 'meth4' to be implemented by 'Quux::Class4'/, 'exception mentions all the require methods that are accessors at once, as well as missing methods, but not the one that exists' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
package My::Test1;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Foo', 'Role::Bar';
- } '... our mutually recursive roles combine okay';
+ }, undef, '... our mutually recursive roles combine okay' );
package My::Test2;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Bar', 'Role::Foo';
- } '... our mutually recursive roles combine okay (no matter what order)';
+ }, undef, '... our mutually recursive roles combine okay (no matter what order)' );
}
my $test1 = My::Test1->new;
package My::Test3;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Role::Bling', 'Role::Bling::Bling';
- } qr/Due to a method name conflict in roles 'Role::Bling' and 'Role::Bling::Bling', the method 'bling' must be implemented or excluded by 'My::Test3'/, '... role methods conflict and method was required';
+ }, qr/Due to a method name conflict in roles 'Role::Bling' and 'Role::Bling::Bling', the method 'bling' must be implemented or excluded by 'My::Test3'/, '... role methods conflict and method was required' );
package My::Test4;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Bling';
with 'Role::Bling::Bling';
- } '... role methods didnt conflict when manually combined';
+ }, undef, '... role methods didnt conflict when manually combined' );
package My::Test5;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Bling::Bling';
with 'Role::Bling';
- } '... role methods didnt conflict when manually combined (in opposite order)';
+ }, undef, '... role methods didnt conflict when manually combined (in opposite order)' );
package My::Test6;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Bling::Bling', 'Role::Bling';
- } '... role methods didnt conflict when manually resolved';
+ }, undef, '... role methods didnt conflict when manually resolved' );
sub bling { 'My::Test6::bling' }
}
package My::Test7;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Role::Boo', 'Role::Boo::Hoo';
- } qr/We have encountered an attribute conflict.+ghost/;
+ }, qr/We have encountered an attribute conflict.+ghost/ );
package My::Test8;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Boo';
with 'Role::Boo::Hoo';
- } '... role attrs didnt conflict when manually combined';
+ }, undef, '... role attrs didnt conflict when manually combined' );
package My::Test9;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Boo::Hoo';
with 'Role::Boo';
- } '... role attrs didnt conflict when manually combined';
+ }, undef, '... role attrs didnt conflict when manually combined' );
package My::Test10;
use Moose;
has 'ghost' => (is => 'ro', default => 'My::Test10::ghost');
- ::throws_ok {
+ ::like( ::exception {
with 'Role::Boo', 'Role::Boo::Hoo';
- } qr/We have encountered an attribute conflict/,
- '... role attrs conflict and cannot be manually disambiguted';
+ }, qr/We have encountered an attribute conflict/, '... role attrs conflict and cannot be manually disambiguted' );
}
extends 'My::Test::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Truth';
- } '... composed the role with override okay';
+ }, undef, '... composed the role with override okay' );
package My::Test12;
use Moose;
extends 'My::Test::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Plot';
- } '... composed the role with override okay';
+ }, undef, '... composed the role with override okay' );
package My::Test13;
use Moose;
- ::dies_ok {
+ ::isnt( ::exception {
with 'Role::Plot';
- } '... cannot compose it because we have no superclass';
+ }, undef, '... cannot compose it because we have no superclass' );
package My::Test14;
use Moose;
extends 'My::Test::Base';
- ::throws_ok {
+ ::like( ::exception {
with 'Role::Plot', 'Role::Truth';
- } qr/Two \'override\' methods of the same name encountered/,
- '... cannot compose it because we have no superclass';
+ }, qr/Two \'override\' methods of the same name encountered/, '... cannot compose it because we have no superclass' );
}
ok(My::Test11->meta->has_method('twist'), '... the twist method has been added');
package Role::Reality;
use Moose::Role;
- ::throws_ok {
+ ::like( ::exception {
with 'Role::Plot';
- } qr/A local method of the same name as been found/,
- '... could not compose roles here, it dies';
+ }, qr/A local method of the same name as been found/, '... could not compose roles here, it dies' );
sub twist {
'Role::Reality::twist';
package Conflicts;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with qw(Role1 Role2);
- } qr/Due to a method name conflict in roles 'Role1' and 'Role2', the method 'foo' must be implemented or excluded by 'Conflicts'/;
+ }, qr/Due to a method name conflict in roles 'Role1' and 'Role2', the method 'foo' must be implemented or excluded by 'Conflicts'/ );
}
=pod
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
package My::Test1;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Molecule::Organic';
- } '... adding the role (w/ excluded roles) okay';
+ }, undef, '... adding the role (w/ excluded roles) okay' );
package My::Test2;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Molecule::Organic', 'Molecule::Inorganic';
- } qr/Conflict detected: Role Molecule::Organic excludes role 'Molecule::Inorganic'/,
- '... adding the role w/ excluded role conflict dies okay';
+ }, qr/Conflict detected: Role Molecule::Organic excludes role 'Molecule::Inorganic'/, '... adding the role w/ excluded role conflict dies okay' );
package My::Test3;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Molecule::Organic';
- } '... adding the role (w/ excluded roles) okay';
+ }, undef, '... adding the role (w/ excluded roles) okay' );
- ::throws_ok {
+ ::like( ::exception {
with 'Molecule::Inorganic';
- } qr/Conflict detected: My::Test3 excludes role 'Molecule::Inorganic'/,
- '... adding the role w/ excluded role conflict dies okay';
+ }, qr/Conflict detected: My::Test3 excludes role 'Molecule::Inorganic'/, '... adding the role w/ excluded role conflict dies okay' );
}
ok(My::Test1->does('Molecule::Organic'), '... My::Test1 does Molecule::Organic');
extends 'Methane';
- ::throws_ok {
+ ::like( ::exception {
with 'Molecule::Inorganic';
- } qr/Conflict detected: My::Test4 excludes role \'Molecule::Inorganic\'/,
- '... cannot add exculded role into class which extends Methane';
+ }, qr/Conflict detected: My::Test4 excludes role \'Molecule::Inorganic\'/, '... cannot add exculded role into class which extends Methane' );
}
ok(Methane->does('Molecule::Organic'), '... Methane does Molecule::Organic');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
use warnings;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method will not exist yet (but we will live)';
+ }, undef, '... the required "foo" method will not exist yet (but we will live)' );
override 'foo' => sub { 'Role::ProvideFoo::foo' };
}
extends 'Class::ProvideFoo::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method will be found in the superclass';
+ }, undef, '... the required "foo" method will be found in the superclass' );
override 'foo' => sub { 'Class::ProvideFoo::foo' };
override 'foo' => sub { 'Class::ProvideFoo::foo' };
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method exists, although it is overriden locally';
+ }, undef, '... the required "foo" method exists, although it is overriden locally' );
}
extends 'Class::ProvideFoo::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method will be found in the superclass';
+ }, undef, '... the required "foo" method will be found in the superclass' );
before 'foo' => sub { 'Class::ProvideFoo::foo:before' };
before 'foo' => sub { 'Class::ProvideFoo::foo:before' };
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method exists, although it is a before modifier locally';
+ }, undef, '... the required "foo" method exists, although it is a before modifier locally' );
package Class::ProvideFoo::Before3;
use Moose;
sub foo { 'Class::ProvideFoo::foo' }
before 'foo' => sub { 'Class::ProvideFoo::foo:before' };
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method exists locally, and it is modified locally';
+ }, undef, '... the required "foo" method exists locally, and it is modified locally' );
package Class::ProvideFoo::Before4;
use Moose;
::is(__PACKAGE__->meta->get_method('foo')->get_original_method->package_name, __PACKAGE__,
'... but the original method is from our package');
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method exists in the symbol table (and we will live)';
+ }, undef, '... the required "foo" method exists in the symbol table (and we will live)' );
}
extends 'Class::ProvideFoo::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method will be found in the superclass (but then overriden)';
+ }, undef, '... the required "foo" method will be found in the superclass (but then overriden)' );
has 'foo' => (is => 'ro');
has 'foo' => (is => 'ro');
- ::lives_ok {
+ ::is( ::exception {
with 'Role::RequireFoo';
- } '... the required "foo" method exists, and is an accessor';
+ }, undef, '... the required "foo" method exists, and is an accessor' );
}
# ...
use Moose;
extends 'Foo::Class::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role';
- } '... our role combined successfully';
+ }, undef, '... our role combined successfully' );
}
# a method required in a role and implemented in a superclass, with a method
package Bar::Class::Grandchild;
use Moose;
extends 'Bar::Class::Child';
- ::lives_ok {
+ ::is( ::exception {
with 'Bar::Role';
- } 'required method exists in superclass as non-modifier, so we live';
+ }, undef, 'required method exists in superclass as non-modifier, so we live' );
}
{
package Bar2::Class::Grandchild;
use Moose;
extends 'Bar2::Class::Child';
- ::lives_ok {
+ ::is( ::exception {
with 'Bar2::Role';
- } 'required method exists in superclass as non-modifier, so we live';
+ }, undef, 'required method exists in superclass as non-modifier, so we live' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
package My::Test::Class1;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Derived1', 'Role::Derived2';
- } '... roles composed okay (no conflicts)';
+ }, undef, '... roles composed okay (no conflicts)' );
}
ok(Role::Base->meta->has_method('foo'), '... have the method foo as expected');
extends 'My::Test::Class2::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Derived3', 'Role::Derived4';
- } '... roles composed okay (no conflicts)';
+ }, undef, '... roles composed okay (no conflicts)' );
}
ok(Role::Base2->meta->has_override_method_modifier('foo'), '... have the method foo as expected');
extends 'My::Test::Class3::Base';
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Derived5', 'Role::Derived6';
- } '... roles composed okay (no conflicts)';
+ }, undef, '... roles composed okay (no conflicts)' );
}
ok(Role::Base3->meta->has_around_method_modifiers('foo'), '... have the method foo as expected');
package My::Test::Class4;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Derived7', 'Role::Derived8';
- } '... roles composed okay (no conflicts)';
+ }, undef, '... roles composed okay (no conflicts)' );
}
ok(Role::Base4->meta->has_attribute('foo'), '... have the attribute foo as expected');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package SubAB;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with "SubAA", "RootA";
- } '... role was composed as expected';
+ }, undef, '... role was composed as expected' );
}
ok( SubAB->does("SubAA"), "does SubAA");
can_ok( $i, "foo" );
my $foo_rv;
- lives_ok {
+ is( exception {
$foo_rv = $i->foo;
- } '... called foo successfully';
+ }, undef, '... called foo successfully' );
is($foo_rv, "RootA::foo", "... got the right foo rv");
}
package SubBB;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with "SubBA";
- } '... composed the role successfully';
+ }, undef, '... composed the role successfully' );
}
ok( SubBB->does("SubBA"), "BB does SubBA" );
can_ok( $i, "foo" );
my $foo_rv;
- lives_ok {
+ is( exception {
$foo_rv = $i->foo
- } '... called foo successfully';
+ }, undef, '... called foo successfully' );
is( $foo_rv, "RootB::foo", "foo rv" );
is( $i->counter, 1, "after hook called" );
- lives_ok { $i->foo } '... called foo successfully (again)';
+ is( exception { $i->foo }, undef, '... called foo successfully (again)' );
is( $i->counter, 2, "after hook called (again)" );
ok(SubBA->meta->has_method('foo'), '... this has the foo method');
with "RootC";
- ::dies_ok {
+ ::isnt( ::exception {
override foo => sub { "overridden" };
- } '... cannot compose an override over a local method';
+ }, undef, '... cannot compose an override over a local method' );
}
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Role::C;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::A Role::B); # no conflict here
- } "define role C";
+ }, undef, "define role C" );
sub foo { 'Role::C::foo' }
sub zot { 'Role::C::zot' }
package Class::A;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::C);
- } "define class A";
+ }, undef, "define class A" );
sub zot { 'Class::A::zot' }
}
package Class::A::Conflict;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Role::A::Conflict';
- } qr/Due to a method name conflict in roles 'Role::A' and 'Role::A::Conflict', the method 'bar' must be implemented or excluded by 'Class::A::Conflict'/, '... did not fufill the requirement of &bar method';
+ }, qr/Due to a method name conflict in roles 'Role::A' and 'Role::A::Conflict', the method 'bar' must be implemented or excluded by 'Class::A::Conflict'/, '... did not fufill the requirement of &bar method' );
package Class::A::Resolved;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::A::Conflict';
- } '... did fufill the requirement of &bar method';
+ }, undef, '... did fufill the requirement of &bar method' );
sub bar { 'Class::A::Resolved::bar' }
}
package Role::F;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::D Role::E); # conflict between 'foo's here
- } "define role Role::F";
+ }, undef, "define role Role::F" );
sub foo { 'Role::F::foo' }
sub zot { 'Role::F::zot' }
package Class::B;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::F);
- } "define class Class::B";
+ }, undef, "define class Class::B" );
sub zot { 'Class::B::zot' }
}
package Role::D::And::E::Conflict;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::D Role::E); # conflict between 'foo's here
- } "... define role Role::D::And::E::Conflict";
+ }, undef, "... define role Role::D::And::E::Conflict" );
sub foo { 'Role::D::And::E::Conflict::foo' } # this overrides ...
package Role::I;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::J Role::H); # conflict between 'foo's here
- } "define role Role::I";
+ }, undef, "define role Role::I" );
sub zot { 'Role::I::zot' }
sub zzy { 'Role::I::zzy' }
package Class::C;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with qw(Role::I);
- } qr/Due to a method name conflict in roles 'Role::H' and 'Role::J', the method 'foo' must be implemented or excluded by 'Class::C'/, "defining class Class::C fails";
+ }, qr/Due to a method name conflict in roles 'Role::H' and 'Role::J', the method 'foo' must be implemented or excluded by 'Class::C'/, "defining class Class::C fails" );
sub zot { 'Class::C::zot' }
package Class::E;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with qw(Role::I);
- } "resolved with method";
+ }, undef, "resolved with method" );
sub foo { 'Class::E::foo' }
sub zot { 'Class::E::zot' }
ok(Role::I->meta->requires_method('foo'), '... Role::I still have the &foo requirement');
{
- lives_ok {
+ is( exception {
package Class::D;
use Moose;
with qw(Role::I);
- } "resolved with attr";
+ }, undef, "resolved with attr" );
can_ok( Class::D->new, qw(foo bar xxy zot) );
is( eval { Class::D->new->bar }, "Role::H::bar", "bar" );
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::Foo::Class;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role' => { -excludes => 'foo' },
'Bar::Role' => { -excludes => 'foo' },
'Baz::Role';
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
package My::Foo::Class::Broken;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Foo::Role',
'Bar::Role' => { -excludes => 'foo' },
'Baz::Role';
- } qr/Due to a method name conflict in roles 'Baz::Role' and 'Foo::Role', the method 'foo' must be implemented or excluded by 'My::Foo::Class::Broken'/,
- '... composed our roles correctly';
+ }, qr/Due to a method name conflict in roles 'Baz::Role' and 'Foo::Role', the method 'foo' must be implemented or excluded by 'My::Foo::Class::Broken'/, '... composed our roles correctly' );
}
{
package My::Foo::Role;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role' => { -excludes => 'foo' },
'Bar::Role' => { -excludes => 'foo' },
'Baz::Role';
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
}
ok(My::Foo::Role->meta->has_method('foo'), "we have a foo method");
package My::Foo::Role::Other;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role',
'Bar::Role' => { -excludes => 'foo' },
'Baz::Role';
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
}
ok(!My::Foo::Role::Other->meta->has_method('foo'), "we dont have a foo method");
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::Class;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'My::Role' => { -alias => { bar => 'role_bar' } };
- } '... this succeeds';
+ }, undef, '... this succeeds' );
package My::Class::Failure;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'My::Role' => { -alias => { bar => 'role_bar' } };
- } qr/Cannot create a method alias if a local method of the same name exists/, '... this succeeds';
+ }, qr/Cannot create a method alias if a local method of the same name exists/, '... this succeeds' );
sub role_bar { 'FAIL' }
}
package My::OtherRole;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'My::Role' => { -alias => { bar => 'role_bar' } };
- } '... this succeeds';
+ }, undef, '... this succeeds' );
sub bar { 'My::OtherRole::bar' }
package My::OtherRole::Failure;
use Moose::Role;
- ::throws_ok {
+ ::like( ::exception {
with 'My::Role' => { -alias => { bar => 'role_bar' } };
- } qr/Cannot create a method alias if a local method of the same name exists/, '... cannot alias to a name that exists';
+ }, qr/Cannot create a method alias if a local method of the same name exists/, '... cannot alias to a name that exists' );
sub role_bar { 'FAIL' }
}
package My::AliasingRole;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'My::Role' => { -alias => { bar => 'role_bar' } };
- } '... this succeeds';
+ }, undef, '... this succeeds' );
}
ok(My::AliasingRole->meta->has_method($_), "we have a $_ method") for qw(foo baz role_bar);
package My::Foo::Class;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role' => { -alias => { 'foo' => 'foo_foo' }, -excludes => 'foo' },
'Bar::Role' => { -alias => { 'foo' => 'bar_foo' }, -excludes => 'foo' },
'Baz::Role';
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
package My::Foo::Class::Broken;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Foo::Role' => { -alias => { 'foo' => 'foo_foo' }, -excludes => 'foo' },
'Bar::Role' => { -alias => { 'foo' => 'foo_foo' }, -excludes => 'foo' },
'Baz::Role';
- } qr/Due to a method name conflict in roles 'Bar::Role' and 'Foo::Role', the method 'foo_foo' must be implemented or excluded by 'My::Foo::Class::Broken'/,
- '... composed our roles correctly';
+ }, qr/Due to a method name conflict in roles 'Bar::Role' and 'Foo::Role', the method 'foo_foo' must be implemented or excluded by 'My::Foo::Class::Broken'/, '... composed our roles correctly' );
}
{
package My::Foo::Role;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role' => { -alias => { 'foo' => 'foo_foo' }, -excludes => 'foo' },
'Bar::Role' => { -alias => { 'foo' => 'bar_foo' }, -excludes => 'foo' },
'Baz::Role';
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
}
ok(My::Foo::Role->meta->has_method($_), "we have a $_ method") for qw/foo foo_foo bar_foo/;;
package My::Foo::Role::Other;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role' => { -alias => { 'foo' => 'foo_foo' }, -excludes => 'foo' },
'Bar::Role' => { -alias => { 'foo' => 'foo_foo' }, -excludes => 'foo' },
'Baz::Role';
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
}
ok(!My::Foo::Role::Other->meta->has_method('foo_foo'), "we dont have a foo_foo method");
package My::Foo::AliasOnly;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo::Role' => { -alias => { 'foo' => 'foo_foo' } },
- } '... composed our roles correctly';
+ }, undef, '... composed our roles correctly' );
}
ok(My::Foo::AliasOnly->meta->has_method('foo'), 'we have a foo method');
package Role::Bar;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Foo' => {
-alias => { x1 => 'foo_x1' },
-excludes => ['y1'],
};
- }
- 'Compose Role::Foo into Role::Bar with alias and exclude';
+ }, undef, 'Compose Role::Foo into Role::Bar with alias and exclude' );
sub x1 {}
sub y1 {}
package Role::Baz;
use Moose::Role;
- ::lives_ok {
+ ::is( ::exception {
with 'Role::Foo' => {
-alias => { x1 => 'foo_x1' },
-excludes => ['y1'],
};
- }
- 'Compose Role::Foo into Role::Baz with alias and exclude';
+ }, undef, 'Compose Role::Foo into Role::Baz with alias and exclude' );
}
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::Class;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'Foo' => { -excludes => [qw/bar baz gorch/], -alias => { gorch => 'foo_gorch' } },
'Bar' => { -excludes => [qw/foo baz gorch/] },
'Baz' => { -excludes => [qw/foo bar gorch/], -alias => { foo => 'baz_foo', bar => 'baz_bar' } },
'Gorch' => { -excludes => [qw/foo bar baz/] };
- } '... everything works out all right';
+ }, undef, '... everything works out all right' );
}
my $c = My::Class->new;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util 'blessed';
ok(!$obj->can( 'fur' ), 'ditto');
ok(!$obj->does('Dog'), '... we do not do any roles yet');
-dies_ok {
+isnt( exception {
$obj->dog($obj)
-} '... and setting the accessor fails (not a Dog yet)';
+}, undef, '... and setting the accessor fails (not a Dog yet)' );
Dog->meta->apply($obj);
is($obj->talk, 'woof', '... got the right return value for the newly composed method');
-lives_ok {
+is( exception {
$obj->dog($obj)
-} '... and setting the accessor is okay';
+}, undef, '... and setting the accessor is okay' );
is($obj->fur, "dirty", "role attr initialized");
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util 'blessed';
ok(!$bar->can( 'talk' ), "... the role is not composed yet");
-dies_ok {
+isnt( exception {
$foo->dog($bar)
-} '... and setting the accessor fails (not a Dog yet)';
+}, undef, '... and setting the accessor fails (not a Dog yet)' );
Dog->meta->apply($bar);
is($bar->talk, 'woof', '... got the right return value for the newly composed method');
-lives_ok {
+is( exception {
$foo->dog($bar)
-} '... and setting the accessor is okay';
+}, undef, '... and setting the accessor is okay' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
with 'Foo::Role';
- ::lives_ok {
+ ::is( ::exception {
has '+bar' => (default => sub { 100 });
- } '... extended the attribute successfully';
+ }, undef, '... extended the attribute successfully' );
}
my $foo = Foo->new;
with 'Bar::Role';
- ::lives_ok {
+ ::is( ::exception {
has '+foo' => (
isa => 'Int',
)
- } "... narrowed the role's type constraint successfully";
+ }, undef, "... narrowed the role's type constraint successfully" );
}
my $bar = Bar->new(foo => 42);
$bar->foo(100);
is($bar->foo, 100, "... can change the attribute's value to an Int");
-throws_ok { $bar->foo("baz") } qr/^Attribute \(foo\) does not pass the type constraint because: Validation failed for 'Int' with value baz at /;
+like( exception { $bar->foo("baz") }, qr/^Attribute \(foo\) does not pass the type constraint because: Validation failed for 'Int' with value baz at / );
is($bar->foo, 100, "... still has the old Int value");
with 'Baz::Role';
- ::lives_ok {
+ ::is( ::exception {
has '+baz' => (
isa => 'Int | ClassName',
)
- } "... narrowed the role's type constraint successfully";
+ }, undef, "... narrowed the role's type constraint successfully" );
}
my $baz = Baz->new(baz => 99);
$baz->baz('Foo');
is($baz->baz, 'Foo', "... can change the attribute's value to a ClassName");
-throws_ok { $baz->baz("zonk") } qr/^Attribute \(baz\) does not pass the type constraint because: Validation failed for 'ClassName\|Int' with value zonk at /;
+like( exception { $baz->baz("zonk") }, qr/^Attribute \(baz\) does not pass the type constraint because: Validation failed for 'ClassName\|Int' with value zonk at / );
is_deeply($baz->baz, 'Foo', "... still has the old ClassName value");
=> as 'Int'
=> where { $_ > 0 };
- ::lives_ok {
+ ::is( ::exception {
has '+quux' => (
isa => 'Positive | ArrayRef',
)
- } "... narrowed the role's type constraint successfully";
+ }, undef, "... narrowed the role's type constraint successfully" );
}
my $quux = Quux->new(quux => 99);
$quux->quux(["hi"]);
is_deeply($quux->quux, ["hi"], "... can change the attribute's value to an ArrayRef");
-throws_ok { $quux->quux("quux") } qr/^Attribute \(quux\) does not pass the type constraint because: Validation failed for 'ArrayRef\|Positive' with value quux at /;
+like( exception { $quux->quux("quux") }, qr/^Attribute \(quux\) does not pass the type constraint because: Validation failed for 'ArrayRef\|Positive' with value quux at / );
is_deeply($quux->quux, ["hi"], "... still has the old ArrayRef value");
-throws_ok { $quux->quux({a => 1}) } qr/^Attribute \(quux\) does not pass the type constraint because: Validation failed for 'ArrayRef\|Positive' with value HASH\(\w+\) at /;
+like( exception { $quux->quux({a => 1}) }, qr/^Attribute \(quux\) does not pass the type constraint because: Validation failed for 'ArrayRef\|Positive' with value HASH\(\w+\) at / );
is_deeply($quux->quux, ["hi"], "... still has the old ArrayRef value");
with 'Err::Role';
- ::lives_ok {
+ ::is( ::exception {
has '+err1' => (isa => 'Defined');
- } "can get less specific in the subclass";
+ }, undef, "can get less specific in the subclass" );
- ::lives_ok {
+ ::is( ::exception {
has '+err2' => (isa => 'Bool');
- } "or change the type completely";
+ }, undef, "or change the type completely" );
- ::lives_ok {
+ ::is( ::exception {
has '+err3' => (isa => 'Str | ArrayRef');
- } "or add new types to the union";
+ }, undef, "or add new types to the union" );
}
{
with 'Foo::Role';
- ::throws_ok {
+ ::like( ::exception {
has '+bar' => ( is => 'ro' );
- } qr/has '\+attr' is not supported in roles/,
- "Test has '+attr' in roles explodes";
+ }, qr/has '\+attr' is not supported in roles/, "Test has '+attr' in roles explodes" );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
is($foo->bar, 'BAR', '... got the expect value');
ok(!$foo->can('baz'), '... no baz method though');
- lives_ok {
+ is( exception {
Bar->meta->apply($foo)
- } '... this works';
+ }, undef, '... this works' );
is($foo->bar, 'BAR', '... got the expect value');
ok($foo->can('baz'), '... we have baz method now');
is($foo->bar, 'BAR', '... got the expect value');
ok(!$foo->can('baz'), '... no baz method though');
- lives_ok {
+ is( exception {
Bar->meta->apply($foo, (rebless_params => { baz => 'FOO-BAZ' }))
- } '... this works';
+ }, undef, '... this works' );
is($foo->bar, 'BAR', '... got the expect value');
ok($foo->can('baz'), '... we have baz method now');
is($foo->bar, 'BAR', '... got the expect value');
ok(!$foo->can('baz'), '... no baz method though');
- lives_ok {
+ is( exception {
Bar->meta->apply($foo, (rebless_params => { bar => 'FOO-BAR', baz => 'FOO-BAZ' }))
- } '... this works';
+ }, undef, '... this works' );
is($foo->bar, 'FOO-BAR', '... got the expect value');
ok($foo->can('baz'), '... we have baz method now');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
Role::Baz
);
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this composed okay';
+ }, undef, '... this composed okay' );
##... now nest 'em
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
ok(Role::DoesExcludesFoo->meta->excludes_role('Role::Foo'), '... got the right exclusions');
# test simple exclusion
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test no conflicts
{
is($c->name, 'Role::Foo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this lives as expected';
+ }, undef, '... this lives as expected' );
}
# test no conflicts w/exclusion
is($c->name, 'Role::Bar|Role::ExcludesFoo', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this lives as expected';
+ }, undef, '... this lives as expected' );
is_deeply([$c->get_excluded_roles_list], ['Role::Foo'], '... has excluded roles');
}
# test conflict with an "inherited" exclusion
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test conflict with an "inherited" exclusion of an "inherited" role
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
is($c->name, 'Role::Foo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_required_method_list ],
is($c->name, 'Role::Foo|Role::ProvidesFoo', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_required_method_list ],
is($c->name, 'Role::Foo|Role::ProvidesFoo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_required_method_list ],
is($c->name, 'Role::Foo|Role::ProvidesFoo|Role::ProvidesBar|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_required_method_list ],
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
is($c->name, 'Role::Foo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_attribute_list ],
}
# test simple conflict
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test complex conflict
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test simple conflict
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
is($c->name, 'Role::Foo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_method_list ],
is($c->name, 'Role::Foo|Role::FooConflict', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_method_list ],
is($c->name, 'Role::Foo|Role::Bar|Role::FooConflict|Role::BarConflict', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_method_list ],
is($c->name, 'Role::Foo|Role::AnotherFooConflict', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_method_list ],
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
is($c->name, 'Role::Foo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this lives ok';
+ }, undef, '... this lives ok' );
is_deeply(
[ sort $c->get_method_modifier_list('override') ],
}
# test simple overrides w/ conflicts
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test simple overrides w/ conflicts
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test simple overrides w/ conflicts
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
# test simple overrides w/ conflicts
-dies_ok {
+isnt( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply(
Moose::Meta::Role::Composite->new(
roles => [
]
)
);
-} '... this fails as expected';
+}, undef, '... this fails as expected' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role::Application::RoleSummation;
use Moose::Meta::Role::Composite;
is($c->name, 'Role::Foo|Role::Bar', '... got the composite role name');
- lives_ok {
+ is( exception {
Moose::Meta::Role::Application::RoleSummation->new->apply($c);
- } '... this succeeds as expected';
+ }, undef, '... this succeeds as expected' );
is_deeply(
[ sort $c->get_method_modifier_list('before') ],
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Class;
use Moose::Util;
# Note that this test passed (pre svn #5543) if we inlined the role
# definitions in this file, as it was very timing sensitive.
-lives_ok {
+is( exception {
my $builder_meta = Moose::Meta::Class->create(
'YATTA' => (
superclass => 'Moose::Meta::Class',
roles => [qw( Role::Interface Role::Child )],
)
);
-}
-'Create a new class with several roles';
+}, undef, 'Create a new class with several roles' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Bomb;
package PracticalJoke;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
with 'Bomb', 'Spouse';
- } qr/Due to method name conflicts in roles 'Bomb' and 'Spouse', the methods 'explode' and 'fuse' must be implemented or excluded by 'PracticalJoke'/;
+ }, qr/Due to method name conflicts in roles 'Bomb' and 'Spouse', the methods 'explode' and 'fuse' must be implemented or excluded by 'PracticalJoke'/ );
- ::throws_ok {
+ ::like( ::exception {
with (
'Bomb', 'Spouse',
'Caninish', 'Treeve',
);
- } qr/Due to a method name conflict in roles 'Caninish' and 'Treeve', the method 'bark' must be implemented or excluded by 'PracticalJoke'/;
+ }, qr/Due to a method name conflict in roles 'Caninish' and 'Treeve', the method 'bark' must be implemented or excluded by 'PracticalJoke'/ );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::Role1;
# roles they consume.
{
local $TODO = "role attributes don't satisfy method requirements";
- lives_ok { package My::Test1; use Moose; with 'My::Role2'; }
- 'role2(provides attribute) consumes role1';
+ is( exception { package My::Test1; use Moose; with 'My::Role2'; }, undef, 'role2(provides attribute) consumes role1' );
}
-lives_ok { package My::Test2; use Moose; with 'My::Role3'; }
-'role3(provides method) consumes role1';
+is( exception { package My::Test2; use Moose; with 'My::Role3'; }, undef, 'role3(provides method) consumes role1' );
# As I understand the design, Roles composed in the same with() statement
# should NOT demonstrate ordering dependency. Alter these tests if that
# assumption is false. -Vince Veselosky
{
local $TODO = "role attributes don't satisfy method requirements";
- lives_ok { package My::Test3; use Moose; with 'My::Role4', 'My::Role1'; }
- 'class consumes role4(provides attribute), role1';
+ is( exception { package My::Test3; use Moose; with 'My::Role4', 'My::Role1'; }, undef, 'class consumes role4(provides attribute), role1' );
}
{
local $TODO = "role attributes don't satisfy method requirements";
- lives_ok { package My::Test4; use Moose; with 'My::Role1', 'My::Role4'; }
- 'class consumes role1, role4(provides attribute)';
+ is( exception { package My::Test4; use Moose; with 'My::Role1', 'My::Role4'; }, undef, 'class consumes role1, role4(provides attribute)' );
}
-lives_ok { package My::Test5; use Moose; with 'My::Role5', 'My::Role1'; }
-'class consumes role5(provides method), role1';
+is( exception { package My::Test5; use Moose; with 'My::Role5', 'My::Role1'; }, undef, 'class consumes role5(provides method), role1' );
-lives_ok { package My::Test6; use Moose; with 'My::Role1', 'My::Role5'; }
-'class consumes role1, role5(provides method)';
+is( exception { package My::Test6; use Moose; with 'My::Role1', 'My::Role5'; }, undef, 'class consumes role1, role5(provides method)' );
# Inherited methods/attributes should satisfy requires(), as long as
# extends() comes first in code order.
-lives_ok {
+is( exception {
package My::Test7;
use Moose;
extends 'My::Base1';
with 'My::Role1';
-}
-'class extends base1(provides attribute), consumes role1';
+}, undef, 'class extends base1(provides attribute), consumes role1' );
-lives_ok {
+is( exception {
package My::Test8;
use Moose;
extends 'My::Base2';
with 'My::Role1';
-}
-'class extends base2(provides method), consumes role1';
+}, undef, 'class extends base2(provides method), consumes role1' );
# Attributes/methods implemented in class should satisfy requires()
-lives_ok {
+is( exception {
package My::Test9;
use Moose;
has 'test_output', is => 'rw';
with 'My::Role1';
-}
-'class provides attribute, consumes role1';
+}, undef, 'class provides attribute, consumes role1' );
-lives_ok {
+is( exception {
package My::Test10;
use Moose;
sub test_output { }
with 'My::Role1';
-}
-'class provides method, consumes role1';
+}, undef, 'class provides method, consumes role1' );
# Roles composed in separate with() statements SHOULD demonstrate ordering
# dependency. See comment with tests 3-6 above.
-lives_ok {
+is( exception {
package My::Test11;
use Moose;
with 'My::Role4';
with 'My::Role1';
-}
-'class consumes role4(provides attribute); consumes role1';
+}, undef, 'class consumes role4(provides attribute); consumes role1' );
-dies_ok { package My::Test12; use Moose; with 'My::Role1'; with 'My::Role4'; }
-'class consumes role1; consumes role4(provides attribute)';
+isnt( exception { package My::Test12; use Moose; with 'My::Role1'; with 'My::Role4'; }, undef, 'class consumes role1; consumes role4(provides attribute)' );
-lives_ok {
+is( exception {
package My::Test13;
use Moose;
with 'My::Role5';
with 'My::Role1';
-}
-'class consumes role5(provides method); consumes role1';
+}, undef, 'class consumes role5(provides method); consumes role1' );
-dies_ok { package My::Test14; use Moose; with 'My::Role1'; with 'My::Role5'; }
-'class consumes role1; consumes role5(provides method)';
+isnt( exception { package My::Test14; use Moose; with 'My::Role1'; with 'My::Role5'; }, undef, 'class consumes role1; consumes role5(provides method)' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::Role1;
is => 'ro',
);
- ::throws_ok { with 'My::Role1' } qr/attribute conflict.+My::Role2.+foo/,
- 'attribute conflict when composing one role into another';
+ ::like( ::exception { with 'My::Role1' }, qr/attribute conflict.+My::Role2.+foo/, 'attribute conflict when composing one role into another' );
}
done_testing;
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
my $FooRole;
{
package Quux::Role;
use Moose::Role;
{ our $TODO; local $TODO = "can't handle regexes yet";
- ::lives_ok {
+ ::is( ::exception {
after qr/foo|bar/ => sub { $QuuxRole++ }
- };
+ }, undef );
}
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util ();
"This is not a string (5)",
'... validated unsuccessfully (got error)');
-lives_ok { Moose::Meta::Attribute->new('bob', isa => 'Spong') }
- 'meta-attr construction ok even when type constraint utils loaded first';
+is( exception { Moose::Meta::Attribute->new('bob', isa => 'Spong') }, undef, 'meta-attr construction ok even when type constraint utils loaded first' );
# Test type constraint predicate return values.
# Test adding things which don't look like types to the registry throws an exception
my $r = Moose::Util::TypeConstraints->get_type_constraint_registry;
-throws_ok {$r->add_type_constraint()} qr/not a valid type constraint/, '->add_type_constraint(undef) throws';
-throws_ok {$r->add_type_constraint('foo')} qr/not a valid type constraint/, '->add_type_constraint("foo") throws';
-throws_ok {$r->add_type_constraint(bless {}, 'SomeClass')} qr/not a valid type constraint/, '->add_type_constraint(SomeClass->new) throws';
+like( exception {$r->add_type_constraint()}, qr/not a valid type constraint/, '->add_type_constraint(undef) throws' );
+like( exception {$r->add_type_constraint('foo')}, qr/not a valid type constraint/, '->add_type_constraint("foo") throws' );
+like( exception {$r->add_type_constraint(bless {}, 'SomeClass')}, qr/not a valid type constraint/, '->add_type_constraint(SomeClass->new) throws' );
# Test some specific things that in the past did not work,
# specifically weird variations on anon subtypes.
}
{
- throws_ok { subtype 'Foo' } qr/cannot consist solely of a name/,
- 'Cannot call subtype with a single string argument';
+ like( exception { subtype 'Foo' }, qr/cannot consist solely of a name/, 'Cannot call subtype with a single string argument' );
}
# Back-compat for being called without sugar. Previously, calling with
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok('Moose::Util::TypeConstraints');
my $anon_type = subtype Object => where { $_->isa('HTTPHeader') };
-lives_ok {
+is( exception {
coerce $anon_type
=> from ArrayRef
=> via { HTTPHeader->new(array => $_[0]) }
=> from HashRef
=> via { HTTPHeader->new(hash => $_[0]) };
-} 'coercion of anonymous subtype succeeds';
+}, undef, 'coercion of anonymous subtype succeeds' );
foreach my $coercion (
find_type_constraint('Header')->coercion,
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
# try with arrays
- lives_ok {
+ is( exception {
$engine->header([ 1, 2, 3 ]);
- } '... type was coerced without incident';
+ }, undef, '... type was coerced without incident' );
isa_ok($engine->header, 'HTTPHeader');
is_deeply(
# try with hash
- lives_ok {
+ is( exception {
$engine->header({ one => 1, two => 2, three => 3 });
- } '... type was coerced without incident';
+ }, undef, '... type was coerced without incident' );
isa_ok($engine->header, 'HTTPHeader');
is_deeply(
'... got the right hash value of the header');
ok(!defined($engine->header->array), '... no array value set');
- dies_ok {
+ isnt( exception {
$engine->header("Foo");
- } '... dies with the wrong type, even after coercion';
+ }, undef, '... dies with the wrong type, even after coercion' );
- lives_ok {
+ is( exception {
$engine->header(HTTPHeader->new);
- } '... lives with the right type, even after coercion';
+ }, undef, '... lives with the right type, even after coercion' );
}
{
ok(!defined($engine->header->array), '... no array value set');
}
-dies_ok {
+isnt( exception {
Engine->new(header => 'Foo');
-} '... dies correctly with bad params';
+}, undef, '... dies correctly with bad params' );
-dies_ok {
+isnt( exception {
Engine->new(header => \(my $var));
-} '... dies correctly with bad params';
+}, undef, '... dies correctly with bad params' );
{
my $tc = Moose::Util::TypeConstraints::find_type_constraint('HTTPHeader');
isa_ok($from_href, 'HTTPHeader', 'assert_coerce from href to HTTPHeader');
is_deeply($from_href->hash, { a => 1 }, '...and has the right guts');
- throws_ok { $tc->assert_coerce('total garbage') }
- qr/Validation failed for .HTTPHeader./,
- "assert_coerce throws if result is not acceptable";
+ like( exception { $tc->assert_coerce('total garbage') }, qr/Validation failed for .HTTPHeader./, "assert_coerce throws if result is not acceptable" );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Requires {
'IO::String' => '0.01', # skip all if not installed
is($email->as_string, '... this is my body ...', '... got correct string');
- lives_ok {
+ is( exception {
$email->raw_body('... this is the next body ...');
- } '... this will coerce correctly';
+ }, undef, '... this will coerce correctly' );
isa_ok($email->raw_body, 'IO::String');
my $str2 = '... this is the next body (ref) ...';
- lives_ok {
+ is( exception {
$email->raw_body(\$str2);
- } '... this will coerce correctly';
+ }, undef, '... this will coerce correctly' );
isa_ok($email->raw_body, 'IO::String');
my $io_str2 = IO::String->new('... this is the next body (IO::String) ...');
- lives_ok {
+ is( exception {
$email->raw_body($io_str2);
- } '... this will coerce correctly';
+ }, undef, '... this will coerce correctly' );
isa_ok($email->raw_body, 'IO::String');
is($email->raw_body, $io_str2, '... and it is the one we expected');
{
my $foo;
- lives_ok { $foo = Foo->new( carray => 1 ) }
- 'Can pass non-ref value for carray';
+ is( exception { $foo = Foo->new( carray => 1 ) }, undef, 'Can pass non-ref value for carray' );
is_deeply(
$foo->carray, [1],
'carray was coerced to an array ref'
);
- throws_ok { Foo->new( carray => {} ) }
- qr/\QValidation failed for 'Coerced|Coerced' with value \E(?!undef)/,
- 'Cannot pass a hash ref for carray attribute, and hash ref is not coerced to an undef';
+ like( exception { Foo->new( carray => {} ) }, qr/\QValidation failed for 'Coerced|Coerced' with value \E(?!undef)/, 'Cannot pass a hash ref for carray attribute, and hash ref is not coerced to an undef' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util qw(refaddr);
BEGIN {
# subtype 'aliasing' ...
-lives_ok {
+is( exception {
subtype 'Numb3rs' => as 'Num';
-} '... create bare subtype fine';
+}, undef, '... create bare subtype fine' );
my $numb3rs = find_type_constraint('Numb3rs');
isa_ok($numb3rs, 'Moose::Meta::TypeConstraint');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Scalar::Util ();
ok( !$anon_enum->is_a_type_of('ThisTypeDoesNotExist'), 'enum not type of nonexistant type');
# validation
-throws_ok { Moose::Meta::TypeConstraint::Enum->new(name => 'ZeroValues', values => []) }
- qr/You must have at least two values to enumerate through/;
+like( exception { Moose::Meta::TypeConstraint::Enum->new(name => 'ZeroValues', values => []) }, qr/You must have at least two values to enumerate through/ );
-throws_ok { Moose::Meta::TypeConstraint::Enum->new(name => 'OneValue', values => [ 'a' ]) }
- qr/You must have at least two values to enumerate through/;
+like( exception { Moose::Meta::TypeConstraint::Enum->new(name => 'OneValue', values => [ 'a' ]) }, qr/You must have at least two values to enumerate through/ );
-throws_ok { Moose::Meta::TypeConstraint::Enum->new(name => 'ReferenceInEnum', values => [ 'a', {} ]) }
- qr/Enum values must be strings, not 'HASH\(0x\w+\)'/;
+like( exception { Moose::Meta::TypeConstraint::Enum->new(name => 'ReferenceInEnum', values => [ 'a', {} ]) }, qr/Enum values must be strings, not 'HASH\(0x\w+\)'/ );
-throws_ok { Moose::Meta::TypeConstraint::Enum->new(name => 'UndefInEnum', values => [ 'a', undef ]) }
- qr/Enum values must be strings, not undef/;
+like( exception { Moose::Meta::TypeConstraint::Enum->new(name => 'UndefInEnum', values => [ 'a', undef ]) }, qr/Enum values must be strings, not undef/ );
-throws_ok {
+like( exception {
package Foo;
use Moose;
use Moose::Util::TypeConstraints;
isa => enum ['a', 'aa', 'aaa'], # should be parenthesized!
default => 'aa',
);
-} qr/enum called with an array reference and additional arguments\. Did you mean to parenthesize the enum call's parameters\?/;
+}, qr/enum called with an array reference and additional arguments\. Did you mean to parenthesize the enum call's parameters\?/ );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok("Moose::Util::TypeConstraints");
}
-lives_ok {
+is( exception {
subtype 'MySpecialHash' => as 'HashRef[Int]';
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
{
my $t = find_type_constraint('MySpecialHash');
ok( !$t->is_subtype_of("ThisTypeDoesNotExist"), "not a subtype of a non existant type" );
}
-lives_ok {
+is( exception {
subtype 'MySpecialHashExtended'
=> as 'HashRef[Int]'
=> where {
# all values are less then 10
(scalar grep { $_ < 10 } values %{$_}) ? 1 : undef
};
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
{
my $t = find_type_constraint('MySpecialHashExtended');
ok(!$t->check({ one => "ONE", two => "TWO" }), '... validated it correctly');
}
-lives_ok {
+is( exception {
subtype 'MyNonSpecialHash'
=> as "HashRef"
=> where { keys %$_ == 3 };
-};
+}, undef );
{
my $t = find_type_constraint('MyNonSpecialHash');
ok $SubOfMyArrayRef->check([15,20,25]), '[15,20,25] is a bunch of big ints';
ok ! $SubOfMyArrayRef->check([15,5,25]), '[15,5,25] is NOT a bunch of big ints';
- throws_ok {
+ like( exception {
my $SubOfMyArrayRef = subtype 'SubSubOfMyArrayRef',
as 'SubOfMyArrayRef[Str]';
- } qr/Str is not a subtype of BiggerInt/, 'Failed to parameterize with a bad type parameter';
+ }, qr/Str is not a subtype of BiggerInt/, 'Failed to parameterize with a bad type parameter' );
}
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok("Moose::Util::TypeConstraints");
}
-lives_ok {
+is( exception {
subtype 'MyCollections' => as 'ArrayRef | HashRef';
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
{
my $t = find_type_constraint('MyCollections');
ok(!$t->check(1), '... validated it correctly');
}
-lives_ok {
+is( exception {
subtype 'MyCollectionsExtended'
=> as 'ArrayRef|HashRef'
=> where {
}
1;
};
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
{
my $t = find_type_constraint('MyCollectionsExtended');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok("Moose::Util::TypeConstraints");
use_ok('Moose::Meta::TypeConstraint::Parameterized');
}
-lives_ok {
+is( exception {
subtype 'AlphaKeyHash' => as 'HashRef'
=> where {
# no keys match non-alpha
(grep { /[^a-zA-Z]/ } keys %$_) == 0
};
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
-lives_ok {
+is( exception {
subtype 'Trihash' => as 'AlphaKeyHash'
=> where {
keys(%$_) == 3
};
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
-lives_ok {
+is( exception {
subtype 'Noncon' => as 'Item';
-} '... created the subtype special okay';
+}, undef, '... created the subtype special okay' );
{
my $t = find_type_constraint('AlphaKeyHash');
ok(!$th->check({ one => 1, two => 2, three => 1 }), '... validated it correctly');
ok(!$th->check({foo1 => 1, bar2 => 0, baz3 => 1}), '... validated it correctly');
-dies_ok {
+isnt( exception {
Moose::Meta::TypeConstraint::Parameterized->new(
name => 'Str[Int]',
parent => find_type_constraint('Str'),
type_parameter => find_type_constraint('Int'),
);
-} 'non-containers cannot be parameterized';
+}, undef, 'non-containers cannot be parameterized' );
-dies_ok {
+isnt( exception {
Moose::Meta::TypeConstraint::Parameterized->new(
name => 'Noncon[Int]',
parent => find_type_constraint('Noncon'),
type_parameter => find_type_constraint('Int'),
);
-} 'non-containers cannot be parameterized';
+}, undef, 'non-containers cannot be parameterized' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok("Moose::Util::TypeConstraints");
subtype 'MyList' => as 'Object' => where { $_->isa('MyList') };
-lives_ok {
+is( exception {
coerce 'ArrayRef'
=> from 'MyList'
=> via { [ $_->items ] }
-} '... created the coercion okay';
+}, undef, '... created the coercion okay' );
my $mylist = Moose::Util::TypeConstraints::find_or_parse_type_constraint('MyList[Int]');
# XXX: get this to work *without* the declaration. I suspect it'll be a new
# method in Moose::Meta::TypeCoercion that will look at the parents of the
# coerced type as well. but will that be too "action at a distance"-ey?
-lives_ok {
+is( exception {
coerce 'ArrayRef'
=> from 'EvenList'
=> via { [ $_->items ] }
-} '... created the coercion okay';
+}, undef, '... created the coercion okay' );
my $evenlist = Moose::Util::TypeConstraints::find_or_parse_type_constraint('EvenList[Int]');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok('Moose::Util::TypeConstraints');
}
-lives_ok { class_type 'Beep' } 'class_type keywork works';
-lives_ok { class_type('Boop', message { "${_} is not a Boop" }) }
- 'class_type keywork works with message';
+is( exception { class_type 'Beep' }, undef, 'class_type keywork works' );
+is( exception { class_type('Boop', message { "${_} is not a Boop" }) }, undef, 'class_type keywork works with message' );
my $type = find_type_constraint("Foo");
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util::TypeConstraints;
has 'maybe_bar' => (is => 'rw', isa => maybe_type(class_type('Bar')));
}
-lives_ok {
+is( exception {
Foo->new(arr => [], bar => Bar->new);
-} '... Bar->new isa Bar';
+}, undef, '... Bar->new isa Bar' );
-dies_ok {
+isnt( exception {
Foo->new(arr => [], bar => undef);
-} '... undef isnta Bar';
+}, undef, '... undef isnta Bar' );
-lives_ok {
+is( exception {
Foo->new(arr => [], maybe_bar => Bar->new);
-} '... Bar->new isa maybe(Bar)';
+}, undef, '... Bar->new isa maybe(Bar)' );
-lives_ok {
+is( exception {
Foo->new(arr => [], maybe_bar => undef);
-} '... undef isa maybe(Bar)';
+}, undef, '... undef isa maybe(Bar)' );
-dies_ok {
+isnt( exception {
Foo->new(arr => [], maybe_bar => 1);
-} '... 1 isnta maybe(Bar)';
+}, undef, '... 1 isnta maybe(Bar)' );
-lives_ok {
+is( exception {
Foo->new(arr => []);
-} '... it worked!';
+}, undef, '... it worked!' );
-lives_ok {
+is( exception {
Foo->new(arr => undef);
-} '... it worked!';
+}, undef, '... it worked!' );
-dies_ok {
+isnt( exception {
Foo->new(arr => 100);
-} '... failed the type check';
+}, undef, '... failed the type check' );
-dies_ok {
+isnt( exception {
Foo->new(arr => 'hello world');
-} '... failed the type check';
+}, undef, '... failed the type check' );
{
ok !$Maybe_Int->check("")
=> 'failed ("")';
-throws_ok { $obj->Maybe_Int("") }
- qr/Attribute \(Maybe_Int\) does not pass the type constraint/
- => 'failed assigned ("")';
+like( exception { $obj->Maybe_Int("") }, qr/Attribute \(Maybe_Int\) does not pass the type constraint/, 'failed assigned ("")' );
ok !$Maybe_Int->check("a")
=> 'failed ("a")';
-throws_ok { $obj->Maybe_Int("a") }
- qr/Attribute \(Maybe_Int\) does not pass the type constraint/
- => 'failed assigned ("a")';
+like( exception { $obj->Maybe_Int("a") }, qr/Attribute \(Maybe_Int\) does not pass the type constraint/, 'failed assigned ("a")' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Animal;
);
}
-lives_ok { my $goat = Animal->new( leg_count => 4 ) }
-'... no errors thrown, value is good';
-lives_ok { my $spider = Animal->new( leg_count => 8 ) }
-'... no errors thrown, value is good';
+is( exception { my $goat = Animal->new( leg_count => 4 ) }, undef, '... no errors thrown, value is good' );
+is( exception { my $spider = Animal->new( leg_count => 8 ) }, undef, '... no errors thrown, value is good' );
-throws_ok { my $fern = Animal->new( leg_count => 0 ) }
-qr/This number \(0\) is not less than ten!/,
- 'gave custom supertype error message on new';
+like( exception { my $fern = Animal->new( leg_count => 0 ) }, qr/This number \(0\) is not less than ten!/, 'gave custom supertype error message on new' );
-throws_ok { my $centipede = Animal->new( leg_count => 30 ) }
-qr/This number \(30\) is not less than ten!/,
- 'gave custom subtype error message on new';
+like( exception { my $centipede = Animal->new( leg_count => 30 ) }, qr/This number \(30\) is not less than ten!/, 'gave custom subtype error message on new' );
my $chimera;
-lives_ok { $chimera = Animal->new( leg_count => 4 ) }
-'... no errors thrown, value is good';
+is( exception { $chimera = Animal->new( leg_count => 4 ) }, undef, '... no errors thrown, value is good' );
-throws_ok { $chimera->leg_count(0) }
-qr/This number \(0\) is not less than ten!/,
- 'gave custom supertype error message on set to 0';
+like( exception { $chimera->leg_count(0) }, qr/This number \(0\) is not less than ten!/, 'gave custom supertype error message on set to 0' );
-throws_ok { $chimera->leg_count(16) }
-qr/This number \(16\) is not less than ten!/,
- 'gave custom subtype error message on set to 16';
+like( exception { $chimera->leg_count(16) }, qr/This number \(16\) is not less than ten!/, 'gave custom subtype error message on set to 16' );
my $gimp = eval { Animal->new() };
is( $@, '', '... no errors thrown, value is good' );
-throws_ok { $gimp->leg_count }
-qr/This number \(0\) is not less than ten!/,
- 'gave custom supertype error message on lazy set to 0';
+like( exception { $gimp->leg_count }, qr/This number \(0\) is not less than ten!/, 'gave custom supertype error message on lazy set to 0' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
my $foo = Foo->new;
-lives_ok { $foo->vUndef(undef) } '... undef is a Foo->Undef';
-dies_ok { $foo->vDefined(undef) } '... undef is NOT a Foo->Defined';
-dies_ok { $foo->vInt(undef) } '... undef is NOT a Foo->Int';
-dies_ok { $foo->vNumber(undef) } '... undef is NOT a Foo->Number';
-dies_ok { $foo->vStr(undef) } '... undef is NOT a Foo->Str';
-dies_ok { $foo->vString(undef) } '... undef is NOT a Foo->String';
-
-dies_ok { $foo->vUndef(5) } '... 5 is NOT a Foo->Undef';
-lives_ok { $foo->vDefined(5) } '... 5 is a Foo->Defined';
-lives_ok { $foo->vInt(5) } '... 5 is a Foo->Int';
-lives_ok { $foo->vNumber(5) } '... 5 is a Foo->Number';
-lives_ok { $foo->vStr(5) } '... 5 is a Foo->Str';
-dies_ok { $foo->vString(5) } '... 5 is NOT a Foo->String';
-
-dies_ok { $foo->vUndef(0.5) } '... 0.5 is NOT a Foo->Undef';
-lives_ok { $foo->vDefined(0.5) } '... 0.5 is a Foo->Defined';
-dies_ok { $foo->vInt(0.5) } '... 0.5 is NOT a Foo->Int';
-lives_ok { $foo->vNumber(0.5) } '... 0.5 is a Foo->Number';
-lives_ok { $foo->vStr(0.5) } '... 0.5 is a Foo->Str';
-dies_ok { $foo->vString(0.5) } '... 0.5 is NOT a Foo->String';
-
-dies_ok { $foo->vUndef('Foo') } '... "Foo" is NOT a Foo->Undef';
-lives_ok { $foo->vDefined('Foo') } '... "Foo" is a Foo->Defined';
-dies_ok { $foo->vInt('Foo') } '... "Foo" is NOT a Foo->Int';
-dies_ok { $foo->vNumber('Foo') } '... "Foo" is NOT a Foo->Number';
-lives_ok { $foo->vStr('Foo') } '... "Foo" is a Foo->Str';
-lives_ok { $foo->vString('Foo') } '... "Foo" is a Foo->String';
+is( exception { $foo->vUndef(undef) }, undef, '... undef is a Foo->Undef' );
+isnt( exception { $foo->vDefined(undef) }, undef, '... undef is NOT a Foo->Defined' );
+isnt( exception { $foo->vInt(undef) }, undef, '... undef is NOT a Foo->Int' );
+isnt( exception { $foo->vNumber(undef) }, undef, '... undef is NOT a Foo->Number' );
+isnt( exception { $foo->vStr(undef) }, undef, '... undef is NOT a Foo->Str' );
+isnt( exception { $foo->vString(undef) }, undef, '... undef is NOT a Foo->String' );
+
+isnt( exception { $foo->vUndef(5) }, undef, '... 5 is NOT a Foo->Undef' );
+is( exception { $foo->vDefined(5) }, undef, '... 5 is a Foo->Defined' );
+is( exception { $foo->vInt(5) }, undef, '... 5 is a Foo->Int' );
+is( exception { $foo->vNumber(5) }, undef, '... 5 is a Foo->Number' );
+is( exception { $foo->vStr(5) }, undef, '... 5 is a Foo->Str' );
+isnt( exception { $foo->vString(5) }, undef, '... 5 is NOT a Foo->String' );
+
+isnt( exception { $foo->vUndef(0.5) }, undef, '... 0.5 is NOT a Foo->Undef' );
+is( exception { $foo->vDefined(0.5) }, undef, '... 0.5 is a Foo->Defined' );
+isnt( exception { $foo->vInt(0.5) }, undef, '... 0.5 is NOT a Foo->Int' );
+is( exception { $foo->vNumber(0.5) }, undef, '... 0.5 is a Foo->Number' );
+is( exception { $foo->vStr(0.5) }, undef, '... 0.5 is a Foo->Str' );
+isnt( exception { $foo->vString(0.5) }, undef, '... 0.5 is NOT a Foo->String' );
+
+isnt( exception { $foo->vUndef('Foo') }, undef, '... "Foo" is NOT a Foo->Undef' );
+is( exception { $foo->vDefined('Foo') }, undef, '... "Foo" is a Foo->Defined' );
+isnt( exception { $foo->vInt('Foo') }, undef, '... "Foo" is NOT a Foo->Int' );
+isnt( exception { $foo->vNumber('Foo') }, undef, '... "Foo" is NOT a Foo->Number' );
+is( exception { $foo->vStr('Foo') }, undef, '... "Foo" is a Foo->Str' );
+is( exception { $foo->vString('Foo') }, undef, '... "Foo" is a Foo->String' );
# the lazy tests
-lives_ok { $foo->v_lazy_Undef() } '... undef is a Foo->Undef';
-dies_ok { $foo->v_lazy_Defined() } '... undef is NOT a Foo->Defined';
-dies_ok { $foo->v_lazy_Int() } '... undef is NOT a Foo->Int';
-dies_ok { $foo->v_lazy_Number() } '... undef is NOT a Foo->Number';
-dies_ok { $foo->v_lazy_Str() } '... undef is NOT a Foo->Str';
-dies_ok { $foo->v_lazy_String() } '... undef is NOT a Foo->String';
+is( exception { $foo->v_lazy_Undef() }, undef, '... undef is a Foo->Undef' );
+isnt( exception { $foo->v_lazy_Defined() }, undef, '... undef is NOT a Foo->Defined' );
+isnt( exception { $foo->v_lazy_Int() }, undef, '... undef is NOT a Foo->Int' );
+isnt( exception { $foo->v_lazy_Number() }, undef, '... undef is NOT a Foo->Number' );
+isnt( exception { $foo->v_lazy_Str() }, undef, '... undef is NOT a Foo->Str' );
+isnt( exception { $foo->v_lazy_String() }, undef, '... undef is NOT a Foo->String' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok('Moose::Util::TypeConstraints');
}
-lives_ok { role_type('Boop', message { "${_} is not a Boop" }) }
- 'role_type keywork works with message';
+is( exception { role_type('Boop', message { "${_} is not a Boop" }) }, undef, 'role_type keywork works with message' );
my $type = find_type_constraint("Foo");
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok('Moose::Util::TypeConstraints');
# test parameterizable
-lives_ok {
+is( exception {
$params->parameterizable( { a => 'Hello', b => 'World' } );
-} 'No problem setting parameterizable';
+}, undef, 'No problem setting parameterizable' );
is_deeply $params->parameterizable,
{ a => 'Hello', b => 'World' } => 'Got expected values';
# test parameterized
-lives_ok {
+is( exception {
$params->parameterized( { a => 1, b => 2 } );
-} 'No problem setting parameterized';
+}, undef, 'No problem setting parameterized' );
is_deeply $params->parameterized, { a => 1, b => 2 } => 'Got expected values';
-throws_ok {
+like( exception {
$params->parameterized( { a => 'Hello', b => 'World' } );
- } qr/Attribute \(parameterized\) does not pass the type constraint/ =>
- 'parameterized throws expected error';
+ }, qr/Attribute \(parameterized\) does not pass the type constraint/, 'parameterized throws expected error' );
# test from_parameterizable
-lives_ok {
+is( exception {
$params->from_parameterizable( { a => 1, b => 2 } );
-} 'No problem setting from_parameterizable';
+}, undef, 'No problem setting from_parameterizable' );
is_deeply $params->from_parameterizable,
{ a => 1, b => 2 } => 'Got expected values';
-throws_ok {
+like( exception {
$params->from_parameterizable( { a => 'Hello', b => 'World' } );
- }
- qr/Attribute \(from_parameterizable\) does not pass the type constraint/,
- 'from_parameterizable throws expected error';
+ }, qr/Attribute \(from_parameterizable\) does not pass the type constraint/, 'from_parameterizable throws expected error' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok('Moose::Util::TypeConstraints');
subtype 'MySubType' => as 'Int' => where { 1 };
}
-throws_ok {
+like( exception {
package Some::Other::Class;
use Moose::Util::TypeConstraints;
subtype 'MySubType' => as 'Int' => where { 1 };
-} qr/cannot be created again/, 'Trying to create same type twice throws';
+}, qr/cannot be created again/, 'Trying to create same type twice throws' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util::TypeConstraints;
use Moose::Meta::TypeConstraint;
);
}
-throws_ok {
+like( exception {
Quux->new(age => 3)
-} qr/^Attribute \(age\) does not pass the type constraint because: Validation failed for 'Positive' with value 3 \(not isa Positive\)/;
+}, qr/^Attribute \(age\) does not pass the type constraint because: Validation failed for 'Positive' with value 3 \(not isa Positive\)/ );
-lives_ok {
+is( exception {
Quux->new(age => (bless {}, 'Positive'));
-};
+}, undef );
eval "
package Positive;
use Moose;
";
-throws_ok {
+like( exception {
Quux->new(age => 3)
-} qr/^Attribute \(age\) does not pass the type constraint because: Validation failed for 'Positive' with value 3 \(not isa Positive\)/;
+}, qr/^Attribute \(age\) does not pass the type constraint because: Validation failed for 'Positive' with value 3 \(not isa Positive\)/ );
-lives_ok {
+is( exception {
Quux->new(age => Positive->new)
-};
+}, undef );
class_type 'Negative' => message { "$_ is not a Negative Nancy" };
);
}
-throws_ok {
+like( exception {
Quux::Ier->new(age => 3)
-} qr/^Attribute \(age\) does not pass the type constraint because: 3 is not a Negative Nancy /;
+}, qr/^Attribute \(age\) does not pass the type constraint because: 3 is not a Negative Nancy / );
-lives_ok {
+is( exception {
Quux::Ier->new(age => (bless {}, 'Negative'))
-};
+}, undef );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
use Test::Fatal;
use Moose::Meta::TypeConstraint;
}
}
-lives_ok { Moose::Meta::TypeConstraint->new( name => 'Foo.Bar::Baz' ) }
-'Type names can contain periods and colons';
+is( exception { Moose::Meta::TypeConstraint->new( name => 'Foo.Bar::Baz' ) }, undef, 'Type names can contain periods and colons' );
-throws_ok { subtype 'Foo-Baz' => as 'Item' }
-qr/contains invalid characters/,
- 'Type names cannot contain a dash (via subtype sugar)';
+like( exception { subtype 'Foo-Baz' => as 'Item' }, qr/contains invalid characters/, 'Type names cannot contain a dash (via subtype sugar)' );
-lives_ok { subtype 'Foo.Bar::Baz' => as 'Item' }
-'Type names can contain periods and colons (via subtype sugar)';
+is( exception { subtype 'Foo.Bar::Baz' => as 'Item' }, undef, 'Type names can contain periods and colons (via subtype sugar)' );
is( Moose::Util::TypeConstraints::find_or_parse_type_constraint('ArrayRef[In-valid]'),
undef,
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
}
# try giving it a duck
-lives_ok { DucktypeTest->new( duck => Duck->new ) } 'the Duck lives okay';
+is( exception { DucktypeTest->new( duck => Duck->new ) }, undef, 'the Duck lives okay' );
# try giving it a swan which is like a duck, but not close enough
-throws_ok { DucktypeTest->new( duck => Swan->new ) }
-qr/Swan is missing methods 'quack'/,
- "the Swan doesn't quack";
+like( exception { DucktypeTest->new( duck => Swan->new ) }, qr/Swan is missing methods 'quack'/, "the Swan doesn't quack" );
# try giving it a rubber RubberDuckey
-lives_ok { DucktypeTest->new( swan => Swan->new ) } 'but a Swan can honk';
+is( exception { DucktypeTest->new( swan => Swan->new ) }, undef, 'but a Swan can honk' );
# try giving it a rubber RubberDuckey
-lives_ok { DucktypeTest->new( duck => RubberDuck->new ) }
-'the RubberDuck lives okay';
+is( exception { DucktypeTest->new( duck => RubberDuck->new ) }, undef, 'the RubberDuck lives okay' );
# try with the other constraint form
-lives_ok { DucktypeTest->new( other_swan => Swan->new ) } 'but a Swan can honk';
+is( exception { DucktypeTest->new( other_swan => Swan->new ) }, undef, 'but a Swan can honk' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util::TypeConstraints;
is( is_acceptable_color( 'yellow' ), 'CMYK', '... got the right value');
is( is_acceptable_color( 'black' ), 'CMYK', '... got the right value');
-dies_ok {
+isnt( exception {
is_acceptable_color( 'orange' )
-} '... got the exception';
+}, undef, '... got the exception' );
## using it in an OO context
CodeRef => sub { $_->('Hello code ref world') };
}
-throws_ok {
+like( exception {
not_enough_matches( [] )
-} qr/No cases matched for /, '... not enough matches';
+}, qr/No cases matched for /, '... not enough matches' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
-lives_ok {
+is( exception {
package MooseX::Attribute::Test;
use Moose::Role;
-} 'creating custom attribute "metarole" is okay';
+}, undef, 'creating custom attribute "metarole" is okay' );
-lives_ok {
+is( exception {
package Moose::Meta::Attribute::Custom::Test;
use Moose;
extends 'Moose::Meta::Attribute';
with 'MooseX::Attribute::Test';
-} 'custom attribute metaclass extending role is okay';
+}, undef, 'custom attribute metaclass extending role is okay' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Requires {
'Test::Output' => '0.01', # skip all if not installed
use Moose ();
- ::dies_ok
- {
- Moose::Exporter->setup_import_methods(
+ ::like(
+ ::exception{ Moose::Exporter->setup_import_methods(
also => [ 'Moose', 'MooseX::CircularAlso' ],
);
- }
- 'a circular reference in also dies with an error';
-
- ::like(
- $@,
+ },
qr/\QCircular reference in 'also' parameter to Moose::Exporter between MooseX::CircularAlso and MooseX::CircularAlso/,
- 'got the expected error from circular reference in also'
+ 'a circular reference in also dies with an error'
);
}
use Moose ();
- ::dies_ok
- {
- Moose::Exporter->setup_import_methods(
- also => [ 'NoSuchThing' ],
- );
- }
- 'a package which does not use Moose::Exporter in also dies with an error';
-
::like(
- $@,
+ ::exception{ Moose::Exporter->setup_import_methods(
+ also => ['NoSuchThing'],
+ );
+ },
qr/\QPackage in also (NoSuchThing) does not seem to use Moose::Exporter (is it loaded?) at /,
- 'got the expected error from a reference in also to a package which is not loaded'
+ 'a package which does not use Moose::Exporter in also dies with an error'
);
}
use Moose ();
- ::dies_ok
- {
- Moose::Exporter->setup_import_methods(
- also => [ 'Moose::Meta::Method' ],
- );
- }
- 'a package which does not use Moose::Exporter in also dies with an error';
-
::like(
- $@,
+ ::exception{ Moose::Exporter->setup_import_methods(
+ also => ['Moose::Meta::Method'],
+ );
+ },
qr/\QPackage in also (Moose::Meta::Method) does not seem to use Moose::Exporter at /,
- 'got the expected error from a reference in also to a package which does not use Moose::Exporter'
+ 'a package which does not use Moose::Exporter in also dies with an error'
);
}
use lib 't/lib', 'lib';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::SimpleTrait;
{
require Moose::Util::TypeConstraints;
- dies_ok { Moose::Util::TypeConstraints->import( -traits => 'My::SimpleTrait' ) }
- 'cannot provide -traits to an exporting module that does not init_meta';
- like( $@, qr/does not have an init_meta/,
- '... and error provides a useful explanation' );
+ like(
+ exception {
+ Moose::Util::TypeConstraints->import(
+ -traits => 'My::SimpleTrait' );
+ },
+ qr/does not have an init_meta/,
+ 'cannot provide -traits to an exporting module that does not init_meta'
+ );
}
{
has an_attr => ( is => 'ro' );
}
-lives_ok {
+is( exception {
my $instance = Class::WithAlreadyPresentTrait->new( an_attr => 'value' );
is( $instance->an_attr, 'value', 'Can get value' );
-}
-'Can create instance and access attributes';
+}, undef, 'Can create instance and access attributes' );
{
has an_attr => ( is => 'ro' );
}
-lives_ok {
+is( exception {
my $instance = Class::WhichLoadsATraitFromDisk->new( an_attr => 'value' );
is( $instance->an_attr, 'value', 'Can get value' );
-}
-'Can create instance and access attributes';
+}, undef, 'Can create instance and access attributes' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
# Some packages out in the wild cooperate with Moose by using goto
# &Moose::import. we want to make sure it still works.
MooseAlike1->import();
- ::lives_ok { has( 'size', is => 'bare' ) }
- 'has was exported via MooseAlike1';
+ ::is( ::exception { has( 'size', is => 'bare' ) }, undef, 'has was exported via MooseAlike1' );
MooseAlike1->unimport();
}
MooseAlike2->import();
- ::lives_ok { has( 'size', is => 'bare' ) }
- 'has was exported via MooseAlike2';
+ ::is( ::exception { has( 'size', is => 'bare' ) }, undef, 'has was exported via MooseAlike2' );
MooseAlike2->unimport();
}
use lib 't/lib', 'lib';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util::MetaRole;
}
}
-lives_ok {
+is( exception {
package UsesExportedMoose;
ExportsMoose->import;
-} 'import module which loads a role from disk during init_meta';
+}, undef, 'import module which loads a role from disk during init_meta' );
{
package Foo::Meta::Role;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
);
use Moose;
- ::dies_ok { extends 'Baz::Sub' } 'error_class is included in metaclass compatibility checks';
+ ::isnt( ::exception { extends 'Baz::Sub' }, undef, 'error_class is included in metaclass compatibility checks' );
}
{
package Foo::Sub::Sub;
use Moose;
- ::lives_ok { extends 'Foo::Sub' } 'error_class differs by role so incompat is handled';
+ ::is( ::exception { extends 'Foo::Sub' }, undef, 'error_class differs by role so incompat is handled' );
Moose::Util::MetaRole::apply_metaroles(
for => __PACKAGE__,
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package HasFoo;
package main;
my $anon;
-lives_ok {
+is( exception {
$anon = My::Metaclass->create_anon_class( foo => 'this' );
-} 'create anon class with required attr';
+}, undef, 'create anon class with required attr' );
isa_ok( $anon, 'My::Metaclass' );
cmp_ok( $anon->foo, 'eq', 'this', 'foo is this' );
-dies_ok {
+isnt( exception {
$anon = My::Metaclass->create_anon_class();
-} 'failed to create anon class without required attr';
+}, undef, 'failed to create anon class without required attr' );
my $meta;
-lives_ok {
+is( exception {
$meta
= My::Metaclass->initialize( 'Class::Name1' => ( foo => 'that' ) );
-} 'initialize a class with required attr';
+}, undef, 'initialize a class with required attr' );
isa_ok( $meta, 'My::Metaclass' );
cmp_ok( $meta->foo, 'eq', 'that', 'foo is that' );
cmp_ok( $meta->name, 'eq', 'Class::Name1', 'for the correct class' );
-dies_ok {
+isnt( exception {
$meta
= My::Metaclass->initialize( 'Class::Name2' );
-} 'failed to initialize a class without required attr';
+}, undef, 'failed to initialize a class without required attr' );
-lives_ok {
+is( exception {
eval qq{
package Class::Name3;
use metaclass 'My::Metaclass' => (
use Moose;
};
die $@ if $@;
-} 'use metaclass with required attr';
+}, undef, 'use metaclass with required attr' );
$meta = Class::Name3->meta;
isa_ok( $meta, 'My::Metaclass' );
cmp_ok( $meta->foo, 'eq', 'another', 'foo is another' );
cmp_ok( $meta->name, 'eq', 'Class::Name3', 'for the correct class' );
-dies_ok {
+isnt( exception {
eval qq{
package Class::Name4;
use metaclass 'My::Metaclass';
use Moose;
};
die $@ if $@;
-} 'failed to use metaclass without required attr';
+}, undef, 'failed to use metaclass without required attr' );
# how do we pass a required attribute to -traits?
-dies_ok {
+isnt( exception {
eval qq{
package Class::Name5;
use Moose -traits => 'HasFoo';
};
die $@ if $@;
-} 'failed to use trait without required attr';
+}, undef, 'failed to use trait without required attr' );
done_testing;
use MyExporter;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
-lives_and {
+is( exception {
with_prototype {
my $caller = caller(0);
is($caller, 'MyExporter', "With_caller prototype code gets called from MyMooseX");
};
-} "check function with prototype";
+}, undef, "check function with prototype" );
-lives_and {
+is( exception {
as_is_prototype {
my $caller = caller(0);
is($caller, 'MyExporter', "As-is prototype code gets called from MyMooseX");
};
-} "check function with prototype";
+}, undef, "check function with prototype" );
done_testing;
}
use Test::More;
-use Test::Exception;
+use Test::Fatal;
-lives_ok {
+is( exception {
Moose->init_meta(for_class => 'SomeClass');
-} 'Moose class => use base => Moose Class, then Moose->init_meta on middle class ok';
+}, undef, 'Moose class => use base => Moose Class, then Moose->init_meta on middle class ok' );
done_testing;
use lib 't/lib', 'lib';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util::MetaRole;
}
}
-lives_ok {
+is( exception {
package UsesExportedMoose;
ExportsMoose->import;
-} 'import module which loads a role from disk during init_meta';
+}, undef, 'import module which loads a role from disk during init_meta' );
{
package Foo::Meta::Role;
use warnings;
use lib 't/lib';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
our $called = 0;
{
package Baz2;
use Moose;
my $meta = __PACKAGE__->meta;
- ::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
+ ::is( ::exception { $meta->superclasses('Foo2') }, undef, "can set superclasses once" );
::isa_ok($meta, Foo2->meta->meta->name);
- ::lives_ok { $meta->superclasses('Bar2') } "can still set superclasses";
+ ::is( ::exception { $meta->superclasses('Bar2') }, undef, "can still set superclasses" );
::isa_ok($meta, Bar2->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo2::Role'],
"still have the role attached");
::ok(!$meta->is_immutable,
"immutable superclass doesn't make this class immutable");
- ::lives_ok { $meta->make_immutable } "can still make immutable";
+ ::is( ::exception { $meta->make_immutable }, undef, "can still make immutable" );
}
{
package Foo3::Role;
package Baz3;
use Moose -traits => ['Foo3::Role'];
my $meta = __PACKAGE__->meta;
- ::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
+ ::is( ::exception { $meta->superclasses('Foo2') }, undef, "can set superclasses once" );
::isa_ok($meta, Foo2->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo2::Role', 'Foo3::Role'],
"reconciled roles correctly");
- ::lives_ok { $meta->superclasses('Bar3') } "can still set superclasses";
+ ::is( ::exception { $meta->superclasses('Bar3') }, undef, "can still set superclasses" );
::isa_ok($meta, Bar3->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo2::Role', 'Foo3::Role'],
"roles still the same");
::ok(!$meta->is_immutable,
"immutable superclass doesn't make this class immutable");
- ::lives_ok { $meta->make_immutable } "can still make immutable";
+ ::is( ::exception { $meta->make_immutable }, undef, "can still make immutable" );
}
{
package Quux3;
package Quuux3;
use Moose -traits => ['Foo3::Role'];
my $meta = __PACKAGE__->meta;
- ::lives_ok { $meta->superclasses('Foo2') } "can set superclasses once";
+ ::is( ::exception { $meta->superclasses('Foo2') }, undef, "can set superclasses once" );
::isa_ok($meta, Foo2->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo2::Role', 'Foo3::Role'],
"reconciled roles correctly");
- ::lives_ok { $meta->superclasses('Quux3') } "can still set superclasses";
+ ::is( ::exception { $meta->superclasses('Quux3') }, undef, "can still set superclasses" );
::isa_ok($meta, Quux3->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo2::Role', 'Foo3::Role'],
"roles still the same");
::ok(!$meta->is_immutable,
"immutable superclass doesn't make this class immutable");
- ::lives_ok { $meta->make_immutable } "can still make immutable";
+ ::is( ::exception { $meta->make_immutable }, undef, "can still make immutable" );
}
{
package Baz4;
use Moose;
my $meta = __PACKAGE__->meta;
- ::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
+ ::is( ::exception { $meta->superclasses('Foo4') }, undef, "can set superclasses once" );
::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
- ::lives_ok { $meta->superclasses('Bar4') } "can still set superclasses";
+ ::is( ::exception { $meta->superclasses('Bar4') }, undef, "can still set superclasses" );
::isa_ok($meta, Bar4->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo4::Role'],
"still have the role attached");
::ok(!$meta->is_immutable,
"immutable superclass doesn't make this class immutable");
- ::lives_ok { $meta->make_immutable } "can still make immutable";
+ ::is( ::exception { $meta->make_immutable }, undef, "can still make immutable" );
}
{
package Foo5::Role;
package Baz5;
use Moose -traits => ['Foo5::Role'];
my $meta = __PACKAGE__->meta;
- ::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
+ ::is( ::exception { $meta->superclasses('Foo4') }, undef, "can set superclasses once" );
::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo4::Role', 'Foo5::Role'],
"reconciled roles correctly");
- ::lives_ok { $meta->superclasses('Bar5') } "can still set superclasses";
+ ::is( ::exception { $meta->superclasses('Bar5') }, undef, "can still set superclasses" );
::isa_ok($meta, Bar5->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo4::Role', 'Foo5::Role'],
"roles still the same");
::ok(!$meta->is_immutable,
"immutable superclass doesn't make this class immutable");
- ::lives_ok { $meta->make_immutable } "can still make immutable";
+ ::is( ::exception { $meta->make_immutable }, undef, "can still make immutable" );
}
{
package Quux5;
package Quuux5;
use Moose -traits => ['Foo5::Role'];
my $meta = __PACKAGE__->meta;
- ::lives_ok { $meta->superclasses('Foo4') } "can set superclasses once";
+ ::is( ::exception { $meta->superclasses('Foo4') }, undef, "can set superclasses once" );
::isa_ok($meta, Foo4->meta->_get_mutable_metaclass_name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo4::Role', 'Foo5::Role'],
"reconciled roles correctly");
- ::lives_ok { $meta->superclasses('Quux5') } "can still set superclasses";
+ ::is( ::exception { $meta->superclasses('Quux5') }, undef, "can still set superclasses" );
::isa_ok($meta, Quux5->meta->meta->name);
::is_deeply([sort map { $_->name } $meta->meta->calculate_all_roles_with_inheritance],
['Foo4::Role', 'Foo5::Role'],
"roles still the same");
::ok(!$meta->is_immutable,
"immutable superclass doesn't make this class immutable");
- ::lives_ok { $meta->make_immutable } "can still make immutable";
+ ::is( ::exception { $meta->make_immutable }, undef, "can still make immutable" );
}
{
push(@superclasses, 'Foo5::SuperClass::After::Attribute');
- ::lives_ok {
+ ::is( ::exception {
extends @superclasses;
- } 'MI extends after_generated_methods with metaclass roles';
- ::lives_ok {
+ }, undef, 'MI extends after_generated_methods with metaclass roles' );
+ ::is( ::exception {
extends reverse @superclasses;
- }
- 'MI extends after_generated_methods with metaclass roles (reverse)';
+ }, undef, 'MI extends after_generated_methods with metaclass roles (reverse)' );
}
{
push(@superclasses, 'Foo6::SuperClass::After::Attribute');
- ::throws_ok {
+ ::like( ::exception {
extends @superclasses;
- } qr/compat.*pristine/,
- 'unsafe MI extends after_generated_methods with metaclass roles';
- ::throws_ok {
+ }, qr/compat.*pristine/, 'unsafe MI extends after_generated_methods with metaclass roles' );
+ ::like( ::exception {
extends reverse @superclasses;
- } qr/compat.*pristine/,
- 'unsafe MI extends after_generated_methods with metaclass roles (reverse)';
+ }, qr/compat.*pristine/, 'unsafe MI extends after_generated_methods with metaclass roles (reverse)' );
}
{
package Bar7;
# in an external file
use Moose -traits => ['Bar7::Meta::Trait'];
- ::lives_ok { extends 'Foo7' } "role reconciliation works";
+ ::is( ::exception { extends 'Foo7' }, undef, "role reconciliation works" );
}
{
package Bar72;
# in an external file
use Moose -traits => ['Bar7::Meta::Trait2'];
- ::lives_ok { extends 'Foo7' } "role reconciliation works";
+ ::is( ::exception { extends 'Foo7' }, undef, "role reconciliation works" );
}
done_testing;
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Foo::Meta::Constructor1;
for => __PACKAGE__,
class_metaroles => { constructor => ['Foo::Meta::Constructor2'] },
);
- ::lives_ok { extends 'Foo::Sub' } "doesn't try to fix if nothing is needed";
+ ::is( ::exception { extends 'Foo::Sub' }, undef, "doesn't try to fix if nothing is needed" );
}
done_testing;
use warnings;
use Test::More;
use Test::Moose;
-use Test::Exception;
+use Test::Fatal;
sub check_meta_sanity {
my ($meta, $class) = @_;
BEGIN { extends 'Moose::Meta::Attribute' };
}
-throws_ok {
+like( exception {
Moose::Meta::Class->reinitialize(
'Bar',
method_metaclass => 'Bar::Meta::Method',
attribute_metaclass => 'Bar::Meta::Attribute',
);
-} qr/compatible/;
+}, qr/compatible/ );
{
package Baz::Meta::Class;
extends 'Moose::Meta::Attribute';
}
-throws_ok {
+like( exception {
Moose::Meta::Class->reinitialize(
'Baz',
method_metaclass => 'Baz::Meta::Method',
attribute_metaclass => 'Baz::Meta::Attribute',
);
-} qr/compatible/;
+}, qr/compatible/ );
{
package Quux;
use lib 't/lib', 'lib';
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use File::Spec;
use File::Temp 'tempdir';
is($_->meta->name, $_, '... initialized the meta correctly');
- lives_ok {
+ is( exception {
Module::Refresh->new->refresh_module($_ . '.pm')
- } '... successfully refreshed ' . $_;
+ }, undef, '... successfully refreshed ' );
} foreach @modules;
=pod
close FILE;
}
-lives_ok {
+is( exception {
Module::Refresh->new->refresh_module('TestBaz.pm')
-} '... successfully refreshed ' . $test_module_file;
+}, undef, '... successfully refreshed ' );
is(TestBaz->meta->name, 'TestBaz', '... initialized the meta correctly');
ok(TestBaz->meta->has_attribute('foo'), '... it has the foo attribute as well');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
is( $foo_moose->moose, 'Foo',
'... got the right value from the Foo::Moose method' );
-lives_ok {
+is( exception {
Old::Bucket::Nose->meta->make_immutable( debug => 0 );
-}
-'Immutability on Moose class extending Class::MOP class ok';
+}, undef, 'Immutability on Moose class extending Class::MOP class ok' );
-lives_ok {
+is( exception {
SubClass2->meta->superclasses('MyBase');
-}
-'Can subclass the same non-Moose class twice with different metaclasses';
+}, undef, 'Can subclass the same non-Moose class twice with different metaclasses' );
done_testing;
package SubSubClassUseBase;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends 'SubClassUseBase';
- }
- 'Can extend non-Moose class with parent class that is a Moose class with a meta role';
+ }, undef, 'Can extend non-Moose class with parent class that is a Moose class with a meta role' );
}
{
package MultiParent1;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends qw( SubClassUseBase OtherSubClassUseBase );
- }
- 'Can extend two non-Moose classes with parents that are different Moose metaclasses';
+ }, undef, 'Can extend two non-Moose classes with parents that are different Moose metaclasses' );
}
{
package MultiParent2;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends qw( OtherSubClassUseBase SubClassUseBase );
- }
- 'Can extend two non-Moose classes with parents that are different Moose metaclasses (reverse order)';
+ }, undef, 'Can extend two non-Moose classes with parents that are different Moose metaclasses (reverse order)' );
}
{
package MultiParent3;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends qw( OtherClass SubClassUseBase );
- }
- 'Can extend one Moose class and one non-Moose class';
+ }, undef, 'Can extend one Moose class and one non-Moose class' );
}
{
package MultiParent4;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends qw( SubClassUseBase OtherClass );
- }
- 'Can extend one non-Moose class and one Moose class';
+ }, undef, 'Can extend one non-Moose class and one Moose class' );
}
{
package MultiChild1;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends 'MultiParent1';
- }
- 'Can extend class that itself extends two non-Moose classes with Moose parents';
+ }, undef, 'Can extend class that itself extends two non-Moose classes with Moose parents' );
}
{
package MultiChild2;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends 'MultiParent2';
- }
- 'Can extend class that itself extends two non-Moose classes with Moose parents (reverse order)';
+ }, undef, 'Can extend class that itself extends two non-Moose classes with Moose parents (reverse order)' );
}
{
package MultiChild3;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends 'MultiParent3';
- }
- 'Can extend class that itself extends one Moose and one non-Moose parent';
+ }, undef, 'Can extend class that itself extends one Moose and one non-Moose parent' );
}
{
package MultiChild4;
use Moose;
use Test::More;
- use Test::Exception;
- lives_ok {
+ use Test::Fatal;
+ is( exception {
extends 'MultiParent4';
- }
- 'Can extend class that itself extends one non-Moose and one Moose parent';
+ }, undef, 'Can extend class that itself extends one non-Moose and one Moose parent' );
}
{
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Moose;
{
for => __PACKAGE__,
class_metaroles => { class => ['Foo::Role', 'Bar::Role'] },
);
- ::lives_ok { extends 'Parent' };
+ ::is( ::exception { extends 'Parent' }, undef );
}
with_immutable {
use Moose::Util::TypeConstraints;
use NoInlineAttribute;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Moose;
{
ok( !$obj->is_empty, 'values is not empty' );
is( $obj->count, 3, 'count returns 3' );
- throws_ok { $obj->count(22) }
- qr/Cannot call count with any arguments/,
- 'throws an error when passing an argument passed to count';
+ like( exception { $obj->count(22) }, qr/Cannot call count with any arguments/, 'throws an error when passing an argument passed to count' );
- lives_ok { $obj->push( 1, 2, 3 ) }
- 'pushed three new values and lived';
+ is( exception { $obj->push( 1, 2, 3 ) }, undef, 'pushed three new values and lived' );
- lives_ok { $obj->push() } 'call to push without arguments lives';
+ is( exception { $obj->push() }, undef, 'call to push without arguments lives' );
- lives_and {
+ is( exception {
is( $obj->unshift( 101, 22 ), 8,
'unshift returns size of the new array' );
- }
- 'unshifted two values and lived';
+ }, undef, 'unshifted two values and lived' );
is_deeply(
$obj->_values, [ 101, 22, 10, 12, 42, 1, 2, 3 ],
'unshift changed the value of the array in the object'
);
- lives_ok { $obj->unshift() }
- 'call to unshift without arguments lives';
+ is( exception { $obj->unshift() }, undef, 'call to unshift without arguments lives' );
is( $obj->pop, 3, 'pop returns the last value in the array' );
'pop changed the value of the array in the object'
);
- throws_ok { $obj->pop(42) }
- qr/Cannot call pop with any arguments/,
- 'call to pop with arguments dies';
+ like( exception { $obj->pop(42) }, qr/Cannot call pop with any arguments/, 'call to pop with arguments dies' );
is( $obj->shift, 101, 'shift returns the first value' );
- throws_ok { $obj->shift(42) }
- qr/Cannot call shift with any arguments/,
- 'call to shift with arguments dies';
+ like( exception { $obj->shift(42) }, qr/Cannot call shift with any arguments/, 'call to shift with arguments dies' );
is_deeply(
$obj->_values, [ 22, 10, 12, 42, 1, 2 ],
'call to elements returns values as a list'
);
- throws_ok { $obj->elements(22) }
- qr/Cannot call elements with any arguments/,
- 'throws an error when passing an argument passed to elements';
+ like( exception { $obj->elements(22) }, qr/Cannot call elements with any arguments/, 'throws an error when passing an argument passed to elements' );
$obj->_values( [ 1, 2, 3 ] );
is( $obj->get(2), 3, 'get values at index 2' );
is( $obj->get_curried, 2, 'get_curried returns value at index 1' );
- throws_ok { $obj->get() }
- qr/Cannot call get without at least 1 argument/,
- 'throws an error when get is called without any arguments';
+ like( exception { $obj->get() }, qr/Cannot call get without at least 1 argument/, 'throws an error when get is called without any arguments' );
- throws_ok { $obj->get( {} ) }
- qr/The index passed to get must be an integer/,
- 'throws an error when get is called with an invalid argument';
+ like( exception { $obj->get( {} ) }, qr/The index passed to get must be an integer/, 'throws an error when get is called with an invalid argument' );
- throws_ok { $obj->get(2.2) }
- qr/The index passed to get must be an integer/,
- 'throws an error when get is called with an invalid argument';
+ like( exception { $obj->get(2.2) }, qr/The index passed to get must be an integer/, 'throws an error when get is called with an invalid argument' );
- throws_ok { $obj->get('foo') }
- qr/The index passed to get must be an integer/,
- 'throws an error when get is called with an invalid argument';
+ like( exception { $obj->get('foo') }, qr/The index passed to get must be an integer/, 'throws an error when get is called with an invalid argument' );
- throws_ok { $obj->get_curried(2) }
- qr/Cannot call get with more than 1 argument/,
- 'throws an error when get_curried is called with an argument';
+ like( exception { $obj->get_curried(2) }, qr/Cannot call get with more than 1 argument/, 'throws an error when get_curried is called with an argument' );
- lives_and {
+ is( exception {
is( $obj->set( 1, 100 ), 100, 'set returns new value' );
- }
- 'set value at index 1 lives';
+ }, undef, 'set value at index 1 lives' );
is( $obj->get(1), 100, 'get value at index 1 returns new value' );
- throws_ok { $obj->set( 1, 99, 42 ) }
- qr/Cannot call set with more than 2 arguments/,
- 'throws an error when set is called with three arguments';
+ like( exception { $obj->set( 1, 99, 42 ) }, qr/Cannot call set with more than 2 arguments/, 'throws an error when set is called with three arguments' );
- lives_ok { $obj->set_curried_1(99) } 'set_curried_1 lives';
+ is( exception { $obj->set_curried_1(99) }, undef, 'set_curried_1 lives' );
is( $obj->get(1), 99, 'get value at index 1 returns new value' );
- throws_ok { $obj->set_curried_1( 99, 42 ) }
- qr/Cannot call set with more than 2 arguments/,
- 'throws an error when set_curried_1 is called with two arguments';
+ like( exception { $obj->set_curried_1( 99, 42 ) }, qr/Cannot call set with more than 2 arguments/, 'throws an error when set_curried_1 is called with two arguments' );
- lives_ok { $obj->set_curried_2 } 'set_curried_2 lives';
+ is( exception { $obj->set_curried_2 }, undef, 'set_curried_2 lives' );
is( $obj->get(1), 98, 'get value at index 1 returns new value' );
- throws_ok { $obj->set_curried_2(42) }
- qr/Cannot call set with more than 2 arguments/,
- 'throws an error when set_curried_2 is called with one argument';
+ like( exception { $obj->set_curried_2(42) }, qr/Cannot call set with more than 2 arguments/, 'throws an error when set_curried_2 is called with one argument' );
is(
$obj->accessor(1), 98,
'accessor with one argument returns value at index 1'
);
- lives_and {
+ is( exception {
is( $obj->accessor( 1 => 97 ), 97, 'accessor returns new value' );
- }
- 'accessor as writer lives';
+ }, undef, 'accessor as writer lives' );
is(
$obj->get(1), 97,
'accessor set value at index 1'
);
- throws_ok { $obj->accessor( 1, 96, 42 ) }
- qr/Cannot call accessor with more than 2 arguments/,
- 'throws an error when accessor is called with three arguments';
+ like( exception { $obj->accessor( 1, 96, 42 ) }, qr/Cannot call accessor with more than 2 arguments/, 'throws an error when accessor is called with three arguments' );
is(
$obj->accessor_curried_1, 97,
'accessor_curried_1 returns expected value when called with no arguments'
);
- lives_ok { $obj->accessor_curried_1(95) }
- 'accessor_curried_1 as writer lives';
+ is( exception { $obj->accessor_curried_1(95) }, undef, 'accessor_curried_1 as writer lives' );
is(
$obj->get(1), 95,
'accessor_curried_1 set value at index 1'
);
- throws_ok { $obj->accessor_curried_1( 96, 42 ) }
- qr/Cannot call accessor with more than 2 arguments/,
- 'throws an error when accessor_curried_1 is called with two arguments';
+ like( exception { $obj->accessor_curried_1( 96, 42 ) }, qr/Cannot call accessor with more than 2 arguments/, 'throws an error when accessor_curried_1 is called with two arguments' );
- lives_ok { $obj->accessor_curried_2 }
- 'accessor_curried_2 as writer lives';
+ is( exception { $obj->accessor_curried_2 }, undef, 'accessor_curried_2 as writer lives' );
is(
$obj->get(1), 90,
'accessor_curried_2 set value at index 1'
);
- throws_ok { $obj->accessor_curried_2(42) }
- qr/Cannot call accessor with more than 2 arguments/,
- 'throws an error when accessor_curried_2 is called with one argument';
+ like( exception { $obj->accessor_curried_2(42) }, qr/Cannot call accessor with more than 2 arguments/, 'throws an error when accessor_curried_2 is called with one argument' );
- lives_ok { $obj->clear } 'clear lives';
+ is( exception { $obj->clear }, undef, 'clear lives' );
ok( $obj->is_empty, 'values is empty after call to clear' );
$obj->set( 0 => 42 );
- throws_ok { $obj->clear(50) }
- qr/Cannot call clear with any arguments/,
- 'throws an error when clear is called with an argument';
+ like( exception { $obj->clear(50) }, qr/Cannot call clear with any arguments/, 'throws an error when clear is called with an argument' );
ok(
!$obj->is_empty,
'values is not empty after failed call to clear'
);
- throws_ok { $obj->is_empty(50) }
- qr/Cannot call is_empty with any arguments/,
- 'throws an error when is_empty is called with an argument';
+ like( exception { $obj->is_empty(50) }, qr/Cannot call is_empty with any arguments/, 'throws an error when is_empty is called with an argument' );
$obj->clear;
is(
'pushed 4 elements, got number of elements in the array back'
);
- lives_and {
+ is( exception {
is( $obj->delete(2), 10, 'delete returns deleted value' );
- }
- 'delete lives';
+ }, undef, 'delete lives' );
is_deeply(
$obj->_values, [ 1, 5, 42 ],
'delete removed the specified element'
);
- throws_ok { $obj->delete( 2, 3 ) }
- qr/Cannot call delete with more than 1 argument/,
- 'throws an error when delete is called with two arguments';
+ like( exception { $obj->delete( 2, 3 ) }, qr/Cannot call delete with more than 1 argument/, 'throws an error when delete is called with two arguments' );
- lives_ok { $obj->delete_curried } 'delete_curried lives';
+ is( exception { $obj->delete_curried }, undef, 'delete_curried lives' );
is_deeply(
$obj->_values, [ 1, 42 ],
'delete removed the specified element'
);
- throws_ok { $obj->delete_curried(2) }
- qr/Cannot call delete with more than 1 argument/,
- 'throws an error when delete_curried is called with one argument';
+ like( exception { $obj->delete_curried(2) }, qr/Cannot call delete with more than 1 argument/, 'throws an error when delete_curried is called with one argument' );
- lives_ok { $obj->insert( 1, 21 ) } 'insert lives';
+ is( exception { $obj->insert( 1, 21 ) }, undef, 'insert lives' );
is_deeply(
$obj->_values, [ 1, 21, 42 ],
'insert added the specified element'
);
- throws_ok { $obj->insert( 1, 22, 44 ) }
- qr/Cannot call insert with more than 2 arguments/,
- 'throws an error when insert is called with three arguments';
+ like( exception { $obj->insert( 1, 22, 44 ) }, qr/Cannot call insert with more than 2 arguments/, 'throws an error when insert is called with three arguments' );
- lives_and {
+ is( exception {
is_deeply(
[ $obj->splice( 1, 0, 2, 3 ) ],
[],
'return value of splice is empty list when not removing elements'
);
- }
- 'splice lives';
+ }, undef, 'splice lives' );
is_deeply(
$obj->_values, [ 1, 2, 3, 21, 42 ],
'splice added the specified elements'
);
- lives_and {
+ is( exception {
is_deeply(
[ $obj->splice( 1, 2, 99 ) ],
[ 2, 3 ],
'splice returns list of removed values'
);
- }
- 'splice lives';
+ }, undef, 'splice lives' );
is_deeply(
$obj->_values, [ 1, 99, 21, 42 ],
'splice added the specified elements'
);
- throws_ok { $obj->splice() }
- qr/Cannot call splice without at least 1 argument/,
- 'throws an error when splice is called with no arguments';
+ like( exception { $obj->splice() }, qr/Cannot call splice without at least 1 argument/, 'throws an error when splice is called with no arguments' );
- throws_ok { $obj->splice( 1, 'foo', ) }
- qr/The length argument passed to splice must be an integer/,
- 'throws an error when splice is called with an invalid length';
+ like( exception { $obj->splice( 1, 'foo', ) }, qr/The length argument passed to splice must be an integer/, 'throws an error when splice is called with an invalid length' );
- lives_ok { $obj->splice_curried_1( 2, 101 ) }
- 'splice_curried_1 lives';
+ is( exception { $obj->splice_curried_1( 2, 101 ) }, undef, 'splice_curried_1 lives' );
is_deeply(
$obj->_values, [ 1, 101, 42 ],
'splice added the specified elements'
);
- lives_ok { $obj->splice_curried_2(102) } 'splice_curried_2 lives';
+ is( exception { $obj->splice_curried_2(102) }, undef, 'splice_curried_2 lives' );
is_deeply(
$obj->_values, [ 1, 102 ],
'splice added the specified elements'
);
- lives_ok { $obj->splice_curried_all } 'splice_curried_all lives';
+ is( exception { $obj->splice_curried_all }, undef, 'splice_curried_all lives' );
is_deeply(
$obj->_values, [ 1, 3, 4, 5 ],
'sort returns values sorted by provided function'
);
- throws_ok { $obj->sort(1) }
- qr/The argument passed to sort must be a code reference/,
- 'throws an error when passing a non coderef to sort';
+ like( exception { $obj->sort(1) }, qr/The argument passed to sort must be a code reference/, 'throws an error when passing a non coderef to sort' );
- throws_ok {
+ like( exception {
$obj->sort( sub { }, 27 );
- }
- qr/Cannot call sort with more than 1 argument/,
- 'throws an error when passing two arguments to sort';
+ }, qr/Cannot call sort with more than 1 argument/, 'throws an error when passing two arguments to sort' );
$obj->_values( [ 3, 9, 5, 22, 11 ] );
'sort_in_place with function sorts values'
);
- throws_ok {
+ like( exception {
$obj->sort_in_place( 27 );
- }
- qr/The argument passed to sort_in_place must be a code reference/,
- 'throws an error when passing a non coderef to sort_in_place';
+ }, qr/The argument passed to sort_in_place must be a code reference/, 'throws an error when passing a non coderef to sort_in_place' );
- throws_ok {
+ like( exception {
$obj->sort_in_place( sub { }, 27 );
- }
- qr/Cannot call sort_in_place with more than 1 argument/,
- 'throws an error when passing two arguments to sort_in_place';
+ }, qr/Cannot call sort_in_place with more than 1 argument/, 'throws an error when passing two arguments to sort_in_place' );
$obj->_values( [ 3, 9, 5, 22, 11 ] );
'sort_in_place_curried sorts values'
);
- throws_ok { $obj->sort_in_place_curried(27) }
- qr/Cannot call sort_in_place with more than 1 argument/,
- 'throws an error when passing one argument passed to sort_in_place_curried';
+ like( exception { $obj->sort_in_place_curried(27) }, qr/Cannot call sort_in_place with more than 1 argument/, 'throws an error when passing one argument passed to sort_in_place_curried' );
$obj->_values( [ 1 .. 5 ] );
'map returns the expected values'
);
- throws_ok { $obj->map }
- qr/Cannot call map without at least 1 argument/,
- 'throws an error when passing no arguments to map';
+ like( exception { $obj->map }, qr/Cannot call map without at least 1 argument/, 'throws an error when passing no arguments to map' );
- throws_ok {
+ like( exception {
$obj->map( sub { }, 2 );
- }
- qr/Cannot call map with more than 1 argument/,
- 'throws an error when passing two arguments to map';
+ }, qr/Cannot call map with more than 1 argument/, 'throws an error when passing two arguments to map' );
- throws_ok { $obj->map( {} ) }
- qr/The argument passed to map must be a code reference/,
- 'throws an error when passing a non coderef to map';
+ like( exception { $obj->map( {} ) }, qr/The argument passed to map must be a code reference/, 'throws an error when passing a non coderef to map' );
$obj->_values( [ 1 .. 5 ] );
'map_curried returns the expected values'
);
- throws_ok {
+ like( exception {
$obj->map_curried( sub { } );
- }
- qr/Cannot call map with more than 1 argument/,
- 'throws an error when passing one argument passed to map_curried';
+ }, qr/Cannot call map with more than 1 argument/, 'throws an error when passing one argument passed to map_curried' );
$obj->_values( [ 2 .. 9 ] );
'grep returns the expected values'
);
- throws_ok { $obj->grep }
- qr/Cannot call grep without at least 1 argument/,
- 'throws an error when passing no arguments to grep';
+ like( exception { $obj->grep }, qr/Cannot call grep without at least 1 argument/, 'throws an error when passing no arguments to grep' );
- throws_ok {
+ like( exception {
$obj->grep( sub { }, 2 );
- }
- qr/Cannot call grep with more than 1 argument/,
- 'throws an error when passing two arguments to grep';
+ }, qr/Cannot call grep with more than 1 argument/, 'throws an error when passing two arguments to grep' );
- throws_ok { $obj->grep( {} ) }
- qr/The argument passed to grep must be a code reference/,
- 'throws an error when passing a non coderef to grep';
+ like( exception { $obj->grep( {} ) }, qr/The argument passed to grep must be a code reference/, 'throws an error when passing a non coderef to grep' );
my $overloader = Overloader->new( sub { $_ < 5 } );
is_deeply(
'grep_curried returns the expected values'
);
- throws_ok {
+ like( exception {
$obj->grep_curried( sub { } );
- }
- qr/Cannot call grep with more than 1 argument/,
- 'throws an error when passing one argument passed to grep_curried';
+ }, qr/Cannot call grep with more than 1 argument/, 'throws an error when passing one argument passed to grep_curried' );
$obj->_values( [ 2, 4, 22, 99, 101, 6 ] );
'first returns expected value'
);
- throws_ok { $obj->first }
- qr/Cannot call first without at least 1 argument/,
- 'throws an error when passing no arguments to first';
+ like( exception { $obj->first }, qr/Cannot call first without at least 1 argument/, 'throws an error when passing no arguments to first' );
- throws_ok {
+ like( exception {
$obj->first( sub { }, 2 );
- }
- qr/Cannot call first with more than 1 argument/,
- 'throws an error when passing two arguments to first';
+ }, qr/Cannot call first with more than 1 argument/, 'throws an error when passing two arguments to first' );
- throws_ok { $obj->first( {} ) }
- qr/The argument passed to first must be a code reference/,
- 'throws an error when passing a non coderef to first';
+ like( exception { $obj->first( {} ) }, qr/The argument passed to first must be a code reference/, 'throws an error when passing a non coderef to first' );
is(
$obj->first_curried,
'first_curried returns expected value'
);
- throws_ok {
+ like( exception {
$obj->first_curried( sub { } );
- }
- qr/Cannot call first with more than 1 argument/,
- 'throws an error when passing one argument passed to first_curried';
+ }, qr/Cannot call first with more than 1 argument/, 'throws an error when passing one argument passed to first_curried' );
$obj->_values( [ 1 .. 4 ] );
'join returns expected result when joining with empty string'
);
- throws_ok { $obj->join }
- qr/Cannot call join without at least 1 argument/,
- 'throws an error when passing no arguments to join';
+ like( exception { $obj->join }, qr/Cannot call join without at least 1 argument/, 'throws an error when passing no arguments to join' );
- throws_ok { $obj->join( '-', 2 ) }
- qr/Cannot call join with more than 1 argument/,
- 'throws an error when passing two arguments to join';
+ like( exception { $obj->join( '-', 2 ) }, qr/Cannot call join with more than 1 argument/, 'throws an error when passing two arguments to join' );
- throws_ok { $obj->join( {} ) }
- qr/The argument passed to join must be a string/,
- 'throws an error when passing a non string to join';
+ like( exception { $obj->join( {} ) }, qr/The argument passed to join must be a string/, 'throws an error when passing a non string to join' );
is_deeply(
[ sort $obj->shuffle ],
'shuffle returns all values (cannot check for a random order)'
);
- throws_ok { $obj->shuffle(2) }
- qr/Cannot call shuffle with any arguments/,
- 'throws an error when passing an argument passed to shuffle';
+ like( exception { $obj->shuffle(2) }, qr/Cannot call shuffle with any arguments/, 'throws an error when passing an argument passed to shuffle' );
$obj->_values( [ 1 .. 4, 2, 5, 3, 7, 3, 3, 1 ] );
'uniq returns expected values (in original order)'
);
- throws_ok { $obj->uniq(2) }
- qr/Cannot call uniq with any arguments/,
- 'throws an error when passing an argument passed to uniq';
+ like( exception { $obj->uniq(2) }, qr/Cannot call uniq with any arguments/, 'throws an error when passing an argument passed to uniq' );
$obj->_values( [ 1 .. 5 ] );
'reduce returns expected value'
);
- throws_ok { $obj->reduce }
- qr/Cannot call reduce without at least 1 argument/,
- 'throws an error when passing no arguments to reduce';
+ like( exception { $obj->reduce }, qr/Cannot call reduce without at least 1 argument/, 'throws an error when passing no arguments to reduce' );
- throws_ok {
+ like( exception {
$obj->reduce( sub { }, 2 );
- }
- qr/Cannot call reduce with more than 1 argument/,
- 'throws an error when passing two arguments to reduce';
+ }, qr/Cannot call reduce with more than 1 argument/, 'throws an error when passing two arguments to reduce' );
- throws_ok { $obj->reduce( {} ) }
- qr/The argument passed to reduce must be a code reference/,
- 'throws an error when passing a non coderef to reduce';
+ like( exception { $obj->reduce( {} ) }, qr/The argument passed to reduce must be a code reference/, 'throws an error when passing a non coderef to reduce' );
is(
$obj->reduce_curried,
'reduce_curried returns expected value'
);
- throws_ok {
+ like( exception {
$obj->reduce_curried( sub { } );
- }
- qr/Cannot call reduce with more than 1 argument/,
- 'throws an error when passing one argument passed to reduce_curried';
+ }, qr/Cannot call reduce with more than 1 argument/, 'throws an error when passing one argument passed to reduce_curried' );
$obj->_values( [ 1 .. 6 ] );
'natatime with function returns expected value'
);
- throws_ok { $obj->natatime( {} ) }
- qr/The n value passed to natatime must be an integer/,
- 'throws an error when passing a non integer to natatime';
+ like( exception { $obj->natatime( {} ) }, qr/The n value passed to natatime must be an integer/, 'throws an error when passing a non integer to natatime' );
- throws_ok { $obj->natatime( 2, {} ) }
- qr/The second argument passed to natatime must be a code reference/,
- 'throws an error when passing a non code ref to natatime';
+ like( exception { $obj->natatime( 2, {} ) }, qr/The second argument passed to natatime must be a code reference/, 'throws an error when passing a non code ref to natatime' );
$it = $obj->natatime_curried();
@nat = ();
'natatime_curried with function returns expected value'
);
- throws_ok { $obj->natatime_curried( {} ) }
- qr/The second argument passed to natatime must be a code reference/,
- 'throws an error when passing a non code ref to natatime_curried';
+ like( exception { $obj->natatime_curried( {} ) }, qr/The second argument passed to natatime must be a code reference/, 'throws an error when passing a non code ref to natatime_curried' );
if ( $class->meta->get_attribute('_values')->is_lazy ) {
my $obj = $class->new;
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
use Moose::Util::TypeConstraints;
$foo->array_int( [] );
is_deeply( $foo->array_int, [], "array_int - correct contents" );
- dies_ok { $foo->push_array_int('foo') }
- "array_int - can't push wrong type";
+ isnt( exception { $foo->push_array_int('foo') }, undef, "array_int - can't push wrong type" );
is_deeply( $foo->array_int, [], "array_int - correct contents" );
$foo->push_array_int(1);
}
{
- dies_ok { $foo->push_a1('foo') } "a1 - can't push onto undef";
+ isnt( exception { $foo->push_a1('foo') }, undef, "a1 - can't push onto undef" );
$foo->a1( [] );
is_deeply( $foo->a1, [], "a1 - correct contents" );
- dies_ok { $foo->push_a1('foo') } "a1 - can't push wrong type";
+ isnt( exception { $foo->push_a1('foo') }, undef, "a1 - can't push wrong type" );
is_deeply( $foo->a1, [], "a1 - correct contents" );
}
{
- dies_ok { $foo->push_a2('foo') } "a2 - can't push onto undef";
+ isnt( exception { $foo->push_a2('foo') }, undef, "a2 - can't push onto undef" );
$foo->a2( [] );
is_deeply( $foo->a2, [], "a2 - correct contents" );
$foo->push_a2('foo');
is_deeply( $foo->a2, ['foo'], "a2 - correct contents" );
- dies_ok { $foo->push_a2('bar') } "a2 - can't push more than one element";
+ isnt( exception { $foo->push_a2('bar') }, undef, "a2 - can't push more than one element" );
is_deeply( $foo->a2, ['foo'], "a2 - correct contents" );
}
{
- dies_ok { $foo->push_a3(1) } "a3 - can't push onto undef";
+ isnt( exception { $foo->push_a3(1) }, undef, "a3 - can't push onto undef" );
$foo->a3( [] );
is_deeply( $foo->a3, [], "a3 - correct contents" );
- dies_ok { $foo->push_a3('foo') } "a3 - can't push non-int";
+ isnt( exception { $foo->push_a3('foo') }, undef, "a3 - can't push non-int" );
- dies_ok { $foo->push_a3(100) }
- "a3 - can't violate overall type constraint";
+ isnt( exception { $foo->push_a3(100) }, undef, "a3 - can't violate overall type constraint" );
is_deeply( $foo->a3, [], "a3 - correct contents" );
$foo->push_a3(1);
is_deeply( $foo->a3, [1], "a3 - correct contents" );
- dies_ok { $foo->push_a3(100) }
- "a3 - can't violate overall type constraint";
+ isnt( exception { $foo->push_a3(100) }, undef, "a3 - can't violate overall type constraint" );
is_deeply( $foo->a3, [1], "a3 - correct contents" );
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
use Moose::Util::TypeConstraints;
use NoInlineAttribute;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Moose;
{
ok( $obj->is_lit, 'set is_lit to 1 using ->illuminate' );
ok( !$obj->is_dark, 'check if is_dark does the right thing' );
- throws_ok { $obj->illuminate(1) }
- qr/Cannot call set with any arguments/,
- 'set throws an error when an argument is passed';
+ like( exception { $obj->illuminate(1) }, qr/Cannot call set with any arguments/, 'set throws an error when an argument is passed' );
ok( !$obj->darken, 'unset returns false' );
ok( !$obj->is_lit, 'set is_lit to 0 using ->darken' );
ok( $obj->is_dark, 'check if is_dark does the right thing' );
- throws_ok { $obj->darken(1) }
- qr/Cannot call unset with any arguments/,
- 'unset throws an error when an argument is passed';
+ like( exception { $obj->darken(1) }, qr/Cannot call unset with any arguments/, 'unset throws an error when an argument is passed' );
ok( $obj->flip_switch, 'toggle returns new value' );
ok( $obj->is_lit, 'toggle is_lit back to 1 using ->flip_switch' );
ok( !$obj->is_dark, 'check if is_dark does the right thing' );
- throws_ok { $obj->flip_switch(1) }
- qr/Cannot call toggle with any arguments/,
- 'toggle throws an error when an argument is passed';
+ like( exception { $obj->flip_switch(1) }, qr/Cannot call toggle with any arguments/, 'toggle throws an error when an argument is passed' );
$obj->flip_switch;
ok( !$obj->is_lit,
use Moose ();
use Moose::Util::TypeConstraints;
use NoInlineAttribute;
-use Test::Exception;
+use Test::Fatal;
use Test::More;
use Test::Moose;
is( $obj->inc_counter, 2, 'inc returns new value' );
is( $obj->counter, 2, '... got the incremented value (again)' );
- throws_ok { $obj->inc_counter( 1, 2 ) }
- qr/Cannot call inc with more than 1 argument/,
- 'inc throws an error when two arguments are passed';
+ like( exception { $obj->inc_counter( 1, 2 ) }, qr/Cannot call inc with more than 1 argument/, 'inc throws an error when two arguments are passed' );
is( $obj->dec_counter, 1, 'dec returns new value' );
is( $obj->counter, 1, '... got the decremented value' );
- throws_ok { $obj->dec_counter( 1, 2 ) }
- qr/Cannot call dec with more than 1 argument/,
- 'dec throws an error when two arguments are passed';
+ like( exception { $obj->dec_counter( 1, 2 ) }, qr/Cannot call dec with more than 1 argument/, 'dec throws an error when two arguments are passed' );
is( $obj->reset_counter, 0, 'reset returns new value' );
is( $obj->counter, 0, '... got the original value' );
- throws_ok { $obj->reset_counter(2) }
- qr/Cannot call reset with any arguments/,
- 'reset throws an error when an argument is passed';
+ like( exception { $obj->reset_counter(2) }, qr/Cannot call reset with any arguments/, 'reset throws an error when an argument is passed' );
is( $obj->set_counter(5), 5, 'set returns new value' );
is( $obj->counter, 5, '... set the value' );
- throws_ok { $obj->set_counter( 1, 2 ) }
- qr/Cannot call set with more than 1 argument/,
- 'set throws an error when two arguments are passed';
+ like( exception { $obj->set_counter( 1, 2 ) }, qr/Cannot call set with more than 1 argument/, 'set throws an error when two arguments are passed' );
$obj->inc_counter(2);
is( $obj->counter, 7, '... increment by arg' );
use Moose ();
use Moose::Util::TypeConstraints;
use NoInlineAttribute;
-use Test::Exception;
+use Test::Fatal;
use Test::More;
use Test::Moose;
is_deeply( $obj->options, {}, '... no options yet' );
ok( !$obj->has_option('foo'), '... we have no foo option' );
- lives_and {
+ is( exception {
is(
$obj->set_option( foo => 'bar' ),
'bar',
'set return single new value in scalar context'
);
- }
- '... set the option okay';
+ }, undef, '... set the option okay' );
ok( $obj->is_defined('foo'), '... foo is defined' );
ok( $obj->has_option('foo'), '... we have a foo option' );
is_deeply( $obj->options, { foo => 'bar' }, '... got options now' );
- lives_ok {
+ is( exception {
$obj->set_option( bar => 'baz' );
- }
- '... set the option okay';
+ }, undef, '... set the option okay' );
is( $obj->num_options, 2, '... we have 2 option(s)' );
is_deeply(
'... got last option in scalar context'
);
- lives_ok {
+ is( exception {
$obj->set_option( oink => "blah", xxy => "flop" );
- }
- '... set the option okay';
+ }, undef, '... set the option okay' );
is( $obj->num_options, 4, "4 options" );
is_deeply(
[qw(bar baz blah flop)], "get multiple options at once"
);
- lives_and {
+ is( exception {
is( scalar $obj->delete_option('bar'), 'baz',
'delete returns deleted value' );
- }
- '... deleted the option okay';
+ }, undef, '... deleted the option okay' );
- lives_ok {
+ is( exception {
is_deeply(
[ $obj->delete_option( 'oink', 'xxy' ) ],
[ 'blah', 'flop' ],
'delete returns all deleted values in list context'
);
- }
- '... deleted multiple option okay';
+ }, undef, '... deleted multiple option okay' );
is( $obj->num_options, 1, '... we have 1 option(s)' );
is_deeply(
is_deeply( $obj->options, {}, "... cleared options" );
- lives_ok {
+ is( exception {
$obj->quantity(4);
- }
- '... options added okay with defaults';
+ }, undef, '... options added okay with defaults' );
is( $obj->quantity, 4, 'reader part of curried accessor works' );
'... returns what we expect'
);
- lives_ok {
+ is( exception {
$class->new( options => { foo => 'BAR' } );
- }
- '... good constructor params';
+ }, undef, '... good constructor params' );
- dies_ok {
+ isnt( exception {
$obj->set_option( bar => {} );
- }
- '... could not add a hash ref where an string is expected';
+ }, undef, '... could not add a hash ref where an string is expected' );
- dies_ok {
+ isnt( exception {
$class->new( options => { foo => [] } );
- }
- '... bad constructor params';
+ }, undef, '... bad constructor params' );
is_deeply(
[ $obj->set_option( oink => "blah", xxy => "flop" ) ],
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
use Moose::Util::TypeConstraints;
$foo->hash_int( {} );
is_deeply( $foo->hash_int, {}, "hash_int - correct contents" );
- dies_ok { $foo->set_hash_int( x => 'foo' ) }
- "hash_int - can't set wrong type";
+ isnt( exception { $foo->set_hash_int( x => 'foo' ) }, undef, "hash_int - can't set wrong type" );
is_deeply( $foo->hash_int, {}, "hash_int - correct contents" );
$foo->set_hash_int( x => 1 );
}
{
- dies_ok { $foo->set_h1('foo') } "h1 - can't set onto undef";
+ isnt( exception { $foo->set_h1('foo') }, undef, "h1 - can't set onto undef" );
$foo->h1( {} );
is_deeply( $foo->h1, {}, "h1 - correct contents" );
- dies_ok { $foo->set_h1( x => 'foo' ) } "h1 - can't set wrong type";
+ isnt( exception { $foo->set_h1( x => 'foo' ) }, undef, "h1 - can't set wrong type" );
is_deeply( $foo->h1, {}, "h1 - correct contents" );
}
{
- dies_ok { $foo->set_h2('foo') } "h2 - can't set onto undef";
+ isnt( exception { $foo->set_h2('foo') }, undef, "h2 - can't set onto undef" );
$foo->h2( {} );
is_deeply( $foo->h2, {}, "h2 - correct contents" );
$foo->set_h2( x => 'foo' );
is_deeply( $foo->h2, { x => 'foo' }, "h2 - correct contents" );
- dies_ok { $foo->set_h2( y => 'bar' ) }
- "h2 - can't set more than one element";
+ isnt( exception { $foo->set_h2( y => 'bar' ) }, undef, "h2 - can't set more than one element" );
is_deeply( $foo->h2, { x => 'foo' }, "h2 - correct contents" );
}
{
- dies_ok { $foo->set_h3(1) } "h3 - can't set onto undef";
+ isnt( exception { $foo->set_h3(1) }, undef, "h3 - can't set onto undef" );
$foo->h3( {} );
is_deeply( $foo->h3, {}, "h3 - correct contents" );
- dies_ok { $foo->set_h3( x => 'foo' ) } "h3 - can't set non-int";
+ isnt( exception { $foo->set_h3( x => 'foo' ) }, undef, "h3 - can't set non-int" );
- dies_ok { $foo->set_h3( x => 100 ) }
- "h3 - can't violate overall type constraint";
+ isnt( exception { $foo->set_h3( x => 100 ) }, undef, "h3 - can't violate overall type constraint" );
is_deeply( $foo->h3, {}, "h3 - correct contents" );
$foo->set_h3( x => 1 );
is_deeply( $foo->h3, { x => 1 }, "h3 - correct contents" );
- dies_ok { $foo->set_h3( x => 100 ) }
- "h3 - can't violate overall type constraint";
+ isnt( exception { $foo->set_h3( x => 100 ) }, undef, "h3 - can't violate overall type constraint" );
is_deeply( $foo->h3, { x => 1 }, "h3 - correct contents" );
use Moose ();
use Moose::Util::TypeConstraints;
use NoInlineAttribute;
-use Test::Exception;
+use Test::Fatal;
use Test::More;
use Test::Moose;
is( $obj->integer, 15, 'Add ten for fithteen' );
- throws_ok { $obj->add( 10, 2 ) }
- qr/Cannot call add with more than 1 argument/,
- 'add throws an error when 2 arguments are passed';
+ like( exception { $obj->add( 10, 2 ) }, qr/Cannot call add with more than 1 argument/, 'add throws an error when 2 arguments are passed' );
is( $obj->sub(3), 12, 'sub returns new value' );
is( $obj->integer, 12, 'Subtract three for 12' );
- throws_ok { $obj->sub( 10, 2 ) }
- qr/Cannot call sub with more than 1 argument/,
- 'sub throws an error when 2 arguments are passed';
+ like( exception { $obj->sub( 10, 2 ) }, qr/Cannot call sub with more than 1 argument/, 'sub throws an error when 2 arguments are passed' );
is( $obj->set(10), 10, 'set returns new value' );
is( $obj->integer, 10, 'Set to ten' );
- throws_ok { $obj->set( 10, 2 ) }
- qr/Cannot call set with more than 1 argument/,
- 'set throws an error when 2 arguments are passed';
+ like( exception { $obj->set( 10, 2 ) }, qr/Cannot call set with more than 1 argument/, 'set throws an error when 2 arguments are passed' );
is( $obj->div(2), 5, 'div returns new value' );
is( $obj->integer, 5, 'divide by 2' );
- throws_ok { $obj->div( 10, 2 ) }
- qr/Cannot call div with more than 1 argument/,
- 'div throws an error when 2 arguments are passed';
+ like( exception { $obj->div( 10, 2 ) }, qr/Cannot call div with more than 1 argument/, 'div throws an error when 2 arguments are passed' );
is( $obj->mul(2), 10, 'mul returns new value' );
is( $obj->integer, 10, 'multiplied by 2' );
- throws_ok { $obj->mul( 10, 2 ) }
- qr/Cannot call mul with more than 1 argument/,
- 'mul throws an error when 2 arguments are passed';
+ like( exception { $obj->mul( 10, 2 ) }, qr/Cannot call mul with more than 1 argument/, 'mul throws an error when 2 arguments are passed' );
is( $obj->mod(2), 0, 'mod returns new value' );
is( $obj->integer, 0, 'Mod by 2' );
- throws_ok { $obj->mod( 10, 2 ) }
- qr/Cannot call mod with more than 1 argument/,
- 'mod throws an error when 2 arguments are passed';
+ like( exception { $obj->mod( 10, 2 ) }, qr/Cannot call mod with more than 1 argument/, 'mod throws an error when 2 arguments are passed' );
$obj->set(7);
is( $obj->abs, 1, 'abs returns new value' );
- throws_ok { $obj->abs(10) }
- qr/Cannot call abs with any arguments/,
- 'abs throws an error when an argument is passed';
+ like( exception { $obj->abs(10) }, qr/Cannot call abs with any arguments/, 'abs throws an error when an argument is passed' );
is( $obj->integer, 1, 'abs 1' );
use Moose::Util::TypeConstraints;
use NoInlineAttribute;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Moose;
{
$obj->_string('a');
is( $obj->length, 1, 'length returns 1 for new string' );
- throws_ok { $obj->length(42) }
- qr/Cannot call length with any arguments/,
- 'length throws an error when an argument is passed';
+ like( exception { $obj->length(42) }, qr/Cannot call length with any arguments/, 'length throws an error when an argument is passed' );
is( $obj->inc, 'b', 'inc returns new value' );
is( $obj->_string, 'b', 'a becomes b after inc' );
- throws_ok { $obj->inc(42) }
- qr/Cannot call inc with any arguments/,
- 'inc throws an error when an argument is passed';
+ like( exception { $obj->inc(42) }, qr/Cannot call inc with any arguments/, 'inc throws an error when an argument is passed' );
is( $obj->append('foo'), 'bfoo', 'append returns new value' );
is( $obj->_string, 'bfoo', 'appended to the string' );
- throws_ok { $obj->append( 'foo', 2 ) }
- qr/Cannot call append with more than 1 argument/,
- 'append throws an error when two arguments are passed';
+ like( exception { $obj->append( 'foo', 2 ) }, qr/Cannot call append with more than 1 argument/, 'append throws an error when two arguments are passed' );
$obj->append_curried;
is( $obj->_string, 'bfoo!', 'append_curried appended to the string' );
- throws_ok { $obj->append_curried('foo') }
- qr/Cannot call append with more than 1 argument/,
- 'append_curried throws an error when two arguments are passed';
+ like( exception { $obj->append_curried('foo') }, qr/Cannot call append with more than 1 argument/, 'append_curried throws an error when two arguments are passed' );
$obj->_string("has nl$/");
is( $obj->chomp, 1, 'chomp returns number of characters removed' );
'chomp is a no-op when string has no line ending'
);
- throws_ok { $obj->chomp(42) }
- qr/Cannot call chomp with any arguments/,
- 'chomp throws an error when an argument is passed';
+ like( exception { $obj->chomp(42) }, qr/Cannot call chomp with any arguments/, 'chomp throws an error when an argument is passed' );
is( $obj->chop, 'l', 'chop returns character removed' );
is( $obj->_string, 'has n', 'chopped string' );
- throws_ok { $obj->chop(42) }
- qr/Cannot call chop with any arguments/,
- 'chop throws an error when an argument is passed';
+ like( exception { $obj->chop(42) }, qr/Cannot call chop with any arguments/, 'chop throws an error when an argument is passed' );
$obj->_string('x');
is( $obj->prepend('bar'), 'barx', 'prepend returns new value' );
is( $obj->_string, 'af',
'replace accepts an empty string as first argument' );
- throws_ok { $obj->replace( {}, 'x' ) }
- qr/The first argument passed to replace must be a string or regexp reference/,
- 'replace throws an error when the first argument is not a string or regexp';
+ like( exception { $obj->replace( {}, 'x' ) }, qr/The first argument passed to replace must be a string or regexp reference/, 'replace throws an error when the first argument is not a string or regexp' );
- throws_ok { $obj->replace( qr/x/, {} ) }
- qr/The second argument passed to replace must be a string or code reference/,
- 'replace throws an error when the first argument is not a string or regexp';
+ like( exception { $obj->replace( qr/x/, {} ) }, qr/The second argument passed to replace must be a string or code reference/, 'replace throws an error when the first argument is not a string or regexp' );
$obj->_string('Moosex');
$obj->replace_curried;
'match with empty string as argument returns true'
);
- throws_ok { $obj->match }
- qr/Cannot call match without at least 1 argument/,
- 'match throws an error when no arguments are passed';
+ like( exception { $obj->match }, qr/Cannot call match without at least 1 argument/, 'match throws an error when no arguments are passed' );
- throws_ok { $obj->match( {} ) }
- qr/The argument passed to match must be a string or regexp reference/,
- 'match throws an error when an invalid argument is passed';
+ like( exception { $obj->match( {} ) }, qr/The argument passed to match must be a string or regexp reference/, 'match throws an error when an invalid argument is passed' );
$obj->_string('1234');
ok( !$obj->match_curried, 'match_curried returns false' );
$obj->clear;
is( $obj->_string, q{}, 'clear' );
- throws_ok { $obj->clear(42) }
- qr/Cannot call clear with any arguments/,
- 'clear throws an error when an argument is passed';
+ like( exception { $obj->clear(42) }, qr/Cannot call clear with any arguments/, 'clear throws an error when an argument is passed' );
$obj->_string('some long string');
is(
'substr as setter with three arguments, replacment is empty string'
);
- throws_ok { $obj->substr }
- qr/Cannot call substr without at least 1 argument/,
- 'substr throws an error when no argumemts are passed';
+ like( exception { $obj->substr }, qr/Cannot call substr without at least 1 argument/, 'substr throws an error when no argumemts are passed' );
- throws_ok { $obj->substr( 1, 2, 3, 4 ) }
- qr/Cannot call substr with more than 3 arguments/,
- 'substr throws an error when four argumemts are passed';
+ like( exception { $obj->substr( 1, 2, 3, 4 ) }, qr/Cannot call substr with more than 3 arguments/, 'substr throws an error when four argumemts are passed' );
- throws_ok { $obj->substr( {} ) }
- qr/The first argument passed to substr must be an integer/,
- 'substr throws an error when first argument is not an integer';
+ like( exception { $obj->substr( {} ) }, qr/The first argument passed to substr must be an integer/, 'substr throws an error when first argument is not an integer' );
- throws_ok { $obj->substr( 1, {} ) }
- qr/The second argument passed to substr must be an integer/,
- 'substr throws an error when second argument is not an integer';
+ like( exception { $obj->substr( 1, {} ) }, qr/The second argument passed to substr must be an integer/, 'substr throws an error when second argument is not an integer' );
- throws_ok { $obj->substr( 1, 2, {} ) }
- qr/The third argument passed to substr must be a string/,
- 'substr throws an error when third argument is not a string';
+ like( exception { $obj->substr( 1, 2, {} ) }, qr/The third argument passed to substr must be a string/, 'substr throws an error when third argument is not a string' );
$obj->_string('some long string');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Foo;
package Stuff;
use Moose;
- ::lives_ok{ with 'Stuffed::Role';
- } '... this should work correctly';
+ ::is( ::exception { with 'Stuffed::Role';
+ }, undef, '... this should work correctly' );
- ::lives_ok{ with 'Bulkie::Role';
- } '... this should work correctly';
+ ::is( ::exception { with 'Bulkie::Role';
+ }, undef, '... this should work correctly' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package MyHomePage;
reset_counter
];
-lives_ok {
+is( exception {
$page->meta->remove_attribute('counter');
-}
-'... removed the counter attribute okay';
+}, undef, '... removed the counter attribute okay' );
ok( !$page->meta->has_attribute('counter'),
'... no longer has the attribute' );
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Moose;
{
}
);
- ::lives_ok {
+ ::is( ::exception {
has array => (
traits => ['Array'],
isa => 'ArrayRef',
array_natatime_curried => [ natatime => 2 ],
},
);
- } "native array trait inlines properly";
+ }, undef, "native array trait inlines properly" );
- ::lives_ok {
+ ::is( ::exception {
has bool => (
traits => ['Bool'],
isa => 'Bool',
bool_is_dark => 'not',
},
);
- } "native bool trait inlines properly";
+ }, undef, "native bool trait inlines properly" );
- ::lives_ok {
+ ::is( ::exception {
has code => (
traits => ['Code'],
isa => 'CodeRef',
code_execute_method => 'execute_method',
},
);
- } "native code trait inlines properly";
+ }, undef, "native code trait inlines properly" );
- ::lives_ok {
+ ::is( ::exception {
has counter => (
traits => ['Counter'],
isa => 'Int',
set_counter_42 => [ set => 42 ],
},
);
- } "native counter trait inlines properly";
+ }, undef, "native counter trait inlines properly" );
- ::lives_ok {
+ ::is( ::exception {
has hash => (
traits => ['Hash'],
isa => 'HashRef',
hash_set_option => 'set',
},
);
- } "native hash trait inlines properly";
+ }, undef, "native hash trait inlines properly" );
- ::lives_ok {
+ ::is( ::exception {
has number => (
traits => ['Number'],
isa => 'Num',
num_dec => [ sub => 1 ],
},
);
- } "native number trait inlines properly";
+ }, undef, "native number trait inlines properly" );
- ::lives_ok {
+ ::is( ::exception {
has string => (
traits => ['String'],
is => 'ro',
string_substr_curried_3 => [ substr => ( 1, 3, 'ong' ) ],
},
);
- } "native string trait inlines properly";
+ }, undef, "native string trait inlines properly" );
}
with_immutable {
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
package Foo;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has 'bar' => (
is => 'ro',
isa => 'Int',
lazy => 1,
default => 10,
);
- } '... this didnt die';
+ }, undef, '... this didnt die' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Foo;
package Bar;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has 'baz' => (
is => 'ro',
isa => 'Foo',
default => sub { Foo->new() },
handles => qr/^a$/,
);
- } '... can create the attribute with delegations';
+ }, undef, '... can create the attribute with delegations' );
}
my $bar;
-lives_ok {
+is( exception {
$bar = Bar->new;
-} '... created the object ok';
+}, undef, '... created the object ok' );
isa_ok($bar, 'Bar');
is($bar->a, 'Foo::a', '... got the right delgated value');
package Baz;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has 'bar' => (
is => 'ro',
isa => 'Foo',
default => sub { Foo->new() },
handles => qr/.*/,
);
- } '... can create the attribute with delegations';
+ }, undef, '... can create the attribute with delegations' );
}
my $baz;
-lives_ok {
+is( exception {
$baz = Baz->new;
-} '... created the object ok';
+}, undef, '... created the object ok' );
isa_ok($baz, 'Baz');
is($baz->a, 'Foo::a', '... got the right delgated value');
package Blart;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
has 'bar' => (
is => 'ro',
isa => 'Foo',
default => sub { Foo->new() },
handles => [qw(a new)],
);
- } '... can create the attribute with delegations';
+ }, undef, '... can create the attribute with delegations' );
}
my $blart;
-lives_ok {
+is( exception {
$blart = Blart->new;
-} '... created the object ok';
+}, undef, '... created the object ok' );
isa_ok($blart, 'Blart');
is($blart->a, 'Foo::a', '... got the right delgated value');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package My::Class;
use Moose;
- ::throws_ok {
+ ::like( ::exception {
extends 'My::Role';
- } qr/You cannot inherit from a Moose Role \(My\:\:Role\)/,
- '... this croaks correctly';
+ }, qr/You cannot inherit from a Moose Role \(My\:\:Role\)/, '... this croaks correctly' );
}
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
# RT #37569
my $foo = Foo->new;
my $obj = MyObject->new;
-throws_ok {
+like( exception {
$foo->ar( [] );
-}
-qr/Attribute \(ar\) does not pass the type constraint because: ref: ARRAY/,
- '... got the right error message';
+}, qr/Attribute \(ar\) does not pass the type constraint because: ref: ARRAY/, '... got the right error message' );
-throws_ok {
+like( exception {
$foo->obj($foo); # Doh!
-}
-qr/Attribute \(obj\) does not pass the type constraint because: Well it is an object/,
- '... got the right error message';
+}, qr/Attribute \(obj\) does not pass the type constraint because: Well it is an object/, '... got the right error message' );
-throws_ok {
+like( exception {
$foo->nt($foo); # scalar
-}
-qr/Attribute \(nt\) does not pass the type constraint because: blessed/,
- '... got the right error message';
+}, qr/Attribute \(nt\) does not pass the type constraint because: blessed/, '... got the right error message' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
ok( MyClass->meta->meta->does_role('MyRole'), 'metaclass does MyRole' );
is( MyClass->meta->foo, 'i am foo', '... foo method returns expected value' );
-lives_ok {
+is( exception {
MyClass->meta->make_immutable;
-} '... make MyClass immutable okay';
+}, undef, '... make MyClass immutable okay' );
is(MyClass->meta, $mc, '... these metas are still the same thing');
is(MyClass->meta->meta, $mc->meta, '... these meta-metas are the same thing');
ok( MyClass->meta->meta->does_role('MyRole'), 'metaclass does MyRole' );
is( MyClass->meta->foo, 'i am foo', '... foo method returns expected value' );
-lives_ok {
+is( exception {
MyClass->meta->make_mutable;
-} '... make MyClass mutable okay';
+}, undef, '... make MyClass mutable okay' );
is(MyClass->meta, $mc, '... these metas are still the same thing');
is(MyClass->meta->meta, $mc->meta, '... these meta-metas are the same thing');
ok( MyClass->meta->meta->does_role('MyRole'), 'metaclass does MyRole' );
is( MyClass->meta->foo, 'i am foo', '... foo method returns expected value' );
-lives_ok {
+is( exception {
MyMetaclass->meta->make_immutable;
-} '... make MyMetaclass immutable okay';
+}, undef, '... make MyMetaclass immutable okay' );
is(MyClass->meta, $mc, '... these metas are still the same thing');
is(MyClass->meta->meta, $mc->meta, '... these meta-metas are the same thing');
ok( MyClass->meta->meta->does_role('MyRole'), 'metaclass does MyRole' );
is( MyClass->meta->foo, 'i am foo', '... foo method returns expected value' );
-lives_ok {
+is( exception {
MyClass->meta->make_immutable;
-} '... make MyClass immutable (again) okay';
+}, undef, '... make MyClass immutable (again) okay' );
is(MyClass->meta, $mc, '... these metas are still the same thing');
is(MyClass->meta->meta, $mc->meta, '... these meta-metas are the same thing');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package MyClass;
# The bug happened when DEMOLISHALL called
# Class::MOP::class_of($object) and did not get a metaclass object
# back.
-lives_ok { $object->DESTROY }
-'can call DESTROY on an object without a metaclass object in the CMOP cache';
+is( exception { $object->DESTROY }, undef, 'can call DESTROY on an object without a metaclass object in the CMOP cache' );
MyClass->meta->make_immutable;
# The bug didn't manifest for immutable objects, but this test should
# help us prevent it happening in the future.
-lives_ok { $object->DESTROY }
-'can call DESTROY on an object without a metaclass object in the CMOP cache (immutable version)';
+is( exception { $object->DESTROY }, undef, 'can call DESTROY on an object without a metaclass object in the CMOP cache (immutable version)' );
done_testing;
use strict;
use warnings;
-use Test::Exception;
+use Test::Fatal;
use Test::More;
{
local $TODO = 'UNIVERSAL methods should be wrappable';
- ::lives_ok { with 'FakeBar' } 'applied role';
+ ::is( ::exception { with 'FakeBar' }, undef, 'applied role' );
my $foo = Foo->new;
::isa_ok $foo, 'Bar';
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Class;
= 'Loading Moose::Meta::Class without loading Moose.pm causes weird problems';
my $meta;
- lives_ok {
+ is( exception {
$meta = Moose::Meta::Class->create_anon_class(
superclasses => [ 'Moose::Object', ],
);
- }
- 'Class is created successfully';
+ }, undef, 'Class is created successfully' );
}
done_testing;
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package MyRole1;
ok (($instance_with_role1->does('MyRole1')),
'role was applied to the correct instance');
-lives_and {
+is( exception {
is $instance_with_role1->a_role_method, 'foo'
-} 'instance has correct role method';
+}, undef, 'instance has correct role method' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Test::Moose;
{
}
with_immutable {
- lives_ok { Foo->new( x => {} ) }
- 'Setting coerce => 1 without a coercion on the type does not cause an error in the constructor';
+ is( exception { Foo->new( x => {} ) }, undef, 'Setting coerce => 1 without a coercion on the type does not cause an error in the constructor' );
- lives_ok { Foo->new->x( {} ) }
- 'Setting coerce => 1 without a coercion on the type does not cause an error when setting the attribut';
+ is( exception { Foo->new->x( {} ) }, undef, 'Setting coerce => 1 without a coercion on the type does not cause an error when setting the attribut' );
- throws_ok { Foo->new( x => 42 ) }
- qr/\QAttribute (x) does not pass the type constraint because/,
- 'Attempting to provide an invalid value to the constructor for this attr still fails';
+ like( exception { Foo->new( x => 42 ) }, qr/\QAttribute (x) does not pass the type constraint because/, 'Attempting to provide an invalid value to the constructor for this attr still fails' );
- throws_ok { Foo->new->x(42) }
- qr/\QAttribute (x) does not pass the type constraint because/,
- 'Attempting to provide an invalid value to the accessor for this attr still fails';
+ like( exception { Foo->new->x(42) }, qr/\QAttribute (x) does not pass the type constraint because/, 'Attempting to provide an invalid value to the accessor for this attr still fails' );
}
'Foo';
'DateTime::Format::MySQL' => '0.01',
};
-use Test::Exception;
+use Test::Fatal;
BEGIN {
# in case there are leftovers
my $article_ref;
{
my $article;
- lives_ok {
+ is( exception {
$article = Newswriter::Article->new(
headline => 'Home Office Redecorated',
summary => 'The home office was recently redecorated to match the new company colors',
status => 'pending'
);
- } '... created my article successfully';
+ }, undef, '... created my article successfully' );
isa_ok($article, 'Newswriter::Article');
isa_ok($article, 'MooseX::POOP::Object');
- lives_ok {
+ is( exception {
$article->start_date(DateTime->new(year => 2006, month => 6, day => 10));
$article->end_date(DateTime->new(year => 2006, month => 6, day => 17));
- } '... add the article date-time stuff';
+ }, undef, '... add the article date-time stuff' );
## check some meta stuff
my $article2_ref;
{
my $article2;
- lives_ok {
+ is( exception {
$article2 = Newswriter::Article->new(
headline => 'Company wins Lottery',
summary => 'An email was received today that informed the company we have won the lottery',
status => 'posted'
);
- } '... created my article successfully';
+ }, undef, '... created my article successfully' );
isa_ok($article2, 'Newswriter::Article');
isa_ok($article2, 'MooseX::POOP::Object');
## orig-article
my $article;
- lives_ok {
+ is( exception {
$article = Newswriter::Article->new(oid => $article_oid);
- } '... (re)-created my article successfully';
+ }, undef, '... (re)-created my article successfully' );
isa_ok($article, 'Newswriter::Article');
isa_ok($article, 'MooseX::POOP::Object');
is($article->author->first_name, 'Truman', '... got the right author first name');
is($article->author->last_name, 'Capote', '... got the right author last name');
- lives_ok {
+ is( exception {
$article->author->first_name('Dan');
$article->author->last_name('Rather');
- } '... changed the value ok';
+ }, undef, '... changed the value ok' );
is($article->author->first_name, 'Dan', '... got the changed author first name');
is($article->author->last_name, 'Rather', '... got the changed author last name');
{
my $article;
- lives_ok {
+ is( exception {
$article = Newswriter::Article->new(oid => $article_oid);
- } '... (re)-created my article successfully';
+ }, undef, '... (re)-created my article successfully' );
isa_ok($article, 'Newswriter::Article');
isa_ok($article, 'MooseX::POOP::Object');
is($article->status, 'pending', '... got the right status');
my $article2;
- lives_ok {
+ is( exception {
$article2 = Newswriter::Article->new(oid => $article2_oid);
- } '... (re)-created my article successfully';
+ }, undef, '... (re)-created my article successfully' );
isa_ok($article2, 'Newswriter::Article');
isa_ok($article2, 'MooseX::POOP::Object');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
sub U {
my $f = shift;
package My::List1;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'List', 'List::Immutable';
- } '... successfully composed roles together';
+ }, undef, '... successfully composed roles together' );
package My::List2;
use Moose;
- ::lives_ok {
+ ::is( ::exception {
with 'List::Immutable', 'List';
- } '... successfully composed roles together';
+ }, undef, '... successfully composed roles together' );
}
'Declare::Constraints::Simple' => '0.01', # skip all if not installed
};
-use Test::Exception;
+use Test::Fatal;
{
package Foo;
my $array_of_ints = [ 1 .. 10 ];
my $foo;
-lives_ok {
+is( exception {
$foo = Foo->new(
'bar' => $hash_of_arrays_of_objs,
'baz' => $array_of_ints,
);
-} '... construction succeeded';
+}, undef, '... construction succeeded' );
isa_ok($foo, 'Foo');
is_deeply($foo->bar, $hash_of_arrays_of_objs, '... got our value correctly');
is_deeply($foo->baz, $array_of_ints, '... got our value correctly');
-dies_ok {
+isnt( exception {
$foo->bar([]);
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
-dies_ok {
+isnt( exception {
$foo->bar({ foo => 3 });
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
-dies_ok {
+isnt( exception {
$foo->bar({ foo => [ 1, 2, 3 ] });
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
-dies_ok {
+isnt( exception {
$foo->baz([ "foo" ]);
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
-dies_ok {
+isnt( exception {
$foo->baz({});
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
done_testing;
'Test::Deep' => '0.01', # skip all if not installed
};
-use Test::Exception;
+use Test::Fatal;
{
package Foo;
];
my $foo;
-lives_ok {
+is( exception {
$foo = Foo->new('bar' => $array_of_hashes);
-} '... construction succeeded';
+}, undef, '... construction succeeded' );
isa_ok($foo, 'Foo');
is_deeply($foo->bar, $array_of_hashes, '... got our value correctly');
-dies_ok {
+isnt( exception {
$foo->bar({});
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
-dies_ok {
+isnt( exception {
$foo->bar([{ foo => 3 }]);
-} '... validation failed correctly';
+}, undef, '... validation failed correctly' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Meta::Role;
my $foo_role = Moose::Meta::Role->initialize('FooRole');
my $meta = Foo->meta;
- lives_ok { Foo->new } "lazy_build works";
+ is( exception { Foo->new }, undef, "lazy_build works" );
is( Foo->new->foos, 'many foos',
"correct value for 'foos' before inlining constructor" );
is( Foo->new->bars, 'many bars',
"correct value for 'bars' before inlining constructor" );
is( Foo->new->bazes, 'many bazes',
"correct value for 'bazes' before inlining constructor" );
- lives_ok { $meta->make_immutable } "Foo is imutable";
- lives_ok { $meta->identifier } "->identifier on metaclass lives";
- dies_ok { $meta->add_role($foo_role) } "Add Role is locked";
- lives_ok { Foo->new } "Inlined constructor works with lazy_build";
+ is( exception { $meta->make_immutable }, undef, "Foo is imutable" );
+ is( exception { $meta->identifier }, undef, "->identifier on metaclass lives" );
+ isnt( exception { $meta->add_role($foo_role) }, undef, "Add Role is locked" );
+ is( exception { Foo->new }, undef, "Inlined constructor works with lazy_build" );
is( Foo->new->foos, 'many foos',
"correct value for 'foos' after inlining constructor" );
is( Foo->new->bars, 'many bars',
"correct value for 'bars' after inlining constructor" );
is( Foo->new->bazes, 'many bazes',
"correct value for 'bazes' after inlining constructor" );
- lives_ok { $meta->make_mutable } "Foo is mutable";
- lives_ok { $meta->add_role($foo_role) } "Add Role is unlocked";
+ is( exception { $meta->make_mutable }, undef, "Foo is mutable" );
+ is( exception { $meta->add_role($foo_role) }, undef, "Add Role is unlocked" );
}
sub BUILD { 'baz' }
}
-lives_ok { Bar->meta->make_immutable }
- 'Immutable meta with single BUILD';
+is( exception { Bar->meta->make_immutable }, undef, 'Immutable meta with single BUILD' );
-lives_ok { Baz->meta->make_immutable }
- 'Immutable meta with multiple BUILDs';
+is( exception { Baz->meta->make_immutable }, undef, 'Immutable meta with multiple BUILDs' );
=pod
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
is($foo->baz, 'Foo::baz', '... got the right value');
-lives_ok {
+is( exception {
My::Role->meta->apply($foo)
-} '... successfully applied the role to immutable instance';
+}, undef, '... successfully applied the role to immutable instance' );
is($foo->baz, 'My::Role::baz(Foo::baz)', '... got the right value');
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
);
}
-lives_ok {
+is( exception {
My::Meta->meta()->make_immutable(debug => 0)
-} '... can make a meta class immutable';
+}, undef, '... can make a meta class immutable' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
for (1..2) {
my $is_immutable = Foo->meta->is_immutable;
my $mutable_string = $is_immutable ? 'immutable' : 'mutable';
- lives_ok {
+ is( exception {
my $f = Foo->new(foo => 10, bar => "Hello World", baz => 10, zot => 4);
is($f->moo, 69, "Type coercion works as expected on default ($mutable_string)");
is($f->boo, 69, "Type coercion works as expected on builder ($mutable_string)");
- } "... this passes the constuctor correctly ($mutable_string)";
+ }, undef, "... this passes the constuctor correctly ($mutable_string)" );
- lives_ok {
+ is( exception {
Foo->new(foo => 10, bar => "Hello World", baz => 10, zot => "not an int");
- } "... the constructor doesn't care about 'zot' ($mutable_string)";
+ }, undef, "... the constructor doesn't care about 'zot' ($mutable_string)" );
- dies_ok {
+ isnt( exception {
Foo->new(foo => "Hello World", bar => 100, baz => "Hello World");
- } "... this fails the constuctor correctly ($mutable_string)";
+ }, undef, "... this fails the constuctor correctly ($mutable_string)" );
Foo->meta->make_immutable(debug => 0) unless $is_immutable;
}
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
sub DEMOLISH { }
}
-lives_ok {
+is( exception {
Bar->new();
-} 'Bar->new()';
+}, undef, 'Bar->new()' );
-lives_ok {
+is( exception {
Bar->meta->make_immutable;
-} 'Bar->meta->make_immutable';
+}, undef, 'Bar->meta->make_immutable' );
is( Bar->meta->get_method('DESTROY')->package_name, 'Bar',
'Bar has a DESTROY method in the Bar class (not inherited)' );
-lives_ok {
+is( exception {
Foo->meta->make_immutable;
-} 'Foo->meta->make_immutable';
+}, undef, 'Foo->meta->make_immutable' );
is( Foo->meta->get_method('DESTROY')->package_name, 'Foo',
'Foo has a DESTROY method in the Bar class (not inherited)' );
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
eval { AClass->new(baz => 'bar') };
like ($@, qr/^Pulling the Baz trigger/, "trigger from immutable constructor");
-lives_ok { AClass->new(bar => 'bar') } '... no triggers called';
+is( exception { AClass->new(bar => 'bar') }, undef, '... no triggers called' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
=pod
}
my $scalar = 1;
-throws_ok { Foo->new($scalar) } qr/\QSingle parameters to new() must be a HASH ref/,
- 'Non-ref provided to immutable constructor gives useful error message';
-throws_ok { Foo->new(\$scalar) } qr/\QSingle parameters to new() must be a HASH ref/,
- 'Scalar ref provided to immutable constructor gives useful error message';
-throws_ok { Foo->new(undef) } qr/\QSingle parameters to new() must be a HASH ref/,
- 'undef provided to immutable constructor gives useful error message';
+like( exception { Foo->new($scalar) }, qr/\QSingle parameters to new() must be a HASH ref/, 'Non-ref provided to immutable constructor gives useful error message' );
+like( exception { Foo->new(\$scalar) }, qr/\QSingle parameters to new() must be a HASH ref/, 'Scalar ref provided to immutable constructor gives useful error message' );
+like( exception { Foo->new(undef) }, qr/\QSingle parameters to new() must be a HASH ref/, 'undef provided to immutable constructor gives useful error message' );
done_testing;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
has 'buz' => ( is => 'rw', default => q{"'\\} );
has 'faz' => ( is => 'rw', default => qq{\0} );
- ::lives_ok { __PACKAGE__->meta->make_immutable }
- 'no errors making a package immutable when it has default values that could break quoting';
+ ::is( ::exception { __PACKAGE__->meta->make_immutable }, undef, 'no errors making a package immutable when it has default values that could break quoting' );
}
my $foo = Foo->new;
has 'buz' => ( is => 'rw', default => q{"'\\}, lazy => 1 );
has 'faz' => ( is => 'rw', default => qq{\0}, lazy => 1 );
- ::lives_ok { __PACKAGE__->meta->make_immutable }
- 'no errors making a package immutable when it has lazy default values that could break quoting';
+ ::is( ::exception { __PACKAGE__->meta->make_immutable }, undef, 'no errors making a package immutable when it has lazy default values that could break quoting' );
}
my $bar = Bar->new;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
use Moose::Util qw( add_method_modifier );
my $COUNT = 0;
sub bar { }
}
-lives_ok {
+is( exception {
add_method_modifier('Foo', 'before', [ ['foo', 'bar'], sub { $COUNT++ } ]);
-} 'method modifier with an arrayref';
+}, undef, 'method modifier with an arrayref' );
-dies_ok {
+isnt( exception {
add_method_modifier('Foo', 'before', [ {'foo' => 'bar'}, sub { $COUNT++ } ]);
-} 'method modifier with a hashref';
+}, undef, 'method modifier with a hashref' );
my $foo = Foo->new;
$foo->foo;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
use_ok('Moose::Util::TypeConstraints');
}
-lives_ok {
+is( exception {
subtype 'ParentConstraint' => as 'Str' => where {0};
-} 'specified parent type constraint';
+}, undef, 'specified parent type constraint' );
my $tc;
-lives_ok {
+is( exception {
$tc = subtype 'ChildConstraint' => as 'ParentConstraint' => where {1};
-} 'specified child type constraint';
+}, undef, 'specified child type constraint' );
{
my $errmsg = $tc->validate();
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
sub req_or_has ($$) {
my ( $role, $method ) = @_;
# this doesn't fail but it produces a requires in the role
# the order doesn't matter
has twist => ( is => "rw" );
- ::lives_ok { with qw(Dancer) };
+ ::is( ::exception { with qw(Dancer) }, undef );
package Dancer::Something;
use Moose;
has twist => ( is => "rw" );
{
- ::lives_ok { with qw(Dancer) };
+ ::is( ::exception { with qw(Dancer) }, undef );
}
package Dancer::80s;
# but due to the deferrence logic that doesn't actually work
{
local our $TODO = "attribute accessor in role doesn't satisfy role requires";
- ::lives_ok { with qw(Dancer::Robot) };
+ ::is( ::exception { with qw(Dancer::Robot) }, undef );
}
package Foo;
{
local our $TODO = "attrs and methods from a role should clash";
- ::dies_ok { with qw(Tree Dog) }
+ ::isnt( ::exception { with qw(Tree Dog) }, undef );
}
}
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
{
package Foo::API;
package Foo::Class;
use Moose;
{ our $TODO; local $TODO = "role accessors don't satisfy other role requires";
- ::lives_ok { with 'Foo' } 'requirements are satisfied properly';
+ ::is( ::exception { with 'Foo' }, undef, 'requirements are satisfied properly' );
}
}
use Moose;
{ our $TODO; local $TODO = "role accessors don't satisfy other role requires";
- ::lives_ok { with qw(Bar Baz) } 'requirements are satisfied properly';
+ ::is( ::exception { with qw(Bar Baz) }, undef, 'requirements are satisfied properly' );
}
}
use strict;
use warnings;
use Test::More;
-use Test::Exception;
+use Test::Fatal;
BEGIN {
{
package Child;
use Moose -traits => 'Bar';
{ our $TODO; local $TODO = "no idea what's going on here";
- ::lives_ok { extends 'Parent' };
+ ::is( ::exception { extends 'Parent' }, undef );
}
}
projects / gitmo/Moose.git / commitdiff