libtest-mockclass-perl/t/00_MockClass.t

462 lines
15 KiB
Perl
Raw Normal View History

2017-09-15 16:00:59 +02:00
#!/usr/bin/perl
#
# Test script for Test::MockClass
# $Id: 00_MockClass.t,v 1.3 2005/02/18 21:16:20 phaedrus Exp $
#
# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl test.pl'
#
# Please do not commit any changes you make to the module without a
# successful 'make test'!
#
# always use these:
use strict;
use warnings qw{all};
use Test::SimpleUnit qw{:functions};
Test::SimpleUnit::AutoskipFailedSetup(1);
# this is actually the very first test, the one to see if the package compile-checks:
{
no warnings; # for some reason I get:
# Use of uninitialized value in eval "string"
eval { use Test::MockClass; };
}
my $evalError = $@;
# create all objects and variables that will be set up later:
my $mainObject = undef;
my $result = '';
my @results = ();
my @testSuite = (
# the setup function:
{
name => 'setup',
func => sub {
$mainObject = Test::MockClass->new('FakeClass');
},
},
# the teardown function:
{
name => 'teardown',
func => sub {
# $mainObject->DESTROY;
$mainObject = undef;
},
},
{
name => 'File Loading',
test => sub {
assertNot( $evalError );
},
},
{
name => 'Object Creation',
test => sub {
# do assertions knowing that stuff has been set up
assertInstanceOf( 'Test::MockClass', $mainObject );
assert($INC{'FakeClass.pm'});
assert($FakeClass::VERSION == -1);
my $maker = '';
assertNoException( sub {
$maker = &FakeClass::___getMaker();
});
assertInstanceOf( 'Test::MockClass', $maker );
},
},
{
name => 'noTracking method',
test => sub {
assertNoException( sub {
$mainObject->noTracking;
});
assert($mainObject->{'Test::MockClass::noConstructorCallTracking'});
assert($mainObject->{'Test::MockClass::noMethodCallTracking'});
assert($mainObject->{'Test::MockClass::noAttributeAccessTracking'});
},
},
{
name => 'tracking method',
test => sub {
assertNoException( sub {
$mainObject->tracking;
});
assertNot($mainObject->{'Test::MockClass::noConstructorCallTracking'});
assertNot($mainObject->{'Test::MockClass::noMethodCallTracking'});
assertNot($mainObject->{'Test::MockClass::noAttributeAccessTracking'});
},
},
{
name => 'constructor method',
test => sub {
assertNoException( sub {
$mainObject->constructor('shazam');
});
assert($mainObject->{'Test::MockClass::hasConstructor'} eq 'shazam');
my $mockObject = '';
assertNoException( sub {
$mainObject->defaultConstructor;
$mockObject = FakeClass->shazam();
});
},
},
{
name => 'addMethod method',
test => sub {
$mainObject->noTracking;
assertNoException( sub {
$mainObject->addMethod( 'fooberries', sub {return 1;});
});
assert(&UNIVERSAL::can('FakeClass', 'fooberries'));
assertNoException( sub {
$result = &FakeClass::fooberries;
});
assert($result);
},
},
{
name => 'defaultConstructor method',
test => sub {
$mainObject->noTracking;
my %args = (cat => 'rat', bat => 'hat');
assertNoException( sub {
$mainObject->defaultConstructor(%args);
});
assert(&UNIVERSAL::can('FakeClass', 'new'));
assert($mainObject->{'Test::MockClass::hasConstructor'} eq 'new');
assertNoException( sub {
$result = &FakeClass::new('FakeClass', cat => 'hat');
});
assertInstanceOf( 'FakeClass', $result );
assert($result->{bat} eq 'hat');
assert($result->{cat} eq 'hat');
},
},
{
name => 'setReturnValues method',
test => sub {
$mainObject->noTracking;
assertNoException( sub {
$mainObject->setReturnValues('truth', 'true');
});
assert(&UNIVERSAL::can('FakeClass', 'truth'));
assertNoException( sub {
$result = &FakeClass::truth();
});
assert($result);
assertNoException( sub {
$mainObject->setReturnValues('falseness', 'false');
});
assert(&UNIVERSAL::can('FakeClass', 'falseness'));
assertNoException( sub {
$result = &FakeClass::falseness();
});
assertNot($result);
assertNoException( sub {
$mainObject->setReturnValues('nothing', 'undef');
});
assert(&UNIVERSAL::can('FakeClass', 'nothing'));
assertNoException( sub {
$result = &FakeClass::nothing();
});
assertNot(defined($result));
assertNoException( sub {
$mainObject->setReturnValues('two', 'always', 2);
});
assert(&UNIVERSAL::can('FakeClass', 'two'));
assertNoException( sub {
$result = &FakeClass::two();
});
assert($result == 2);
assertNoException( sub {
$mainObject->setReturnValues('twoNtwo', 'always', 2, 2);
});
assert(&UNIVERSAL::can('FakeClass', 'twoNtwo'));
assertNoException( sub {
@results = &FakeClass::twoNtwo();
});
assert($results[0] == 2);
assert($results[1] == 2);
assertNoException( sub {
$mainObject->setReturnValues('twoNthree', 'always', 2, 3);
});
assert(&UNIVERSAL::can('FakeClass', 'twoNthree'));
assertNoException( sub {
$result = &FakeClass::twoNthree();
});
assert($result->[0] == 2);
assert($result->[1] == 3);
assertNoException( sub {
$mainObject->setReturnValues('fibonacci', 'series', 1, 1, 2, 3, 5);
});
assert(&UNIVERSAL::can('FakeClass', 'fibonacci'));
assertNoException( sub {
$result = &FakeClass::fibonacci();
});
assert($result == 1);
assertNoException( sub {
$result = &FakeClass::fibonacci();
});
assert($result == 1);
assertNoException( sub {
$result = &FakeClass::fibonacci();
});
assert($result == 2);
assertNoException( sub {
$result = &FakeClass::fibonacci();
});
assert($result == 3);
assertNoException( sub {
$result = &FakeClass::fibonacci();
});
assert($result == 5);
assertNoException( sub {
$mainObject->setReturnValues('flipflop', 'cycle', 1, 0);
});
assert(&UNIVERSAL::can('FakeClass', 'flipflop'));
assertNoException( sub {
$result = &FakeClass::flipflop();
});
assert($result == 1);
assertNoException( sub {
$result = &FakeClass::flipflop();
});
assert($result == 0);
assertNoException( sub {
$result = &FakeClass::flipflop();
});
assert($result == 1);
assertNoException( sub {
$result = &FakeClass::flipflop();
});
assert($result == 0);
assertNoException( sub {
$mainObject->setReturnValues('randomUser', 'random', (0..9));
});
assertNoException( sub {
$result = &FakeClass::randomUser();
});
assert($result =~ m{\d});
assert($result >= 0);
assert($result < 10);
# print "result: $result\n";
},
},
{
name => 'create method',
test => sub {
$mainObject->noTracking;
assertNoException(sub {
$mainObject->defaultConstructor('cat' => 'rat', 'bat'=> 'hat');
});
assertNoException(sub {
$result = $mainObject->create('cat' => 'hat');
});
assertInstanceOf('FakeClass', $result);
assert($result->{bat} eq 'hat');
assert($result->{cat} eq 'hat');
},
},
{
name => 'getNextObjectId method',
test => sub {
assertNoException(sub {
$mainObject->defaultConstructor();
$results[0] = $mainObject->create();
$results[1] = $mainObject->create();
$results[2] = $mainObject->create();
});
my $objectId = '';
assertNoException(sub {
$objectId = $mainObject->getNextObjectId();
});
assert($objectId eq "$results[0]");
$objectId = '';
assertNoException(sub {
$objectId = $mainObject->getNextObjectId();
});
assert($objectId eq "$results[1]");
$objectId = '';
assertNoException(sub {
$objectId = $mainObject->getNextObjectId();
});
assert($objectId eq "$results[2]");
assertNoException(sub {
$objectId = $mainObject->getNextObjectId();
});
assert(not(defined($objectId)));
assertNoException(sub {
$objectId = $mainObject->getNextObjectId();
});
assert($objectId eq "$results[0]");
},
},
{
name => 'setCallOrder, getCallOrder, verifyCallOrder methods',
test => sub {
assertNoException( sub {
$mainObject->defaultConstructor();
$mainObject->setReturnValues('thingy', 'always', 'thingy');
$mainObject->setReturnValues('foosh', 'true');
});
assertNoException( sub {
$mainObject->setCallOrder('new', 'thingy', 'foosh');
});
my @objects = ();
assertNoException( sub {
$objects[0] = $mainObject->create();
$objects[1] = $mainObject->create();
$objects[2] = $mainObject->create();
$objects[0]->thingy;
$objects[1]->foosh;
$objects[1]->thingy;
$objects[2]->thingy;
$objects[2]->foosh;
});
assertNoException( sub {
$results[0] = $mainObject->getCallOrder("$objects[0]");
$results[1] = $mainObject->getCallOrder("$objects[1]");
$results[2] = $mainObject->getCallOrder("$objects[2]");
});
assert($results[0][0] eq 'new');
assert($results[0][1] eq 'thingy');
assert($results[1][0] eq 'new');
assert($results[1][1] eq 'foosh');
assert($results[1][2] eq 'thingy');
assert($results[2][0] eq 'new');
assert($results[2][1] eq 'thingy');
assert($results[2][2] eq 'foosh');
assertNoException( sub {
$result = $mainObject->verifyCallOrder("$objects[0]");
});
assertNot($result);
my $breakpoint;
assertNoException( sub {
$result = $mainObject->verifyCallOrder("$objects[1]");
});
assertNot($result);
assertNoException( sub {
$result = $mainObject->verifyCallOrder("$objects[2]");
});
assert($result);
},
},
{
name => 'getArgumentList method',
test => sub {
assertNoException( sub {
$mainObject->defaultConstructor();
$mainObject->setReturnValues('thingy', 'always', 'thingy');
$mainObject->setReturnValues('foosh', 'true');
});
my @objects = ();
assertNoException( sub {
$objects[0] = $mainObject->create();
$objects[1] = $mainObject->create('foo');
$objects[2] = $mainObject->create('foo', 'bar');
$objects[0]->thingy();
$objects[1]->foosh('cat');
$objects[1]->thingy('bat');
$objects[2]->thingy('cat', 'rat');
$objects[2]->foosh('bat', 'hat');
});
assertNoException( sub {
$results[0] = $mainObject->getArgumentList("$objects[0]", 'new', 0);
$results[1] = $mainObject->getArgumentList("$objects[1]", 'new', 0);
$results[2] = $mainObject->getArgumentList("$objects[2]", 'new', 0);
});
assertNot(scalar(@{$results[0]}));
assert(scalar(@{$results[1]}) == 1);
assert(scalar(@{$results[2]}) == 2);
assert($results[1][0] eq 'foo');
assert($results[2][0] eq 'foo');
assert($results[2][1] eq 'bar');
assertNoException( sub {
$results[0] = $mainObject->getArgumentList("$objects[0]", 'thingy', 0);
$results[1] = $mainObject->getArgumentList("$objects[1]", 'thingy', 0);
$results[2] = $mainObject->getArgumentList("$objects[2]", 'thingy', 0);
});
assert(scalar(@{$results[0]}) == 0);
assert(scalar(@{$results[1]}) == 1);
assert(scalar(@{$results[2]}) == 2);
assert($results[1][0] eq 'bat');
assert($results[2][0] eq 'cat');
assert($results[2][1] eq 'rat');
assertNoException( sub {
$objects[0]->thingy();
$objects[1]->foosh('fan');
$objects[1]->thingy('man');
$objects[2]->thingy('plan', 'ran');
$objects[2]->foosh('flan', 'stan');
$results[0] = $mainObject->getArgumentList("$objects[0]", 'thingy', 1);
$results[1] = $mainObject->getArgumentList("$objects[1]", 'thingy', 1);
$results[2] = $mainObject->getArgumentList("$objects[2]", 'thingy', 1);
});
assert(scalar(@{$results[0]}) == 0);
assert(scalar(@{$results[1]}) == 1);
assert(scalar(@{$results[2]}) == 2);
assert($results[1][0] eq 'man');
assert($results[2][0] eq 'plan');
assert($results[2][1] eq 'ran');
},
},
{
name => 'getAttributeAccess method',
test => sub {
my @objects = ();
assertNoException( sub {
$mainObject->defaultConstructor('cat' => 'rat');
$objects[0] = $mainObject->create();
$objects[1] = $mainObject->create();
});
assertNoException( sub {
$objects[0]->{cat} = 'hat';
my $thingy = $objects[1]->{cat};
$objects[1]->{cat} = 'fat';
$objects[1]->{bat} = 'mat';
});
assertNoException( sub {
$results[0] = $mainObject->getAttributeAccess("$objects[0]");
$results[1] = $mainObject->getAttributeAccess("$objects[1]");
});
assert($results[0][0][0] eq 'store');
assert($results[0][0][1] eq 'cat');
assert($results[0][0][2] eq 'hat');
assert($results[1][0][0] eq 'fetch');
assert($results[1][0][1] eq 'cat');
assert($results[1][1][0] eq 'store');
assert($results[1][1][1] eq 'cat');
assert($results[1][1][2] eq 'fat');
assert($results[1][2][0] eq 'store');
assert($results[1][2][1] eq 'bat');
assert($results[1][2][2] eq 'mat');
},
},
);
runTests(@testSuite);