BuildSystem/test/test_ToolDoc.pm

#
# ToolDoc.pm test suite
#

package BuildSystem::test::test_ToolDoc;
require 5.001;
use BuildSystem::Tool;
use BuildSystem::ToolDoc;

@ISA = ("Utilities::TestClass"); #methods both from the test class

sub init {
        my $self=shift;
        $self->{testfile}=$self->datadir()."/ToolDocTest";
        $self->{tool}=BuildSystem::Tool->new();
        $self->{tool}->url($self->{testfile});
        $self->{testlocation}=$self->temparea()."/".$self->newfilename();

        # -- make a dummy lib tool
        $self->{dummylib}=$self->temparea()."/".$self->newfilename();
        use Utilities::AddDir;
        AddDir::adddir($self->{dummylib}."/lib");
        $fh=FileHandle->new();
        $fh->open(">".$self->{dummylib}."/lib/lib1");
        $fh->close();
        $fh->open(">".$self->{dummylib}."/lib/lib2");
        $fh->close();

        # A test searcher object
        $self->{projlevels}=5; #-- 5 dummy project areas to look at!
        $self->{toolcall}=0;
        
}

sub test {
        my $self=shift;
        my $dummyvar=$self->{dummylib};
        $self->newtest("Initiation test");
        $self->newobject();
        $self->testinterface("verbosity", 1);
        $self->testinterface("tool",$self->{tool});
        $self->{object}->{ToolEnv}{dummyvar}=$self->{dummylib};
        $self->newtest("Test of setup");
        $self->testinterface("setup",$self->{testfile},"Test","version1");
        
        # check if our object is initialised OK
        $self->_teststring("test",$self->{tool}->name());
        $self->_teststring("version1",$self->{tool}->version(),"version1");
        my @vals=$self->{tool}->features();
        $self->_expectarray(\@vals,"lib","Testvar1","Testvar2","Testvar3","Testvar4","Testvar5","_externals");
        my ($temp)=$self->{tool}->getfeature("Testvar1");
        $self->_teststring("A",$temp);
        ($temp)=$self->{tool}->getfeature("Testvar2");
        $self->_teststring("A/B",$temp);
        @vals=$self->{tool}->getfeature("lib");
        $self->_expectarray(\@vals,"lib1","lib2");
        @vals=$self->{tool}->getfeature("_externals");
        $self->_expectarray(\@vals,"package1","package2");
        @vals=$self->{tool}->getfeature("Testvar5");
        $self->_expectarray(\@vals,"$dummyvar/lib",$dummyvar);

        # -- Check setup has not overwritten the url
        $self->newtest("test that there is no overwrite of url");
        $self->cmpstring($self->{testfile},$self->{tool}->url());

        # -- setup with a searcher
        $self->newtest("Setup with a tool searcher");
        $self->newobject();
        $self->testinterface("verbosity", 1);
        $self->{tool}=BuildSystem::Tool->new();
        $self->{tool}->url($self->{testfile});
        $self->testinterface("tool",$self->{tool});
        $self->testinterface("toolsearcher", $self);

        $self->newtest("testing tool searcher algorithm");
        $self->{numcalls}=0;
        my @tools=$self->testinterface("_searchtools", $self->{tool}, $self);
        if ( $self->{numcalls} != $self->{projlevels} ) {
           $self->testfail("All projects have not been checked");
        }
        if ( $#tools != 2 ) {
           $self->testfail("Expected 3 tools got ".($#tools+1));
        }

        $self->newtest("testing tool parameter fetching method");
        $self->{numcalls}=0;
        @vals=$self->testinterface("_getparamsets", $self->{tool}, "Test");
        my $n=0;
        foreach $val ( @vals ) {
          $n++;
          $self->_expectarray($val,"testreturnvalue1_".$n,
                                        "testreturnvalue2_".$n,
                                        "testreturnvalue3_".$n)
        }
        if ( $n ne 3 ) {
          $self->testfail("Wrong number of tool matches - got $n not 3");
        }

        $self->newtest("testing tool parameter fetching method");

        $self->{object}->{ToolEnv}{dummyvar}=$self->{dummylib};
        #$self->_expectarray(\@vals,"$dummyvar/lib",$dummyvar);
        $self->{alastnumb}=2;
        $self->testinterface("setup",$self->{testfile},"Test","version1");
        @vals=$self->{tool}->features();
        $self->_expectarray(\@vals,"lib","Testvar1","Testvar2","Testvar3","Testvar4","Testvar5","_externals");
        @vals=$self->{tool}->getfeature("Testvar5");
        $self->_expectarray(\@vals,"$dummyvar/lib",$dummyvar);

        # -- Check setup has not overwritten the url
        $self->newtest("test that there is no overwrite of url");
        $self->cmpstring($self->{testfile},$self->{tool}->url());
}

sub _teststring {
        my $self=shift;
        my $string1=shift;
        my $string2=shift;

        if ( $string1 eq $string2 ) {
          $self->testpass("$string2 returned as expected");
        }
        else {
          $self->testfail("Expecting $string1 got $string2");
        }
}

sub _expectarray {
        my $self=shift;
        my $array=shift;
        my @vals=@_;

        if ( $#{$array} ne $#vals) { $self->testfail(
                 $#{$array}." items retuned, $#vals expected");
            print "returned @$array"."\n";
        }
        else {
        for( my $i=0; $i<= $#{$array}; $i++) {
           $self->_teststring($vals[$i],$$array[$i]);
        }
        }
}

# -- stubs

sub newiterator {
        my $self=shift;
        require Scram::SearchIterator;
        my $it=Scram::SearchIterator->new($self);
        return $it;
}

sub levels {
        my $self=shift;
        return $self->{projlevels};
}

sub get {
        my $self=shift;
        $self->{numcalls}++;
        return $self;
}

sub location {
        my $self=shift;
        return $self->{testlocation}."_".$self->{numcalls};
}

sub toolbox {
        my $self=shift;
        return $self;
}


sub gettool {
        my $self=shift; # -- the second project will not have the tool
        return (($self->{numcalls}==2)?undef:$self);
}

sub getfeature {
        my $self=shift;
        my $name=shift;
        print "Feature $name requested - returning multiple\n";
        $self->{toolcall}++;
        return ( "testreturnvalue1_".$self->{toolcall}, 
                 "testreturnvalue2_".$self->{toolcall}, 
                 "testreturnvalue3_".$self->{toolcall});
}

sub equals {
        my $self=shift;
        return (($self->{numcalls}==3)?0:1 ); # -- tool number 3 dosnt match
}

sub name {
        my $self=shift;
        return "TestName_".$self->{numcalls};
}

sub version {
        my $self=shift;
        return "TestVersion";
}
Revision:	1.3
Committed:	Tue Nov 14 15:18:28 2000 UTC (24 years, 6 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V1_0_1, V1_0_0, V1_pre0, SCRAM_V1, SCRAMV1_IMPORT, V0_19_7, V0_19_6, V0_19_6p1, V0_19_5, SFATEST, V0_19_4, V0_19_4_pre3, V0_19_4_pre2, V0_19_4_pre1, V0_19_3, V0_19_2, V0_19_1, V0_19_0, V0_18_5, V0_18_4, V0_18_2, V0_18_1
Branch point for:	V1_pre1, SCRAM_V1_BRANCH, V0_19_4_B
Changes since 1.2:	+64 -18 lines
Log Message:	tests imported
#	User	Rev	Content
1	williamc	1.2	#
2			# ToolDoc.pm test suite
3			#
4
5			package BuildSystem::test::test_ToolDoc;
6			require 5.001;
7			use BuildSystem::Tool;
8			use BuildSystem::ToolDoc;
9
10			@ISA = ("Utilities::TestClass"); #methods both from the test class
11
12			sub init {
13			my $self=shift;
14			$self->{testfile}=$self->datadir()."/ToolDocTest";
15			$self->{tool}=BuildSystem::Tool->new();
16			$self->{tool}->url($self->{testfile});
17			$self->{testlocation}=$self->temparea()."/".$self->newfilename();
18
19	williamc	1.3	# -- make a dummy lib tool
20	williamc	1.2	$self->{dummylib}=$self->temparea()."/".$self->newfilename();
21			use Utilities::AddDir;
22			AddDir::adddir($self->{dummylib}."/lib");
23			$fh=FileHandle->new();
24			$fh->open(">".$self->{dummylib}."/lib/lib1");
25			$fh->close();
26			$fh->open(">".$self->{dummylib}."/lib/lib2");
27			$fh->close();
28	williamc	1.3
29			# A test searcher object
30			$self->{projlevels}=5; #-- 5 dummy project areas to look at!
31			$self->{toolcall}=0;
32
33	williamc	1.2	}
34
35			sub test {
36			my $self=shift;
37			my $dummyvar=$self->{dummylib};
38			$self->newtest("Initiation test");
39			$self->newobject();
40			$self->testinterface("verbosity", 1);
41			$self->testinterface("tool",$self->{tool});
42			$self->{object}->{ToolEnv}{dummyvar}=$self->{dummylib};
43			$self->newtest("Test of setup");
44			$self->testinterface("setup",$self->{testfile},"Test","version1");
45
46			# check if our object is initialised OK
47			$self->_teststring("test",$self->{tool}->name());
48			$self->_teststring("version1",$self->{tool}->version(),"version1");
49			my @vals=$self->{tool}->features();
50			$self->_expectarray(\@vals,"lib","Testvar1","Testvar2","Testvar3","Testvar4","Testvar5","_externals");
51			my ($temp)=$self->{tool}->getfeature("Testvar1");
52			$self->_teststring("A",$temp);
53			($temp)=$self->{tool}->getfeature("Testvar2");
54			$self->_teststring("A/B",$temp);
55			@vals=$self->{tool}->getfeature("lib");
56			$self->_expectarray(\@vals,"lib1","lib2");
57			@vals=$self->{tool}->getfeature("_externals");
58			$self->_expectarray(\@vals,"package1","package2");
59			@vals=$self->{tool}->getfeature("Testvar5");
60			$self->_expectarray(\@vals,"$dummyvar/lib",$dummyvar);
61
62			# -- Check setup has not overwritten the url
63			$self->newtest("test that there is no overwrite of url");
64			$self->cmpstring($self->{testfile},$self->{tool}->url());
65
66			# -- setup with a searcher
67			$self->newtest("Setup with a tool searcher");
68			$self->newobject();
69			$self->testinterface("verbosity", 1);
70			$self->{tool}=BuildSystem::Tool->new();
71			$self->{tool}->url($self->{testfile});
72			$self->testinterface("tool",$self->{tool});
73	williamc	1.3	$self->testinterface("toolsearcher", $self);
74
75			$self->newtest("testing tool searcher algorithm");
76			$self->{numcalls}=0;
77			my @tools=$self->testinterface("_searchtools", $self->{tool}, $self);
78			if ( $self->{numcalls} != $self->{projlevels} ) {
79			$self->testfail("All projects have not been checked");
80			}
81			if ( $#tools != 2 ) {
82			$self->testfail("Expected 3 tools got ".($#tools+1));
83			}
84
85			$self->newtest("testing tool parameter fetching method");
86			$self->{numcalls}=0;
87			@vals=$self->testinterface("_getparamsets", $self->{tool}, "Test");
88			my $n=0;
89			foreach $val ( @vals ) {
90			$n++;
91			$self->_expectarray($val,"testreturnvalue1_".$n,
92			"testreturnvalue2_".$n,
93			"testreturnvalue3_".$n)
94			}
95			if ( $n ne 3 ) {
96			$self->testfail("Wrong number of tool matches - got $n not 3");
97			}
98
99			$self->newtest("testing tool parameter fetching method");
100
101	williamc	1.2	$self->{object}->{ToolEnv}{dummyvar}=$self->{dummylib};
102	williamc	1.3	#$self->_expectarray(\@vals,"$dummyvar/lib",$dummyvar);
103	williamc	1.2	$self->{alastnumb}=2;
104			$self->testinterface("setup",$self->{testfile},"Test","version1");
105			@vals=$self->{tool}->features();
106			$self->_expectarray(\@vals,"lib","Testvar1","Testvar2","Testvar3","Testvar4","Testvar5","_externals");
107			@vals=$self->{tool}->getfeature("Testvar5");
108			$self->_expectarray(\@vals,"$dummyvar/lib",$dummyvar);
109
110			# -- Check setup has not overwritten the url
111			$self->newtest("test that there is no overwrite of url");
112			$self->cmpstring($self->{testfile},$self->{tool}->url());
113			}
114
115			sub _teststring {
116			my $self=shift;
117			my $string1=shift;
118			my $string2=shift;
119
120			if ( $string1 eq $string2 ) {
121			$self->testpass("$string2 returned as expected");
122			}
123			else {
124			$self->testfail("Expecting $string1 got $string2");
125			}
126			}
127
128			sub _expectarray {
129			my $self=shift;
130			my $array=shift;
131			my @vals=@_;
132
133			if ( $#{$array} ne $#vals) { $self->testfail(
134			$#{$array}." items retuned, $#vals expected");
135			print "returned @$array"."\n";
136			}
137			else {
138			for( my $i=0; $i<= $#{$array}; $i++) {
139			$self->_teststring($vals[$i],$$array[$i]);
140			}
141			}
142			}
143
144			# -- stubs
145
146			sub newiterator {
147			my $self=shift;
148	williamc	1.3	require Scram::SearchIterator;
149			my $it=Scram::SearchIterator->new($self);
150			return $it;
151			}
152
153			sub levels {
154			my $self=shift;
155			return $self->{projlevels};
156	williamc	1.2	}
157
158	williamc	1.3	sub get {
159	williamc	1.2	my $self=shift;
160	williamc	1.3	$self->{numcalls}++;
161	williamc	1.2	return $self;
162			}
163
164			sub location {
165			my $self=shift;
166	williamc	1.3	return $self->{testlocation}."_".$self->{numcalls};
167	williamc	1.2	}
168
169			sub toolbox {
170			my $self=shift;
171			return $self;
172			}
173
174	williamc	1.3
175	williamc	1.2	sub gettool {
176	williamc	1.3	my $self=shift; # -- the second project will not have the tool
177			return (($self->{numcalls}==2)?undef:$self);
178	williamc	1.2	}
179
180			sub getfeature {
181			my $self=shift;
182			my $name=shift;
183			print "Feature $name requested - returning multiple\n";
184	williamc	1.3	$self->{toolcall}++;
185			return ( "testreturnvalue1_".$self->{toolcall},
186			"testreturnvalue2_".$self->{toolcall},
187			"testreturnvalue3_".$self->{toolcall});
188	williamc	1.2	}
189
190			sub equals {
191			my $self=shift;
192	williamc	1.3	return (($self->{numcalls}==3)?0:1 ); # -- tool number 3 dosnt match
193			}
194
195			sub name {
196			my $self=shift;
197			return "TestName_".$self->{numcalls};
198			}
199
200			sub version {
201			my $self=shift;
202			return "TestVersion";
203	williamc	1.2	}