462 lines
15 KiB
Perl
462 lines
15 KiB
Perl
#!/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);
|