JUnit: A Cooks Tour
J U nit A Cook's
Tour
1. Introduction
In an earlier article (see Test Infected: Programmers
Love Writing Tests, Java Report, July 1998, Volume 3, Number 7), we described
how to use a simple framework to write repeatable tests. In this article,
we will take a peek under the covers and show you how the framework itself
is constructed.
We carefully studied the JUnit framework and reflected
on how we constructed it. We found lessons at many different levels. In
this article we will try communicate them all at once, a hopeless task,
but at least we will do it in the context of showing you the design and
construction of a piece of software with proven value.
We open with a discussion of the goals of the framework.
The goals will reappear in many small details during the presentation of
the framework itself. Following this, we present the design and implementation
of the framework. The design will be described in terms of patterns (surprise,
surprise), the implementation as a literate program. We conclude with a
few choice thoughts about framework development.
2. Goals
What are the goals of JUnit?
First, we have to get back to the assumptions of development.
If a program feature lacks an automated test, we assume it doesnt work.
This seems much safer than the prevailing assumption, that if a developer
assures us a program feature works, then it works now and forever.
From this perspective, developers arent done when they
write and debug the code, they must also write tests that demonstrate that
the program works. However, everybody is too busy, they have too much to
do, they dont have enough time, to screw around with testing. I have too
much code to write already, how am I supposed write test code, too? Answer
me that, Mr. Hard-case Project Manager.
So, the number one goal is to write a framework within
which we have some glimmer of hope that developers will actually write
tests. The framework has to use familiar tools, so there is little new
to learn. It has to require no more work than absolutely necessary to write
a new test. It has to eliminate duplicated effort.
If this was all tests had to do, you would be done just
by writing expressions in a debugger. However, this isnt sufficient for
testing. Telling me that your program works now doesnt help me, because
it doesnt assure me that your program will work one minute from now after
I integrate, and it doesnt assure me that your program will still work
in five years, when you are long gone.
So, the second goal of testing is creating tests that
retain their value over time. Someone other than the original author has
to be able to execute the tests and interpret the results. It should be
possible to combine tests from various authors and run them together without
fear of interference.
Finally, it has to be possible to leverage existing tests
to create new ones. Creating a setup or fixture is expensive and a framework
has to enable reusing fixtures to run different tests. Oh, is that all?
3. The Design of JUnit
The design of JUnit will be presented in a style first
used in (see "Patterns Generate Architectures", Kent Beck and Ralph Johnson,
ECOOP 94). The idea is to explain the design of a system by starting with
nothing and applying patterns, one after another, until you have the architecture
of the system. We will present the architectural problem to be solved,
summarize the pattern that solves it, and then show how the pattern was
applied to JUnit.
3.1 Getting started- TestCase
First we have to make an object to represent our basic
concept, the TestCase. Developers often have tests cases in mind, but they
realize them in many different ways-
print statements,
debugger expressions,
test scripts.
If we want to make manipulating tests easy, we have to make
them objects. This takes a test that was only implicit in the developers
mind and makes it concrete, supporting our goal of creating tests that
retain their value over time. At the same time, object developers are used
to, well, developing with objects, so the decision to make tests into objects
supports our goal of making test writing more inviting (or at least less
imposing).
The Command pattern (see Gamma, E., et al. Design Patterns:
Elements of Reusable Object-Oriented Software, Addison-Wesley, Reading,
MA, 1995) fits our needs quite nicely. Quoting from the intent, "Encapsulate
a request as an object, thereby letting you queue or log requests" Command
tells us to create an object for an operation and give it a method "execute".
Here is the code for the class definition of TestCase:
public abstract class TestCase
implements Test { }
Because we expect this class to be reused through inheritance,
we declare it "public abstract". For now, ignore the fact that it implements
the Test interface. For the purposes of our current design, you can think
of TestCase as a lone class.
Every TestCase is created with a name, so if a test fails,
you can identify which test failed.
public abstract class TestCase
implements Test { private final String
fName; public TestCase (String
name) {
fName= name; }
public abstract
void run ();
}
To illustrate the evolution of JUnit, we use diagrams that
show snapshots of the architecture. The notation we use is simple. It annotates
classes with shaded boxes containing the associated pattern. When the role
of the class in the pattern is obvious then only the pattern name is shown.
If the role isnt clear then the shaded box is augmented by the name of
the participant this class corresponds to. This notation minimizes the
clutter in diagrams and was first shown in (see Gamma, E., Applying Design
Patterns in Java, in Java Gems, SIGS Reference Library, 1997) Figure 1
shows this notation applied to TestCase. Since we are dealing with a single
class and there can be no ambiguities just the pattern name is shown.
Figure 1 TestCase applies Command
3.2 Blanks to fill in- run()
The next problem to solve is giving the developer a convenient
"place" to put their fixture code and their test code. The declaration
of TestCase as abstract says that the developer is expected to reuse TestCase
by subclassing. However, if all we could do was provide a superclass with
one variable and no behavior, we wouldnt be doing much to satisfy our
first goal, making tests easier to write.
Fortunately, there is a common structure to all tests-
they set up a test fixture, run some code against the fixture, check some
results, and then clean up the fixture. This means that each test will
run with a fresh fixture and the results of one test cant influence the
result of another. This supports the goal of maximizing the value of the
tests.
Template Method addresses our problem quite nicely. Quoting
from the intent, "Define the skeleton of an algorithm in an operation,
deferring some steps to subclasses. Template Method lets subclasses redefine
certain steps of an algorithm without changing the algorithms structure."
This is exactly right. We want the developer to be able to separately consider
how to write the fixture (set up and tear down) code and how to write the
testing code. The execution of this sequence, however, will remain the
same for all tests, no matter how the fixture code is written or how the
testing code is written.
Here is the template method:
public void run () { setUp(); runTest(); tearDown(); }
The default implementations of these methods do nothing:
protected void runTest () { } protected void setUp () { }
protected void tearDown () { }
Since setUp and tearDown are intended to be overridden but
will be called by the framework we declare them as protected. The second
snapshot of our tour is depicted in Figure 2.
Figure 2 TestCase.run() applies Template Method
3.3 Reporting results- TestResult
If a TestCase runs in a forest, does anyone care about
the result? Sure- you run tests to make sure they run. After the test has
run, you want a record, a summary of what did and didnt work.
If tests had equal chances of succeeding or failing, or
if we only ever ran one test, we could just set a flag in the TestCase
object and go look at the flag when the test completed. However, tests
are (intended to be) highly asymmetric- they usually work. Therefore, we
only want to record the failures and a highly condensed summary of the
successes.
The Smalltalk Best Practice Patterns (see Beck, K. Smalltalk
Best Practice Patterns, Prentice Hall, 1996) has a pattern that is applicable.
It is called Collecting Parameter . It suggests that when you need
to collect results over several methods, you should add a parameter to
the method and pass an object that will collect the results for you. We
create a new object, TestResult, to collect the results of running tests.
public class TestResult extends
Object { protected int fRunTests; public TestResult ()
{
fRunTests= 0; } }
This simple version of TestResult only counts the number
of tests run. To use it, we have to add a parameter to the TestCase.run()
method and notify the TestResult that the test is running:
public void run (TestResult
result) { result.startTest(this); setUp(); runTest(); tearDown(); }
And the TestResult has to keep track of the number of tests
run:
public synchronized void startTest (Test
test) { fRunTests++; }
We declare the TestResult method startTest as synchronized
so that a single TestResult can collect the results safely when the tests
are run in different threads. Finally, we want to retain the simple external
interface of TestCase, so we create a no-parameter version of run() that
creates its own TestResult:
public TestResult run () { TestResult result=
createResult(); run(result); return result; } protected TestResult createResult ()
{ return new TestResult(); }
Figure 3 shows our next design snapshot.
Figure 3: TestResult applies Collecting Parameter
If tests always ran correctly, then we wouldnt have to
write them. Tests are interesting when they fail, especially if we didnt
expect them to fail. Whats more, tests can fail in ways that we expect,
for example by computing an incorrect result, or they can fail in more
spectacular ways, for example by writing outside the bounds of an array.
No matter how the test fails we want to execute the following tests.
JUnit distinguishes between failures and errors .
The possibility of a failure is anticipated and checked for with assertions.
Errors are unanticipated problems like an ArrayIndexOutOfBoundsException.
Failures are signaled with an AssertionFailedError error. To distinguish
an unanticipated error from a failure, failures are caught in an extra
catch clause (1). The second clause (2) catches all other exceptions and
ensures that our test run continues..
public void run (TestResult
result) { result.startTest(this); setUp(); try {
runTest(); } catch (AssertionFailedError
e) { //1
result.addFailure(this, e); } catch (Throwable
e) { // 2
result.addError(this, e); } finally {
tearDown(); } }
An AssertionFailedError is triggered by the assert methods
provided by TestCase. JUnit provides a set of assert methods for different
purposes. Here is the simplest one:
protected void assertTrue (boolean
condition) { if (!condition)
throw new AssertionFailedError(); }
The AssertionFailedError is not meant to be caught by the
client (a testing method inside a TestCase) but inside the Template Method
TestCase.run(). We therefore derive AssertionFailedError from Error.
public class AssertionFailedError
extends Error { public AssertionFailedError
() {} }
The methods to collect the errors in TestResult are shown
below:
public synchronized void addError (Test
test, Throwable t) { fErrors.addElement(new
TestFailure(test, t)); } public synchronized void addFailure (Test
test, Throwable t) { fFailures.addElement(new
TestFailure(test, t)); }
TestFailure is a little framework internal helper class to
bind together the failed test and the signaled exception for later reporting.
public class TestFailure extends
Object { protected Test
fFailedTest; protected Throwable
fThrownException; }
The canonical form of collecting parameter requires us to
pass the collecting parameter to each method. If we followed this advice,
each of the testing methods would require a parameter for the TestResult.
This results in a "pollution" of these method signatures. As a benevolent
side effect of using exceptions to signal failures we can avoid this signature
pollution. A test case method, or a helper method called from it, can throw
an exception without having to know about the TestResult. As a refresher
here is a sample test method from our MoneyTest suite. It illustrates how
a testing method doesnt have to know anything about a TestResult:
public void testMoneyEquals ()
{ assertTrue(!f12CHF.equals(null)); assertEquals(f12CHF,
f12CHF); assertEquals(f12CHF,
new Money(12, "CHF")); assertTrue(!f12CHF.equals(f14CHF)); }
JUnit comes with different implementations of TestResult.
The default implementation counts the number of failures and errors and
collects the results. TextTestResult collects the results and presents
them in a textual form. Finally, UITestResult is used by the graphical
version of the JUnit Test Runner to update the graphical test status.
TestResult is an extension point of the framework. Clients
can define their own custom TestResult classes, for example, an HTMLTestResult
reports the results as an HTML document.
3.4 No stupid subclasses - TestCase again
We have applied Command to represent a test. Command relies
on a single method like execute() (called run() in TestCase) to invoke
it. This simple interface allows us to invoke different implementations
of a command through the same interface.
We need an interface to generically run our tests. However,
all test cases are implemented as different methods in the same class.
This avoids the unnecessary proliferation of classes. A given test case
class may implement many different methods, each defining a single test
case. Each test case has a descriptive name like testMoneyEquals or testMoneyAdd.
The test cases dont conform to a simple command interface. Different instances
of the same Command class need to be invoked with different methods. Therefore
our next problem is make all the test cases look the same from the point
of view of the invoker of the test.
Reviewing the problems addressed by available design patterns,
the Adapter pattern springs to mind. Adapter has the following intent "Convert
the interface of a class into another interface clients expect". This sounds
like a good match. Adapter tells us different ways to do this. One of them
is a class adapter, which uses subclassing to adapt the interface. For
example, to adapt testMoneyEquals to runTest we implement a subclass of
MoneyTest and override runTest to invoke testMoneyEquals.
public class TestMoneyEquals
extends MoneyTest { public TestMoneyEquals()
{ super("testMoneyEquals"); } protected void
runTest () { testMoneyEquals(); } }
The use of subclassing requires us to implement a subclass
for each test case. This puts an additional burden on the tester. This
is against the JUnit goal that the framework should make it as simple as
possible to add a test case. In addition, creating a subclass for each
testing method results in class bloat. Many classes with only a single
method are not worth their costs and it will be difficult to come up with
meaningful names.
Java provides anonymous inner classes which provide an
interesting Java-specific solution to the class naming problem. With anonymous
inner classes we can create an Adapter without having to invent a class
name:
TestCase test= new MoneyTest("testMoneyEquals
") { protected void
runTest() { testMoneyEquals(); } };
This is much more convenient than full subclassing. It preserves
compile-time type checking at the cost of some burden on the developer.
Smalltalk Best Practice Patterns describes another solution for the problem
of different instances behaving differently under the common heading of
pluggable behavior . The idea is to use a single class which can be
parameterized to perform different logic without requiring subclassing.
The simplest form of pluggable behavior is the Pluggable
Selector . Pluggable Selector stores a Smalltalk method selector in
an instance variable. This idea is not limited to Smalltalk. It is also
applicable to Java. In Java there is no notion of a method selector. However,
the Java reflection API allows us to invoke a method from a string representing
the methods name. We can use this feature to implement a pluggable selector
in Java. As an aside, we usually dont use reflection in ordinary application
code. In our case we are dealing with an infrastructure framework and it
is therefore OK to wear the reflection hat.
JUnit offers the client the choice of using pluggable
selector or implementing an anonymous adapter class as shown above. To
do so, we provide the pluggable selector as the default implementation
of the runTest method. In this case the name of the test case has to correspond
to the name of a test method. We use reflection to invoke the method as
shown below. First we look up the Method object. Once we have the method
object we can invoke it and pass its arguments. Since our test methods
take no arguments we can pass an empty argument array:
protected void runTest () throws
Throwable { Method runMethod=
null; try {
runMethod= getClass().getMethod(fName, new Class[0]); } catch (NoSuchMethodException
e) {
assertTrue("Method \""+fName+"\" not found", false); } try {
runMethod.invoke(this, new Class[0]); } // catch InvocationTargetException
and IllegalAccessException }
The JDK 1.1 reflection API only allows us to find public
methods. For this reason you have to declare the test methods as public,
otherwise you will get a NoSuchMethodException.
Here is the next design snapshot, with Adapter and Pluggable
Selector added.
Figure 4: TestCase applies either Adapter with an anonymous
inner class or Pluggable Selector
3.5 Dont care about one or many - TestSuite
To get confidence in the state of a system we need to
run many tests. Up to this point JUnit can run a single test case and report
the result in a TestResult. Our next challenge is to extend it so that
it can run many different tests. This problem can be solved easily when
the invoker of the tests doesnt have to care about whether it runs one
or many test cases. A popular pattern to pull out in such a situation is
Composite. To quote its intent "Compose objects into tree structures to
represent part-whole hierarchies. Composite lets clients treat individual
objects and compositions of objects uniformly." The point about part-whole
hierarchies is of interest here. We want to support suites of suites of
suites of tests.
Composite introduces the following participants:
Component: declares the interface we want to use to interact
with our tests.
Composite: implements this interface and maintains a collection
of tests.
Leaf: represents a test case in a composition that conforms
to the Component interface.
The pattern tells us to introduce an abstract class which
defines the common interface for single and composite objects. The primary
purpose of the class is to define an interface. When applying Composite
in Java we prefer to define an interface and not an abstract class. Using
an interface avoids committing JUnit to a specific base class for tests.
All that is required is that the tests conform to this interface. We therefore
tweak the pattern description and introduce a Test interface:
public interface Test { public abstract
void run(TestResult result); }
TestCase corresponds to a Leaf in Composite and implements
this interface as we have seen above.
Next, we introduce the Composite participant. We name
the class TestSuite. A TestSuite keeps its child tests in a Vector:
public class TestSuite implements
Test
{ private Vector
fTests= new Vector(); }
The run() method delegates to its children:
public void run (TestResult
result) { for (Enumeration
e= fTests.elements(); e.hasMoreElements(); ) {
Test test= (Test)e.nextElement();
test.run(result); } }
Figure 5: TestSuite applies Composite
Finally, clients have to be able to add tests to a suite,
they can do so with the method addTest:
public void addTest (Test test)
{ fTests.addElement(test); }
Notice how all of the above code only depends on the Test
interface. Since both TestCase and TestSuite conform to the Test interface
we can recursively compose suites of test suites. All developers can create
their own TestSuites. We can run them all by creating a TestSuite composed
of those suites.
Here is an example of creating a TestSuite:
public static Test suite ()
{ TestSuite suite=
new TestSuite(); suite.addTest(new
MoneyTest("testMoneyEquals")); suite.addTest(new
MoneyTest("testSimpleAdd")); }
This works fine, but it requires us to add all the tests
to a suite manually. Early adopters of JUnit told us this was stupid. Whenever
you write a new test case you have to remember to add it to a static suite()
method, otherwise it will not be run. We added a convenience constructor
to TestSuite which takes the test case class as an argument. Its purpose
is to extract the test methods and create a suite containing them. The
test methods must follow the simple convention that they start with the
prefix "test" and take no arguments. The convenience constructor uses this
convention, constructing the test objects by using reflection to find the
testing methods. Using this constructor the above code is simplified to:
public static Test suite ()
{ return new TestSuite(MoneyTest.class); }
The original way is still useful when you want to run a subset
of the test cases only.
3.6 Summary
We are at the end of our cooks tour through JUnit. The
following figure shows the design of JUnit at a glance explained with patterns.
Figure 6: JUnit Patterns Summary
Notice how TestCase, the central abstraction in the framework,
is involved in four patterns. Pictures of mature object designs show this
same "pattern density". The star of the design has a rich set of relationships
with the supporting players.
Here is another way of looking at all of the patterns
in JUnit. In this storyboard you see an abstract representation of the
effect of each of the patterns in turn. So, the Command pattern creates
the TestCase class, the Template Method pattern creates the run method,
and so on. (The notation of the storyboard is the notation of figure 6
with all the text deleted).
Figure 7: JUnit Pattern Storyboard
One point to notice about the storyboard is how the complexity
of the picture jumps when we apply Composite. This is pictorial corroboration
for our intuition that Composite is a powerful pattern, but that it "complicates
the picture." It should therefore be used with caution.
4. Conclusion
To conclude, lets make some general observations:
Patterns
We found discussing the design in terms of patterns to
be invaluable, both as we were developing the framework and as we try to
explain it to others. You are now in a perfect position to judge whether
describing a framework with patterns is effective. If you liked the discussion
above, try the same style of presentation for your own system.
Pattern density
There is a high pattern "density" around TestCase, which
is the key abstraction of JUnit. Designs with high pattern density are
easier to use but harder to change. We have found that such a high pattern
density around key abstractions is common for mature frameworks. The opposite
should be true of immature frameworks - they should have low pattern density.
Once you discover what problem you are really solving, then you can begin
to "compress" the solution, leading to a denser and denser field of patterns
where they provide leverage.
Eat your own dog food
As soon as we had the base unit testing functionality
implemented, we applied it ourselves. A TestTest verifies that the framework
reports the correct results for errors, successes, and failures. We found
this invaluable as we continued to evolve the design of the framework.
We found that the most challenging application of JUnit was testing its
own behavior.
Intersection, not union
There is a temptation in framework development to include
every feature you can. After all, you want to make the framework as valuable
as possible. However, there is a counteracting force- developers have to
decide to use your framework. The fewer features the framework has, the
easier it is to learn, the more likely a developer will use it. JUnit is
written in this style. It implements only those features absolutely essential
to running tests- running suites of tests, isolating the execution of tests
from each other, and running tests automatically. Sure, we couldnt resist
adding some features but we were careful to put them into their own extensions
package (test.extensions). A notable member of this package is a TestDecorator
allowing execution of additional code before and after a test.
Framework writers read their code
We spent far more time reading the JUnit code than we
spent writing it, and nearly as much time removing duplicate functionality
as we spent adding new functionality. We experimented aggressively with
the design, adding new classes and moving responsibility around in as many
different ways as we could imagine. We were rewarded (and are still being
rewarded) for our monomania by a continuous flow of insights into JUnit,
testing, object design, framework development, and opportunities for further
articles.
The latest version of JUnit can be downloaded from http://www.junit.org.
5. Acknowledgements
Thanks to John Vlissides, Ralph Johnson, and Nick Edgar
for careful reading and gentle correction.
junit4-r4.13.2/doc/markdown.sh 0000664 0000000 0000000 00000000073 14011777271 0016132 0 ustar 00root root 0000000 0000000 ~/bin/Markdown.pl ReleaseNotes4.8.txt >ReleaseNotes4.8.html junit4-r4.13.2/doc/testinfected/ 0000775 0000000 0000000 00000000000 14011777271 0016435 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/doc/testinfected/IMG00001.GIF 0000664 0000000 0000000 00000014432 14011777271 0017765 0 ustar 00root root 0000000 0000000 GIF89a6 @ @ @ @@ @ @ ` `@ ` ` @ @ @ @ @ @ @ @@ @ @ ` `@ ` ` @ @ @ @ @ @ @@ @ @ @ @@ @ @@ @@@@@@@@` @`@@`@`@ @@@@@ @@@@@ @@@@@ @@@@` ` @` ` ` ` @` ` `@ `@@`@`@`` ``@````` `@``` `@``` `@``` `@`` @ @ @ @@@@` `@`` @ @ @ @ @ @ @ @@@@` `@`` @ @ @ @ @ @ @ @@@@` `@`` @ @ @ @ @ @ @ @@@@` `@`` @ @ @ @! , 6 H*\ȰÇ#JHŋ3jܨmB Iɓ(S\ɲ˗0cʜI͛8s#H[@
JѣH*]ʴӧPJJիXV֯`Ê Kٳhri+۷pʝKݻx˷߿ L6@IpA,˘3k̹|dd^ͺװ5@nEwz;dG N?2\ܶ=sZ྅ $atC" OJ}{ѥwع[+>p~whށ&zIރ={BQ8 }֘~q
蘀 #Ɨ
"`Q Dآ^( uoq_@^% ~G"PQ/PP iLaޙs9`hhݏkQiy5z0ʘWI!r v1ʦi饖MiTC][
!YZJfJ&͉*j`i~:afhߛ!gRsNNV[`*,VKBVlҚv +:`\{XJ* k;zz7ߍHwn"lv wܱG ̱s z,sn͜-K/wDmt_BL7PG=RWmXg58n`-]mhSepǍurmxcEw|{- x'xԇ/㐃ԕn]#5y35F~_gκS#c^Fz4N:V:o <̧ީ i+:~:Л?Zϭ ?? >.u_7:)P~
l'/;UP~d`
|A9p~`1H児۠٣ gBrp4 / nЁ+
PzU_8D 0[H/H@6bx7vqpK` iІZc =Y3|G_{!X;mr̤&Mzi$(GIʭLNV,|,gyXl-s^.싾 0L.L2f:Ќ4IjF1^ Nl 8IrL:yNd#鉋)*m̧>Osk
7驛~MBuOO(D'*ъR$&tEz
A5D,A3$Җ0m Iд( hPѐ&MLJ~j&NwzԂ="6XISeCt(5ݡ
rӁɚ%XVsڢ˵`]{
,xƱ
Ko⽎n 0ʖN/Ή#{|Ҧ-gFHzr~*&
4aSϺs.|*w 4ßCr*fڮlѿY/ q3/oj??@bM7WB$0ؠBRXbrء Rוz$p+آ/3X7☣;أ?XU'YG"K2dBVESRYWbPR%_cf%q
*"k٦ohT^Yw≤Qљ{:է"hfBj*2(SRh)E2)ꑨꡧJjGZu'z.:"엹I*F2`-i-DNA
{mr.8{бF4{.11"
˭ [ܰ)PkPmCk˱ɶzl <2|̥z\
~w'9vE D ( `6 <3F)P4̙v| H|Y9`sz㜊 oB!qv̘J҇ ~sr !OMs4x&$Τ}Hlu&Ѕ\TM_Lp&Tb \I0}la "{++pb YA8 )Y)*QD-^ĘQF 3OG%MDRJ-[9L5męSC#wTP6{,TRM uUTU-BUVEvVX_ɞEVmAkݾ+m\u{W^eCXy F B隃9dq'0Sq?n 0;tk1ȔBH#/"H%l(I&')Ē+䒾-/$ӱ1D0`M7߄3N9礳N;3O=O?4PAd05C4QEeQG 4RI'RK/4SM7 0'TQG%TSOE5UUWeUW_5VYgV[ouSCd&\6Xa%XcUW@EYg6Zi-U٪6[mh
ׅ|\sE7QMN\U7^yXvr7!x_+l&`7faMة bW/3fjcG&`}KfyOVJdgBMkghaNJf&ޛ٠fY*iBrjaZǥj65&hivZlFmmn;o ooɖk/YpFqE·~p/m6s?=t?WiP(u{?~goM/ly^'?~ /}tr義Ђ"va>PyD2h:Ё{adЄLa:Li ^g(CHPz,uV -@ :цcbiA7QQ2 {%Ģ Hc 7D&285U+I lg`Am SaC!F8bE1fԸcG A^hm$QT%I, 2fH7qԹgOG4ْhQ/i& OOF:jå$պ Jg2MXlYgNZM[oƕ;\Ie~Mo_ -paÇ'Vx^]G<\1gn2A=ZagͧQs3iׯa56Wzcֽڿ˛xq}W,ϡCOãgמ{zn?^tw3'_kGٺ}}RO}]6 ,LPl!Ы( -
5= E,\M?s)Eb2FqQ yB'Qk+߄$R% nB {),?//Ĭ*,3r0+)*(I6鬓=!3R3JTQA-H9%K3
UTN'RuRNtS2 QieSqEWUWeZ5-tVO{S`O]T^M/~%6Zi]fu?l_5kMem)+r\l˭yWmE7uU߅%1%X^bθa Nz I.QNYYɍaxcpYy矁瘉fmn駡Zꩩ+F)˽X.{N[V;YM\ wǻޖ!\)1WI{I0>뜞|p}E(T+9%1C/|[=@/Qw`
텯W \`+_KGkx_! 5ABP
S?|!
]ZJ8|aǹ/;T h {5t! D NOQ(A bш9>xB/qIXdXDn H@po"/b+U\ hiϏģ!4r\$)=)y u}Lcb8ޑd(1yJFN҃BԊ5x2nRq$,'@)fЎ}< ^0mt# YJZҘd LiZll {xZ.Qa&]p~whށ&zIރ={BQ8 }֘~q
蘀 #Ɨ
"`Q Dآ^( uoq_@^% ~G"PQ/PP iLaޙs9`hhݏkQiy5z0ʘWI!r v1ʦi饖MiTC][
!YZJfJ&͉*j`i~:afhߛ!gRsNNV[`*,VKBVlҚv +:`\{XJ* k;zz7ߍHwn"lv wܱG ̱s z,sn͜-K/wDmt_BL7PG=RWmXg58n`-]mhSepǍurmxcEw|{- x'xԇ/㐃ԕn]#5y35F~_gκS#c^Fz4N:V:o <̧ީ i+:~:Л?Zϭ ?? >.u_7:)P~
l'/;UP~d`
|A9p~`1H児۠٣ gBrp4 / nЁ+
PzU_8D 0[H/H@6bx7vqpK` iІZc =Y3|G_{!X;mr̤&Mzi$(GIʭLNV,|,gyXl-s^.싾 0L.L2f:Ќ4IjF1^ Nl 8IrL:yNd#鉋)*m̧>Osk
7驛~MBuOti$&tEZͨA*-"h4JҒ-(<RtCIEC2Sk6(ͩNҫT-/eZQس,ANԚ4)4**.SGjҴ^G*VU$5mHZV6pUVrUF֏)UނUdb
`kVug=aظ:'h
ʩjEXאSi`&5mI
־8[+EQ(yE 8%i AkXYK^h =5%8$mE[l%,qKMsSK Pwc
^vEq_8=}|gasaįZ[^I2]ζ .YEn
\ر$ P)dTHLK7NzZ^ūL*ۄM*촬V_U,^-[6N;3, R7pnɒzMB 5=2#ΐv3Ii44-wNӞ5(A-RgԦN5 ml,h
2l!Ĉ'Rh"ƌ7r옱
=,i$ʔ*Wlȁ.gҬi&Μ: 'РBSfѤJ2mJӨRRj*C ZZ+ؙX0X6,ڴj 铬Yen5;W-\ 7/k ,t&1Ɛ Sly["8g_.mrf'nbҰOӮ 6hͬ?/;§⎫z7ޑAC=9n -b ;9o7oﾨO>t
(txx.D
: J8!Zx!j! z!!!u]G8)"-"18#5x#9#=#%Zu"Ey$I*$M(dUD:9%UZy%Y%URj%a9f\B(&mfJ%uy'Hy'S}
z(I~h&J:)2e(j)RIrz*z:Ѩ(B:+*QC+~',Ɏ9,ŚtJ[%:[jFQܚ{nBP;*ۢ>k)"D0;D $1 +pCx)1r jB S\Zl% r3̩ 38 -3ӳm3ADp-4֪f$AROo=5٩>}m^ Y6Zom,6U}7 >8~8+8;8KFrr YrB0Ry?CvWD魻zy.`_ /_^+ ]; \KoZ[OYkV{ mKFŞDõM}uƕ^9tG ;Q Y?.w
c ,"
v#AL! #
K@ͤ51zRh
ѧB
p#Ck( }q
QRA7IDob~A]ڲș[f9h۵EMΛ_&[wSW'ͼ`/Gճ8TWcn{_.oiT9B_;ހ }>R
a^~ ݄-C'V\7]s",$ f*gMX vfV|-RhBiED
%PdT9eXxe\ҷe` ed:6fh Ylp)tix|矀*( fx&袌6裐F*餔Vj饘f ա*ꨤjꩨꪬ꫰*무j뭮zj +k챳j6F+*[d--ߊږkz;қn
v m SWؾ.,*
ꮸ믩BL.+k2lmx.|[rq6 /1 L4O7lr+'ײB/wsrPT
GLߨ/Nӄ?Noyފ~{3N; G0E~ˮZ 7\n{K_{?;k
>ߚ>u/|旳٘'玾çKUڧ= uMl]>ɏ~\9mx[8?0~ˠ6:wΓY w/p[lH #_Sh|]4jX *6CZ
{K !ט8-krW' z c&D0Z (GgXVl 5 >rڣRXF:Cm̤&7Nz (GIRL*)>&,gIZ%)Y,$ 0Ibe\`"Ќ4YLe
Œ̦6nnϚA7Irs8vJO zДIX
-z
Mh' ~Jə
D#2n顾dD'юHGJҒ(-)HzPz0='HyQ8Lo@Py_fsͩRZ
D$IQ5zT&Xj-wLUUJֲr}IM[:Vj 5l+\WD*ULs-#E%jCYJ~e_+d'ͤ,\fU=+ SU]ig{ZBHO!"XV
nNQܺg
yQG{Y:>Y.G{#Mo[j.N[X.MKUlg`Am SaC!F8bE1fԸcG A^hm TeKDhr`˙!qԹgO?n $GQ&ETiSOڊi3P7fպkW_Z%YeYf^ZS-XoƕUl6wջo_|SR)3\Ç'V -I !G:α zwޯg_ ?mǗz}{p} ˿ p%i! ) 1P
9 Lim!Q" Dn"{$15#TS7dtO=ųK1qSsTRW<YCFGYMPXQԂ"a Z=Usز҄YavKYVZq}=W7UKuscSuJ7s6{ö]veQUt]` W~ex)N_Θĉ+ۇǭXٌd`|=f$|YiqYg<猷y{[裑NZ饙n駛YꅗWӖAZ뭹[챹\L[mDx[nܞn;ռot[ 2O\q_!W)<-\[A]I/O751o% a]iq]61-.'tBo r%e^uuȡGų/v@w%eiH[ 2 }7w(Xcߖg?X,;UP%9 Ū ā(A
B0 9A TUw`,
ł!zC ,
IC#L b _8,D%TJ# ρAd%1d$#hF(QBtcTq`dH1K wHB (F>fІpt A+1٢ YH/R,$ CM1T# ILna%=GEr$J\*r,-Q 'URp$ULLrHl ?S fSCjL =6|T7IaRdb#3|:DϢٓ§~_2BPXԴPnRz<{Qn G3:,I9T*eKRts2M)gStq:O SoB%QfT.mSUNUUIm]WVUk3Yњ ; junit4-r4.13.2/doc/testinfected/IMG00003.GIF 0000664 0000000 0000000 00000013550 14011777271 0017767 0 ustar 00root root 0000000 0000000 GIF89a
@ @ @ @@ @ @ ` `@ ` ` @ @ @ @ @ @ @ @@ @ @ ` `@ ` ` @ @ @ @ @ @ @@ @ @ @ @@ @ @@ @@@@@@@@` @`@@`@`@ @@@@@ @@@@@ @@@@@ @@@@` ` @` ` ` ` @` ` `@ `@@`@`@`` ``@````` `@``` `@``` `@``` `@`` @ @ @ @@@@` `@`` @ @ @ @ @ @ @ @@@@` `@`` @ @ @ @ @ @ @ @@@@` `@`` @ @ @ @ @ @ @ @@@@` `@`` @ @ @ @! ,
H*\ȰÇ#JHŋ3jȱǏɓ(S\ɲ˗0cʜI͛8sɳϟ@
F$I[H*]ʴӧPJJիXjʵׯ`Ê K֢#]˶۷pʝKݮh
߿ LÈ+^̸ǐ#KL˘3/FW )'zIͨS^ͺװc˞ Q|Q6 N1E&G _i27mZtسkν wa:K}:~;.98߯xԼ ږ6^ӕ^o!'!{EXe _T (!%R'}vZ`ƈᄈG $SC"YbR*u^m,2HaQ%tby%_&e|Jcj衫ԙKG nv4'{N _}qjd6(D"fI9zYN8
ka2*jbjκ}kkbdž+n m
l(knj V;jz:H c#j:J^Kb)W n ®sD$lc,,R0p1|xV<3_ -t@-b7O?7ӲI TW
we\w`bmhZp-tvx|߀.uw' G.ڎOngVw砛4n騧ꬷ.n{-o'7G/WozޢCu/o==@o>/oRQ+ H<_1'H
[ڇAD9IB'9KDĒ6,,
Mx07DɀDCȇ??ЈD! whD%3ԉ
}(RQKa #Xb-Oo ` ˨'qe< h;QgTDARqL#P9H::" ߉\&C-Na
x?"$b wQ e*[YHZVё&u)HR\fA ?ҏN\ f&ge3yLҚה0OYYrtf.)(]ҁf8YH;2D$2 Ov^9>QNeJҔ?jP>6ԛL>I(.'? ̀Ft(4ѓVad&ϙЌ\g2IcRӥ0iK Ln̦:sLiHsGVJt3hcF.ԨiFGʑ6Le
fsԔNMk9Rvħ-9ymzҗ4? bխjV jRXNL(.ؿs]C#GBդIXJ=/UyWzv%NkZӪVBe!YZUlINBMjڤ6K)[ UmwQԵ=dMyVwiqңlTFUjj[L*1`K[eŮAڵgwc_SuL2[J0 ʽ6NU1_ Nt,GJؖ p0- .i-&dB*>)ArI"%`3u|crflCu$YL:x̽<π ЈNɧ?O{'MJ[Z&\~!MF .ӌT
Ƥ~wN %{Puj5!li^!ӳ2Lj_x1j][6C# L2 /%c T/eykb[px P}Aky9ٚ+.}o%p@VЂfsܣst1}jzG
-iU0Ta
ԙ| _[ T+]Tw)a ԘiN߄ȶ4? 6tbD *XqE)Z F &4$J*1v cK/At&I#qc͜3agK<{NtjTS
4x BX&Bc S(Z5]tۛoֵ -]y%J_98dқyu2`Ub#wy21ŋxE}4cJuiل3vbu&;eOJm zo{PөW偔3ozxɗ7 yͳW^<)W+x ;/@
J+;%
-02>.E 3$H+绯K|e+۰iܑ }q?SGerqKjњ|,&|6$l'!!.G,I##tO˗,.7k7
<\H"I'{B =51AOH\NMC-%JA1uT7J:D/sISCTdX{N0TQA00
t 6+ػX/iӫ\}ZvŔ
N0ljU|HZ"1]lD]g9lm5PjQkך_lWy-6^a̯L2CR+4,8muՔ+ 9QIWڏ\MUNW =Oh?EM%Z^Q#Ur_ gyi}i^*Nau`}^ȖNgFvn1w؍{ڬkY>o}5wnQl^~V\-ۚM[HURL4N_u=yvEA>s] 5\!+w{h$xWsߞɚ@/z볇_}?۟/x0 @zⷢ $ .R]
дp-z: 8YJ'X5_Hn:ܜt79Md[#CH*V'J
RZTy5.eR
xMk4U:X8kbvE)Y_JԄ"͈B8li x*.97<WA:p'|ʑ7\ #G7qa^s 9ys AЉ^,ml,h
D!Ĉ'Rh"ƌ7r#Ȑ"G,*S\%̗/ ND&Dp2t8p!>M-j(ҤJ2m:Rg̨2RU3hOy
Ʉ` JpӴjײm-܆AҭjwUgRzЫ_yk0Ċ#Zݘf kM˖j1ТGv2xr6ksج%sҺw;lw'<;9MUmnެ3'ϩ(Ǔ//.zNq7o>_]E$w9 *z9ҁ VD`wYEXj[=- ۴q")-"18#5x#9#=#A
9d^ן45$QJ9%UZy%Yj%]z%a9&e j9w
q9'uy'y'}'
:(z(*(7`}H:)Zz)j)z):*z**q8+
+
;, X,*k :,-ZZj-Թ-Q{yz\ߢ.ԨvnNkًܱ
'kޭ>??W?? (2| #( RT ; junit4-r4.13.2/doc/testinfected/logo.gif 0000664 0000000 0000000 00000001704 14011777271 0020066 0 ustar 00root root 0000000 0000000 GIF89a&
!
, & @ HD#B(1
b (ѠE C,Ñ(KrHE/3tQI(mn̙Seŏ?<9TC'4h͖JD0hTX{N%!ή
jҊ)w z'Χ3R-JnۥbE.W{;գU~ D;q@ ; junit4-r4.13.2/doc/testinfected/testing.htm 0000664 0000000 0000000 00000075367 14011777271 0020646 0 ustar 00root root 0000000 0000000
Test Infected:
J U nit Test
Infected: Programmers Love Writing Tests
Testing is not closely integrated with development. This prevents you
from measuring the progress of development- you can't tell when something
starts working or when something stops working. Using JUnit you
can cheaply and incrementally build a test suite that will help you measure
your progress, spot unintended side effects, and focus your development
efforts.
Contents
Every programmer knows they should write tests for their code. Few do.
The universal response to "Why not?" is "I'm in too much of a hurry." This
quickly becomes a vicious cycle- the more pressure you feel, the fewer
tests you write. The fewer tests you write, the less productive you are
and the less stable your code becomes. The less productive and accurate
you are, the more pressure you feel.
Programmers burn out from just such cycles. Breaking out requires an
outside influence. We found the outside influence we needed in a simple
testing framework that lets us do a little testing that makes a big difference.
The best way to convince you of the value of writing your own tests
would be to sit down with you and do a bit of development. Along the way,
we would encounter new bugs, catch them with tests, fix them, have them
come back, fix them again, and so on. You would see the value of the immediate
feedback you get from writing and saving and rerunning your own unit tests.
Unfortunately, this is an article, not an office overlooking charming
old-town Zürich, with the bustle of medieval commerce outside and
the thump of techno from the record store downstairs, so we'll have to
simulate the process of development. We'll write a simple program and its
tests, and show you the results of running the tests. This way you can
get a feel for the process we use and advocate without having to pay for
our presence.
As you read, pay attention to the interplay of the code and the tests.
The style here is to write a few lines of code, then a test that should
run, or even better, to write a test that won't run, then write the code
that will make it run.
The program we write will solve the problem of representing arithmetic
with multiple currencies. Arithmetic between single currencies is trivial,
you can just add the two amounts. Simple numbers suffice. You can ignore
the presence of currencies altogether.
Things get more interesting once multiple currencies are involved. You
cannot just convert one currency into another for doing arithmetic since
there is no single conversion rate- you may need to compare the value of
a portfolio at yesterday's rate and today's rate.
Let's start simple and define a class Money
to represent a value in a single currency. We represent the amount by a
simple int. To get full accuracy you would probably use double or java.math.BigDecimal
to store arbitrary-precision signed decimal numbers. We represent a currency
as a string holding the ISO three letter abbreviation (USD, CHF, etc.).
In more complex implementations, currency might deserve its own object.
class Money {
private int fAmount;
private String fCurrency; public Money(int amount, String currency) {
fAmount= amount;
fCurrency= currency;
}
public int amount() {
return fAmount;
}
public String currency() {
return fCurrency;
}
} you add two Moneys of the same currency, the
resulting Money has as its amount the sum of the other two amounts.
public Money add(Money m) {
return new Money(amount()+m.amount(), currency());
} latest
copy JUnit (or write your own equivalent- it's not so much work).
JUnit defines how to structure your test cases and provides the tools
to run them. You implement a test in a subclass of TestCase. To test our
Money implementation we therefore define MoneyTest
as a subclass of TestCase. In Java, classes are contained in packages and
we have to decide where to put MoneyTest. Our current practice is to put
MoneyTest in the same package as the classes under test. In this way a
test case has access to the package private methods. We add a test method
testSimpleAdd, that will exercise the simple version of Money.add()
above. A JUnit test method is an ordinary method without any parameters.
public class MoneyTest extends TestCase {
//
public void testSimpleAdd() {
Money m12CHF= new Money(12, "CHF"); //
Code which creates the objects we will interact
with during the test. This testing context is commonly referred to as a
test's fixture . All we need for the testSimpleAdd test are some
Money objects.
Code which exercises the objects in the fixture.
Code which verifies the result.
Before we can verify the result we have to digress a little since we need
a way to test that two Money objects are equal. The Java idiom to do so
is to override the method equals defined in Object. Before we implement
equals let's a write a test for equals in MoneyTest.
public void testEquals() {
Money m12CHF= new Money(12, "CHF");
Money m14CHF= new Money(14, "CHF");
Assert.assertTrue(!m12CHF.equals(null));
Assert.assertEquals(m12CHF, m12CHF);
Assert.assertEquals(m12CHF, new Money(12, "CHF")); // value object . Two Monies are considered equal
if they have the same currency and value. To test this property we have
added a test (1) to verify that Monies are equal
when they have the same value but are not the same object.
Next let's write the equals method in Money:
public boolean equals(Object anObject) {
if (anObject instanceof Money) {
Money aMoney= (Money)anObject;
return aMoney.currency().equals(currency())
&& amount() == aMoney.amount();
}
return false;
} With an equals method in hand we can verify the outcome of testSimpleAdd.
In JUnit you do so by a calling
Assert.assertTrue ,
which triggers a failure that is recorded by JUnit when the argument isn't
true. Since assertions for equality are very common, there is also
an Assert.assertEquals convenience method. In addition to testing for equality
with equals, it reports the printed value of the two objects in the case they
differ. This lets us immediately see why a test failed in a JUnit test
result report. The value a string representation created by
the toString converter method.
There are
other assertXXXX variants not discussed here.
Now that we have implemented two test cases we notice some code duplication
for setting-up the tests. It would be nice to reuse some of this test set-up
code. In other words, we would like to have a common fixture for running
the tests. With JUnit you can do so by storing the fixture's objects in
instance variables of your
TestCase
subclass and initialize them by overriding
the setUp method. The symmetric operation to setUp is tearDown which you
can override to clean up the test fixture at the end of a test. Each test
runs in its own fixture and JUnit calls setUp and tearDown for each test
so that there can be no side effects among test runs.
public class MoneyTest extends TestCase {
private Money f12CHF;
private Money f14CHF;
protected void setUp() {
f12CHF= new Money(12, "CHF");
f14CHF= new Money(14, "CHF");
}
} public void testEquals() {
Assert.assertTrue(!f12CHF.equals(null));
Assert.assertEquals(f12CHF, f12CHF);
Assert.assertEquals(f12CHF, new Money(12, "CHF"));
Assert.assertTrue(!f12CHF.equals(f14CHF));
}
public void testSimpleAdd() {
Money expected= new Money(26, "CHF");
Money result= f12CHF.add(f14CHF);
Assert.assertTrue(expected.equals(result));
}
define how to run an individual test case,
define how to run a test suite .
JUnit supports two ways of running single tests:
In the static way you override the runTest method inherited from TestCase
and call the desired test case. A convenient way to do this is with an
anonymous inner class. Note that each test must be given a name, so you
can identify it if it fails.
TestCase test= new MoneyTest("simple add") {
public void runTest() {
testSimpleAdd();
}
}; [1]
in the superclass will make sure runTest is executed when the time comes.
The dynamic way to create a test case to be run uses reflection to implement
runTest. It assumes the name of the test is the name of the test case method
to invoke. It dynamically finds and invokes the test method. To invoke
the testSimpleAdd test we therefore construct a MoneyTest as shown below:
TestCase test= new MoneyTest("testSimpleAdd"); As the last step to getting both test cases to run together, we have
to define a test suite. In JUnit this requires the definition of a static
method called suite. The suite method is like a main method that is specialized
to run tests. Inside suite you add the tests to be run to a
TestSuite object
and return it. A TestSuite can run a collection of tests. TestSuite and
TestCase both implement an interface called Test which defines the methods
to run a test. This enables the creation of test suites by composing arbitrary
TestCases and TestSuites. In short TestSuite is a Composite [1].
The code below illustrates the creation of a test suite with the dynamic
way to run a test.
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(new MoneyTest("testEquals"));
suite.addTest(new MoneyTest("testSimpleAdd"));
return suite;
} public static Test suite() {
Here is the corresponding code using the static way.
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(
new MoneyTest("money equals") {
protected void runTest() { testEquals(); }
}
);
suite.addTest(
new MoneyTest("simple add") {
protected void runTest() { testSimpleAdd(); }
}
);
return suite;
} Figure 1
shows the TestRunner window after we run our trivial test suite.
Figure 1 : A Successful RunAfter having verified that the simple currency case works we move on
to multiple currencies. As mentioned above the problem of mixed currency
arithmetic is that there isn't a single exchange rate. To avoid this problem
we introduce a MoneyBag which defers exchange rate conversions. For example
adding 12 Swiss Francs to 14 US Dollars is represented as a bag containing
the two Monies 12 CHF and 14 USD. Adding another 10 Swiss francs gives
a bag with 22 CHF and 14 USD. We can later evaluate a MoneyBag with different
exchange rates.
A MoneyBag is represented as a list of Monies and provides different
constructors to create a MoneyBag. Note, that the constructors are package
private since MoneyBags are created behind the scenes when doing currency
arithmetic.
class MoneyBag {
private Vector fMonies= new Vector();
MoneyBag(Money m1, Money m2) {
appendMoney(m1);
appendMoney(m2);
}
MoneyBag(Money bag[]) {
for (int i= 0; i < bag.length; i++)
appendMoney(bag[i]);
}
} protected void setUp() {
f12CHF= new Money(12, "CHF");
f14CHF= new Money(14, "CHF");
f7USD= new Money( 7, "USD");
f21USD= new Money(21, "USD");
fMB1= new MoneyBag(f12CHF, f7USD);
fMB2= new MoneyBag(f14CHF, f21USD);
} public void testBagEquals() {
Assert.assertTrue(!fMB1.equals(null));
Assert.assertEquals(fMB1, fMB1);
Assert.assertTrue(!fMB1.equals(f12CHF));
Assert.assertTrue(!f12CHF.equals(fMB1));
Assert.assertTrue(!fMB1.equals(fMB2));
} public Money add(Money m) {
if (m.currency().equals(currency()) )
return new Money(amount()+m.amount(), currency());
return new MoneyBag(this, m);
} interface IMoney {
public abstract IMoney add(IMoney aMoney);
//
} public void testMixedSimpleAdd() {
// [12 CHF] + [7 USD] == {[12 CHF][7 USD]}
Money bag[]= { f12CHF, f7USD };
MoneyBag expected= new MoneyBag(bag);
Assert.assertEquals(expected, f12CHF.add(f7USD));
}
testBagSimpleAdd - to add a MoneyBag to a simple Money
testSimpleBagAdd - to add a simple Money to a MoneyBag
testBagBagAdd - to add two MoneyBags
Next, we extend our test suite accordingly:
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(new MoneyTest("testMoneyEquals"));
suite.addTest(new MoneyTest("testBagEquals"));
suite.addTest(new MoneyTest("testSimpleAdd"));
suite.addTest(new MoneyTest("testMixedSimpleAdd"));
suite.addTest(new MoneyTest("testBagSimpleAdd"));
suite.addTest(new MoneyTest("testSimpleBagAdd"));
suite.addTest(new MoneyTest("testBagBagAdd"));
return suite;
} [2]
is an elegant way to solve this problem. The idea behind double dispatch
is to use an additional call to discover the kind of argument we are dealing
with. We call a method on the argument with the name of the original method
followed by the class name of the receiver. The add method in Money and
MoneyBag becomes:
class Money implements IMoney {
public IMoney add(IMoney m) {
return m.addMoney(this);
}
//
} class MoneyBag implements IMoney {
public IMoney add(IMoney m) {
return m.addMoneyBag(this);
}
//
} interface IMoney {
//
IMoney addMoney(Money aMoney);
IMoney addMoneyBag(MoneyBag aMoneyBag);
} public IMoney addMoney(Money m) {
if (m.currency().equals(currency()) )
return new Money(amount()+m.amount(), currency());
return new MoneyBag(this, m);
}
public IMoney addMoneyBag(MoneyBag s) {
return s.addMoney(this);
} public IMoney addMoney(Money m) {
return new MoneyBag(m, this);
}
public IMoney addMoneyBag(MoneyBag s) {
return new MoneyBag(s, this);
} public void testSimplify() {
// {[12 CHF][7 USD]} + [-12 CHF] == [7 USD]
Money expected= new Money(7, "USD");
Assert.assertEquals(expected, fMB1.add(new Money(-12, "CHF")));
} It comes to no surprise that our test run ends with a red progress bar
indicating the failure. So we fix the code in MoneyBag to get back to a
green state.
public IMoney addMoney(Money m) {
return (new MoneyBag(m, this)).simplify();
}
public IMoney addMoneyBag(MoneyBag s) {
return (new MoneyBag(s, this)).simplify();
}
private IMoney simplify() {
if (fMonies.size() == 1)
return (IMoney)fMonies.firstElement()
return this;
} The code above solves only a small portion of the multi-currency arithmetic
problem. We have to represent different exchange rates, print formatting,
and the other arithmetic operations, and do it all with reasonable speed.
However, we hope you can see how you could develop the rest of the objects
one test at a time- a little test, a little code, a little test, a little
code.
In particular, review how in the development above:
We wrote the first test, testSimpleAdd, immediately after we had written
add(). In general, your development will go much smoother if you write
tests a little at a time as you develop. It is at the moment that you are
coding that you are imagining how that code will work. That's the perfect
time to capture your thoughts in a test.
We refactored the existing tests, testSimpleAdd and testEqual, as soon
as we introduced the common setUp code. Test code is just like model code
in working best if it is factored well. When you see you have the same
test code in two places, try to find a way to refactor it so it only appears
once.
We created a suite method, then extended it when we applied Double Dispatch.
Keeping old tests running is just as important as making new ones run.
The ideal is to always run all of your tests. Sometimes that will be too
slow to do 10 times an hour. Make sure you run all of your tests at least
daily.
We created a new test immediately when we thought of the requirement that
a one element MoneyBag should just return its element. It can be difficult
to learn to switch gears like this, but we have found it valuable. When
you are struck by an idea of what your system should do, defer thinking
about the implementation. Instead, first write the test. Then run it (you
never know, it might already work). Then work on the implementation.
Martin Fowler makes this easy for you. He says, "Whenever you are tempted
to type something into a print statement or a debugger expression, write
it as a test instead." At first you will find that you have to create a
new fixtures all the time, and testing will seem to slow you down a little.
Soon, however, you will begin reusing your library of fixtures and new
tests will usually be as simple as adding a method to an existing TestCase
subclass.
You can always write more tests. However, you will quickly find that
only a fraction of the tests you can imagine are actually useful. What
you want is to write tests that fail even though you think they should
work, or tests that succeed even though you think they should fail. Another
way to think of it is in cost/benefit terms. You want to write tests that
will pay you back with information.
Here are a couple of the times that you will receive a reasonable return
on your testing investment:
During Development- When you need to add new functionality to the system,
write the tests first. Then, you will be done developing when the test
runs.
During Debugging- When someone discovers a defect in your code, first write
a test that will succeed if the code is working. Then debug until the test
succeeds.
One word of caution about your tests. Once you get them running, make sure
they stay running. There is a huge difference between having your suite
running and having it broken. Ideally, you would run every test in your
suite every time you change a method. Practically, your suite will soon
grow too large to run all the time. Try to optimize your setup code so
you can run all the tests. Or, at the very least, create special suites
that contain all the tests that might possibly be affected by your current
development. Then, run the suite every time you compile. And make sure
you run every test at least once a day: overnight, during lunch, during
one of those long meetings.
This article only scratches the surface of testing. However, it focuses
on a style of testing that with a remarkably small investment will make
you a faster, more productive, more predictable, and less stressed developer.
Once you've been test infected, your attitude toward development is
likely to change. Here are some of the changes we have noticed:
There is a huge difference between tests that are all running correctly
and tests that aren't. Part of being test infected is not being able to
go home if your tests aren't 100%. If you run your suite ten or a hundred
times an hour, though, you won't be able to create enough havoc to make
you late for supper.
Sometimes you just won't feel like writing tests, especially at first.
Don't. However, pay attention to how much more trouble you get into, how
much more time you spend debugging, and how much more stress you feel when
you don't have tests. We have been amazed at how much more fun programming
is and how much more aggressive we are willing to be and how much less
stress we feel when we are supported by tests. The difference is dramatic
enough to keep us writing tests even when we don't feel like it.
You will be able to refactor much more aggressively once you have the
tests. You won't understand at first just how much you can do, though.
Try to catch yourself saying, "Oh, I see, I should have designed this thus
and so. I can't change it now. I don't want to break anything." When you
say this, save a copy of your current code and give yourself a couple of
hours to clean up. (This part works best you can get a buddy to look over
your shoulder while you work.) Make your changes, all the while running
your tests. You will be surprised at how much ground you can cover in a
couple of hours if you aren't worrying every second about what you might
be breaking.
For example, we switched from the Vector-based implementation of MoneyBag
to one based on HashTable. We were able to make the switch very quickly
and confidently because we had so many tests to rely on. If the tests all
worked, we were sure we hadn't changed the answers the system produced
at all.
You will want to get the rest of your team writing tests. The best way
we have found to spread the test infection is through direct contact. The
next time someone asks you for help debugging, get them to talk about the
problem in terms of a fixture and expected results. Then say, "I'd like
to write down what you just told me in a form we can use." Have them watch
while you write one little test. Run it. Fix it. Write another. Pretty
soon they will be writing their own.
So- give JUnit a try. If you make it better, please send us the changes
so we can spread them around. Our next article will double click on the
JUnit framework itself. We will show you how it is constructed, and talk
a little about our philosophy of framework development.
We would like to thank Martin Fowler, as good a programmer as any analyst
can ever hope to be, for his helpful comments in spite of being subjected
to early versions of JUnit.
References
Eclipse Public License - Version 1.0
Eclipse Public License - v 1.0
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial
code and documentation distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program
originate from and are distributed by that particular Contributor. A
Contribution 'originates' from a Contributor if it was added to the
Program by such Contributor itself or anyone acting on such
Contributor's behalf. Contributions do not include additions to the
Program which: (i) are separate modules of software distributed in
conjunction with the Program under their own license agreement, and (ii)
are not derivative works of the Program.
"Contributor" means any person or entity that distributes
the Program.
"Licensed Patents" mean patent claims licensable by a
Contributor which are necessarily infringed by the use or sale of its
Contribution alone or when combined with the Program.
"Program" means the Contributions distributed in accordance
with this Agreement.
"Recipient" means anyone who receives the Program under
this Agreement, including all Contributors.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each
Contributor hereby grants Recipient a non-exclusive, worldwide,
royalty-free copyright license to reproduce, prepare derivative works
of, publicly display, publicly perform, distribute and sublicense the
Contribution of such Contributor, if any, and such derivative works, in
source code and object code form.
b) Subject to the terms of this Agreement, each
Contributor hereby grants Recipient a non-exclusive, worldwide,
royalty-free patent license under Licensed Patents to make, use, sell,
offer to sell, import and otherwise transfer the Contribution of such
Contributor, if any, in source code and object code form. This patent
license shall apply to the combination of the Contribution and the
Program if, at the time the Contribution is added by the Contributor,
such addition of the Contribution causes such combination to be covered
by the Licensed Patents. The patent license shall not apply to any other
combinations which include the Contribution. No hardware per se is
licensed hereunder.
c) Recipient understands that although each Contributor
grants the licenses to its Contributions set forth herein, no assurances
are provided by any Contributor that the Program does not infringe the
patent or other intellectual property rights of any other entity. Each
Contributor disclaims any liability to Recipient for claims brought by
any other entity based on infringement of intellectual property rights
or otherwise. As a condition to exercising the rights and licenses
granted hereunder, each Recipient hereby assumes sole responsibility to
secure any other intellectual property rights needed, if any. For
example, if a third party patent license is required to allow Recipient
to distribute the Program, it is Recipient's responsibility to acquire
that license before distributing the Program.
d) Each Contributor represents that to its knowledge it
has sufficient copyright rights in its Contribution, if any, to grant
the copyright license set forth in this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the Program in object code
form under its own license agreement, provided that:
a) it complies with the terms and conditions of this
Agreement; and
b) its license agreement:
i) effectively disclaims on behalf of all Contributors
all warranties and conditions, express and implied, including warranties
or conditions of title and non-infringement, and implied warranties or
conditions of merchantability and fitness for a particular purpose;
ii) effectively excludes on behalf of all Contributors
all liability for damages, including direct, indirect, special,
incidental and consequential damages, such as lost profits;
iii) states that any provisions which differ from this
Agreement are offered by that Contributor alone and not by any other
party; and
iv) states that source code for the Program is available
from such Contributor, and informs licensees how to obtain it in a
reasonable manner on or through a medium customarily used for software
exchange.
When the Program is made available in source code form:
a) it must be made available under this Agreement; and
b) a copy of this Agreement must be included with each
copy of the Program.
Contributors may not remove or alter any copyright notices contained
within the Program.
Each Contributor must identify itself as the originator of its
Contribution, if any, in a manner that reasonably allows subsequent
Recipients to identify the originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain
responsibilities with respect to end users, business partners and the
like. While this license is intended to facilitate the commercial use of
the Program, the Contributor who includes the Program in a commercial
product offering should do so in a manner which does not create
potential liability for other Contributors. Therefore, if a Contributor
includes the Program in a commercial product offering, such Contributor
("Commercial Contributor") hereby agrees to defend and
indemnify every other Contributor ("Indemnified Contributor")
against any losses, damages and costs (collectively "Losses")
arising from claims, lawsuits and other legal actions brought by a third
party against the Indemnified Contributor to the extent caused by the
acts or omissions of such Commercial Contributor in connection with its
distribution of the Program in a commercial product offering. The
obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In
order to qualify, an Indemnified Contributor must: a) promptly notify
the Commercial Contributor in writing of such claim, and b) allow the
Commercial Contributor to control, and cooperate with the Commercial
Contributor in, the defense and any related settlement negotiations. The
Indemnified Contributor may participate in any such claim at its own
expense.
For example, a Contributor might include the Program in a commercial
product offering, Product X. That Contributor is then a Commercial
Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance
claims and warranties are such Commercial Contributor's responsibility
alone. Under this section, the Commercial Contributor would have to
defend claims against the other Contributors related to those
performance claims and warranties, and if a court requires any other
Contributor to pay any damages as a result, the Commercial Contributor
must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
responsible for determining the appropriateness of using and
distributing the Program and assumes all risks associated with its
exercise of rights under this Agreement , including but not limited to
the risks and costs of program errors, compliance with applicable laws,
damage to or loss of data, programs or equipment, and unavailability or
interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under
applicable law, it shall not affect the validity or enforceability of
the remainder of the terms of this Agreement, and without further action
by the parties hereto, such provision shall be reformed to the minimum
extent necessary to make such provision valid and enforceable.
If Recipient institutes patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the
Program itself (excluding combinations of the Program with other
software or hardware) infringes such Recipient's patent(s), then such
Recipient's rights granted under Section 2(b) shall terminate as of the
date such litigation is filed.
All Recipient's rights under this Agreement shall terminate if it
fails to comply with any of the material terms or conditions of this
Agreement and does not cure such failure in a reasonable period of time
after becoming aware of such noncompliance. If all Recipient's rights
under this Agreement terminate, Recipient agrees to cease use and
distribution of the Program as soon as reasonably practicable. However,
Recipient's obligations under this Agreement and any licenses granted by
Recipient relating to the Program shall continue and survive.
Everyone is permitted to copy and distribute copies of this
Agreement, but in order to avoid inconsistency the Agreement is
copyrighted and may only be modified in the following manner. The
Agreement Steward reserves the right to publish new versions (including
revisions) of this Agreement from time to time. No one other than the
Agreement Steward has the right to modify this Agreement. The Eclipse
Foundation is the initial Agreement Steward. The Eclipse Foundation may
assign the responsibility to serve as the Agreement Steward to a
suitable separate entity. Each new version of the Agreement will be
given a distinguishing version number. The Program (including
Contributions) may always be distributed subject to the version of the
Agreement under which it was received. In addition, after a new version
of the Agreement is published, Contributor may elect to distribute the
Program (including its Contributions) under the new version. Except as
expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
rights or licenses to the intellectual property of any Contributor under
this Agreement, whether expressly, by implication, estoppel or
otherwise. All rights in the Program not expressly granted under this
Agreement are reserved.
This Agreement is governed by the laws of the State of New York and
the intellectual property laws of the United States of America. No party
to this Agreement will bring a legal action under this Agreement more
than one year after the cause of action arose. Each party waives its
rights to a jury trial in any resulting litigation.
junit4-r4.13.2/pom.xml 0000664 0000000 0000000 00000064612 14011777271 0014535 0 ustar 00root root 0000000 0000000
4.0.0
junit
junit
4.13.2
JUnit
JUnit is a unit testing framework for Java, created by Erich Gamma and Kent Beck.
http://junit.org
2002
JUnit
http://www.junit.org
Eclipse Public License 1.0
http://www.eclipse.org/legal/epl-v10.html
repo
dsaff
David Saff
david@saff.net
kcooney
Kevin Cooney
kcooney@google.com
stefanbirkner
Stefan Birkner
mail@stefan-birkner.de
marcphilipp
Marc Philipp
mail@marcphilipp.de
JUnit contributors
JUnit
team@junit.org
https://github.com/junit-team/junit4/graphs/contributors
developers
3.0.4
scm:git:git://github.com/junit-team/junit4.git
scm:git:git@github.com:junit-team/junit4.git
https://github.com/junit-team/junit4
r4.13.2
github
https://github.com/junit-team/junit4/issues
github
https://github.com/junit-team/junit4/actions
https://github.com/junit-team/junit4/wiki/Download-and-Install
junit-snapshot-repo
Nexus Snapshot Repository
https://oss.sonatype.org/content/repositories/snapshots/
junit-releases-repo
Nexus Release Repository
https://oss.sonatype.org/service/local/staging/deploy/maven2/
junit.github.io
gitsite:git@github.com/junit-team/junit4.git
1.5
2.19.1
1.3
1.4
2.6
2.10.3
ISO-8859-1
67893CC4
org.hamcrest
hamcrest-core
${hamcrestVersion}
org.hamcrest
hamcrest-library
${hamcrestVersion}
test
${project.basedir}/src/main/resources
${project.basedir}
LICENSE-junit.txt
maven-enforcer-plugin
${enforcerPluginVersion}
enforce-versions
initialize
enforce
true
Current version of Maven ${maven.version} required to build the project
should be ${project.prerequisites.maven}, or higher!
[${project.prerequisites.maven},)
Current JDK version ${java.version} should be ${jdkVersion}, or higher!
${jdkVersion}
Best Practice is to never define repositories in pom.xml (use a repository
manager instead).
No Snapshots Dependencies Allowed!
com.google.code.maven-replacer-plugin
replacer
1.5.3
process-sources
replace
false
${project.build.sourceDirectory}/junit/runner/Version.java.template
${project.build.sourceDirectory}/junit/runner/Version.java
false
@version@
${project.version}
maven-compiler-plugin
3.3
${project.build.sourceEncoding}
${jdkVersion}
${jdkVersion}
${jdkVersion}
${jdkVersion}
1.5
true
true
true
true
-Xlint:unchecked
128m
org.codehaus.mojo
animal-sniffer-maven-plugin
1.14
signature-check
test
check
org.codehaus.mojo.signature
java15
1.0
maven-surefire-plugin
${surefireVersion}
org/junit/tests/AllTests.java
true
false
org.apache.maven.surefire
surefire-junit47
${surefireVersion}
maven-source-plugin
2.4
maven-javadoc-plugin
${javadocPluginVersion}
${basedir}/src/main/javadoc/stylesheet.css
protected
false
false
false
true
true
true
JUnit API
UTF-8
en
${jdkVersion}
api_${jdkVersion}
http://docs.oracle.com/javase/${jdkVersion}.0/docs/api/
*.internal.*
true
32m
128m
true
true
org.hamcrest:hamcrest-core:*
maven-release-plugin
2.5.2
forked-path
false
-Pgenerate-docs,junit-release ${arguments}
r@{project.version}
maven-site-plugin
3.4
com.github.stephenc.wagon
wagon-gitsite
0.4.1
org.apache.maven.doxia
doxia-module-markdown
1.5
maven-jar-plugin
${jarPluginVersion}
false
true
junit
maven-clean-plugin
2.6.1
maven-deploy-plugin
2.8.2
maven-install-plugin
2.5.2
maven-resources-plugin
2.7
maven-project-info-reports-plugin
2.8
false
index
dependency-info
modules
license
project-team
scm
issue-tracking
mailing-list
dependency-management
dependencies
dependency-convergence
cim
distribution-management
maven-javadoc-plugin
${javadocPluginVersion}
javadoc/latest
${basedir}/src/main/javadoc/stylesheet.css
protected
false
false
false
true
true
true
JUnit API
UTF-8
en
${jdkVersion}
api_${jdkVersion}
http://docs.oracle.com/javase/${jdkVersion}.0/docs/api/
junit.*,*.internal.*
true
32m
128m
true
true
org.hamcrest:hamcrest-core:*
javadoc
junit-release
maven-gpg-plugin
1.6
gpg-sign
verify
sign
generate-docs
maven-source-plugin
attach-sources
prepare-package
jar-no-fork
maven-javadoc-plugin
attach-javadoc
package
jar
restrict-doclint
[1.8,)
maven-compiler-plugin
-Xlint:unchecked
-Xdoclint:accessibility,reference,syntax
maven-javadoc-plugin
-Xdoclint:accessibility -Xdoclint:reference
maven-javadoc-plugin
-Xdoclint:accessibility -Xdoclint:reference
java9
[1.9,12)
1.6
maven-javadoc-plugin
1.6
maven-javadoc-plugin
1.6
java12
[12,)
1.7
3.0.0-M3
3.2.0
3.2.0
maven-javadoc-plugin
1.7
false
maven-compiler-plugin
-Xdoclint:none
maven-javadoc-plugin
1.7
false
junit4-r4.13.2/src/ 0000775 0000000 0000000 00000000000 14011777271 0013776 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/ 0000775 0000000 0000000 00000000000 14011777271 0014722 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/ 0000775 0000000 0000000 00000000000 14011777271 0015643 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/junit/ 0000775 0000000 0000000 00000000000 14011777271 0016774 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/junit/extensions/ 0000775 0000000 0000000 00000000000 14011777271 0021173 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/junit/extensions/ActiveTestSuite.java 0000664 0000000 0000000 00000003367 14011777271 0025134 0 ustar 00root root 0000000 0000000 package junit.extensions;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;
/**
* A TestSuite for active Tests. It runs each
* test in a separate thread and waits until all
* threads have terminated.
* -- Aarhus Radisson Scandinavian Center 11th floor
*/
public class ActiveTestSuite extends TestSuite {
private volatile int fActiveTestDeathCount;
public ActiveTestSuite() {
}
public ActiveTestSuite(Class theClass) {
super(theClass);
}
public ActiveTestSuite(String name) {
super(name);
}
public ActiveTestSuite(Class theClass, String name) {
super(theClass, name);
}
@Override
public void run(TestResult result) {
fActiveTestDeathCount = 0;
super.run(result);
waitUntilFinished();
}
@Override
public void runTest(final Test test, final TestResult result) {
Thread t = new Thread() {
@Override
public void run() {
try {
// inlined due to limitation in VA/Java
//ActiveTestSuite.super.runTest(test, result);
test.run(result);
} finally {
ActiveTestSuite.this.runFinished();
}
}
};
t.start();
}
synchronized void waitUntilFinished() {
while (fActiveTestDeathCount < testCount()) {
try {
wait();
} catch (InterruptedException e) {
return; // ignore
}
}
}
public synchronized void runFinished() {
fActiveTestDeathCount++;
notifyAll();
}
} junit4-r4.13.2/src/main/java/junit/extensions/RepeatedTest.java 0000664 0000000 0000000 00000001567 14011777271 0024440 0 ustar 00root root 0000000 0000000 package junit.extensions;
import junit.framework.Test;
import junit.framework.TestResult;
/**
* A Decorator that runs a test repeatedly.
*/
public class RepeatedTest extends TestDecorator {
private int fTimesRepeat;
public RepeatedTest(Test test, int repeat) {
super(test);
if (repeat < 0) {
throw new IllegalArgumentException("Repetition count must be >= 0");
}
fTimesRepeat = repeat;
}
@Override
public int countTestCases() {
return super.countTestCases() * fTimesRepeat;
}
@Override
public void run(TestResult result) {
for (int i = 0; i < fTimesRepeat; i++) {
if (result.shouldStop()) {
break;
}
super.run(result);
}
}
@Override
public String toString() {
return super.toString() + "(repeated)";
}
} junit4-r4.13.2/src/main/java/junit/extensions/TestDecorator.java 0000664 0000000 0000000 00000001650 14011777271 0024622 0 ustar 00root root 0000000 0000000 package junit.extensions;
import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestResult;
/**
* A Decorator for Tests. Use TestDecorator as the base class for defining new
* test decorators. Test decorator subclasses can be introduced to add behaviour
* before or after a test is run.
*/
@SuppressWarnings("deprecation")
public class TestDecorator extends Assert implements Test {
protected Test fTest;
public TestDecorator(Test test) {
fTest = test;
}
/**
* The basic run behaviour.
*/
public void basicRun(TestResult result) {
fTest.run(result);
}
public int countTestCases() {
return fTest.countTestCases();
}
public void run(TestResult result) {
basicRun(result);
}
@Override
public String toString() {
return fTest.toString();
}
public Test getTest() {
return fTest;
}
} junit4-r4.13.2/src/main/java/junit/extensions/TestSetup.java 0000664 0000000 0000000 00000002041 14011777271 0023773 0 ustar 00root root 0000000 0000000 package junit.extensions;
import junit.framework.Protectable;
import junit.framework.Test;
import junit.framework.TestResult;
/**
* A Decorator to set up and tear down additional fixture state. Subclass
* TestSetup and insert it into your tests when you want to set up additional
* state once before the tests are run.
*/
public class TestSetup extends TestDecorator {
public TestSetup(Test test) {
super(test);
}
@Override
public void run(final TestResult result) {
Protectable p = new Protectable() {
public void protect() throws Exception {
setUp();
basicRun(result);
tearDown();
}
};
result.runProtected(this, p);
}
/**
* Sets up the fixture. Override to set up additional fixture state.
*/
protected void setUp() throws Exception {
}
/**
* Tears down the fixture. Override to tear down the additional fixture
* state.
*/
protected void tearDown() throws Exception {
}
} junit4-r4.13.2/src/main/java/junit/extensions/package-info.java 0000664 0000000 0000000 00000000124 14011777271 0024357 0 ustar 00root root 0000000 0000000 /**
* Provides extended functionality for JUnit v3.x.
*/
package junit.extensions; junit4-r4.13.2/src/main/java/junit/framework/ 0000775 0000000 0000000 00000000000 14011777271 0020771 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/junit/framework/Assert.java 0000664 0000000 0000000 00000025110 14011777271 0023074 0 ustar 00root root 0000000 0000000 package junit.framework;
/**
* A set of assert methods. Messages are only displayed when an assert fails.
*
* @deprecated Please use {@link org.junit.Assert} instead.
*/
@Deprecated
public class Assert {
/**
* Protect constructor since it is a static only class
*/
protected Assert() {
}
/**
* Asserts that a condition is true. If it isn't it throws
* an AssertionFailedError with the given message.
*/
public static void assertTrue(String message, boolean condition) {
if (!condition) {
fail(message);
}
}
/**
* Asserts that a condition is true. If it isn't it throws
* an AssertionFailedError.
*/
public static void assertTrue(boolean condition) {
assertTrue(null, condition);
}
/**
* Asserts that a condition is false. If it isn't it throws
* an AssertionFailedError with the given message.
*/
public static void assertFalse(String message, boolean condition) {
assertTrue(message, !condition);
}
/**
* Asserts that a condition is false. If it isn't it throws
* an AssertionFailedError.
*/
public static void assertFalse(boolean condition) {
assertFalse(null, condition);
}
/**
* Fails a test with the given message.
*/
public static void fail(String message) {
if (message == null) {
throw new AssertionFailedError();
}
throw new AssertionFailedError(message);
}
/**
* Fails a test with no message.
*/
public static void fail() {
fail(null);
}
/**
* Asserts that two objects are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, Object expected, Object actual) {
if (expected == null && actual == null) {
return;
}
if (expected != null && expected.equals(actual)) {
return;
}
failNotEquals(message, expected, actual);
}
/**
* Asserts that two objects are equal. If they are not
* an AssertionFailedError is thrown.
*/
public static void assertEquals(Object expected, Object actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two Strings are equal.
*/
public static void assertEquals(String message, String expected, String actual) {
if (expected == null && actual == null) {
return;
}
if (expected != null && expected.equals(actual)) {
return;
}
String cleanMessage = message == null ? "" : message;
throw new ComparisonFailure(cleanMessage, expected, actual);
}
/**
* Asserts that two Strings are equal.
*/
public static void assertEquals(String expected, String actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two doubles are equal concerning a delta. If they are not
* an AssertionFailedError is thrown with the given message. If the expected
* value is infinity then the delta value is ignored.
*/
public static void assertEquals(String message, double expected, double actual, double delta) {
if (Double.compare(expected, actual) == 0) {
return;
}
if (!(Math.abs(expected - actual) <= delta)) {
failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual));
}
}
/**
* Asserts that two doubles are equal concerning a delta. If the expected
* value is infinity then the delta value is ignored.
*/
public static void assertEquals(double expected, double actual, double delta) {
assertEquals(null, expected, actual, delta);
}
/**
* Asserts that two floats are equal concerning a positive delta. If they
* are not an AssertionFailedError is thrown with the given message. If the
* expected value is infinity then the delta value is ignored.
*/
public static void assertEquals(String message, float expected, float actual, float delta) {
if (Float.compare(expected, actual) == 0) {
return;
}
if (!(Math.abs(expected - actual) <= delta)) {
failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
}
}
/**
* Asserts that two floats are equal concerning a delta. If the expected
* value is infinity then the delta value is ignored.
*/
public static void assertEquals(float expected, float actual, float delta) {
assertEquals(null, expected, actual, delta);
}
/**
* Asserts that two longs are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, long expected, long actual) {
assertEquals(message, Long.valueOf(expected), Long.valueOf(actual));
}
/**
* Asserts that two longs are equal.
*/
public static void assertEquals(long expected, long actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two booleans are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, boolean expected, boolean actual) {
assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));
}
/**
* Asserts that two booleans are equal.
*/
public static void assertEquals(boolean expected, boolean actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two bytes are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, byte expected, byte actual) {
assertEquals(message, Byte.valueOf(expected), Byte.valueOf(actual));
}
/**
* Asserts that two bytes are equal.
*/
public static void assertEquals(byte expected, byte actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two chars are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, char expected, char actual) {
assertEquals(message, Character.valueOf(expected), Character.valueOf(actual));
}
/**
* Asserts that two chars are equal.
*/
public static void assertEquals(char expected, char actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two shorts are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, short expected, short actual) {
assertEquals(message, Short.valueOf(expected), Short.valueOf(actual));
}
/**
* Asserts that two shorts are equal.
*/
public static void assertEquals(short expected, short actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two ints are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, int expected, int actual) {
assertEquals(message, Integer.valueOf(expected), Integer.valueOf(actual));
}
/**
* Asserts that two ints are equal.
*/
public static void assertEquals(int expected, int actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that an object isn't null.
*/
public static void assertNotNull(Object object) {
assertNotNull(null, object);
}
/**
* Asserts that an object isn't null. If it is
* an AssertionFailedError is thrown with the given message.
*/
public static void assertNotNull(String message, Object object) {
assertTrue(message, object != null);
}
/**
* Asserts that an object is null. If it isn't an {@link AssertionError} is
* thrown.
* Message contains: Expected: but was: object
*
* @param object Object to check or null
*/
public static void assertNull(Object object) {
if (object != null) {
assertNull("Expected: but was: " + object.toString(), object);
}
}
/**
* Asserts that an object is null. If it is not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertNull(String message, Object object) {
assertTrue(message, object == null);
}
/**
* Asserts that two objects refer to the same object. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertSame(String message, Object expected, Object actual) {
if (expected == actual) {
return;
}
failNotSame(message, expected, actual);
}
/**
* Asserts that two objects refer to the same object. If they are not
* the same an AssertionFailedError is thrown.
*/
public static void assertSame(Object expected, Object actual) {
assertSame(null, expected, actual);
}
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object an AssertionFailedError is thrown with the
* given message.
*/
public static void assertNotSame(String message, Object expected, Object actual) {
if (expected == actual) {
failSame(message);
}
}
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object an AssertionFailedError is thrown.
*/
public static void assertNotSame(Object expected, Object actual) {
assertNotSame(null, expected, actual);
}
public static void failSame(String message) {
String formatted = (message != null) ? message + " " : "";
fail(formatted + "expected not same");
}
public static void failNotSame(String message, Object expected, Object actual) {
String formatted = (message != null) ? message + " " : "";
fail(formatted + "expected same:<" + expected + "> was not:<" + actual + ">");
}
public static void failNotEquals(String message, Object expected, Object actual) {
fail(format(message, expected, actual));
}
public static String format(String message, Object expected, Object actual) {
String formatted = "";
if (message != null && message.length() > 0) {
formatted = message + " ";
}
return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
}
}
junit4-r4.13.2/src/main/java/junit/framework/AssertionFailedError.java 0000664 0000000 0000000 00000001464 14011777271 0025727 0 ustar 00root root 0000000 0000000 package junit.framework;
/**
* Thrown when an assertion failed.
*/
public class AssertionFailedError extends AssertionError {
private static final long serialVersionUID = 1L;
/**
* Constructs a new AssertionFailedError without a detail message.
*/
public AssertionFailedError() {
}
/**
* Constructs a new AssertionFailedError with the specified detail message.
* A null message is replaced by an empty String.
* @param message the detail message. The detail message is saved for later
* retrieval by the {@code Throwable.getMessage()} method.
*/
public AssertionFailedError(String message) {
super(defaultString(message));
}
private static String defaultString(String message) {
return message == null ? "" : message;
}
} junit4-r4.13.2/src/main/java/junit/framework/ComparisonCompactor.java 0000664 0000000 0000000 00000005161 14011777271 0025621 0 ustar 00root root 0000000 0000000 package junit.framework;
public class ComparisonCompactor {
private static final String ELLIPSIS = "...";
private static final String DELTA_END = "]";
private static final String DELTA_START = "[";
private int fContextLength;
private String fExpected;
private String fActual;
private int fPrefix;
private int fSuffix;
public ComparisonCompactor(int contextLength, String expected, String actual) {
fContextLength = contextLength;
fExpected = expected;
fActual = actual;
}
@SuppressWarnings("deprecation")
public String compact(String message) {
if (fExpected == null || fActual == null || areStringsEqual()) {
return Assert.format(message, fExpected, fActual);
}
findCommonPrefix();
findCommonSuffix();
String expected = compactString(fExpected);
String actual = compactString(fActual);
return Assert.format(message, expected, actual);
}
private String compactString(String source) {
String result = DELTA_START + source.substring(fPrefix, source.length() - fSuffix + 1) + DELTA_END;
if (fPrefix > 0) {
result = computeCommonPrefix() + result;
}
if (fSuffix > 0) {
result = result + computeCommonSuffix();
}
return result;
}
private void findCommonPrefix() {
fPrefix = 0;
int end = Math.min(fExpected.length(), fActual.length());
for (; fPrefix < end; fPrefix++) {
if (fExpected.charAt(fPrefix) != fActual.charAt(fPrefix)) {
break;
}
}
}
private void findCommonSuffix() {
int expectedSuffix = fExpected.length() - 1;
int actualSuffix = fActual.length() - 1;
for (; actualSuffix >= fPrefix && expectedSuffix >= fPrefix; actualSuffix--, expectedSuffix--) {
if (fExpected.charAt(expectedSuffix) != fActual.charAt(actualSuffix)) {
break;
}
}
fSuffix = fExpected.length() - expectedSuffix;
}
private String computeCommonPrefix() {
return (fPrefix > fContextLength ? ELLIPSIS : "") + fExpected.substring(Math.max(0, fPrefix - fContextLength), fPrefix);
}
private String computeCommonSuffix() {
int end = Math.min(fExpected.length() - fSuffix + 1 + fContextLength, fExpected.length());
return fExpected.substring(fExpected.length() - fSuffix + 1, end) + (fExpected.length() - fSuffix + 1 < fExpected.length() - fContextLength ? ELLIPSIS : "");
}
private boolean areStringsEqual() {
return fExpected.equals(fActual);
}
}
junit4-r4.13.2/src/main/java/junit/framework/ComparisonFailure.java 0000664 0000000 0000000 00000002630 14011777271 0025257 0 ustar 00root root 0000000 0000000 package junit.framework;
/**
* Thrown when an assert equals for Strings failed.
*
* Inspired by a patch from Alex Chaffee mailto:alex@purpletech.com
*/
public class ComparisonFailure extends AssertionFailedError {
private static final int MAX_CONTEXT_LENGTH = 20;
private static final long serialVersionUID = 1L;
private String fExpected;
private String fActual;
/**
* Constructs a comparison failure.
*
* @param message the identifying message or null
* @param expected the expected string value
* @param actual the actual string value
*/
public ComparisonFailure(String message, String expected, String actual) {
super(message);
fExpected = expected;
fActual = actual;
}
/**
* Returns "..." in place of common prefix and "..." in
* place of common suffix between expected and actual.
*
* @see Throwable#getMessage()
*/
@Override
public String getMessage() {
return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
}
/**
* Gets the actual string value
*
* @return the actual string value
*/
public String getActual() {
return fActual;
}
/**
* Gets the expected string value
*
* @return the expected string value
*/
public String getExpected() {
return fExpected;
}
} junit4-r4.13.2/src/main/java/junit/framework/JUnit4TestAdapter.java 0000664 0000000 0000000 00000005754 14011777271 0025125 0 ustar 00root root 0000000 0000000 package junit.framework;
import java.util.List;
import org.junit.Ignore;
import org.junit.runner.Describable;
import org.junit.runner.Description;
import org.junit.runner.Request;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Filter;
import org.junit.runner.manipulation.Filterable;
import org.junit.runner.manipulation.Orderer;
import org.junit.runner.manipulation.InvalidOrderingException;
import org.junit.runner.manipulation.NoTestsRemainException;
import org.junit.runner.manipulation.Orderable;
import org.junit.runner.manipulation.Sorter;
/**
* The JUnit4TestAdapter enables running JUnit-4-style tests using a JUnit-3-style test runner.
*
* To use it, add the following to a test class:
*
public static Test suite() {
return new JUnit4TestAdapter(YourJUnit4TestClass .class);
}
*/
public class JUnit4TestAdapter implements Test, Filterable, Orderable, Describable {
private final Class fNewTestClass;
private final Runner fRunner;
private final JUnit4TestAdapterCache fCache;
public JUnit4TestAdapter(Class newTestClass) {
this(newTestClass, JUnit4TestAdapterCache.getDefault());
}
public JUnit4TestAdapter(final Class newTestClass, JUnit4TestAdapterCache cache) {
fCache = cache;
fNewTestClass = newTestClass;
fRunner = Request.classWithoutSuiteMethod(newTestClass).getRunner();
}
public int countTestCases() {
return fRunner.testCount();
}
public void run(TestResult result) {
fRunner.run(fCache.getNotifier(result, this));
}
// reflective interface for Eclipse
public List getTests() {
return fCache.asTestList(getDescription());
}
// reflective interface for Eclipse
public Class getTestClass() {
return fNewTestClass;
}
public Description getDescription() {
Description description = fRunner.getDescription();
return removeIgnored(description);
}
private Description removeIgnored(Description description) {
if (isIgnored(description)) {
return Description.EMPTY;
}
Description result = description.childlessCopy();
for (Description each : description.getChildren()) {
Description child = removeIgnored(each);
if (!child.isEmpty()) {
result.addChild(child);
}
}
return result;
}
private boolean isIgnored(Description description) {
return description.getAnnotation(Ignore.class) != null;
}
@Override
public String toString() {
return fNewTestClass.getName();
}
public void filter(Filter filter) throws NoTestsRemainException {
filter.apply(fRunner);
}
public void sort(Sorter sorter) {
sorter.apply(fRunner);
}
/**
* {@inheritDoc}
*
* @since 4.13
*/
public void order(Orderer orderer) throws InvalidOrderingException {
orderer.apply(fRunner);
}
} junit4-r4.13.2/src/main/java/junit/framework/JUnit4TestAdapterCache.java 0000664 0000000 0000000 00000004734 14011777271 0026046 0 ustar 00root root 0000000 0000000 package junit.framework;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import org.junit.runner.Description;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
import org.junit.runner.notification.RunNotifier;
public class JUnit4TestAdapterCache extends HashMap {
private static final long serialVersionUID = 1L;
private static final JUnit4TestAdapterCache fInstance = new JUnit4TestAdapterCache();
public static JUnit4TestAdapterCache getDefault() {
return fInstance;
}
public Test asTest(Description description) {
if (description.isSuite()) {
return createTest(description);
} else {
if (!containsKey(description)) {
put(description, createTest(description));
}
return get(description);
}
}
Test createTest(Description description) {
if (description.isTest()) {
return new JUnit4TestCaseFacade(description);
} else {
TestSuite suite = new TestSuite(description.getDisplayName());
for (Description child : description.getChildren()) {
suite.addTest(asTest(child));
}
return suite;
}
}
public RunNotifier getNotifier(final TestResult result, final JUnit4TestAdapter adapter) {
RunNotifier notifier = new RunNotifier();
notifier.addListener(new RunListener() {
@Override
public void testFailure(Failure failure) throws Exception {
result.addError(asTest(failure.getDescription()), failure.getException());
}
@Override
public void testFinished(Description description) throws Exception {
result.endTest(asTest(description));
}
@Override
public void testStarted(Description description) throws Exception {
result.startTest(asTest(description));
}
});
return notifier;
}
public List asTestList(Description description) {
if (description.isTest()) {
return Arrays.asList(asTest(description));
} else {
List returnThis = new ArrayList();
for (Description child : description.getChildren()) {
returnThis.add(asTest(child));
}
return returnThis;
}
}
} junit4-r4.13.2/src/main/java/junit/framework/JUnit4TestCaseFacade.java 0000664 0000000 0000000 00000001273 14011777271 0025474 0 ustar 00root root 0000000 0000000 package junit.framework;
import org.junit.runner.Describable;
import org.junit.runner.Description;
public class JUnit4TestCaseFacade implements Test, Describable {
private final Description fDescription;
JUnit4TestCaseFacade(Description description) {
fDescription = description;
}
@Override
public String toString() {
return getDescription().toString();
}
public int countTestCases() {
return 1;
}
public void run(TestResult result) {
throw new RuntimeException(
"This test stub created only for informational purposes.");
}
public Description getDescription() {
return fDescription;
}
} junit4-r4.13.2/src/main/java/junit/framework/Protectable.java 0000664 0000000 0000000 00000000412 14011777271 0024075 0 ustar 00root root 0000000 0000000 package junit.framework;
/**
* A Protectable can be run and can throw a Throwable.
*
* @see TestResult
*/
public interface Protectable {
/**
* Run the following method protected.
*/
public abstract void protect() throws Throwable;
}
junit4-r4.13.2/src/main/java/junit/framework/Test.java 0000664 0000000 0000000 00000000617 14011777271 0022557 0 ustar 00root root 0000000 0000000 package junit.framework;
/**
* A Test can be run and collect its results.
*
* @see TestResult
*/
public interface Test {
/**
* Counts the number of test cases that will be run by this test.
*/
public abstract int countTestCases();
/**
* Runs a test and collects its result in a TestResult instance.
*/
public abstract void run(TestResult result);
} junit4-r4.13.2/src/main/java/junit/framework/TestCase.java 0000664 0000000 0000000 00000036016 14011777271 0023355 0 ustar 00root root 0000000 0000000 package junit.framework;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
* A test case defines the fixture to run multiple tests. To define a test case
* implement a subclass of TestCase
* define instance variables that store the state of the fixture
* initialize the fixture state by overriding {@link #setUp()}
* clean-up after a test by overriding {@link #tearDown()}.
*
* Each test runs in its own fixture so there
* can be no side effects among test runs.
* Here is an example:
*
* public class MathTest extends TestCase {
* protected double fValue1;
* protected double fValue2;
*
* protected void setUp() {
* fValue1= 2.0;
* fValue2= 3.0;
* }
* }
*
*
* For each test implement a method which interacts
* with the fixture. Verify the expected results with assertions specified
* by calling {@link junit.framework.Assert#assertTrue(String, boolean)} with a boolean.
*
* public void testAdd() {
* double result= fValue1 + fValue2;
* assertTrue(result == 5.0);
* }
*
*
* Once the methods are defined you can run them. The framework supports
* both a static type safe and more dynamic way to run a test.
* In the static way you override the runTest method and define the method to
* be invoked. A convenient way to do so is with an anonymous inner class.
*
* TestCase test= new MathTest("add") {
* public void runTest() {
* testAdd();
* }
* };
* test.run();
*
* The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds
* and invokes a method.
* In this case the name of the test case has to correspond to the test method
* to be run.
*
* TestCase test= new MathTest("testAdd");
* test.run();
*
*
* The tests to be run can be collected into a TestSuite. JUnit provides
* different test runners which can run a test suite and collect the results.
* A test runner either expects a static method suite as the entry
* point to get a test to run or it will extract the suite automatically.
*
* public static Test suite() {
* suite.addTest(new MathTest("testAdd"));
* suite.addTest(new MathTest("testDivideByZero"));
* return suite;
* }
*
*
* @see TestResult
* @see TestSuite
*/
@SuppressWarnings("deprecation")
public abstract class TestCase extends Assert implements Test {
/**
* the name of the test case
*/
private String fName;
/**
* No-arg constructor to enable serialization. This method
* is not intended to be used by mere mortals without calling setName().
*/
public TestCase() {
fName = null;
}
/**
* Constructs a test case with the given name.
*/
public TestCase(String name) {
fName = name;
}
/**
* Counts the number of test cases executed by run(TestResult result).
*/
public int countTestCases() {
return 1;
}
/**
* Creates a default TestResult object.
*
* @see TestResult
*/
protected TestResult createResult() {
return new TestResult();
}
/**
* A convenience method to run this test, collecting the results with a
* default TestResult object.
*
* @see TestResult
*/
public TestResult run() {
TestResult result = createResult();
run(result);
return result;
}
/**
* Runs the test case and collects the results in TestResult.
*/
public void run(TestResult result) {
result.run(this);
}
/**
* Runs the bare test sequence.
*
* @throws Throwable if any exception is thrown
*/
public void runBare() throws Throwable {
Throwable exception = null;
setUp();
try {
runTest();
} catch (Throwable running) {
exception = running;
} finally {
try {
tearDown();
} catch (Throwable tearingDown) {
if (exception == null) exception = tearingDown;
}
}
if (exception != null) throw exception;
}
/**
* Override to run the test and assert its state.
*
* @throws Throwable if any exception is thrown
*/
protected void runTest() throws Throwable {
assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
Method runMethod = null;
try {
// use getMethod to get all public inherited
// methods. getDeclaredMethods returns all
// methods of this class but excludes the
// inherited ones.
runMethod = getClass().getMethod(fName, (Class[]) null);
} catch (NoSuchMethodException e) {
fail("Method \"" + fName + "\" not found");
}
if (!Modifier.isPublic(runMethod.getModifiers())) {
fail("Method \"" + fName + "\" should be public");
}
try {
runMethod.invoke(this);
} catch (InvocationTargetException e) {
e.fillInStackTrace();
throw e.getTargetException();
} catch (IllegalAccessException e) {
e.fillInStackTrace();
throw e;
}
}
/**
* Asserts that a condition is true. If it isn't it throws
* an AssertionFailedError with the given message.
*/
public static void assertTrue(String message, boolean condition) {
Assert.assertTrue(message, condition);
}
/**
* Asserts that a condition is true. If it isn't it throws
* an AssertionFailedError.
*/
public static void assertTrue(boolean condition) {
Assert.assertTrue(condition);
}
/**
* Asserts that a condition is false. If it isn't it throws
* an AssertionFailedError with the given message.
*/
public static void assertFalse(String message, boolean condition) {
Assert.assertFalse(message, condition);
}
/**
* Asserts that a condition is false. If it isn't it throws
* an AssertionFailedError.
*/
public static void assertFalse(boolean condition) {
Assert.assertFalse(condition);
}
/**
* Fails a test with the given message.
*/
public static void fail(String message) {
Assert.fail(message);
}
/**
* Fails a test with no message.
*/
public static void fail() {
Assert.fail();
}
/**
* Asserts that two objects are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, Object expected, Object actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two objects are equal. If they are not
* an AssertionFailedError is thrown.
*/
public static void assertEquals(Object expected, Object actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two Strings are equal.
*/
public static void assertEquals(String message, String expected, String actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two Strings are equal.
*/
public static void assertEquals(String expected, String actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two doubles are equal concerning a delta. If they are not
* an AssertionFailedError is thrown with the given message. If the expected
* value is infinity then the delta value is ignored.
*/
public static void assertEquals(String message, double expected, double actual, double delta) {
Assert.assertEquals(message, expected, actual, delta);
}
/**
* Asserts that two doubles are equal concerning a delta. If the expected
* value is infinity then the delta value is ignored.
*/
public static void assertEquals(double expected, double actual, double delta) {
Assert.assertEquals(expected, actual, delta);
}
/**
* Asserts that two floats are equal concerning a positive delta. If they
* are not an AssertionFailedError is thrown with the given message. If the
* expected value is infinity then the delta value is ignored.
*/
public static void assertEquals(String message, float expected, float actual, float delta) {
Assert.assertEquals(message, expected, actual, delta);
}
/**
* Asserts that two floats are equal concerning a delta. If the expected
* value is infinity then the delta value is ignored.
*/
public static void assertEquals(float expected, float actual, float delta) {
Assert.assertEquals(expected, actual, delta);
}
/**
* Asserts that two longs are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, long expected, long actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two longs are equal.
*/
public static void assertEquals(long expected, long actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two booleans are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, boolean expected, boolean actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two booleans are equal.
*/
public static void assertEquals(boolean expected, boolean actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two bytes are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, byte expected, byte actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two bytes are equal.
*/
public static void assertEquals(byte expected, byte actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two chars are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, char expected, char actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two chars are equal.
*/
public static void assertEquals(char expected, char actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two shorts are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, short expected, short actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two shorts are equal.
*/
public static void assertEquals(short expected, short actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that two ints are equal. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertEquals(String message, int expected, int actual) {
Assert.assertEquals(message, expected, actual);
}
/**
* Asserts that two ints are equal.
*/
public static void assertEquals(int expected, int actual) {
Assert.assertEquals(expected, actual);
}
/**
* Asserts that an object isn't null.
*/
public static void assertNotNull(Object object) {
Assert.assertNotNull(object);
}
/**
* Asserts that an object isn't null. If it is
* an AssertionFailedError is thrown with the given message.
*/
public static void assertNotNull(String message, Object object) {
Assert.assertNotNull(message, object);
}
/**
* Asserts that an object is null. If it isn't an {@link AssertionError} is
* thrown.
* Message contains: Expected: but was: object
*
* @param object Object to check or null
*/
public static void assertNull(Object object) {
Assert.assertNull(object);
}
/**
* Asserts that an object is null. If it is not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertNull(String message, Object object) {
Assert.assertNull(message, object);
}
/**
* Asserts that two objects refer to the same object. If they are not
* an AssertionFailedError is thrown with the given message.
*/
public static void assertSame(String message, Object expected, Object actual) {
Assert.assertSame(message, expected, actual);
}
/**
* Asserts that two objects refer to the same object. If they are not
* the same an AssertionFailedError is thrown.
*/
public static void assertSame(Object expected, Object actual) {
Assert.assertSame(expected, actual);
}
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object an AssertionFailedError is thrown with the
* given message.
*/
public static void assertNotSame(String message, Object expected, Object actual) {
Assert.assertNotSame(message, expected, actual);
}
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object an AssertionFailedError is thrown.
*/
public static void assertNotSame(Object expected, Object actual) {
Assert.assertNotSame(expected, actual);
}
public static void failSame(String message) {
Assert.failSame(message);
}
public static void failNotSame(String message, Object expected, Object actual) {
Assert.failNotSame(message, expected, actual);
}
public static void failNotEquals(String message, Object expected, Object actual) {
Assert.failNotEquals(message, expected, actual);
}
public static String format(String message, Object expected, Object actual) {
return Assert.format(message, expected, actual);
}
/**
* Sets up the fixture, for example, open a network connection.
* This method is called before a test is executed.
*/
protected void setUp() throws Exception {
}
/**
* Tears down the fixture, for example, close a network connection.
* This method is called after a test is executed.
*/
protected void tearDown() throws Exception {
}
/**
* Returns a string representation of the test case.
*/
@Override
public String toString() {
return getName() + "(" + getClass().getName() + ")";
}
/**
* Gets the name of a TestCase.
*
* @return the name of the TestCase
*/
public String getName() {
return fName;
}
/**
* Sets the name of a TestCase.
*
* @param name the name to set
*/
public void setName(String name) {
fName = name;
}
}
junit4-r4.13.2/src/main/java/junit/framework/TestFailure.java 0000664 0000000 0000000 00000003135 14011777271 0024065 0 ustar 00root root 0000000 0000000 package junit.framework;
import org.junit.internal.Throwables;
/**
* A {@code TestFailure} collects a failed test together with
* the caught exception.
*
* @see TestResult
*/
public class TestFailure {
protected Test fFailedTest;
protected Throwable fThrownException;
/**
* Constructs a TestFailure with the given test and exception.
*/
public TestFailure(Test failedTest, Throwable thrownException) {
fFailedTest = failedTest;
fThrownException = thrownException;
}
/**
* Gets the failed test.
*/
public Test failedTest() {
return fFailedTest;
}
/**
* Gets the thrown exception.
*/
public Throwable thrownException() {
return fThrownException;
}
/**
* Returns a short description of the failure.
*/
@Override
public String toString() {
return fFailedTest + ": " + fThrownException.getMessage();
}
/**
* Returns a String containing the stack trace of the error
* thrown by TestFailure.
*/
public String trace() {
return Throwables.getStacktrace(thrownException());
}
/**
* Returns a String containing the message from the thrown exception.
*/
public String exceptionMessage() {
return thrownException().getMessage();
}
/**
* Returns {@code true} if the error is considered a failure
* (i.e. if it is an instance of {@code AssertionFailedError}),
* {@code false} otherwise.
*/
public boolean isFailure() {
return thrownException() instanceof AssertionFailedError;
}
} junit4-r4.13.2/src/main/java/junit/framework/TestListener.java 0000664 0000000 0000000 00000000702 14011777271 0024260 0 ustar 00root root 0000000 0000000 package junit.framework;
/**
* A Listener for test progress
*/
public interface TestListener {
/**
* An error occurred.
*/
public void addError(Test test, Throwable e);
/**
* A failure occurred.
*/
public void addFailure(Test test, AssertionFailedError e);
/**
* A test ended.
*/
public void endTest(Test test);
/**
* A test started.
*/
public void startTest(Test test);
} junit4-r4.13.2/src/main/java/junit/framework/TestResult.java 0000664 0000000 0000000 00000011141 14011777271 0023750 0 ustar 00root root 0000000 0000000 package junit.framework;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
/**
* A TestResult collects the results of executing
* a test case. It is an instance of the Collecting Parameter pattern.
* The test framework distinguishes between failures and errors .
* A failure is anticipated and checked for with assertions. Errors are
* unanticipated problems like an {@link ArrayIndexOutOfBoundsException}.
*
* @see Test
*/
public class TestResult {
protected List fFailures;
protected List fErrors;
protected List fListeners;
protected int fRunTests;
private boolean fStop;
public TestResult() {
fFailures = new ArrayList();
fErrors = new ArrayList();
fListeners = new ArrayList();
fRunTests = 0;
fStop = false;
}
/**
* Adds an error to the list of errors. The passed in exception
* caused the error.
*/
public synchronized void addError(Test test, Throwable e) {
fErrors.add(new TestFailure(test, e));
for (TestListener each : cloneListeners()) {
each.addError(test, e);
}
}
/**
* Adds a failure to the list of failures. The passed in exception
* caused the failure.
*/
public synchronized void addFailure(Test test, AssertionFailedError e) {
fFailures.add(new TestFailure(test, e));
for (TestListener each : cloneListeners()) {
each.addFailure(test, e);
}
}
/**
* Registers a TestListener.
*/
public synchronized void addListener(TestListener listener) {
fListeners.add(listener);
}
/**
* Unregisters a TestListener.
*/
public synchronized void removeListener(TestListener listener) {
fListeners.remove(listener);
}
/**
* Returns a copy of the listeners.
*/
private synchronized List cloneListeners() {
List result = new ArrayList();
result.addAll(fListeners);
return result;
}
/**
* Informs the result that a test was completed.
*/
public void endTest(Test test) {
for (TestListener each : cloneListeners()) {
each.endTest(test);
}
}
/**
* Gets the number of detected errors.
*/
public synchronized int errorCount() {
return fErrors.size();
}
/**
* Returns an Enumeration for the errors.
*/
public synchronized Enumeration errors() {
return Collections.enumeration(fErrors);
}
/**
* Gets the number of detected failures.
*/
public synchronized int failureCount() {
return fFailures.size();
}
/**
* Returns an Enumeration for the failures.
*/
public synchronized Enumeration failures() {
return Collections.enumeration(fFailures);
}
/**
* Runs a TestCase.
*/
protected void run(final TestCase test) {
startTest(test);
Protectable p = new Protectable() {
public void protect() throws Throwable {
test.runBare();
}
};
runProtected(test, p);
endTest(test);
}
/**
* Gets the number of run tests.
*/
public synchronized int runCount() {
return fRunTests;
}
/**
* Runs a TestCase.
*/
public void runProtected(final Test test, Protectable p) {
try {
p.protect();
} catch (AssertionFailedError e) {
addFailure(test, e);
} catch (ThreadDeath e) { // don't catch ThreadDeath by accident
throw e;
} catch (Throwable e) {
addError(test, e);
}
}
/**
* Checks whether the test run should stop.
*/
public synchronized boolean shouldStop() {
return fStop;
}
/**
* Informs the result that a test will be started.
*/
public void startTest(Test test) {
final int count = test.countTestCases();
synchronized (this) {
fRunTests += count;
}
for (TestListener each : cloneListeners()) {
each.startTest(test);
}
}
/**
* Marks that the test run should stop.
*/
public synchronized void stop() {
fStop = true;
}
/**
* Returns whether the entire test was successful or not.
*/
public synchronized boolean wasSuccessful() {
return failureCount() == 0 && errorCount() == 0;
}
}
junit4-r4.13.2/src/main/java/junit/framework/TestSuite.java 0000664 0000000 0000000 00000021465 14011777271 0023575 0 ustar 00root root 0000000 0000000 package junit.framework;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import org.junit.internal.MethodSorter;
import org.junit.internal.Throwables;
/**
* A TestSuite is a Composite of Tests.
* It runs a collection of test cases. Here is an example using
* the dynamic test definition.
*
* TestSuite suite= new TestSuite();
* suite.addTest(new MathTest("testAdd"));
* suite.addTest(new MathTest("testDivideByZero"));
*
*
* Alternatively, a TestSuite can extract the tests to be run automatically.
* To do so you pass the class of your TestCase class to the
* TestSuite constructor.
*
* TestSuite suite= new TestSuite(MathTest.class);
*
*
* This constructor creates a suite with all the methods
* starting with "test" that take no arguments.
*
* A final option is to do the same for a large array of test classes.
*
* Class[] testClasses = { MathTest.class, AnotherTest.class };
* TestSuite suite= new TestSuite(testClasses);
*
*
* @see Test
*/
public class TestSuite implements Test {
/**
* ...as the moon sets over the early morning Merlin, Oregon
* mountains, our intrepid adventurers type...
*/
static public Test createTest(Class theClass, String name) {
Constructor constructor;
try {
constructor = getTestConstructor(theClass);
} catch (NoSuchMethodException e) {
return warning("Class " + theClass.getName() + " has no public constructor TestCase(String name) or TestCase()");
}
Object test;
try {
if (constructor.getParameterTypes().length == 0) {
test = constructor.newInstance(new Object[0]);
if (test instanceof TestCase) {
((TestCase) test).setName(name);
}
} else {
test = constructor.newInstance(new Object[]{name});
}
} catch (InstantiationException e) {
return (warning("Cannot instantiate test case: " + name + " (" + Throwables.getStacktrace(e) + ")"));
} catch (InvocationTargetException e) {
return (warning("Exception in constructor: " + name + " (" + Throwables.getStacktrace(e.getTargetException()) + ")"));
} catch (IllegalAccessException e) {
return (warning("Cannot access test case: " + name + " (" + Throwables.getStacktrace(e) + ")"));
}
return (Test) test;
}
/**
* Gets a constructor which takes a single String as
* its argument or a no arg constructor.
*/
public static Constructor getTestConstructor(Class theClass) throws NoSuchMethodException {
try {
return theClass.getConstructor(String.class);
} catch (NoSuchMethodException e) {
// fall through
}
return theClass.getConstructor();
}
/**
* Returns a test which will fail and log a warning message.
*/
public static Test warning(final String message) {
return new TestCase("warning") {
@Override
protected void runTest() {
fail(message);
}
};
}
private String fName;
private Vector fTests = new Vector(10); // Cannot convert this to List because it is used directly by some test runners
/**
* Constructs an empty TestSuite.
*/
public TestSuite() {
}
/**
* Constructs a TestSuite from the given class. Adds all the methods
* starting with "test" as test cases to the suite.
* Parts of this method were written at 2337 meters in the Hueffihuette,
* Kanton Uri
*/
public TestSuite(final Class theClass) {
addTestsFromTestCase(theClass);
}
private void addTestsFromTestCase(final Class theClass) {
fName = theClass.getName();
try {
getTestConstructor(theClass); // Avoid generating multiple error messages
} catch (NoSuchMethodException e) {
addTest(warning("Class " + theClass.getName() + " has no public constructor TestCase(String name) or TestCase()"));
return;
}
if (!Modifier.isPublic(theClass.getModifiers())) {
addTest(warning("Class " + theClass.getName() + " is not public"));
return;
}
Class superClass = theClass;
List names = new ArrayList();
while (Test.class.isAssignableFrom(superClass)) {
for (Method each : MethodSorter.getDeclaredMethods(superClass)) {
addTestMethod(each, names, theClass);
}
superClass = superClass.getSuperclass();
}
if (fTests.size() == 0) {
addTest(warning("No tests found in " + theClass.getName()));
}
}
/**
* Constructs a TestSuite from the given class with the given name.
*
* @see TestSuite#TestSuite(Class)
*/
public TestSuite(Class theClass, String name) {
this(theClass);
setName(name);
}
/**
* Constructs an empty TestSuite.
*/
public TestSuite(String name) {
setName(name);
}
/**
* Constructs a TestSuite from the given array of classes.
*
* @param classes {@link TestCase}s
*/
public TestSuite(Class... classes) {
for (Class each : classes) {
addTest(testCaseForClass(each));
}
}
private Test testCaseForClass(Class each) {
if (TestCase.class.isAssignableFrom(each)) {
return new TestSuite(each.asSubclass(TestCase.class));
} else {
return warning(each.getCanonicalName() + " does not extend TestCase");
}
}
/**
* Constructs a TestSuite from the given array of classes with the given name.
*
* @see TestSuite#TestSuite(Class[])
*/
public TestSuite(Class[] classes, String name) {
this(classes);
setName(name);
}
/**
* Adds a test to the suite.
*/
public void addTest(Test test) {
fTests.add(test);
}
/**
* Adds the tests from the given class to the suite.
*/
public void addTestSuite(Class testClass) {
addTest(new TestSuite(testClass));
}
/**
* Counts the number of test cases that will be run by this test.
*/
public int countTestCases() {
int count = 0;
for (Test each : fTests) {
count += each.countTestCases();
}
return count;
}
/**
* Returns the name of the suite. Not all
* test suites have a name and this method
* can return null.
*/
public String getName() {
return fName;
}
/**
* Runs the tests and collects their result in a TestResult.
*/
public void run(TestResult result) {
for (Test each : fTests) {
if (result.shouldStop()) {
break;
}
runTest(each, result);
}
}
public void runTest(Test test, TestResult result) {
test.run(result);
}
/**
* Sets the name of the suite.
*
* @param name the name to set
*/
public void setName(String name) {
fName = name;
}
/**
* Returns the test at the given index.
*/
public Test testAt(int index) {
return fTests.get(index);
}
/**
* Returns the number of tests in this suite.
*/
public int testCount() {
return fTests.size();
}
/**
* Returns the tests as an enumeration.
*/
public Enumeration tests() {
return fTests.elements();
}
/**
*/
@Override
public String toString() {
if (getName() != null) {
return getName();
}
return super.toString();
}
private void addTestMethod(Method m, List names, Class theClass) {
String name = m.getName();
if (names.contains(name)) {
return;
}
if (!isPublicTestMethod(m)) {
if (isTestMethod(m)) {
addTest(warning("Test method isn't public: " + m.getName() + "(" + theClass.getCanonicalName() + ")"));
}
return;
}
names.add(name);
addTest(createTest(theClass, name));
}
private boolean isPublicTestMethod(Method m) {
return isTestMethod(m) && Modifier.isPublic(m.getModifiers());
}
private boolean isTestMethod(Method m) {
return m.getParameterTypes().length == 0 &&
m.getName().startsWith("test") &&
m.getReturnType().equals(Void.TYPE);
}
}
junit4-r4.13.2/src/main/java/junit/framework/package-info.java 0000664 0000000 0000000 00000000105 14011777271 0024154 0 ustar 00root root 0000000 0000000 /**
* Provides JUnit v3.x core classes.
*/
package junit.framework; junit4-r4.13.2/src/main/java/junit/runner/ 0000775 0000000 0000000 00000000000 14011777271 0020305 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/junit/runner/BaseTestRunner.java 0000664 0000000 0000000 00000023044 14011777271 0024057 0 ustar 00root root 0000000 0000000 package junit.runner;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.text.NumberFormat;
import java.util.Properties;
import junit.framework.AssertionFailedError;
import junit.framework.Test;
import junit.framework.TestListener;
import junit.framework.TestSuite;
import org.junit.internal.Throwables;
/**
* Base class for all test runners.
* This class was born live on stage in Sardinia during XP2000.
*/
public abstract class BaseTestRunner implements TestListener {
public static final String SUITE_METHODNAME = "suite";
private static Properties fPreferences;
static int fgMaxMessageLength = 500;
static boolean fgFilterStack = true;
boolean fLoading = true;
/*
* Implementation of TestListener
*/
public synchronized void startTest(Test test) {
testStarted(test.toString());
}
protected static void setPreferences(Properties preferences) {
fPreferences = preferences;
}
protected static Properties getPreferences() {
if (fPreferences == null) {
fPreferences = new Properties();
fPreferences.put("loading", "true");
fPreferences.put("filterstack", "true");
readPreferences();
}
return fPreferences;
}
public static void savePreferences() throws IOException {
FileOutputStream fos = new FileOutputStream(getPreferencesFile());
try {
getPreferences().store(fos, "");
} finally {
fos.close();
}
}
public static void setPreference(String key, String value) {
getPreferences().put(key, value);
}
public synchronized void endTest(Test test) {
testEnded(test.toString());
}
public synchronized void addError(final Test test, final Throwable e) {
testFailed(TestRunListener.STATUS_ERROR, test, e);
}
public synchronized void addFailure(final Test test, final AssertionFailedError e) {
testFailed(TestRunListener.STATUS_FAILURE, test, e);
}
// TestRunListener implementation
public abstract void testStarted(String testName);
public abstract void testEnded(String testName);
public abstract void testFailed(int status, Test test, Throwable e);
/**
* Returns the Test corresponding to the given suite. This is
* a template method, subclasses override runFailed(), clearStatus().
*/
public Test getTest(String suiteClassName) {
if (suiteClassName.length() <= 0) {
clearStatus();
return null;
}
Class testClass = null;
try {
testClass = loadSuiteClass(suiteClassName);
} catch (ClassNotFoundException e) {
String clazz = e.getMessage();
if (clazz == null) {
clazz = suiteClassName;
}
runFailed("Class not found \"" + clazz + "\"");
return null;
} catch (Exception e) {
runFailed("Error: " + e.toString());
return null;
}
Method suiteMethod = null;
try {
suiteMethod = testClass.getMethod(SUITE_METHODNAME);
} catch (Exception e) {
// try to extract a test suite automatically
clearStatus();
return new TestSuite(testClass);
}
if (!Modifier.isStatic(suiteMethod.getModifiers())) {
runFailed("Suite() method must be static");
return null;
}
Test test = null;
try {
test = (Test) suiteMethod.invoke(null); // static method
if (test == null) {
return test;
}
} catch (InvocationTargetException e) {
runFailed("Failed to invoke suite():" + e.getTargetException().toString());
return null;
} catch (IllegalAccessException e) {
runFailed("Failed to invoke suite():" + e.toString());
return null;
}
clearStatus();
return test;
}
/**
* Returns the formatted string of the elapsed time.
*/
public String elapsedTimeAsString(long runTime) {
return NumberFormat.getInstance().format((double) runTime / 1000);
}
/**
* Processes the command line arguments and
* returns the name of the suite class to run or null
*/
protected String processArguments(String[] args) {
String suiteName = null;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-noloading")) {
setLoading(false);
} else if (args[i].equals("-nofilterstack")) {
fgFilterStack = false;
} else if (args[i].equals("-c")) {
if (args.length > i + 1) {
suiteName = extractClassName(args[i + 1]);
} else {
System.out.println("Missing Test class name");
}
i++;
} else {
suiteName = args[i];
}
}
return suiteName;
}
/**
* Sets the loading behaviour of the test runner
*/
public void setLoading(boolean enable) {
fLoading = enable;
}
/**
* Extract the class name from a String in VA/Java style
*/
public String extractClassName(String className) {
if (className.startsWith("Default package for")) {
return className.substring(className.lastIndexOf(".") + 1);
}
return className;
}
/**
* Truncates a String to the maximum length.
*/
public static String truncate(String s) {
if (fgMaxMessageLength != -1 && s.length() > fgMaxMessageLength) {
s = s.substring(0, fgMaxMessageLength) + "...";
}
return s;
}
/**
* Override to define how to handle a failed loading of
* a test suite.
*/
protected abstract void runFailed(String message);
/**
* Returns the loaded Class for a suite name.
*/
protected Class loadSuiteClass(String suiteClassName) throws ClassNotFoundException {
return Class.forName(suiteClassName);
}
/**
* Clears the status message.
*/
protected void clearStatus() { // Belongs in the GUI TestRunner class
}
protected boolean useReloadingTestSuiteLoader() {
return getPreference("loading").equals("true") && fLoading;
}
private static File getPreferencesFile() {
String home = System.getProperty("user.home");
return new File(home, "junit.properties");
}
private static void readPreferences() {
InputStream is = null;
try {
is = new FileInputStream(getPreferencesFile());
setPreferences(new Properties(getPreferences()));
getPreferences().load(is);
} catch (IOException ignored) {
} catch (SecurityException ignored) {
} finally {
try {
if (is != null) {
is.close();
}
} catch (IOException e1) {
}
}
}
public static String getPreference(String key) {
return getPreferences().getProperty(key);
}
public static int getPreference(String key, int dflt) {
String value = getPreference(key);
int intValue = dflt;
if (value == null) {
return intValue;
}
try {
intValue = Integer.parseInt(value);
} catch (NumberFormatException ne) {
}
return intValue;
}
/**
* Returns a filtered stack trace
*/
public static String getFilteredTrace(Throwable e) {
return BaseTestRunner.getFilteredTrace(Throwables.getStacktrace(e));
}
/**
* Filters stack frames from internal JUnit classes
*/
public static String getFilteredTrace(String stack) {
if (showStackRaw()) {
return stack;
}
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
StringReader sr = new StringReader(stack);
BufferedReader br = new BufferedReader(sr);
String line;
try {
while ((line = br.readLine()) != null) {
if (!filterLine(line)) {
pw.println(line);
}
}
} catch (Exception IOException) {
return stack; // return the stack unfiltered
}
return sw.toString();
}
protected static boolean showStackRaw() {
return !getPreference("filterstack").equals("true") || fgFilterStack == false;
}
static boolean filterLine(String line) {
String[] patterns = new String[]{
"junit.framework.TestCase",
"junit.framework.TestResult",
"junit.framework.TestSuite",
"junit.framework.Assert.", // don't filter AssertionFailure
"junit.swingui.TestRunner",
"junit.awtui.TestRunner",
"junit.textui.TestRunner",
"java.lang.reflect.Method.invoke("
};
for (int i = 0; i < patterns.length; i++) {
if (line.indexOf(patterns[i]) > 0) {
return true;
}
}
return false;
}
static {
fgMaxMessageLength = getPreference("maxmessage", fgMaxMessageLength);
}
}
junit4-r4.13.2/src/main/java/junit/runner/TestRunListener.java 0000664 0000000 0000000 00000001171 14011777271 0024262 0 ustar 00root root 0000000 0000000 package junit.runner;
/**
* A listener interface for observing the
* execution of a test run. Unlike TestListener,
* this interface using only primitive objects,
* making it suitable for remote test execution.
*/
public interface TestRunListener {
/* test status constants*/
int STATUS_ERROR = 1;
int STATUS_FAILURE = 2;
void testRunStarted(String testSuiteName, int testCount);
void testRunEnded(long elapsedTime);
void testRunStopped(long elapsedTime);
void testStarted(String testName);
void testEnded(String testName);
void testFailed(int status, String testName, String trace);
}
junit4-r4.13.2/src/main/java/junit/runner/Version.java 0000664 0000000 0000000 00000000442 14011777271 0022575 0 ustar 00root root 0000000 0000000 package junit.runner;
/**
* This class defines the current version of JUnit
*/
public class Version {
private Version() {
// don't instantiate
}
public static String id() {
return "4.13.2-SNAPSHOT";
}
public static void main(String[] args) {
System.out.println(id());
}
}
junit4-r4.13.2/src/main/java/junit/runner/Version.java.template 0000664 0000000 0000000 00000000434 14011777271 0024410 0 ustar 00root root 0000000 0000000 package junit.runner;
/**
* This class defines the current version of JUnit
*/
public class Version {
private Version() {
// don't instantiate
}
public static String id() {
return "@version@";
}
public static void main(String[] args) {
System.out.println(id());
}
}
junit4-r4.13.2/src/main/java/junit/runner/package-info.java 0000664 0000000 0000000 00000000102 14011777271 0023465 0 ustar 00root root 0000000 0000000 /**
* Provides JUnit v3.x test runners.
*/
package junit.runner; junit4-r4.13.2/src/main/java/junit/textui/ 0000775 0000000 0000000 00000000000 14011777271 0020316 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/junit/textui/ResultPrinter.java 0000664 0000000 0000000 00000007741 14011777271 0024014 0 ustar 00root root 0000000 0000000 package junit.textui;
import java.io.PrintStream;
import java.text.NumberFormat;
import java.util.Enumeration;
import junit.framework.AssertionFailedError;
import junit.framework.Test;
import junit.framework.TestFailure;
import junit.framework.TestListener;
import junit.framework.TestResult;
import junit.runner.BaseTestRunner;
public class ResultPrinter implements TestListener {
PrintStream fWriter;
int fColumn = 0;
public ResultPrinter(PrintStream writer) {
fWriter = writer;
}
/* API for use by textui.TestRunner */
synchronized void print(TestResult result, long runTime) {
printHeader(runTime);
printErrors(result);
printFailures(result);
printFooter(result);
}
void printWaitPrompt() {
getWriter().println();
getWriter().println(" to continue");
}
/* Internal methods */
protected void printHeader(long runTime) {
getWriter().println();
getWriter().println("Time: " + elapsedTimeAsString(runTime));
}
protected void printErrors(TestResult result) {
printDefects(result.errors(), result.errorCount(), "error");
}
protected void printFailures(TestResult result) {
printDefects(result.failures(), result.failureCount(), "failure");
}
protected void printDefects(Enumeration booBoos, int count, String type) {
if (count == 0) return;
if (count == 1) {
getWriter().println("There was " + count + " " + type + ":");
} else {
getWriter().println("There were " + count + " " + type + "s:");
}
for (int i = 1; booBoos.hasMoreElements(); i++) {
printDefect(booBoos.nextElement(), i);
}
}
public void printDefect(TestFailure booBoo, int count) { // only public for testing purposes
printDefectHeader(booBoo, count);
printDefectTrace(booBoo);
}
protected void printDefectHeader(TestFailure booBoo, int count) {
// I feel like making this a println, then adding a line giving the throwable a chance to print something
// before we get to the stack trace.
getWriter().print(count + ") " + booBoo.failedTest());
}
protected void printDefectTrace(TestFailure booBoo) {
getWriter().print(BaseTestRunner.getFilteredTrace(booBoo.trace()));
}
protected void printFooter(TestResult result) {
if (result.wasSuccessful()) {
getWriter().println();
getWriter().print("OK");
getWriter().println(" (" + result.runCount() + " test" + (result.runCount() == 1 ? "" : "s") + ")");
} else {
getWriter().println();
getWriter().println("FAILURES!!!");
getWriter().println("Tests run: " + result.runCount() +
", Failures: " + result.failureCount() +
", Errors: " + result.errorCount());
}
getWriter().println();
}
/**
* Returns the formatted string of the elapsed time.
* Duplicated from BaseTestRunner. Fix it.
*/
protected String elapsedTimeAsString(long runTime) {
return NumberFormat.getInstance().format((double) runTime / 1000);
}
public PrintStream getWriter() {
return fWriter;
}
/**
* @see junit.framework.TestListener#addError(Test, Throwable)
*/
public void addError(Test test, Throwable e) {
getWriter().print("E");
}
/**
* @see junit.framework.TestListener#addFailure(Test, AssertionFailedError)
*/
public void addFailure(Test test, AssertionFailedError t) {
getWriter().print("F");
}
/**
* @see junit.framework.TestListener#endTest(Test)
*/
public void endTest(Test test) {
}
/**
* @see junit.framework.TestListener#startTest(Test)
*/
public void startTest(Test test) {
getWriter().print(".");
if (fColumn++ >= 40) {
getWriter().println();
fColumn = 0;
}
}
}
junit4-r4.13.2/src/main/java/junit/textui/TestRunner.java 0000664 0000000 0000000 00000013360 14011777271 0023275 0 ustar 00root root 0000000 0000000 package junit.textui;
import java.io.PrintStream;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;
import junit.runner.BaseTestRunner;
import junit.runner.Version;
/**
* A command line based tool to run tests.
*
* java junit.textui.TestRunner [-wait] TestCaseClass
*
*
* TestRunner expects the name of a TestCase class as argument.
* If this class defines a static suite method it
* will be invoked and the returned test is run. Otherwise all
* the methods starting with "test" having no arguments are run.
*
* When the wait command line argument is given TestRunner
* waits until the users types RETURN.
*
* TestRunner prints a trace as the tests are executed followed by a
* summary at the end.
*/
public class TestRunner extends BaseTestRunner {
private ResultPrinter fPrinter;
public static final int SUCCESS_EXIT = 0;
public static final int FAILURE_EXIT = 1;
public static final int EXCEPTION_EXIT = 2;
/**
* Constructs a TestRunner.
*/
public TestRunner() {
this(System.out);
}
/**
* Constructs a TestRunner using the given stream for all the output
*/
public TestRunner(PrintStream writer) {
this(new ResultPrinter(writer));
}
/**
* Constructs a TestRunner using the given ResultPrinter all the output
*/
public TestRunner(ResultPrinter printer) {
fPrinter = printer;
}
/**
* Runs a suite extracted from a TestCase subclass.
*/
static public void run(Class testClass) {
run(new TestSuite(testClass));
}
/**
* Runs a single test and collects its results.
* This method can be used to start a test run
* from your program.
*
* public static void main (String[] args) {
* test.textui.TestRunner.run(suite());
* }
*
*/
static public TestResult run(Test test) {
TestRunner runner = new TestRunner();
return runner.doRun(test);
}
/**
* Runs a single test and waits until the user
* types RETURN.
*/
static public void runAndWait(Test suite) {
TestRunner aTestRunner = new TestRunner();
aTestRunner.doRun(suite, true);
}
@Override
public void testFailed(int status, Test test, Throwable e) {
}
@Override
public void testStarted(String testName) {
}
@Override
public void testEnded(String testName) {
}
/**
* Creates the TestResult to be used for the test run.
*/
protected TestResult createTestResult() {
return new TestResult();
}
public TestResult doRun(Test test) {
return doRun(test, false);
}
public TestResult doRun(Test suite, boolean wait) {
TestResult result = createTestResult();
result.addListener(fPrinter);
long startTime = System.currentTimeMillis();
suite.run(result);
long endTime = System.currentTimeMillis();
long runTime = endTime - startTime;
fPrinter.print(result, runTime);
pause(wait);
return result;
}
protected void pause(boolean wait) {
if (!wait) return;
fPrinter.printWaitPrompt();
try {
System.in.read();
} catch (Exception e) {
}
}
public static void main(String[] args) {
TestRunner aTestRunner = new TestRunner();
try {
TestResult r = aTestRunner.start(args);
if (!r.wasSuccessful()) {
System.exit(FAILURE_EXIT);
}
System.exit(SUCCESS_EXIT);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(EXCEPTION_EXIT);
}
}
/**
* Starts a test run. Analyzes the command line arguments and runs the given
* test suite.
*/
public TestResult start(String[] args) throws Exception {
String testCase = "";
String method = "";
boolean wait = false;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-wait")) {
wait = true;
} else if (args[i].equals("-c")) {
testCase = extractClassName(args[++i]);
} else if (args[i].equals("-m")) {
String arg = args[++i];
int lastIndex = arg.lastIndexOf('.');
testCase = arg.substring(0, lastIndex);
method = arg.substring(lastIndex + 1);
} else if (args[i].equals("-v")) {
System.err.println("JUnit " + Version.id() + " by Kent Beck and Erich Gamma");
} else {
testCase = args[i];
}
}
if (testCase.equals("")) {
throw new Exception("Usage: TestRunner [-wait] testCaseName, where name is the name of the TestCase class");
}
try {
if (!method.equals("")) {
return runSingleMethod(testCase, method, wait);
}
Test suite = getTest(testCase);
return doRun(suite, wait);
} catch (Exception e) {
throw new Exception("Could not create and run test suite: " + e);
}
}
protected TestResult runSingleMethod(String testCase, String method, boolean wait) throws Exception {
Class testClass = loadSuiteClass(testCase).asSubclass(TestCase.class);
Test test = TestSuite.createTest(testClass, method);
return doRun(test, wait);
}
@Override
protected void runFailed(String message) {
System.err.println(message);
System.exit(FAILURE_EXIT);
}
public void setPrinter(ResultPrinter printer) {
fPrinter = printer;
}
} junit4-r4.13.2/src/main/java/junit/textui/package-info.java 0000664 0000000 0000000 00000000132 14011777271 0023501 0 ustar 00root root 0000000 0000000 /**
* Provides JUnit v3.x command line based tool to run tests.
*/
package junit.textui; junit4-r4.13.2/src/main/java/org/ 0000775 0000000 0000000 00000000000 14011777271 0016432 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/ 0000775 0000000 0000000 00000000000 14011777271 0017563 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/After.java 0000664 0000000 0000000 00000002412 14011777271 0021466 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* If you allocate external resources in a {@link org.junit.Before} method you need to release them
* after the test runs. Annotating a public void method
* with @After causes that method to be run after the {@link org.junit.Test} method. All @After
* methods are guaranteed to run even if a {@link org.junit.Before} or {@link org.junit.Test} method throws an
* exception. The @After methods declared in superclasses will be run after those of the current
* class, unless they are overridden in the current class.
*
* Here is a simple example:
*
* public class Example {
* File output;
* @Before public void createOutputFile() {
* output= new File(...);
* }
* @Test public void something() {
* ...
* }
* @After public void deleteOutputFile() {
* output.delete();
* }
* }
*
*
* @see org.junit.Before
* @see org.junit.Test
* @since 4.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface After {
}
junit4-r4.13.2/src/main/java/org/junit/AfterClass.java 0000664 0000000 0000000 00000002640 14011777271 0022457 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* If you allocate expensive external resources in a {@link org.junit.BeforeClass} method you need to release them
* after all the tests in the class have run. Annotating a public static void method
* with @AfterClass causes that method to be run after all the tests in the class have been run. All @AfterClass
* methods are guaranteed to run even if a {@link org.junit.BeforeClass} method throws an
* exception. The @AfterClass methods declared in superclasses will be run after those of the current
* class, unless they are shadowed in the current class.
*
* Here is a simple example:
*
* public class Example {
* private static DatabaseConnection database;
* @BeforeClass public static void login() {
* database= ...;
* }
* @Test public void something() {
* ...
* }
* @Test public void somethingElse() {
* ...
* }
* @AfterClass public static void logout() {
* database.logout();
* }
* }
*
*
* @see org.junit.BeforeClass
* @see org.junit.Test
* @since 4.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AfterClass {
}
junit4-r4.13.2/src/main/java/org/junit/Assert.java 0000664 0000000 0000000 00000117205 14011777271 0021675 0 ustar 00root root 0000000 0000000 package org.junit;
import org.hamcrest.Matcher;
import org.hamcrest.MatcherAssert;
import org.junit.function.ThrowingRunnable;
import org.junit.internal.ArrayComparisonFailure;
import org.junit.internal.ExactComparisonCriteria;
import org.junit.internal.InexactComparisonCriteria;
/**
* A set of assertion methods useful for writing tests. Only failed assertions
* are recorded. These methods can be used directly:
* Assert.assertEquals(...), however, they read better if they
* are referenced through static import:
*
*
* import static org.junit.Assert.*;
* ...
* assertEquals(...);
*
*
* @see AssertionError
* @since 4.0
*/
public class Assert {
/**
* Protect constructor since it is a static only class
*/
protected Assert() {
}
/**
* Asserts that a condition is true. If it isn't it throws an
* {@link AssertionError} with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param condition condition to be checked
*/
public static void assertTrue(String message, boolean condition) {
if (!condition) {
fail(message);
}
}
/**
* Asserts that a condition is true. If it isn't it throws an
* {@link AssertionError} without a message.
*
* @param condition condition to be checked
*/
public static void assertTrue(boolean condition) {
assertTrue(null, condition);
}
/**
* Asserts that a condition is false. If it isn't it throws an
* {@link AssertionError} with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param condition condition to be checked
*/
public static void assertFalse(String message, boolean condition) {
assertTrue(message, !condition);
}
/**
* Asserts that a condition is false. If it isn't it throws an
* {@link AssertionError} without a message.
*
* @param condition condition to be checked
*/
public static void assertFalse(boolean condition) {
assertFalse(null, condition);
}
/**
* Fails a test with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @see AssertionError
*/
public static void fail(String message) {
if (message == null) {
throw new AssertionError();
}
throw new AssertionError(message);
}
/**
* Fails a test with no message.
*/
public static void fail() {
fail(null);
}
/**
* Asserts that two objects are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* expected and actual are null,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expected expected value
* @param actual actual value
*/
public static void assertEquals(String message, Object expected,
Object actual) {
if (equalsRegardingNull(expected, actual)) {
return;
}
if (expected instanceof String && actual instanceof String) {
String cleanMessage = message == null ? "" : message;
throw new ComparisonFailure(cleanMessage, (String) expected,
(String) actual);
} else {
failNotEquals(message, expected, actual);
}
}
private static boolean equalsRegardingNull(Object expected, Object actual) {
if (expected == null) {
return actual == null;
}
return isEquals(expected, actual);
}
private static boolean isEquals(Object expected, Object actual) {
return expected.equals(actual);
}
/**
* Asserts that two objects are equal. If they are not, an
* {@link AssertionError} without a message is thrown. If
* expected and actual are null,
* they are considered equal.
*
* @param expected expected value
* @param actual the value to check against expected
*/
public static void assertEquals(Object expected, Object actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two objects are not equals. If they are, an
* {@link AssertionError} is thrown with the given message. If
* unexpected and actual are null,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param unexpected unexpected value to check
* @param actual the value to check against unexpected
*/
public static void assertNotEquals(String message, Object unexpected,
Object actual) {
if (equalsRegardingNull(unexpected, actual)) {
failEquals(message, actual);
}
}
/**
* Asserts that two objects are not equals. If they are, an
* {@link AssertionError} without a message is thrown. If
* unexpected and actual are null,
* they are considered equal.
*
* @param unexpected unexpected value to check
* @param actual the value to check against unexpected
*/
public static void assertNotEquals(Object unexpected, Object actual) {
assertNotEquals(null, unexpected, actual);
}
private static void failEquals(String message, Object actual) {
String formatted = "Values should be different. ";
if (message != null) {
formatted = message + ". ";
}
formatted += "Actual: " + actual;
fail(formatted);
}
/**
* Asserts that two longs are not equals. If they are, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param unexpected unexpected value to check
* @param actual the value to check against unexpected
*/
public static void assertNotEquals(String message, long unexpected, long actual) {
if (unexpected == actual) {
failEquals(message, Long.valueOf(actual));
}
}
/**
* Asserts that two longs are not equals. If they are, an
* {@link AssertionError} without a message is thrown.
*
* @param unexpected unexpected value to check
* @param actual the value to check against unexpected
*/
public static void assertNotEquals(long unexpected, long actual) {
assertNotEquals(null, unexpected, actual);
}
/**
* Asserts that two doubles are not equal to within a positive delta.
* If they are, an {@link AssertionError} is thrown with the given
* message. If the unexpected value is infinity then the delta value is
* ignored. NaNs are considered equal:
* assertNotEquals(Double.NaN, Double.NaN, *) fails
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param unexpected unexpected value
* @param actual the value to check against unexpected
* @param delta the maximum delta between unexpected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertNotEquals(String message, double unexpected,
double actual, double delta) {
if (!doubleIsDifferent(unexpected, actual, delta)) {
failEquals(message, Double.valueOf(actual));
}
}
/**
* Asserts that two doubles are not equal to within a positive delta.
* If they are, an {@link AssertionError} is thrown. If the unexpected
* value is infinity then the delta value is ignored.NaNs are considered
* equal: assertNotEquals(Double.NaN, Double.NaN, *) fails
*
* @param unexpected unexpected value
* @param actual the value to check against unexpected
* @param delta the maximum delta between unexpected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertNotEquals(double unexpected, double actual, double delta) {
assertNotEquals(null, unexpected, actual, delta);
}
/**
* Asserts that two floats are not equal to within a positive delta.
* If they are, an {@link AssertionError} is thrown. If the unexpected
* value is infinity then the delta value is ignored.NaNs are considered
* equal: assertNotEquals(Float.NaN, Float.NaN, *) fails
*
* @param unexpected unexpected value
* @param actual the value to check against unexpected
* @param delta the maximum delta between unexpected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertNotEquals(float unexpected, float actual, float delta) {
assertNotEquals(null, unexpected, actual, delta);
}
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* expecteds and actuals are null,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
public static void assertArrayEquals(String message, Object[] expecteds,
Object[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown. If expected and
* actual are null, they are considered
* equal.
*
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
public static void assertArrayEquals(Object[] expecteds, Object[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two boolean arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* expecteds and actuals are null,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds boolean array with expected values.
* @param actuals boolean array with expected values.
*/
public static void assertArrayEquals(String message, boolean[] expecteds,
boolean[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two boolean arrays are equal. If they are not, an
* {@link AssertionError} is thrown. If expected and
* actual are null, they are considered
* equal.
*
* @param expecteds boolean array with expected values.
* @param actuals boolean array with expected values.
*/
public static void assertArrayEquals(boolean[] expecteds, boolean[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two byte arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds byte array with expected values.
* @param actuals byte array with actual values
*/
public static void assertArrayEquals(String message, byte[] expecteds,
byte[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two byte arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds byte array with expected values.
* @param actuals byte array with actual values
*/
public static void assertArrayEquals(byte[] expecteds, byte[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two char arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds char array with expected values.
* @param actuals char array with actual values
*/
public static void assertArrayEquals(String message, char[] expecteds,
char[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two char arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds char array with expected values.
* @param actuals char array with actual values
*/
public static void assertArrayEquals(char[] expecteds, char[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two short arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds short array with expected values.
* @param actuals short array with actual values
*/
public static void assertArrayEquals(String message, short[] expecteds,
short[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two short arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds short array with expected values.
* @param actuals short array with actual values
*/
public static void assertArrayEquals(short[] expecteds, short[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two int arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds int array with expected values.
* @param actuals int array with actual values
*/
public static void assertArrayEquals(String message, int[] expecteds,
int[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two int arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds int array with expected values.
* @param actuals int array with actual values
*/
public static void assertArrayEquals(int[] expecteds, int[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two long arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds long array with expected values.
* @param actuals long array with actual values
*/
public static void assertArrayEquals(String message, long[] expecteds,
long[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two long arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds long array with expected values.
* @param actuals long array with actual values
*/
public static void assertArrayEquals(long[] expecteds, long[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
/**
* Asserts that two double arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds double array with expected values.
* @param actuals double array with actual values
* @param delta the maximum delta between expecteds[i] and
* actuals[i] for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(String message, double[] expecteds,
double[] actuals, double delta) throws ArrayComparisonFailure {
new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two double arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds double array with expected values.
* @param actuals double array with actual values
* @param delta the maximum delta between expecteds[i] and
* actuals[i] for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(double[] expecteds, double[] actuals, double delta) {
assertArrayEquals(null, expecteds, actuals, delta);
}
/**
* Asserts that two float arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds float array with expected values.
* @param actuals float array with actual values
* @param delta the maximum delta between expecteds[i] and
* actuals[i] for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(String message, float[] expecteds,
float[] actuals, float delta) throws ArrayComparisonFailure {
new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two float arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds float array with expected values.
* @param actuals float array with actual values
* @param delta the maximum delta between expecteds[i] and
* actuals[i] for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(float[] expecteds, float[] actuals, float delta) {
assertArrayEquals(null, expecteds, actuals, delta);
}
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* expecteds and actuals are null,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
private static void internalArrayEquals(String message, Object expecteds,
Object actuals) throws ArrayComparisonFailure {
new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two doubles are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown with the given
* message. If the expected value is infinity then the delta value is
* ignored. NaNs are considered equal:
* assertEquals(Double.NaN, Double.NaN, *) passes
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expected expected value
* @param actual the value to check against expected
* @param delta the maximum delta between expected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertEquals(String message, double expected,
double actual, double delta) {
if (doubleIsDifferent(expected, actual, delta)) {
failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual));
}
}
/**
* Asserts that two floats are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown with the given
* message. If the expected value is infinity then the delta value is
* ignored. NaNs are considered equal:
* assertEquals(Float.NaN, Float.NaN, *) passes
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expected expected value
* @param actual the value to check against expected
* @param delta the maximum delta between expected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertEquals(String message, float expected,
float actual, float delta) {
if (floatIsDifferent(expected, actual, delta)) {
failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
}
}
/**
* Asserts that two floats are not equal to within a positive delta.
* If they are, an {@link AssertionError} is thrown with the given
* message. If the unexpected value is infinity then the delta value is
* ignored. NaNs are considered equal:
* assertNotEquals(Float.NaN, Float.NaN, *) fails
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param unexpected unexpected value
* @param actual the value to check against unexpected
* @param delta the maximum delta between unexpected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertNotEquals(String message, float unexpected,
float actual, float delta) {
if (!floatIsDifferent(unexpected, actual, delta)) {
failEquals(message, Float.valueOf(actual));
}
}
private static boolean doubleIsDifferent(double d1, double d2, double delta) {
if (Double.compare(d1, d2) == 0) {
return false;
}
if ((Math.abs(d1 - d2) <= delta)) {
return false;
}
return true;
}
private static boolean floatIsDifferent(float f1, float f2, float delta) {
if (Float.compare(f1, f2) == 0) {
return false;
}
if ((Math.abs(f1 - f2) <= delta)) {
return false;
}
return true;
}
/**
* Asserts that two longs are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expected expected long value.
* @param actual actual long value
*/
public static void assertEquals(long expected, long actual) {
assertEquals(null, expected, actual);
}
/**
* Asserts that two longs are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expected long expected value.
* @param actual long actual value
*/
public static void assertEquals(String message, long expected, long actual) {
if (expected != actual) {
failNotEquals(message, Long.valueOf(expected), Long.valueOf(actual));
}
}
/**
* @deprecated Use
* assertEquals(double expected, double actual, double delta)
* instead
*/
@Deprecated
public static void assertEquals(double expected, double actual) {
assertEquals(null, expected, actual);
}
/**
* @deprecated Use
* assertEquals(String message, double expected, double actual, double delta)
* instead
*/
@Deprecated
public static void assertEquals(String message, double expected,
double actual) {
fail("Use assertEquals(expected, actual, delta) to compare floating-point numbers");
}
/**
* Asserts that two doubles are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown. If the expected
* value is infinity then the delta value is ignored.NaNs are considered
* equal: assertEquals(Double.NaN, Double.NaN, *) passes
*
* @param expected expected value
* @param actual the value to check against expected
* @param delta the maximum delta between expected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertEquals(double expected, double actual, double delta) {
assertEquals(null, expected, actual, delta);
}
/**
* Asserts that two floats are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown. If the expected
* value is infinity then the delta value is ignored. NaNs are considered
* equal: assertEquals(Float.NaN, Float.NaN, *) passes
*
* @param expected expected value
* @param actual the value to check against expected
* @param delta the maximum delta between expected and
* actual for which both numbers are still
* considered equal.
*/
public static void assertEquals(float expected, float actual, float delta) {
assertEquals(null, expected, actual, delta);
}
/**
* Asserts that an object isn't null. If it is an {@link AssertionError} is
* thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param object Object to check or null
*/
public static void assertNotNull(String message, Object object) {
assertTrue(message, object != null);
}
/**
* Asserts that an object isn't null. If it is an {@link AssertionError} is
* thrown.
*
* @param object Object to check or null
*/
public static void assertNotNull(Object object) {
assertNotNull(null, object);
}
/**
* Asserts that an object is null. If it is not, an {@link AssertionError}
* is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param object Object to check or null
*/
public static void assertNull(String message, Object object) {
if (object == null) {
return;
}
failNotNull(message, object);
}
/**
* Asserts that an object is null. If it isn't an {@link AssertionError} is
* thrown.
*
* @param object Object to check or null
*/
public static void assertNull(Object object) {
assertNull(null, object);
}
private static void failNotNull(String message, Object actual) {
String formatted = "";
if (message != null) {
formatted = message + " ";
}
fail(formatted + "expected null, but was:<" + actual + ">");
}
/**
* Asserts that two objects refer to the same object. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expected the expected object
* @param actual the object to compare to expected
*/
public static void assertSame(String message, Object expected, Object actual) {
if (expected == actual) {
return;
}
failNotSame(message, expected, actual);
}
/**
* Asserts that two objects refer to the same object. If they are not the
* same, an {@link AssertionError} without a message is thrown.
*
* @param expected the expected object
* @param actual the object to compare to expected
*/
public static void assertSame(Object expected, Object actual) {
assertSame(null, expected, actual);
}
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object, an {@link AssertionError} is thrown with the
* given message.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param unexpected the object you don't expect
* @param actual the object to compare to unexpected
*/
public static void assertNotSame(String message, Object unexpected,
Object actual) {
if (unexpected == actual) {
failSame(message);
}
}
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object, an {@link AssertionError} without a message is
* thrown.
*
* @param unexpected the object you don't expect
* @param actual the object to compare to unexpected
*/
public static void assertNotSame(Object unexpected, Object actual) {
assertNotSame(null, unexpected, actual);
}
private static void failSame(String message) {
String formatted = "";
if (message != null) {
formatted = message + " ";
}
fail(formatted + "expected not same");
}
private static void failNotSame(String message, Object expected,
Object actual) {
String formatted = "";
if (message != null) {
formatted = message + " ";
}
fail(formatted + "expected same:<" + expected + "> was not:<" + actual
+ ">");
}
private static void failNotEquals(String message, Object expected,
Object actual) {
fail(format(message, expected, actual));
}
static String format(String message, Object expected, Object actual) {
String formatted = "";
if (message != null && !"".equals(message)) {
formatted = message + " ";
}
String expectedString = String.valueOf(expected);
String actualString = String.valueOf(actual);
if (equalsRegardingNull(expectedString, actualString)) {
return formatted + "expected: "
+ formatClassAndValue(expected, expectedString)
+ " but was: " + formatClassAndValue(actual, actualString);
} else {
return formatted + "expected:<" + expectedString + "> but was:<"
+ actualString + ">";
}
}
private static String formatClass(Class value) {
String className = value.getCanonicalName();
return className == null ? value.getName() : className;
}
private static String formatClassAndValue(Object value, String valueString) {
String className = value == null ? "null" : value.getClass().getName();
return className + "<" + valueString + ">";
}
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* expecteds and actuals are null,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
* @deprecated use assertArrayEquals
*/
@Deprecated
public static void assertEquals(String message, Object[] expecteds,
Object[] actuals) {
assertArrayEquals(message, expecteds, actuals);
}
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown. If expected and
* actual are null, they are considered
* equal.
*
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
* @deprecated use assertArrayEquals
*/
@Deprecated
public static void assertEquals(Object[] expecteds, Object[] actuals) {
assertArrayEquals(expecteds, actuals);
}
/**
* Asserts that actual satisfies the condition specified by
* matcher. If not, an {@link AssertionError} is thrown with
* information about the matcher and failing value. Example:
*
*
* assertThat(0, is(1)); // fails:
* // failure message:
* // expected: is <1>
* // got value: <0>
* assertThat(0, is(not(1))) // passes
*
*
* org.hamcrest.Matcher does not currently document the meaning
* of its type parameter T. This method assumes that a matcher
* typed as Matcher<T> can be meaningfully applied only
* to values that could be assigned to a variable of type T.
*
* @param the static type accepted by the matcher (this can flag obvious
* compile-time problems such as {@code assertThat(1, is("a"))}
* @param actual the computed value being compared
* @param matcher an expression, built of {@link Matcher}s, specifying allowed
* values
* @see org.hamcrest.CoreMatchers
* @deprecated use {@code org.hamcrest.MatcherAssert.assertThat()}
*/
@Deprecated
public static void assertThat(T actual, Matcher matcher) {
assertThat("", actual, matcher);
}
/**
* Asserts that actual satisfies the condition specified by
* matcher. If not, an {@link AssertionError} is thrown with
* the reason and information about the matcher and failing value. Example:
*
*
* assertThat("Help! Integers don't work", 0, is(1)); // fails:
* // failure message:
* // Help! Integers don't work
* // expected: is <1>
* // got value: <0>
* assertThat("Zero is one", 0, is(not(1))) // passes
*
*
* org.hamcrest.Matcher does not currently document the meaning
* of its type parameter T. This method assumes that a matcher
* typed as Matcher<T> can be meaningfully applied only
* to values that could be assigned to a variable of type T.
*
* @param reason additional information about the error
* @param the static type accepted by the matcher (this can flag obvious
* compile-time problems such as {@code assertThat(1, is("a"))}
* @param actual the computed value being compared
* @param matcher an expression, built of {@link Matcher}s, specifying allowed
* values
* @see org.hamcrest.CoreMatchers
* @deprecated use {@code org.hamcrest.MatcherAssert.assertThat()}
*/
@Deprecated
public static void assertThat(String reason, T actual,
Matcher matcher) {
MatcherAssert.assertThat(reason, actual, matcher);
}
/**
* Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
* executed. If it does, the exception object is returned. If it does not throw an exception, an
* {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
* AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
* be obtained by calling {@link AssertionError#getCause}.
*
* @param expectedThrowable the expected type of the exception
* @param runnable a function that is expected to throw an exception when executed
* @return the exception thrown by {@code runnable}
* @since 4.13
*/
public static T assertThrows(Class expectedThrowable,
ThrowingRunnable runnable) {
return assertThrows(null, expectedThrowable, runnable);
}
/**
* Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
* executed. If it does, the exception object is returned. If it does not throw an exception, an
* {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
* AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
* be obtained by calling {@link AssertionError#getCause}.
*
* @param message the identifying message for the {@link AssertionError} (null
* okay)
* @param expectedThrowable the expected type of the exception
* @param runnable a function that is expected to throw an exception when executed
* @return the exception thrown by {@code runnable}
* @since 4.13
*/
public static T assertThrows(String message, Class expectedThrowable,
ThrowingRunnable runnable) {
try {
runnable.run();
} catch (Throwable actualThrown) {
if (expectedThrowable.isInstance(actualThrown)) {
@SuppressWarnings("unchecked") T retVal = (T) actualThrown;
return retVal;
} else {
String expected = formatClass(expectedThrowable);
Class actualThrowable = actualThrown.getClass();
String actual = formatClass(actualThrowable);
if (expected.equals(actual)) {
// There must be multiple class loaders. Add the identity hash code so the message
// doesn't say "expected: java.lang.String ..."
expected += "@" + Integer.toHexString(System.identityHashCode(expectedThrowable));
actual += "@" + Integer.toHexString(System.identityHashCode(actualThrowable));
}
String mismatchMessage = buildPrefix(message)
+ format("unexpected exception type thrown;", expected, actual);
// The AssertionError(String, Throwable) ctor is only available on JDK7.
AssertionError assertionError = new AssertionError(mismatchMessage);
assertionError.initCause(actualThrown);
throw assertionError;
}
}
String notThrownMessage = buildPrefix(message) + String
.format("expected %s to be thrown, but nothing was thrown",
formatClass(expectedThrowable));
throw new AssertionError(notThrownMessage);
}
private static String buildPrefix(String message) {
return message != null && message.length() != 0 ? message + ": " : "";
}
}
junit4-r4.13.2/src/main/java/org/junit/Assume.java 0000664 0000000 0000000 00000014026 14011777271 0021666 0 ustar 00root root 0000000 0000000 package org.junit;
import static java.util.Arrays.asList;
import static org.hamcrest.CoreMatchers.everyItem;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import org.hamcrest.Matcher;
/**
* A set of methods useful for stating assumptions about the conditions in which a test is meaningful.
* A failed assumption does not mean the code is broken, but that the test provides no useful information. Assume
* basically means "don't run this test if these conditions don't apply". The default JUnit runner skips tests with
* failing assumptions. Custom runners may behave differently.
*
* A good example of using assumptions is in Theories where they are needed to exclude certain datapoints that aren't suitable or allowed for a certain test case.
*
* Failed assumptions are usually not logged, because there may be many tests that don't apply to certain
* configurations.
*
*
* These methods can be used directly: Assume.assumeTrue(...), however, they
* read better if they are referenced through static import:
* import static org.junit.Assume.*;
* ...
* assumeTrue(...);
*
*
*
* @see Theories
*
* @since 4.4
*/
public class Assume {
/**
* Do not instantiate.
* @deprecated since 4.13.
*/
@Deprecated
public Assume() {
}
/**
* If called with an expression evaluating to {@code false}, the test will halt and be ignored.
*/
public static void assumeTrue(boolean b) {
assumeThat(b, is(true));
}
/**
* The inverse of {@link #assumeTrue(boolean)}.
*/
public static void assumeFalse(boolean b) {
assumeThat(b, is(false));
}
/**
* If called with an expression evaluating to {@code false}, the test will halt and be ignored.
*
* @param b If false, the method will attempt to stop the test and ignore it by
* throwing {@link AssumptionViolatedException}.
* @param message A message to pass to {@link AssumptionViolatedException}.
*/
public static void assumeTrue(String message, boolean b) {
if (!b) throw new AssumptionViolatedException(message);
}
/**
* The inverse of {@link #assumeTrue(String, boolean)}.
*/
public static void assumeFalse(String message, boolean b) {
assumeTrue(message, !b);
}
/**
* If called with a {@code null} array or one or more {@code null} elements in {@code objects},
* the test will halt and be ignored.
*/
public static void assumeNotNull(Object... objects) {
assumeThat(objects, notNullValue());
assumeThat(asList(objects), everyItem(notNullValue()));
}
/**
* Call to assume that actual satisfies the condition specified by matcher.
* If not, the test halts and is ignored.
* Example:
* :
* assumeThat(1, is(1)); // passes
* foo(); // will execute
* assumeThat(0, is(1)); // assumption failure! test halts
* int x = 1 / 0; // will never execute
*
*
* @param the static type accepted by the matcher (this can flag obvious compile-time problems such as {@code assumeThat(1, is("a"))}
* @param actual the computed value being compared
* @param matcher an expression, built of {@link Matcher}s, specifying allowed values
* @see org.hamcrest.CoreMatchers
* @see org.junit.matchers.JUnitMatchers
*/
public static void assumeThat(T actual, Matcher matcher) {
if (!matcher.matches(actual)) {
throw new AssumptionViolatedException(actual, matcher);
}
}
/**
* Call to assume that actual satisfies the condition specified by matcher.
* If not, the test halts and is ignored.
* Example:
* :
* assumeThat("alwaysPasses", 1, is(1)); // passes
* foo(); // will execute
* assumeThat("alwaysFails", 0, is(1)); // assumption failure! test halts
* int x = 1 / 0; // will never execute
*
*
* @param the static type accepted by the matcher (this can flag obvious compile-time problems such as {@code assumeThat(1, is("a"))}
* @param actual the computed value being compared
* @param matcher an expression, built of {@link Matcher}s, specifying allowed values
* @see org.hamcrest.CoreMatchers
* @see org.junit.matchers.JUnitMatchers
*/
public static void assumeThat(String message, T actual, Matcher matcher) {
if (!matcher.matches(actual)) {
throw new AssumptionViolatedException(message, actual, matcher);
}
}
/**
* Use to assume that an operation completes normally. If {@code e} is non-null, the test will halt and be ignored.
*
* For example:
*
* \@Test public void parseDataFile() {
* DataFile file;
* try {
* file = DataFile.open("sampledata.txt");
* } catch (IOException e) {
* // stop test and ignore if data can't be opened
* assumeNoException(e);
* }
* // ...
* }
*
*
* @param e if non-null, the offending exception
*/
public static void assumeNoException(Throwable e) {
assumeThat(e, nullValue());
}
/**
* Attempts to halt the test and ignore it if Throwable e is
* not null. Similar to {@link #assumeNoException(Throwable)},
* but provides an additional message that can explain the details
* concerning the assumption.
*
* @param e if non-null, the offending exception
* @param message Additional message to pass to {@link AssumptionViolatedException}.
* @see #assumeNoException(Throwable)
*/
public static void assumeNoException(String message, Throwable e) {
assumeThat(message, e, nullValue());
}
}
junit4-r4.13.2/src/main/java/org/junit/AssumptionViolatedException.java 0000664 0000000 0000000 00000002634 14011777271 0026144 0 ustar 00root root 0000000 0000000 package org.junit;
import org.hamcrest.Matcher;
/**
* An exception class used to implement assumptions (state in which a given test
* is meaningful and should or should not be executed). A test for which an assumption
* fails should not generate a test case failure.
*
* @see org.junit.Assume
* @since 4.12
*/
@SuppressWarnings("deprecation")
public class AssumptionViolatedException extends org.junit.internal.AssumptionViolatedException {
private static final long serialVersionUID = 1L;
/**
* An assumption exception with the given actual value and a matcher describing
* the expectation that failed.
*/
public AssumptionViolatedException(T actual, Matcher matcher) {
super(actual, matcher);
}
/**
* An assumption exception with a message with the given actual value and a
* matcher describing the expectation that failed.
*/
public AssumptionViolatedException(String message, T expected, Matcher matcher) {
super(message, expected, matcher);
}
/**
* An assumption exception with the given message only.
*/
public AssumptionViolatedException(String message) {
super(message);
}
/**
* An assumption exception with the given message and a cause.
*/
public AssumptionViolatedException(String message, Throwable t) {
super(message, t);
}
}
junit4-r4.13.2/src/main/java/org/junit/Before.java 0000664 0000000 0000000 00000002136 14011777271 0021632 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* When writing tests, it is common to find that several tests need similar
* objects created before they can run. Annotating a public void method
* with @Before causes that method to be run before the {@link org.junit.Test} method.
* The @Before methods of superclasses will be run before those of the current class,
* unless they are overridden in the current class. No other ordering is defined.
*
* Here is a simple example:
*
* public class Example {
* List empty;
* @Before public void initialize() {
* empty= new ArrayList();
* }
* @Test public void size() {
* ...
* }
* @Test public void remove() {
* ...
* }
* }
*
*
* @see org.junit.BeforeClass
* @see org.junit.After
* @since 4.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Before {
}
junit4-r4.13.2/src/main/java/org/junit/BeforeClass.java 0000664 0000000 0000000 00000002143 14011777271 0022616 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Sometimes several tests need to share computationally expensive setup
* (like logging into a database). While this can compromise the independence of
* tests, sometimes it is a necessary optimization. Annotating a public static void no-arg method
* with @BeforeClass causes it to be run once before any of
* the test methods in the class. The @BeforeClass methods of superclasses
* will be run before those of the current class, unless they are shadowed in the current class.
*
* For example:
*
* public class Example {
* @BeforeClass public static void onlyOnce() {
* ...
* }
* @Test public void one() {
* ...
* }
* @Test public void two() {
* ...
* }
* }
*
*
* @see org.junit.AfterClass
* @since 4.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface BeforeClass {
}
junit4-r4.13.2/src/main/java/org/junit/ClassRule.java 0000664 0000000 0000000 00000007631 14011777271 0022332 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotates static fields that reference rules or methods that return them. A field must be public,
* static, and a subtype of {@link org.junit.rules.TestRule}. A method must be public static, and return
* a subtype of {@link org.junit.rules.TestRule}.
*
* The {@link org.junit.runners.model.Statement} passed
* to the {@link org.junit.rules.TestRule} will run any {@link BeforeClass} methods,
* then the entire body of the test class (all contained methods, if it is
* a standard JUnit test class, or all contained classes, if it is a
* {@link org.junit.runners.Suite}), and finally any {@link AfterClass} methods.
*
* The statement passed to the {@link org.junit.rules.TestRule} will never throw an exception,
* and throwing an exception from the {@link org.junit.rules.TestRule} will result in undefined
* behavior. This means that some {@link org.junit.rules.TestRule}s, such as
* {@link org.junit.rules.ErrorCollector},
* {@link org.junit.rules.ExpectedException},
* and {@link org.junit.rules.Timeout},
* have undefined behavior when used as {@link ClassRule}s.
*
* If there are multiple
* annotated {@link ClassRule}s on a class, they will be applied in an order
* that depends on your JVM's implementation of the reflection API, which is
* undefined, in general. However, Rules defined by fields will always be applied
* after Rules defined by methods, i.e. the Statements returned by the former will
* be executed around those returned by the latter.
*
*
Usage
*
* For example, here is a test suite that connects to a server once before
* all the test classes run, and disconnects after they are finished:
*
* @RunWith(Suite.class)
* @SuiteClasses({A.class, B.class, C.class})
* public class UsesExternalResource {
* public static Server myServer= new Server();
*
* @ClassRule
* public static ExternalResource resource= new ExternalResource() {
* @Override
* protected void before() throws Throwable {
* myServer.connect();
* }
*
* @Override
* protected void after() {
* myServer.disconnect();
* }
* };
* }
*
*
* and the same using a method
*
* @RunWith(Suite.class)
* @SuiteClasses({A.class, B.class, C.class})
* public class UsesExternalResource {
* public static Server myServer= new Server();
*
* @ClassRule
* public static ExternalResource getResource() {
* return new ExternalResource() {
* @Override
* protected void before() throws Throwable {
* myServer.connect();
* }
*
* @Override
* protected void after() {
* myServer.disconnect();
* }
* };
* }
* }
*
*
* For more information and more examples, see {@link org.junit.rules.TestRule}.
*
*
Ordering
*
* You can use {@link #order()} if you want to have control over the order in
* which the Rules are applied.
*
*
* public class ThreeClassRules {
* @ClassRule(order = 0)
* public static LoggingRule outer = new LoggingRule("outer rule");
*
* @ClassRule(order = 1)
* public static LoggingRule middle = new LoggingRule("middle rule");
*
* @ClassRule(order = 2)
* public static LoggingRule inner = new LoggingRule("inner rule");
*
* // ...
* }
*
*
* @since 4.9
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface ClassRule {
/**
* Specifies the order in which rules are applied. The rules with a higher value are inner.
*
* @since 4.13
*/
int order() default Rule.DEFAULT_ORDER;
}
junit4-r4.13.2/src/main/java/org/junit/ComparisonFailure.java 0000664 0000000 0000000 00000013700 14011777271 0024051 0 ustar 00root root 0000000 0000000 package org.junit;
/**
* Thrown when an {@link org.junit.Assert#assertEquals(Object, Object) assertEquals(String, String)} fails.
* Create and throw a ComparisonFailure manually if you want to show users the
* difference between two complex strings.
*
* Inspired by a patch from Alex Chaffee (alex@purpletech.com)
*
* @since 4.0
*/
public class ComparisonFailure extends AssertionError {
/**
* The maximum length for expected and actual strings. If it is exceeded, the strings should be shortened.
*
* @see ComparisonCompactor
*/
private static final int MAX_CONTEXT_LENGTH = 20;
private static final long serialVersionUID = 1L;
/*
* We have to use the f prefix until the next major release to ensure
* serialization compatibility.
* See https://github.com/junit-team/junit4/issues/976
*/
private String fExpected;
private String fActual;
/**
* Constructs a comparison failure.
*
* @param message the identifying message or null
* @param expected the expected string value
* @param actual the actual string value
*/
public ComparisonFailure(String message, String expected, String actual) {
super(message);
this.fExpected = expected;
this.fActual = actual;
}
/**
* Returns "..." in place of common prefix and "..." in place of common suffix between expected and actual.
*
* @see Throwable#getMessage()
*/
@Override
public String getMessage() {
return new ComparisonCompactor(MAX_CONTEXT_LENGTH, fExpected, fActual).compact(super.getMessage());
}
/**
* Returns the actual string value
*
* @return the actual string value
*/
public String getActual() {
return fActual;
}
/**
* Returns the expected string value
*
* @return the expected string value
*/
public String getExpected() {
return fExpected;
}
private static class ComparisonCompactor {
private static final String ELLIPSIS = "...";
private static final String DIFF_END = "]";
private static final String DIFF_START = "[";
/**
* The maximum length for expected and actual strings to show. When
* contextLength is exceeded, the Strings are shortened.
*/
private final int contextLength;
private final String expected;
private final String actual;
/**
* @param contextLength the maximum length of context surrounding the difference between the compared strings.
* When context length is exceeded, the prefixes and suffixes are compacted.
* @param expected the expected string value
* @param actual the actual string value
*/
public ComparisonCompactor(int contextLength, String expected, String actual) {
this.contextLength = contextLength;
this.expected = expected;
this.actual = actual;
}
public String compact(String message) {
if (expected == null || actual == null || expected.equals(actual)) {
return Assert.format(message, expected, actual);
} else {
DiffExtractor extractor = new DiffExtractor();
String compactedPrefix = extractor.compactPrefix();
String compactedSuffix = extractor.compactSuffix();
return Assert.format(message,
compactedPrefix + extractor.expectedDiff() + compactedSuffix,
compactedPrefix + extractor.actualDiff() + compactedSuffix);
}
}
private String sharedPrefix() {
int end = Math.min(expected.length(), actual.length());
for (int i = 0; i < end; i++) {
if (expected.charAt(i) != actual.charAt(i)) {
return expected.substring(0, i);
}
}
return expected.substring(0, end);
}
private String sharedSuffix(String prefix) {
int suffixLength = 0;
int maxSuffixLength = Math.min(expected.length() - prefix.length(),
actual.length() - prefix.length()) - 1;
for (; suffixLength <= maxSuffixLength; suffixLength++) {
if (expected.charAt(expected.length() - 1 - suffixLength)
!= actual.charAt(actual.length() - 1 - suffixLength)) {
break;
}
}
return expected.substring(expected.length() - suffixLength);
}
private class DiffExtractor {
private final String sharedPrefix;
private final String sharedSuffix;
/**
* Can not be instantiated outside {@link org.junit.ComparisonFailure.ComparisonCompactor}.
*/
private DiffExtractor() {
sharedPrefix = sharedPrefix();
sharedSuffix = sharedSuffix(sharedPrefix);
}
public String expectedDiff() {
return extractDiff(expected);
}
public String actualDiff() {
return extractDiff(actual);
}
public String compactPrefix() {
if (sharedPrefix.length() <= contextLength) {
return sharedPrefix;
}
return ELLIPSIS + sharedPrefix.substring(sharedPrefix.length() - contextLength);
}
public String compactSuffix() {
if (sharedSuffix.length() <= contextLength) {
return sharedSuffix;
}
return sharedSuffix.substring(0, contextLength) + ELLIPSIS;
}
private String extractDiff(String source) {
return DIFF_START + source.substring(sharedPrefix.length(), source.length() - sharedSuffix.length())
+ DIFF_END;
}
}
}
}
junit4-r4.13.2/src/main/java/org/junit/FixMethodOrder.java 0000664 0000000 0000000 00000002642 14011777271 0023315 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.runners.MethodSorters;
/**
* This class allows the user to choose the order of execution of the methods within a test class.
*
* The default order of execution of JUnit tests within a class is deterministic but not predictable.
* The order of execution is not guaranteed for Java 7 (and some previous versions), and can even change
* from run to run, so the order of execution was changed to be deterministic (in JUnit 4.11)
*
*
It is recommended that test methods be written so that they are independent of the order that they are executed.
* However, there may be a number of dependent tests either through error or by design.
* This class allows the user to specify the order of execution of test methods.
*
*
For possibilities, see {@link MethodSorters}
*
* Here is an example:
*
*
* @FixMethodOrder(MethodSorters.NAME_ASCENDING)
* public class MyTest {
* }
*
*
* @see org.junit.runners.MethodSorters
* @since 4.11
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface FixMethodOrder {
/**
* Optionally specify value to have the methods executed in a particular order
*/
MethodSorters value() default MethodSorters.DEFAULT;
}
junit4-r4.13.2/src/main/java/org/junit/Ignore.java 0000664 0000000 0000000 00000002656 14011777271 0021662 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Sometimes you want to temporarily disable a test or a group of tests. Methods annotated with
* {@link org.junit.Test} that are also annotated with @Ignore will not be executed as tests.
* Also, you can annotate a class containing test methods with @Ignore and none of the containing
* tests will be executed. Native JUnit 4 test runners should report the number of ignored tests along with the
* number of tests that ran and the number of tests that failed.
*
* For example:
*
* @Ignore @Test public void something() { ...
*
* @Ignore takes an optional default parameter if you want to record why a test is being ignored:
*
* @Ignore("not ready yet") @Test public void something() { ...
*
* @Ignore can also be applied to the test class:
*
* @Ignore public class IgnoreMe {
* @Test public void test1() { ... }
* @Test public void test2() { ... }
* }
*
*
* @since 4.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface Ignore {
/**
* The optional reason why the test is ignored.
*/
String value() default "";
}
junit4-r4.13.2/src/main/java/org/junit/Rule.java 0000664 0000000 0000000 00000006356 14011777271 0021347 0 ustar 00root root 0000000 0000000 package org.junit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotates fields that reference rules or methods that return a rule. A field must be public, not
* static, and a subtype of {@link org.junit.rules.TestRule} (preferred) or
* {@link org.junit.rules.MethodRule}. A method must be public, not static,
* and must return a subtype of {@link org.junit.rules.TestRule} (preferred) or
* {@link org.junit.rules.MethodRule}.
*
* The {@link org.junit.runners.model.Statement} passed
* to the {@link org.junit.rules.TestRule} will run any {@link Before} methods,
* then the {@link Test} method, and finally any {@link After} methods,
* throwing an exception if any of these fail. If there are multiple
* annotated {@link Rule}s on a class, they will be applied in order of methods first, then fields.
* However, if there are multiple fields (or methods) they will be applied in an order
* that depends on your JVM's implementation of the reflection API, which is
* undefined, in general. Rules defined by fields will always be applied
* after Rules defined by methods, i.e. the Statements returned by the former will
* be executed around those returned by the latter.
*
*
Usage
*
* For example, here is a test class that creates a temporary folder before
* each test method, and deletes it after each:
*
* public static class HasTempFolder {
* @Rule
* public TemporaryFolder folder= new TemporaryFolder();
*
* @Test
* public void testUsingTempFolder() throws IOException {
* File createdFile= folder.newFile("myfile.txt");
* File createdFolder= folder.newFolder("subfolder");
* // ...
* }
* }
*
*
* And the same using a method.
*
* public static class HasTempFolder {
* private TemporaryFolder folder= new TemporaryFolder();
*
* @Rule
* public TemporaryFolder getFolder() {
* return folder;
* }
*
* @Test
* public void testUsingTempFolder() throws IOException {
* File createdFile= folder.newFile("myfile.txt");
* File createdFolder= folder.newFolder("subfolder");
* // ...
* }
* }
*
*
* For more information and more examples, see
* {@link org.junit.rules.TestRule}.
*
*
Ordering
*
* You can use {@link #order()} if you want to have control over the order in
* which the Rules are applied.
*
*
* public class ThreeRules {
* @Rule(order = 0)
* public LoggingRule outer = new LoggingRule("outer rule");
*
* @Rule(order = 1)
* public LoggingRule middle = new LoggingRule("middle rule");
*
* @Rule(order = 2)
* public LoggingRule inner = new LoggingRule("inner rule");
*
* // ...
* }
*
*
* @since 4.7
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface Rule {
int DEFAULT_ORDER = -1;
/**
* Specifies the order in which rules are applied. The rules with a higher value are inner.
*
* @since 4.13
*/
int order() default DEFAULT_ORDER;
}
junit4-r4.13.2/src/main/java/org/junit/Test.java 0000664 0000000 0000000 00000011470 14011777271 0021350 0 ustar 00root root 0000000 0000000 package org.junit;
import org.junit.function.ThrowingRunnable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* The Test annotation tells JUnit that the public void method
* to which it is attached can be run as a test case. To run the method,
* JUnit first constructs a fresh instance of the class then invokes the
* annotated method. Any exceptions thrown by the test will be reported
* by JUnit as a failure. If no exceptions are thrown, the test is assumed
* to have succeeded.
*
* A simple test looks like this:
*
* public class Example {
* @Test
* public void method() {
* org.junit.Assert.assertTrue( new ArrayList().isEmpty() );
* }
* }
*
*
* The Test annotation supports two optional parameters for
* exception testing and for limiting test execution time.
*
*
Exception Testing
*
* The parameter expected declares that a test method should throw
* an exception. If it doesn't throw an exception or if it throws a different exception
* than the one declared, the test fails. For example, the following test succeeds:
*
* @Test(expected=IndexOutOfBoundsException.class )
* public void outOfBounds() {
* new ArrayList<Object>().get(1);
* }
*
*
* Using the parameter expected for exception testing comes with
* some limitations: only the exception's type can be checked and it is not
* possible to precisely specify the code that throws the exception. Therefore
* JUnit 4 has improved its support for exception testing with
* {@link Assert#assertThrows(Class, ThrowingRunnable)} and the
* {@link org.junit.rules.ExpectedException ExpectedException} rule.
* With assertThrows the code that throws the exception can be
* precisely specified. If the exception's message or one of its properties
* should be verified, the ExpectedException rule can be used. Further
* information about exception testing can be found at the
* JUnit Wiki .
*
* Timeout
*
* The parameter timeout causes a test to fail if it takes
* longer than a specified amount of clock time (measured in milliseconds). The following test fails:
*
* @Test(timeout=100 )
* public void infinity() {
* while(true);
* }
*
* Warning : while timeout is useful to catch and terminate
* infinite loops, it should not be considered deterministic. The
* following test may or may not fail depending on how the operating system
* schedules threads:
*
* @Test(timeout=100 )
* public void sleep100() {
* Thread.sleep(100);
* }
*
* THREAD SAFETY WARNING: Test methods with a timeout parameter are run in a thread other than the
* thread which runs the fixture's @Before and @After methods. This may yield different behavior for
* code that is not thread safe when compared to the same test method without a timeout parameter.
* Consider using the {@link org.junit.rules.Timeout} rule instead , which ensures a test method is run on the
* same thread as the fixture's @Before and @After methods.
*
* @since 4.0
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {
/**
* Default empty exception.
*/
static class None extends Throwable {
private static final long serialVersionUID = 1L;
private None() {
}
}
/**
* Optionally specify expected, a Throwable, to cause a test method to succeed if
* and only if an exception of the specified class is thrown by the method. If the Throwable's
* message or one of its properties should be verified, the
* {@link org.junit.rules.ExpectedException ExpectedException} rule can be used instead.
*/
Class expected() default None.class;
/**
* Optionally specify timeout in milliseconds to cause a test method to fail if it
* takes longer than that number of milliseconds.
*
* THREAD SAFETY WARNING: Test methods with a timeout parameter are run in a thread other than the
* thread which runs the fixture's @Before and @After methods. This may yield different behavior for
* code that is not thread safe when compared to the same test method without a timeout parameter.
* Consider using the {@link org.junit.rules.Timeout} rule instead , which ensures a test method is run on the
* same thread as the fixture's @Before and @After methods.
*
*/
long timeout() default 0L;
}
junit4-r4.13.2/src/main/java/org/junit/TestCouldNotBeSkippedException.java 0000664 0000000 0000000 00000001313 14011777271 0026461 0 ustar 00root root 0000000 0000000 package org.junit;
/**
* Indicates that a test that indicated that it should be skipped could not be skipped.
* This can be thrown if a test uses the methods in {@link Assume} to indicate that
* it should be skipped, but before processing of the test was completed, other failures
* occured.
*
* @see org.junit.Assume
* @since 4.13
*/
public class TestCouldNotBeSkippedException extends RuntimeException {
private static final long serialVersionUID = 1L;
/** Creates an instance using the given assumption failure. */
public TestCouldNotBeSkippedException(org.junit.internal.AssumptionViolatedException cause) {
super("Test could not be skipped due to other failures", cause);
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/ 0000775 0000000 0000000 00000000000 14011777271 0022260 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/ParallelComputer.java 0000664 0000000 0000000 00000004167 14011777271 0026406 0 ustar 00root root 0000000 0000000 package org.junit.experimental;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.runner.Computer;
import org.junit.runner.Runner;
import org.junit.runners.ParentRunner;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerBuilder;
import org.junit.runners.model.RunnerScheduler;
public class ParallelComputer extends Computer {
private final boolean classes;
private final boolean methods;
public ParallelComputer(boolean classes, boolean methods) {
this.classes = classes;
this.methods = methods;
}
public static Computer classes() {
return new ParallelComputer(true, false);
}
public static Computer methods() {
return new ParallelComputer(false, true);
}
private static Runner parallelize(Runner runner) {
if (runner instanceof ParentRunner) {
((ParentRunner) runner).setScheduler(new RunnerScheduler() {
private final ExecutorService fService = Executors.newCachedThreadPool();
public void schedule(Runnable childStatement) {
fService.submit(childStatement);
}
public void finished() {
try {
fService.shutdown();
fService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
e.printStackTrace(System.err);
}
}
});
}
return runner;
}
@Override
public Runner getSuite(RunnerBuilder builder, java.lang.Class[] classes)
throws InitializationError {
Runner suite = super.getSuite(builder, classes);
return this.classes ? parallelize(suite) : suite;
}
@Override
protected Runner getRunner(RunnerBuilder builder, Class testClass)
throws Throwable {
Runner runner = super.getRunner(builder, testClass);
return methods ? parallelize(runner) : runner;
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/categories/ 0000775 0000000 0000000 00000000000 14011777271 0024405 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/categories/Categories.java 0000664 0000000 0000000 00000033306 14011777271 0027342 0 ustar 00root root 0000000 0000000 package org.junit.experimental.categories;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import org.junit.runner.Description;
import org.junit.runner.manipulation.Filter;
import org.junit.runner.manipulation.NoTestsRemainException;
import org.junit.runners.Suite;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerBuilder;
/**
* From a given set of test classes, runs only the classes and methods that are
* annotated with either the category given with the @IncludeCategory
* annotation, or a subtype of that category.
*
* Note that, for now, annotating suites with {@code @Category} has no effect.
* Categories must be annotated on the direct method or class.
*
* Example:
*
* public interface FastTests {
* }
*
* public interface SlowTests {
* }
*
* public interface SmokeTests
* }
*
* public static class A {
* @Test
* public void a() {
* fail();
* }
*
* @Category(SlowTests.class)
* @Test
* public void b() {
* }
*
* @Category({FastTests.class, SmokeTests.class})
* @Test
* public void c() {
* }
* }
*
* @Category({SlowTests.class, FastTests.class})
* public static class B {
* @Test
* public void d() {
* }
* }
*
* @RunWith(Categories.class)
* @IncludeCategory(SlowTests.class)
* @SuiteClasses({A.class, B.class})
* // Note that Categories is a kind of Suite
* public static class SlowTestSuite {
* // Will run A.b and B.d, but not A.a and A.c
* }
*
*
* Example to run multiple categories:
*
* @RunWith(Categories.class)
* @IncludeCategory({FastTests.class, SmokeTests.class})
* @SuiteClasses({A.class, B.class})
* public static class FastOrSmokeTestSuite {
* // Will run A.c and B.d, but not A.b because it is not any of FastTests or SmokeTests
* }
*
*
* @version 4.12
* @see Categories at JUnit wiki
*/
public class Categories extends Suite {
@Retention(RetentionPolicy.RUNTIME)
public @interface IncludeCategory {
/**
* Determines the tests to run that are annotated with categories specified in
* the value of this annotation or their subtypes unless excluded with {@link ExcludeCategory}.
*/
Class[] value() default {};
/**
* If true , runs tests annotated with any of the categories in
* {@link IncludeCategory#value()}. Otherwise, runs tests only if annotated with all of the categories.
*/
boolean matchAny() default true;
}
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcludeCategory {
/**
* Determines the tests which do not run if they are annotated with categories specified in the
* value of this annotation or their subtypes regardless of being included in {@link IncludeCategory#value()}.
*/
Class[] value() default {};
/**
* If true , the tests annotated with any of the categories in {@link ExcludeCategory#value()}
* do not run. Otherwise, the tests do not run if and only if annotated with all categories.
*/
boolean matchAny() default true;
}
public static class CategoryFilter extends Filter {
private final Set> included;
private final Set> excluded;
private final boolean includedAny;
private final boolean excludedAny;
public static CategoryFilter include(boolean matchAny, Class... categories) {
return new CategoryFilter(matchAny, categories, true, null);
}
public static CategoryFilter include(Class category) {
return include(true, category);
}
public static CategoryFilter include(Class... categories) {
return include(true, categories);
}
public static CategoryFilter exclude(boolean matchAny, Class... categories) {
return new CategoryFilter(true, null, matchAny, categories);
}
public static CategoryFilter exclude(Class category) {
return exclude(true, category);
}
public static CategoryFilter exclude(Class... categories) {
return exclude(true, categories);
}
public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set> inclusions,
boolean matchAnyExclusions, Set> exclusions) {
return new CategoryFilter(matchAnyInclusions, inclusions, matchAnyExclusions, exclusions);
}
@Deprecated
public CategoryFilter(Class includedCategory, Class excludedCategory) {
includedAny = true;
excludedAny = true;
included = nullableClassToSet(includedCategory);
excluded = nullableClassToSet(excludedCategory);
}
protected CategoryFilter(boolean matchAnyIncludes, Set> includes,
boolean matchAnyExcludes, Set> excludes) {
includedAny = matchAnyIncludes;
excludedAny = matchAnyExcludes;
included = copyAndRefine(includes);
excluded = copyAndRefine(excludes);
}
private CategoryFilter(boolean matchAnyIncludes, Class[] inclusions,
boolean matchAnyExcludes, Class[] exclusions) {
includedAny = matchAnyIncludes;
excludedAny = matchAnyExcludes;
included = createSet(inclusions);
excluded = createSet(exclusions);
}
/**
* @see #toString()
*/
@Override
public String describe() {
return toString();
}
/**
* Returns string in the form "[included categories] - [excluded categories]" , where both
* sets have comma separated names of categories.
*
* @return string representation for the relative complement of excluded categories set
* in the set of included categories. Examples:
*
* "categories [all]" for all included categories and no excluded ones;
* "categories [all] - [A, B]" for all included categories and given excluded ones;
* "categories [A, B] - [C, D]" for given included categories and given excluded ones.
*
* @see Class#toString() name of category
*/
@Override public String toString() {
StringBuilder description= new StringBuilder("categories ")
.append(included.isEmpty() ? "[all]" : included);
if (!excluded.isEmpty()) {
description.append(" - ").append(excluded);
}
return description.toString();
}
@Override
public boolean shouldRun(Description description) {
if (hasCorrectCategoryAnnotation(description)) {
return true;
}
for (Description each : description.getChildren()) {
if (shouldRun(each)) {
return true;
}
}
return false;
}
private boolean hasCorrectCategoryAnnotation(Description description) {
final Set> childCategories= categories(description);
// If a child has no categories, immediately return.
if (childCategories.isEmpty()) {
return included.isEmpty();
}
if (!excluded.isEmpty()) {
if (excludedAny) {
if (matchesAnyParentCategories(childCategories, excluded)) {
return false;
}
} else {
if (matchesAllParentCategories(childCategories, excluded)) {
return false;
}
}
}
if (included.isEmpty()) {
// Couldn't be excluded, and with no suite's included categories treated as should run.
return true;
} else {
if (includedAny) {
return matchesAnyParentCategories(childCategories, included);
} else {
return matchesAllParentCategories(childCategories, included);
}
}
}
/**
* @return true if at least one (any) parent category match a child, otherwise false .
* If empty parentCategories , returns false .
*/
private boolean matchesAnyParentCategories(Set> childCategories, Set> parentCategories) {
for (Class parentCategory : parentCategories) {
if (hasAssignableTo(childCategories, parentCategory)) {
return true;
}
}
return false;
}
/**
* @return false if at least one parent category does not match children, otherwise true .
* If empty parentCategories , returns true .
*/
private boolean matchesAllParentCategories(Set> childCategories, Set> parentCategories) {
for (Class parentCategory : parentCategories) {
if (!hasAssignableTo(childCategories, parentCategory)) {
return false;
}
}
return true;
}
private static Set> categories(Description description) {
Set> categories= new HashSet>();
Collections.addAll(categories, directCategories(description));
Collections.addAll(categories, directCategories(parentDescription(description)));
return categories;
}
private static Description parentDescription(Description description) {
Class testClass= description.getTestClass();
return testClass == null ? null : Description.createSuiteDescription(testClass);
}
private static Class[] directCategories(Description description) {
if (description == null) {
return new Class[0];
}
Category annotation= description.getAnnotation(Category.class);
return annotation == null ? new Class[0] : annotation.value();
}
private static Set> copyAndRefine(Set> classes) {
Set> c= new LinkedHashSet>();
if (classes != null) {
c.addAll(classes);
}
c.remove(null);
return c;
}
}
public Categories(Class klass, RunnerBuilder builder) throws InitializationError {
super(klass, builder);
try {
Set> included= getIncludedCategory(klass);
Set> excluded= getExcludedCategory(klass);
boolean isAnyIncluded= isAnyIncluded(klass);
boolean isAnyExcluded= isAnyExcluded(klass);
filter(CategoryFilter.categoryFilter(isAnyIncluded, included, isAnyExcluded, excluded));
} catch (NoTestsRemainException e) {
throw new InitializationError(e);
}
}
private static Set> getIncludedCategory(Class klass) {
IncludeCategory annotation= klass.getAnnotation(IncludeCategory.class);
return createSet(annotation == null ? null : annotation.value());
}
private static boolean isAnyIncluded(Class klass) {
IncludeCategory annotation= klass.getAnnotation(IncludeCategory.class);
return annotation == null || annotation.matchAny();
}
private static Set> getExcludedCategory(Class klass) {
ExcludeCategory annotation= klass.getAnnotation(ExcludeCategory.class);
return createSet(annotation == null ? null : annotation.value());
}
private static boolean isAnyExcluded(Class klass) {
ExcludeCategory annotation= klass.getAnnotation(ExcludeCategory.class);
return annotation == null || annotation.matchAny();
}
private static boolean hasAssignableTo(Set> assigns, Class to) {
for (final Class from : assigns) {
if (to.isAssignableFrom(from)) {
return true;
}
}
return false;
}
private static Set> createSet(Class[] classes) {
// Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.12
// for include(boolean, Class...) and exclude(boolean, Class...)
if (classes == null || classes.length == 0) {
return Collections.emptySet();
}
for (Class category : classes) {
if (category == null) {
throw new NullPointerException("has null category");
}
}
return classes.length == 1
? Collections.>singleton(classes[0])
: new LinkedHashSet>(Arrays.asList(classes));
}
private static Set> nullableClassToSet(Class nullableClass) {
// Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.11
// for CategoryFilter(Class includedCategory, Class excludedCategory)
return nullableClass == null
? Collections.>emptySet()
: Collections.>singleton(nullableClass);
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/categories/Category.java 0000664 0000000 0000000 00000002012 14011777271 0027020 0 ustar 00root root 0000000 0000000 package org.junit.experimental.categories;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import org.junit.validator.ValidateWith;
/**
* Marks a test class or test method as belonging to one or more categories of tests.
* The value is an array of arbitrary classes.
*
* This annotation is only interpreted by the Categories runner (at present).
*
* For example:
*
* public interface FastTests {}
* public interface SlowTests {}
*
* public static class A {
* @Test
* public void a() {
* fail();
* }
*
* @Category(SlowTests.class)
* @Test
* public void b() {
* }
* }
*
* @Category({SlowTests.class, FastTests.class})
* public static class B {
* @Test
* public void c() {
*
* }
* }
*
*
* For more usage, see code example on {@link Categories}.
*/
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@ValidateWith(CategoryValidator.class)
public @interface Category {
Class[] value();
} junit4-r4.13.2/src/main/java/org/junit/experimental/categories/CategoryFilterFactory.java 0000664 0000000 0000000 00000003407 14011777271 0031527 0 ustar 00root root 0000000 0000000 package org.junit.experimental.categories;
import java.util.ArrayList;
import java.util.List;
import org.junit.internal.Classes;
import org.junit.runner.FilterFactory;
import org.junit.runner.FilterFactoryParams;
import org.junit.runner.manipulation.Filter;
/**
* Implementation of FilterFactory for Category filtering.
*/
abstract class CategoryFilterFactory implements FilterFactory {
/**
* Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given a
* {@link FilterFactoryParams} argument.
*
* @param params Parameters needed to create the {@link Filter}
*/
public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
try {
return createFilter(parseCategories(params.getArgs()));
} catch (ClassNotFoundException e) {
throw new FilterNotCreatedException(e);
}
}
/**
* Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given an array of classes.
*
* @param categories Category classes.
*/
protected abstract Filter createFilter(List> categories);
private List> parseCategories(String categories) throws ClassNotFoundException {
List> categoryClasses = new ArrayList>();
for (String category : categories.split(",")) {
/*
* Load the category class using the context class loader.
* If there is no context class loader, use the class loader for this class.
*/
Class categoryClass = Classes.getClass(category, getClass());
categoryClasses.add(categoryClass);
}
return categoryClasses;
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/categories/CategoryValidator.java 0000664 0000000 0000000 00000004210 14011777271 0030670 0 ustar 00root root 0000000 0000000 package org.junit.experimental.categories;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableList;
import static java.util.Collections.unmodifiableSet;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.runners.model.FrameworkMethod;
import org.junit.validator.AnnotationValidator;
/**
* Validates that there are no errors in the use of the {@code Category}
* annotation. If there is, a {@code Throwable} object will be added to the list
* of errors.
*
* @since 4.12
*/
public final class CategoryValidator extends AnnotationValidator {
@SuppressWarnings("unchecked")
private static final Set> INCOMPATIBLE_ANNOTATIONS = unmodifiableSet(new HashSet>(
asList(BeforeClass.class, AfterClass.class, Before.class, After.class)));
/**
* Adds to {@code errors} a throwable for each problem detected. Looks for
* {@code BeforeClass}, {@code AfterClass}, {@code Before} and {@code After}
* annotations.
*
* @param method the method that is being validated
* @return A list of exceptions detected
*
* @since 4.12
*/
@Override
public List validateAnnotatedMethod(FrameworkMethod method) {
List errors = new ArrayList();
Annotation[] annotations = method.getAnnotations();
for (Annotation annotation : annotations) {
for (Class clazz : INCOMPATIBLE_ANNOTATIONS) {
if (annotation.annotationType().isAssignableFrom(clazz)) {
addErrorMessage(errors, clazz);
}
}
}
return unmodifiableList(errors);
}
private void addErrorMessage(List errors, Class clazz) {
String message = String.format("@%s can not be combined with @Category",
clazz.getSimpleName());
errors.add(new Exception(message));
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/categories/ExcludeCategories.java 0000664 0000000 0000000 00000003012 14011777271 0030643 0 ustar 00root root 0000000 0000000 package org.junit.experimental.categories;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.experimental.categories.Categories.CategoryFilter;
import org.junit.runner.manipulation.Filter;
/**
* {@link org.junit.runner.FilterFactory} to exclude categories.
*
* The {@link Filter} that is created will filter out tests that are categorized with any of the
* given categories.
*
* Usage from command line:
*
* --filter=org.junit.experimental.categories.ExcludeCategories=pkg.of.Cat1,pkg.of.Cat2
*
*
* Usage from API:
*
* new ExcludeCategories().createFilter(Cat1.class, Cat2.class);
*
*/
public final class ExcludeCategories extends CategoryFilterFactory {
/**
* Creates a {@link Filter} which is only passed by tests that are
* not categorized with any of the specified categories.
*
* @param categories Category classes.
*/
@Override
protected Filter createFilter(List> categories) {
return new ExcludesAny(categories);
}
private static class ExcludesAny extends CategoryFilter {
public ExcludesAny(List> categories) {
this(new HashSet>(categories));
}
public ExcludesAny(Set> categories) {
super(true, null, true, categories);
}
@Override
public String describe() {
return "excludes " + super.describe();
}
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/categories/IncludeCategories.java 0000664 0000000 0000000 00000003006 14011777271 0030640 0 ustar 00root root 0000000 0000000 package org.junit.experimental.categories;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.experimental.categories.Categories.CategoryFilter;
import org.junit.runner.manipulation.Filter;
/**
* {@link org.junit.runner.FilterFactory} to include categories.
*
* The {@link Filter} that is created will filter out tests that are categorized with any of the
* given categories.
*
* Usage from command line:
*
* --filter=org.junit.experimental.categories.IncludeCategories=pkg.of.Cat1,pkg.of.Cat2
*
*
* Usage from API:
*
* new IncludeCategories().createFilter(Cat1.class, Cat2.class);
*
*/
public final class IncludeCategories extends CategoryFilterFactory {
/**
* Creates a {@link Filter} which is only passed by tests that are
* categorized with any of the specified categories.
*
* @param categories Category classes.
*/
@Override
protected Filter createFilter(List> categories) {
return new IncludesAny(categories);
}
private static class IncludesAny extends CategoryFilter {
public IncludesAny(List> categories) {
this(new HashSet>(categories));
}
public IncludesAny(Set> categories) {
super(true, categories, true, null);
}
@Override
public String describe() {
return "includes " + super.describe();
}
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/max/ 0000775 0000000 0000000 00000000000 14011777271 0023045 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/max/CouldNotReadCoreException.java 0000664 0000000 0000000 00000000507 14011777271 0030725 0 ustar 00root root 0000000 0000000 package org.junit.experimental.max;
/**
* Thrown when Max cannot read the MaxCore serialization
*/
public class CouldNotReadCoreException extends Exception {
private static final long serialVersionUID = 1L;
/**
* Constructs
*/
public CouldNotReadCoreException(Throwable e) {
super(e);
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/max/MaxCore.java 0000664 0000000 0000000 00000014415 14011777271 0025253 0 ustar 00root root 0000000 0000000 package org.junit.experimental.max;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import junit.framework.TestSuite;
import org.junit.internal.requests.SortingRequest;
import org.junit.internal.runners.ErrorReportingRunner;
import org.junit.internal.runners.JUnit38ClassRunner;
import org.junit.runner.Description;
import org.junit.runner.JUnitCore;
import org.junit.runner.Request;
import org.junit.runner.Result;
import org.junit.runner.Runner;
import org.junit.runners.Suite;
import org.junit.runners.model.InitializationError;
/**
* A replacement for JUnitCore, which keeps track of runtime and failure history, and reorders tests
* to maximize the chances that a failing test occurs early in the test run.
*
* The rules for sorting are:
*
* Never-run tests first, in arbitrary order
* Group remaining tests by the date at which they most recently failed.
* Sort groups such that the most recent failure date is first, and never-failing tests are at the end.
* Within a group, run the fastest tests first.
*
*/
public class MaxCore {
private static final String MALFORMED_JUNIT_3_TEST_CLASS_PREFIX = "malformed JUnit 3 test class: ";
/**
* Create a new MaxCore from a serialized file stored at storedResults
*
* @deprecated use storedLocally()
*/
@Deprecated
public static MaxCore forFolder(String folderName) {
return storedLocally(new File(folderName));
}
/**
* Create a new MaxCore from a serialized file stored at storedResults
*/
public static MaxCore storedLocally(File storedResults) {
return new MaxCore(storedResults);
}
private final MaxHistory history;
private MaxCore(File storedResults) {
history = MaxHistory.forFolder(storedResults);
}
/**
* Run all the tests in class.
*
* @return a {@link Result} describing the details of the test run and the failed tests.
*/
public Result run(Class testClass) {
return run(Request.aClass(testClass));
}
/**
* Run all the tests contained in request.
*
* @param request the request describing tests
* @return a {@link Result} describing the details of the test run and the failed tests.
*/
public Result run(Request request) {
return run(request, new JUnitCore());
}
/**
* Run all the tests contained in request.
*
* This variant should be used if {@code core} has attached listeners that this
* run should notify.
*
* @param request the request describing tests
* @param core a JUnitCore to delegate to.
* @return a {@link Result} describing the details of the test run and the failed tests.
*/
public Result run(Request request, JUnitCore core) {
core.addListener(history.listener());
return core.run(sortRequest(request).getRunner());
}
/**
* @return a new Request, which contains all of the same tests, but in a new order.
*/
public Request sortRequest(Request request) {
if (request instanceof SortingRequest) {
// We'll pay big karma points for this
return request;
}
List leaves = findLeaves(request);
Collections.sort(leaves, history.testComparator());
return constructLeafRequest(leaves);
}
private Request constructLeafRequest(List leaves) {
final List runners = new ArrayList();
for (Description each : leaves) {
runners.add(buildRunner(each));
}
return new Request() {
@Override
public Runner getRunner() {
try {
return new Suite((Class) null, runners) {
};
} catch (InitializationError e) {
return new ErrorReportingRunner(null, e);
}
}
};
}
private Runner buildRunner(Description each) {
if (each.toString().equals("TestSuite with 0 tests")) {
return Suite.emptySuite();
}
if (each.toString().startsWith(MALFORMED_JUNIT_3_TEST_CLASS_PREFIX)) {
// This is cheating, because it runs the whole class
// to get the warning for this method, but we can't do better,
// because JUnit 3.8's
// thrown away which method the warning is for.
return new JUnit38ClassRunner(new TestSuite(getMalformedTestClass(each)));
}
Class type = each.getTestClass();
if (type == null) {
throw new RuntimeException("Can't build a runner from description [" + each + "]");
}
String methodName = each.getMethodName();
if (methodName == null) {
return Request.aClass(type).getRunner();
}
return Request.method(type, methodName).getRunner();
}
private Class getMalformedTestClass(Description each) {
try {
return Class.forName(each.toString().replace(MALFORMED_JUNIT_3_TEST_CLASS_PREFIX, ""));
} catch (ClassNotFoundException e) {
return null;
}
}
/**
* @param request a request to run
* @return a list of method-level tests to run, sorted in the order
* specified in the class comment.
*/
public List sortedLeavesForTest(Request request) {
return findLeaves(sortRequest(request));
}
private List findLeaves(Request request) {
List results = new ArrayList();
findLeaves(null, request.getRunner().getDescription(), results);
return results;
}
private void findLeaves(Description parent, Description description, List results) {
if (description.getChildren().isEmpty()) {
if (description.toString().equals("warning(junit.framework.TestSuite$1)")) {
results.add(Description.createSuiteDescription(MALFORMED_JUNIT_3_TEST_CLASS_PREFIX + parent));
} else {
results.add(description);
}
} else {
for (Description each : description.getChildren()) {
findLeaves(description, each, results);
}
}
}
} junit4-r4.13.2/src/main/java/org/junit/experimental/max/MaxHistory.java 0000664 0000000 0000000 00000012614 14011777271 0026023 0 ustar 00root root 0000000 0000000 package org.junit.experimental.max;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import org.junit.runner.Description;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
/**
* Stores a subset of the history of each test:
*
* Last failure timestamp
* Duration of last execution
*
*/
public class MaxHistory implements Serializable {
private static final long serialVersionUID = 1L;
/**
* Loads a {@link MaxHistory} from {@code file}, or generates a new one that
* will be saved to {@code file}.
*/
public static MaxHistory forFolder(File file) {
if (file.exists()) {
try {
return readHistory(file);
} catch (CouldNotReadCoreException e) {
e.printStackTrace();
file.delete();
}
}
return new MaxHistory(file);
}
private static MaxHistory readHistory(File storedResults)
throws CouldNotReadCoreException {
try {
FileInputStream file = new FileInputStream(storedResults);
try {
ObjectInputStream stream = new ObjectInputStream(file);
try {
return (MaxHistory) stream.readObject();
} finally {
stream.close();
}
} finally {
file.close();
}
} catch (Exception e) {
throw new CouldNotReadCoreException(e);
}
}
/*
* We have to use the f prefix until the next major release to ensure
* serialization compatibility.
* See https://github.com/junit-team/junit4/issues/976
*/
private final Map fDurations = new HashMap();
private final Map fFailureTimestamps = new HashMap();
private final File fHistoryStore;
private MaxHistory(File storedResults) {
fHistoryStore = storedResults;
}
private void save() throws IOException {
ObjectOutputStream stream = null;
try {
stream = new ObjectOutputStream(new FileOutputStream(fHistoryStore));
stream.writeObject(this);
} finally {
if (stream != null) {
stream.close();
}
}
}
Long getFailureTimestamp(Description key) {
return fFailureTimestamps.get(key.toString());
}
void putTestFailureTimestamp(Description key, long end) {
fFailureTimestamps.put(key.toString(), end);
}
boolean isNewTest(Description key) {
return !fDurations.containsKey(key.toString());
}
Long getTestDuration(Description key) {
return fDurations.get(key.toString());
}
void putTestDuration(Description description, long duration) {
fDurations.put(description.toString(), duration);
}
private final class RememberingListener extends RunListener {
private long overallStart = System.currentTimeMillis();
private Map starts = new HashMap();
@Override
public void testStarted(Description description) throws Exception {
starts.put(description, System.nanoTime()); // Get most accurate
// possible time
}
@Override
public void testFinished(Description description) throws Exception {
long end = System.nanoTime();
long start = starts.get(description);
putTestDuration(description, end - start);
}
@Override
public void testFailure(Failure failure) throws Exception {
putTestFailureTimestamp(failure.getDescription(), overallStart);
}
@Override
public void testRunFinished(Result result) throws Exception {
save();
}
}
private class TestComparator implements Comparator {
public int compare(Description o1, Description o2) {
// Always prefer new tests
if (isNewTest(o1)) {
return -1;
}
if (isNewTest(o2)) {
return 1;
}
// Then most recently failed first
int result = getFailure(o2).compareTo(getFailure(o1));
return result != 0 ? result
// Then shorter tests first
: getTestDuration(o1).compareTo(getTestDuration(o2));
}
private Long getFailure(Description key) {
Long result = getFailureTimestamp(key);
if (result == null) {
return 0L; // 0 = "never failed (that I know about)"
}
return result;
}
}
/**
* @return a listener that will update this history based on the test
* results reported.
*/
public RunListener listener() {
return new RememberingListener();
}
/**
* @return a comparator that ranks tests based on the JUnit Max sorting
* rules, as described in the {@link MaxCore} class comment.
*/
public Comparator testComparator() {
return new TestComparator();
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/results/ 0000775 0000000 0000000 00000000000 14011777271 0023761 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/results/FailureList.java 0000664 0000000 0000000 00000001351 14011777271 0027047 0 ustar 00root root 0000000 0000000 package org.junit.experimental.results;
import java.util.List;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
class FailureList {
private final List failures;
public FailureList(List failures) {
this.failures = failures;
}
public Result result() {
Result result = new Result();
RunListener listener = result.createListener();
for (Failure failure : failures) {
try {
listener.testFailure(failure);
} catch (Exception e) {
throw new RuntimeException("I can't believe this happened");
}
}
return result;
}
} junit4-r4.13.2/src/main/java/org/junit/experimental/results/PrintableResult.java 0000664 0000000 0000000 00000003440 14011777271 0027744 0 ustar 00root root 0000000 0000000 package org.junit.experimental.results;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.List;
import org.junit.internal.TextListener;
import org.junit.runner.JUnitCore;
import org.junit.runner.Request;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
/**
* A test result that prints nicely in error messages.
* This is only intended to be used in JUnit self-tests.
* For example:
*
*
* assertThat(testResult(HasExpectedException.class), isSuccessful());
*
*/
public class PrintableResult {
private Result result;
/**
* The result of running JUnit on {@code type}
*/
public static PrintableResult testResult(Class type) {
return testResult(Request.aClass(type));
}
/**
* The result of running JUnit on Request {@code request}
*/
public static PrintableResult testResult(Request request) {
return new PrintableResult(new JUnitCore().run(request));
}
/**
* A result that includes the given {@code failures}
*/
public PrintableResult(List failures) {
this(new FailureList(failures).result());
}
private PrintableResult(Result result) {
this.result = result;
}
/**
* Returns the number of failures in this result.
*/
public int failureCount() {
return result.getFailures().size();
}
/**
* Returns the failures in this result.
*
* @since 4.13
*/
public List failures() {
return result.getFailures();
}
@Override
public String toString() {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
new TextListener(new PrintStream(stream)).testRunFinished(result);
return stream.toString();
}
} junit4-r4.13.2/src/main/java/org/junit/experimental/results/ResultMatchers.java 0000664 0000000 0000000 00000006044 14011777271 0027575 0 ustar 00root root 0000000 0000000 package org.junit.experimental.results;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
/**
* Matchers on a PrintableResult, to enable JUnit self-tests.
* For example:
*
*
* assertThat(testResult(HasExpectedException.class), isSuccessful());
*
*/
public class ResultMatchers {
/**
* Do not instantiate.
* @deprecated will be private soon.
*/
@Deprecated
public ResultMatchers() {
}
/**
* Matches if the tests are all successful
*/
public static Matcher isSuccessful() {
return failureCountIs(0);
}
/**
* Matches if there are {@code count} failures
*/
public static Matcher failureCountIs(final int count) {
return new TypeSafeMatcher() {
public void describeTo(Description description) {
description.appendText("has " + count + " failures");
}
@Override
public boolean matchesSafely(PrintableResult item) {
return item.failureCount() == count;
}
};
}
/**
* Matches if the result has exactly one failure, and it contains {@code string}
*/
public static Matcher hasSingleFailureContaining(final String string) {
return new BaseMatcher() {
public boolean matches(Object item) {
return item.toString().contains(string) && failureCountIs(1).matches(item);
}
public void describeTo(Description description) {
description.appendText("has single failure containing " + string);
}
};
}
/**
* Matches if the result has exactly one failure matching the given matcher.
*
* @since 4.13
*/
public static Matcher hasSingleFailureMatching(final Matcher matcher) {
return new TypeSafeMatcher() {
@Override
public boolean matchesSafely(PrintableResult item) {
return item.failureCount() == 1 && matcher.matches(item.failures().get(0).getException());
}
public void describeTo(Description description) {
description.appendText("has failure with exception matching ");
matcher.describeTo(description);
}
};
}
/**
* Matches if the result has one or more failures, and at least one of them
* contains {@code string}
*/
public static Matcher hasFailureContaining(final String string) {
return new TypeSafeMatcher() {
@Override
public boolean matchesSafely(PrintableResult item) {
return item.failureCount() > 0 && item.toString().contains(string);
}
public void describeTo(Description description) {
description.appendText("has failure containing " + string);
}
};
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/runners/ 0000775 0000000 0000000 00000000000 14011777271 0023754 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/runners/Enclosed.java 0000664 0000000 0000000 00000002750 14011777271 0026357 0 ustar 00root root 0000000 0000000 package org.junit.experimental.runners;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import org.junit.runners.Suite;
import org.junit.runners.model.RunnerBuilder;
/**
* If you put tests in inner classes, Ant, for example, won't find them. By running the outer class
* with Enclosed, the tests in the inner classes will be run. You might put tests in inner classes
* to group them for convenience or to share constants. Abstract inner classes are ignored.
*
* So, for example:
*
* @RunWith(Enclosed.class)
* public class ListTests {
* ...useful shared stuff...
* public static class OneKindOfListTest {...}
* public static class AnotherKind {...}
* abstract public static class Ignored {...}
* }
*
*/
public class Enclosed extends Suite {
/**
* Only called reflectively. Do not use programmatically.
*/
public Enclosed(Class klass, RunnerBuilder builder) throws Throwable {
super(builder, klass, filterAbstractClasses(klass.getClasses()));
}
private static Class[] filterAbstractClasses(final Class[] classes) {
final List> filteredList= new ArrayList>(classes.length);
for (final Class clazz : classes) {
if (!Modifier.isAbstract(clazz.getModifiers())) {
filteredList.add(clazz);
}
}
return filteredList.toArray(new Class[filteredList.size()]);
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/ 0000775 0000000 0000000 00000000000 14011777271 0024102 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/theories/DataPoint.java 0000664 0000000 0000000 00000004104 14011777271 0026627 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotating an field or method with @DataPoint will cause the field value
* or the value returned by the method to be used as a potential parameter for
* theories in that class, when run with the
* {@link org.junit.experimental.theories.Theories Theories} runner.
*
* A DataPoint is only considered as a potential value for parameters for
* which its type is assignable. When multiple {@code DataPoint}s exist
* with overlapping types more control can be obtained by naming each DataPoint
* using the value of this annotation, e.g. with
* @DataPoint({"dataset1", "dataset2"}), and then specifying
* which named set to consider as potential values for each parameter using the
* {@link org.junit.experimental.theories.FromDataPoints @FromDataPoints}
* annotation.
*
* Parameters with no specified source (i.e. without @FromDataPoints or
* other {@link org.junit.experimental.theories.ParametersSuppliedBy
* @ParameterSuppliedBy} annotations) will use all {@code DataPoint}s that are
* assignable to the parameter type as potential values, including named sets of
* {@code DataPoint}s.
*
*
* @DataPoint
* public static String dataPoint = "value";
*
* @DataPoint("generated")
* public static String generatedDataPoint() {
* return "generated value";
* }
*
* @Theory
* public void theoryMethod(String param) {
* ...
* }
*
*
* @see org.junit.experimental.theories.Theories
* @see org.junit.experimental.theories.Theory
* @see org.junit.experimental.theories.DataPoint
* @see org.junit.experimental.theories.FromDataPoints
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({FIELD, METHOD})
public @interface DataPoint {
String[] value() default {};
Class[] ignoredExceptions() default {};
} junit4-r4.13.2/src/main/java/org/junit/experimental/theories/DataPoints.java 0000664 0000000 0000000 00000004774 14011777271 0027027 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotating an array or iterable-typed field or method with @DataPoints
* will cause the values in the array or iterable given to be used as potential
* parameters for theories in that class when run with the
* {@link org.junit.experimental.theories.Theories Theories} runner.
*
* DataPoints will only be considered as potential values for parameters for
* which their types are assignable. When multiple sets of DataPoints exist with
* overlapping types more control can be obtained by naming the DataPoints using
* the value of this annotation, e.g. with
* @DataPoints({"dataset1", "dataset2"}), and then specifying
* which named set to consider as potential values for each parameter using the
* {@link org.junit.experimental.theories.FromDataPoints @FromDataPoints}
* annotation.
*
* Parameters with no specified source (i.e. without @FromDataPoints or
* other {@link org.junit.experimental.theories.ParametersSuppliedBy
* @ParameterSuppliedBy} annotations) will use all DataPoints that are
* assignable to the parameter type as potential values, including named sets of
* DataPoints.
*
* DataPoints methods whose array types aren't assignable from the target
* parameter type (and so can't possibly return relevant values) will not be
* called when generating values for that parameter. Iterable-typed datapoints
* methods must always be called though, as this information is not available
* here after generic type erasure, so expensive methods returning iterable
* datapoints are a bad idea.
*
*
* @DataPoints
* public static String[] dataPoints = new String[] { ... };
*
* @DataPoints
* public static String[] generatedDataPoints() {
* return new String[] { ... };
* }
*
* @Theory
* public void theoryMethod(String param) {
* ...
* }
*
*
* @see org.junit.experimental.theories.Theories
* @see org.junit.experimental.theories.Theory
* @see org.junit.experimental.theories.DataPoint
* @see org.junit.experimental.theories.FromDataPoints
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ FIELD, METHOD })
public @interface DataPoints {
String[] value() default {};
Class[] ignoredExceptions() default {};
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/FromDataPoints.java 0000664 0000000 0000000 00000003726 14011777271 0027647 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.experimental.theories.internal.SpecificDataPointsSupplier;
/**
* Annotating a parameter of a {@link org.junit.experimental.theories.Theory
* @Theory} method with @FromDataPoints will limit the
* datapoints considered as potential values for that parameter to just the
* {@link org.junit.experimental.theories.DataPoints DataPoints} with the given
* name. DataPoint names can be given as the value parameter of the
* @DataPoints annotation.
*
* DataPoints without names will not be considered as values for any parameters
* annotated with @FromDataPoints.
*
* @DataPoints
* public static String[] unnamed = new String[] { ... };
*
* @DataPoints("regexes")
* public static String[] regexStrings = new String[] { ... };
*
* @DataPoints({"forMatching", "alphanumeric"})
* public static String[] testStrings = new String[] { ... };
*
* @Theory
* public void stringTheory(String param) {
* // This will be called with every value in 'regexStrings',
* // 'testStrings' and 'unnamed'.
* }
*
* @Theory
* public void regexTheory(@FromDataPoints("regexes") String regex,
* @FromDataPoints("forMatching") String value) {
* // This will be called with only the values in 'regexStrings' as
* // regex, only the values in 'testStrings' as value, and none
* // of the values in 'unnamed'.
* }
*
*
* @see org.junit.experimental.theories.Theory
* @see org.junit.experimental.theories.DataPoint
* @see org.junit.experimental.theories.DataPoints
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
@ParametersSuppliedBy(SpecificDataPointsSupplier.class)
public @interface FromDataPoints {
String value();
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/ParameterSignature.java 0000664 0000000 0000000 00000011021 14011777271 0030542 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ParameterSignature {
private static final Map, Class> CONVERTABLE_TYPES_MAP = buildConvertableTypesMap();
private static Map, Class> buildConvertableTypesMap() {
Map, Class> map = new HashMap, Class>();
putSymmetrically(map, boolean.class, Boolean.class);
putSymmetrically(map, byte.class, Byte.class);
putSymmetrically(map, short.class, Short.class);
putSymmetrically(map, char.class, Character.class);
putSymmetrically(map, int.class, Integer.class);
putSymmetrically(map, long.class, Long.class);
putSymmetrically(map, float.class, Float.class);
putSymmetrically(map, double.class, Double.class);
return Collections.unmodifiableMap(map);
}
private static void putSymmetrically(Map map, T a, T b) {
map.put(a, b);
map.put(b, a);
}
public static ArrayList signatures(Method method) {
return signatures(method.getParameterTypes(), method
.getParameterAnnotations());
}
public static List signatures(Constructor constructor) {
return signatures(constructor.getParameterTypes(), constructor
.getParameterAnnotations());
}
private static ArrayList signatures(
Class[] parameterTypes, Annotation[][] parameterAnnotations) {
ArrayList sigs = new ArrayList();
for (int i = 0; i < parameterTypes.length; i++) {
sigs.add(new ParameterSignature(parameterTypes[i],
parameterAnnotations[i]));
}
return sigs;
}
private final Class type;
private final Annotation[] annotations;
private ParameterSignature(Class type, Annotation[] annotations) {
this.type = type;
this.annotations = annotations;
}
public boolean canAcceptValue(Object candidate) {
return (candidate == null) ? !type.isPrimitive() : canAcceptType(candidate.getClass());
}
public boolean canAcceptType(Class candidate) {
return type.isAssignableFrom(candidate) ||
isAssignableViaTypeConversion(type, candidate);
}
public boolean canPotentiallyAcceptType(Class candidate) {
return candidate.isAssignableFrom(type) ||
isAssignableViaTypeConversion(candidate, type) ||
canAcceptType(candidate);
}
private boolean isAssignableViaTypeConversion(Class targetType, Class candidate) {
if (CONVERTABLE_TYPES_MAP.containsKey(candidate)) {
Class wrapperClass = CONVERTABLE_TYPES_MAP.get(candidate);
return targetType.isAssignableFrom(wrapperClass);
} else {
return false;
}
}
public Class getType() {
return type;
}
public List getAnnotations() {
return Arrays.asList(annotations);
}
public boolean hasAnnotation(Class type) {
return getAnnotation(type) != null;
}
public T findDeepAnnotation(Class annotationType) {
Annotation[] annotations2 = annotations;
return findDeepAnnotation(annotations2, annotationType, 3);
}
private T findDeepAnnotation(
Annotation[] annotations, Class annotationType, int depth) {
if (depth == 0) {
return null;
}
for (Annotation each : annotations) {
if (annotationType.isInstance(each)) {
return annotationType.cast(each);
}
Annotation candidate = findDeepAnnotation(each.annotationType()
.getAnnotations(), annotationType, depth - 1);
if (candidate != null) {
return annotationType.cast(candidate);
}
}
return null;
}
public T getAnnotation(Class annotationType) {
for (Annotation each : getAnnotations()) {
if (annotationType.isInstance(each)) {
return annotationType.cast(each);
}
}
return null;
}
} junit4-r4.13.2/src/main/java/org/junit/experimental/theories/ParameterSupplier.java 0000664 0000000 0000000 00000003172 14011777271 0030414 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import java.util.List;
/**
* Abstract parent class for suppliers of input data points for theories. Extend this class to customize how {@link
* org.junit.experimental.theories.Theories Theories} runner
* finds accepted data points. Then use your class together with @ParametersSuppliedBy on input
* parameters for theories.
*
*
* For example, here is a supplier for values between two integers, and an annotation that references it:
*
*
* @Retention(RetentionPolicy.RUNTIME)
* @ParametersSuppliedBy (BetweenSupplier.class)
* public @interface Between {
* int first();
*
* int last();
* }
*
* public static class BetweenSupplier extends ParameterSupplier {
* @Override
* public List<PotentialAssignment > getValueSources(ParameterSignature sig) {
* List<PotentialAssignment > list = new ArrayList<PotentialAssignment>();
* Between annotation = (Between) sig.getSupplierAnnotation();
*
* for (int i = annotation.first(); i <= annotation.last(); i++)
* list.add(PotentialAssignment .forValue("ints", i));
* return list;
* }
* }
*
*
*
* @see org.junit.experimental.theories.ParametersSuppliedBy
* @see org.junit.experimental.theories.Theories
* @see org.junit.experimental.theories.FromDataPoints
*/
public abstract class ParameterSupplier {
public abstract List getValueSources(ParameterSignature sig) throws Throwable;
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/ParametersSuppliedBy.java 0000664 0000000 0000000 00000002667 14011777271 0031064 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.PARAMETER;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotating a {@link org.junit.experimental.theories.Theory Theory} method
* parameter with @ParametersSuppliedBy causes it to be supplied with
* values from the named
* {@link org.junit.experimental.theories.ParameterSupplier ParameterSupplier}
* when run as a theory by the {@link org.junit.experimental.theories.Theories
* Theories} runner.
*
* In addition, annotations themselves can be annotated with
* @ParametersSuppliedBy, and then used similarly. ParameterSuppliedBy
* annotations on parameters are detected by searching up this hierarchy such
* that these act as syntactic sugar, making:
*
*
* @ParametersSuppliedBy(Supplier.class)
* public @interface SpecialParameter { }
*
* @Theory
* public void theoryMethod(@SpecialParameter String param) {
* ...
* }
*
*
* equivalent to:
*
*
* @Theory
* public void theoryMethod(@ParametersSuppliedBy(Supplier.class) String param) {
* ...
* }
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ANNOTATION_TYPE, PARAMETER })
public @interface ParametersSuppliedBy {
Class value();
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/PotentialAssignment.java 0000664 0000000 0000000 00000003104 14011777271 0030733 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import static java.lang.String.format;
public abstract class PotentialAssignment {
public static class CouldNotGenerateValueException extends Exception {
private static final long serialVersionUID = 1L;
public CouldNotGenerateValueException() {
}
public CouldNotGenerateValueException(Throwable e) {
super(e);
}
}
public static PotentialAssignment forValue(final String name, final Object value) {
return new PotentialAssignment() {
@Override
public Object getValue() {
return value;
}
@Override
public String toString() {
return format("[%s]", value);
}
@Override
public String getDescription() {
String valueString;
if (value == null) {
valueString = "null";
} else {
try {
valueString = format("\"%s\"", value);
} catch (Throwable e) {
valueString = format("[toString() threw %s: %s]",
e.getClass().getSimpleName(), e.getMessage());
}
}
return format("%s ", valueString, name);
}
};
}
public abstract Object getValue() throws CouldNotGenerateValueException;
public abstract String getDescription() throws CouldNotGenerateValueException;
} junit4-r4.13.2/src/main/java/org/junit/experimental/theories/Theories.java 0000664 0000000 0000000 00000031350 14011777271 0026531 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.experimental.theories.internal.Assignments;
import org.junit.experimental.theories.internal.ParameterizedAssertionError;
import org.junit.internal.AssumptionViolatedException;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;
import org.junit.runners.model.TestClass;
/**
* The Theories runner allows to test a certain functionality against a subset of an infinite set of data points.
*
* A Theory is a piece of functionality (a method) that is executed against several data inputs called data points.
* To make a test method a theory you mark it with @Theory . To create a data point you create a public
* field in your test class and mark it with @DataPoint . The Theories runner then executes your test
* method as many times as the number of data points declared, providing a different data point as
* the input argument on each invocation.
*
*
* A Theory differs from standard test method in that it captures some aspect of the intended behavior in possibly
* infinite numbers of scenarios which corresponds to the number of data points declared. Using assumptions and
* assertions properly together with covering multiple scenarios with different data points can make your tests more
* flexible and bring them closer to scientific theories (hence the name).
*
*
* For example:
*
*
* @RunWith(Theories.class )
* public class UserTest {
* @DataPoint
* public static String GOOD_USERNAME = "optimus";
* @DataPoint
* public static String USERNAME_WITH_SLASH = "optimus/prime";
*
* @Theory
* public void filenameIncludesUsername(String username) {
* assumeThat(username, not(containsString("/")));
* assertThat(new User(username).configFileName(), containsString(username));
* }
* }
*
* This makes it clear that the username should be included in the config file name,
* only if it doesn't contain a slash. Another test or theory might define what happens when a username does contain
* a slash. UserTest will attempt to run filenameIncludesUsername on every compatible data
* point defined in the class. If any of the assumptions fail, the data point is silently ignored. If all of the
* assumptions pass, but an assertion fails, the test fails. If no parameters can be found that satisfy all assumptions, the test fails.
*
* Defining general statements as theories allows data point reuse across a bunch of functionality tests and also
* allows automated tools to search for new, unexpected data points that expose bugs.
*
*
* The support for Theories has been absorbed from the Popper project, and more complete documentation can be found
* from that projects archived documentation.
*
*
* @see Archived Popper project documentation
* @see Paper on Theories
*/
public class Theories extends BlockJUnit4ClassRunner {
public Theories(Class klass) throws InitializationError {
super(klass);
}
/** @since 4.13 */
protected Theories(TestClass testClass) throws InitializationError {
super(testClass);
}
@Override
protected void collectInitializationErrors(List errors) {
super.collectInitializationErrors(errors);
validateDataPointFields(errors);
validateDataPointMethods(errors);
}
private void validateDataPointFields(List errors) {
Field[] fields = getTestClass().getJavaClass().getDeclaredFields();
for (Field field : fields) {
if (field.getAnnotation(DataPoint.class) == null && field.getAnnotation(DataPoints.class) == null) {
continue;
}
if (!Modifier.isStatic(field.getModifiers())) {
errors.add(new Error("DataPoint field " + field.getName() + " must be static"));
}
if (!Modifier.isPublic(field.getModifiers())) {
errors.add(new Error("DataPoint field " + field.getName() + " must be public"));
}
}
}
private void validateDataPointMethods(List errors) {
Method[] methods = getTestClass().getJavaClass().getDeclaredMethods();
for (Method method : methods) {
if (method.getAnnotation(DataPoint.class) == null && method.getAnnotation(DataPoints.class) == null) {
continue;
}
if (!Modifier.isStatic(method.getModifiers())) {
errors.add(new Error("DataPoint method " + method.getName() + " must be static"));
}
if (!Modifier.isPublic(method.getModifiers())) {
errors.add(new Error("DataPoint method " + method.getName() + " must be public"));
}
}
}
@Override
protected void validateConstructor(List errors) {
validateOnlyOneConstructor(errors);
}
@Override
protected void validateTestMethods(List errors) {
for (FrameworkMethod each : computeTestMethods()) {
if (each.getAnnotation(Theory.class) != null) {
each.validatePublicVoid(false, errors);
each.validateNoTypeParametersOnArgs(errors);
} else {
each.validatePublicVoidNoArg(false, errors);
}
for (ParameterSignature signature : ParameterSignature.signatures(each.getMethod())) {
ParametersSuppliedBy annotation = signature.findDeepAnnotation(ParametersSuppliedBy.class);
if (annotation != null) {
validateParameterSupplier(annotation.value(), errors);
}
}
}
}
private void validateParameterSupplier(Class supplierClass, List errors) {
Constructor[] constructors = supplierClass.getConstructors();
if (constructors.length != 1) {
errors.add(new Error("ParameterSupplier " + supplierClass.getName() +
" must have only one constructor (either empty or taking only a TestClass)"));
} else {
Class[] paramTypes = constructors[0].getParameterTypes();
if (!(paramTypes.length == 0) && !paramTypes[0].equals(TestClass.class)) {
errors.add(new Error("ParameterSupplier " + supplierClass.getName() +
" constructor must take either nothing or a single TestClass instance"));
}
}
}
@Override
protected List computeTestMethods() {
List testMethods = new ArrayList(super.computeTestMethods());
List theoryMethods = getTestClass().getAnnotatedMethods(Theory.class);
testMethods.removeAll(theoryMethods);
testMethods.addAll(theoryMethods);
return testMethods;
}
@Override
public Statement methodBlock(final FrameworkMethod method) {
return new TheoryAnchor(method, getTestClass());
}
public static class TheoryAnchor extends Statement {
private int successes = 0;
private final FrameworkMethod testMethod;
private final TestClass testClass;
private List fInvalidParameters = new ArrayList();
public TheoryAnchor(FrameworkMethod testMethod, TestClass testClass) {
this.testMethod = testMethod;
this.testClass = testClass;
}
private TestClass getTestClass() {
return testClass;
}
@Override
public void evaluate() throws Throwable {
runWithAssignment(Assignments.allUnassigned(
testMethod.getMethod(), getTestClass()));
//if this test method is not annotated with Theory, then no successes is a valid case
boolean hasTheoryAnnotation = testMethod.getAnnotation(Theory.class) != null;
if (successes == 0 && hasTheoryAnnotation) {
Assert
.fail("Never found parameters that satisfied method assumptions. Violated assumptions: "
+ fInvalidParameters);
}
}
protected void runWithAssignment(Assignments parameterAssignment)
throws Throwable {
if (!parameterAssignment.isComplete()) {
runWithIncompleteAssignment(parameterAssignment);
} else {
runWithCompleteAssignment(parameterAssignment);
}
}
protected void runWithIncompleteAssignment(Assignments incomplete)
throws Throwable {
for (PotentialAssignment source : incomplete
.potentialsForNextUnassigned()) {
runWithAssignment(incomplete.assignNext(source));
}
}
protected void runWithCompleteAssignment(final Assignments complete)
throws Throwable {
new BlockJUnit4ClassRunner(getTestClass()) {
@Override
protected void collectInitializationErrors(
List errors) {
// do nothing
}
@Override
public Statement methodBlock(FrameworkMethod method) {
final Statement statement = super.methodBlock(method);
return new Statement() {
@Override
public void evaluate() throws Throwable {
try {
statement.evaluate();
handleDataPointSuccess();
} catch (AssumptionViolatedException e) {
handleAssumptionViolation(e);
} catch (Throwable e) {
reportParameterizedError(e, complete
.getArgumentStrings(nullsOk()));
}
}
};
}
@Override
protected Statement methodInvoker(FrameworkMethod method, Object test) {
return methodCompletesWithParameters(method, complete, test);
}
@Override
public Object createTest() throws Exception {
Object[] params = complete.getConstructorArguments();
if (!nullsOk()) {
Assume.assumeNotNull(params);
}
return getTestClass().getOnlyConstructor().newInstance(params);
}
}.methodBlock(testMethod).evaluate();
}
private Statement methodCompletesWithParameters(
final FrameworkMethod method, final Assignments complete, final Object freshInstance) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
final Object[] values = complete.getMethodArguments();
if (!nullsOk()) {
Assume.assumeNotNull(values);
}
method.invokeExplosively(freshInstance, values);
}
};
}
protected void handleAssumptionViolation(AssumptionViolatedException e) {
fInvalidParameters.add(e);
}
protected void reportParameterizedError(Throwable e, Object... params)
throws Throwable {
if (params.length == 0) {
throw e;
}
throw new ParameterizedAssertionError(e, testMethod.getName(),
params);
}
private boolean nullsOk() {
Theory annotation = testMethod.getMethod().getAnnotation(
Theory.class);
if (annotation == null) {
return false;
}
return annotation.nullsAccepted();
}
protected void handleDataPointSuccess() {
successes++;
}
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/Theory.java 0000664 0000000 0000000 00000001020 14011777271 0026210 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks test methods that should be read as theories by the {@link org.junit.experimental.theories.Theories Theories} runner.
*
* @see org.junit.experimental.theories.Theories
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(METHOD)
public @interface Theory {
boolean nullsAccepted() default true;
} junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal/ 0000775 0000000 0000000 00000000000 14011777271 0025716 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java 0000664 0000000 0000000 00000017154 14011777271 0032340 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories.internal;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.junit.Assume;
import org.junit.experimental.theories.DataPoint;
import org.junit.experimental.theories.DataPoints;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.PotentialAssignment;
import org.junit.runners.model.FrameworkField;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.TestClass;
/**
* Supplies Theory parameters based on all public members of the target class.
*/
public class AllMembersSupplier extends ParameterSupplier {
static class MethodParameterValue extends PotentialAssignment {
private final FrameworkMethod method;
private MethodParameterValue(FrameworkMethod dataPointMethod) {
method = dataPointMethod;
}
@Override
public Object getValue() throws CouldNotGenerateValueException {
try {
return method.invokeExplosively(null);
} catch (IllegalArgumentException e) {
throw new RuntimeException(
"unexpected: argument length is checked");
} catch (IllegalAccessException e) {
throw new RuntimeException(
"unexpected: getMethods returned an inaccessible method");
} catch (Throwable throwable) {
DataPoint annotation = method.getAnnotation(DataPoint.class);
Assume.assumeTrue(annotation == null || !isAssignableToAnyOf(annotation.ignoredExceptions(), throwable));
throw new CouldNotGenerateValueException(throwable);
}
}
@Override
public String getDescription() throws CouldNotGenerateValueException {
return method.getName();
}
}
private final TestClass clazz;
/**
* Constructs a new supplier for {@code type}
*/
public AllMembersSupplier(TestClass type) {
clazz = type;
}
@Override
public List getValueSources(ParameterSignature sig) throws Throwable {
List list = new ArrayList();
addSinglePointFields(sig, list);
addMultiPointFields(sig, list);
addSinglePointMethods(sig, list);
addMultiPointMethods(sig, list);
return list;
}
private void addMultiPointMethods(ParameterSignature sig, List list) throws Throwable {
for (FrameworkMethod dataPointsMethod : getDataPointsMethods(sig)) {
Class returnType = dataPointsMethod.getReturnType();
if ((returnType.isArray() && sig.canPotentiallyAcceptType(returnType.getComponentType())) ||
Iterable.class.isAssignableFrom(returnType)) {
try {
addDataPointsValues(returnType, sig, dataPointsMethod.getName(), list,
dataPointsMethod.invokeExplosively(null));
} catch (Throwable throwable) {
DataPoints annotation = dataPointsMethod.getAnnotation(DataPoints.class);
if (annotation != null && isAssignableToAnyOf(annotation.ignoredExceptions(), throwable)) {
return;
} else {
throw throwable;
}
}
}
}
}
private void addSinglePointMethods(ParameterSignature sig, List list) {
for (FrameworkMethod dataPointMethod : getSingleDataPointMethods(sig)) {
if (sig.canAcceptType(dataPointMethod.getType())) {
list.add(new MethodParameterValue(dataPointMethod));
}
}
}
private void addMultiPointFields(ParameterSignature sig, List list) {
for (final Field field : getDataPointsFields(sig)) {
Class type = field.getType();
addDataPointsValues(type, sig, field.getName(), list, getStaticFieldValue(field));
}
}
private void addSinglePointFields(ParameterSignature sig, List list) {
for (final Field field : getSingleDataPointFields(sig)) {
Object value = getStaticFieldValue(field);
if (sig.canAcceptValue(value)) {
list.add(PotentialAssignment.forValue(field.getName(), value));
}
}
}
private void addDataPointsValues(Class type, ParameterSignature sig, String name,
List list, Object value) {
if (type.isArray()) {
addArrayValues(sig, name, list, value);
}
else if (Iterable.class.isAssignableFrom(type)) {
addIterableValues(sig, name, list, (Iterable) value);
}
}
private void addArrayValues(ParameterSignature sig, String name, List list, Object array) {
for (int i = 0; i < Array.getLength(array); i++) {
Object value = Array.get(array, i);
if (sig.canAcceptValue(value)) {
list.add(PotentialAssignment.forValue(name + "[" + i + "]", value));
}
}
}
private void addIterableValues(ParameterSignature sig, String name, List list, Iterable iterable) {
Iterator iterator = iterable.iterator();
int i = 0;
while (iterator.hasNext()) {
Object value = iterator.next();
if (sig.canAcceptValue(value)) {
list.add(PotentialAssignment.forValue(name + "[" + i + "]", value));
}
i += 1;
}
}
private Object getStaticFieldValue(final Field field) {
try {
return field.get(null);
} catch (IllegalArgumentException e) {
throw new RuntimeException(
"unexpected: field from getClass doesn't exist on object");
} catch (IllegalAccessException e) {
throw new RuntimeException(
"unexpected: getFields returned an inaccessible field");
}
}
private static boolean isAssignableToAnyOf(Class[] typeArray, Object target) {
for (Class type : typeArray) {
if (type.isAssignableFrom(target.getClass())) {
return true;
}
}
return false;
}
protected Collection getDataPointsMethods(ParameterSignature sig) {
return clazz.getAnnotatedMethods(DataPoints.class);
}
protected Collection getSingleDataPointFields(ParameterSignature sig) {
List fields = clazz.getAnnotatedFields(DataPoint.class);
Collection validFields = new ArrayList();
for (FrameworkField frameworkField : fields) {
validFields.add(frameworkField.getField());
}
return validFields;
}
protected Collection getDataPointsFields(ParameterSignature sig) {
List fields = clazz.getAnnotatedFields(DataPoints.class);
Collection validFields = new ArrayList();
for (FrameworkField frameworkField : fields) {
validFields.add(frameworkField.getField());
}
return validFields;
}
protected Collection getSingleDataPointMethods(ParameterSignature sig) {
return clazz.getAnnotatedMethods(DataPoint.class);
}
} junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal/Assignments.java 0000664 0000000 0000000 00000012533 14011777271 0031060 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories.internal;
import static java.util.Collections.emptyList;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.ParametersSuppliedBy;
import org.junit.experimental.theories.PotentialAssignment;
import org.junit.experimental.theories.PotentialAssignment.CouldNotGenerateValueException;
import org.junit.runners.model.TestClass;
/**
* A potentially incomplete list of value assignments for a method's formal
* parameters
*/
public class Assignments {
private final List assigned;
private final List unassigned;
private final TestClass clazz;
private Assignments(List assigned,
List unassigned, TestClass clazz) {
this.unassigned = unassigned;
this.assigned = assigned;
this.clazz = clazz;
}
/**
* Returns a new assignment list for {@code testMethod}, with no params
* assigned.
*/
public static Assignments allUnassigned(Method testMethod,
TestClass testClass) {
List signatures;
signatures = ParameterSignature.signatures(testClass
.getOnlyConstructor());
signatures.addAll(ParameterSignature.signatures(testMethod));
return new Assignments(new ArrayList(),
signatures, testClass);
}
public boolean isComplete() {
return unassigned.isEmpty();
}
public ParameterSignature nextUnassigned() {
return unassigned.get(0);
}
public Assignments assignNext(PotentialAssignment source) {
List potentialAssignments = new ArrayList(assigned);
potentialAssignments.add(source);
return new Assignments(potentialAssignments, unassigned.subList(1,
unassigned.size()), clazz);
}
public Object[] getActualValues(int start, int stop)
throws CouldNotGenerateValueException {
Object[] values = new Object[stop - start];
for (int i = start; i < stop; i++) {
values[i - start] = assigned.get(i).getValue();
}
return values;
}
public List potentialsForNextUnassigned()
throws Throwable {
ParameterSignature unassigned = nextUnassigned();
List assignments = getSupplier(unassigned).getValueSources(unassigned);
if (assignments.isEmpty()) {
assignments = generateAssignmentsFromTypeAlone(unassigned);
}
return assignments;
}
private List generateAssignmentsFromTypeAlone(ParameterSignature unassigned) {
Class paramType = unassigned.getType();
if (paramType.isEnum()) {
return new EnumSupplier(paramType).getValueSources(unassigned);
} else if (paramType.equals(Boolean.class) || paramType.equals(boolean.class)) {
return new BooleanSupplier().getValueSources(unassigned);
} else {
return emptyList();
}
}
private ParameterSupplier getSupplier(ParameterSignature unassigned)
throws Exception {
ParametersSuppliedBy annotation = unassigned
.findDeepAnnotation(ParametersSuppliedBy.class);
if (annotation != null) {
return buildParameterSupplierFromClass(annotation.value());
} else {
return new AllMembersSupplier(clazz);
}
}
private ParameterSupplier buildParameterSupplierFromClass(
Class cls) throws Exception {
Constructor[] supplierConstructors = cls.getConstructors();
for (Constructor constructor : supplierConstructors) {
Class[] parameterTypes = constructor.getParameterTypes();
if (parameterTypes.length == 1
&& parameterTypes[0].equals(TestClass.class)) {
return (ParameterSupplier) constructor.newInstance(clazz);
}
}
return cls.newInstance();
}
public Object[] getConstructorArguments()
throws CouldNotGenerateValueException {
return getActualValues(0, getConstructorParameterCount());
}
public Object[] getMethodArguments() throws CouldNotGenerateValueException {
return getActualValues(getConstructorParameterCount(), assigned.size());
}
public Object[] getAllArguments() throws CouldNotGenerateValueException {
return getActualValues(0, assigned.size());
}
private int getConstructorParameterCount() {
List signatures = ParameterSignature
.signatures(clazz.getOnlyConstructor());
int constructorParameterCount = signatures.size();
return constructorParameterCount;
}
public Object[] getArgumentStrings(boolean nullsOk)
throws CouldNotGenerateValueException {
Object[] values = new Object[assigned.size()];
for (int i = 0; i < values.length; i++) {
values[i] = assigned.get(i).getDescription();
}
return values;
}
} junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal/BooleanSupplier.java 0000664 0000000 0000000 00000001113 14011777271 0031660 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories.internal;
import java.util.Arrays;
import java.util.List;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.PotentialAssignment;
public class BooleanSupplier extends ParameterSupplier {
@Override
public List getValueSources(ParameterSignature sig) {
return Arrays.asList(PotentialAssignment.forValue("true", true),
PotentialAssignment.forValue("false", false));
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal/EnumSupplier.java 0000664 0000000 0000000 00000001563 14011777271 0031216 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories.internal;
import java.util.ArrayList;
import java.util.List;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.PotentialAssignment;
public class EnumSupplier extends ParameterSupplier {
private Class enumType;
public EnumSupplier(Class enumType) {
this.enumType = enumType;
}
@Override
public List getValueSources(ParameterSignature sig) {
Object[] enumValues = enumType.getEnumConstants();
List assignments = new ArrayList();
for (Object value : enumValues) {
assignments.add(PotentialAssignment.forValue(value.toString(), value));
}
return assignments;
}
}
ParameterizedAssertionError.java 0000664 0000000 0000000 00000002720 14011777271 0034201 0 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal package org.junit.experimental.theories.internal;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
public class ParameterizedAssertionError extends AssertionError {
private static final long serialVersionUID = 1L;
public ParameterizedAssertionError(Throwable targetException,
String methodName, Object... params) {
super(String.format("%s(%s)", methodName, join(", ", params)));
this.initCause(targetException);
}
@Override
public boolean equals(Object obj) {
return obj instanceof ParameterizedAssertionError && toString().equals(obj.toString());
}
@Override
public int hashCode() {
return toString().hashCode();
}
public static String join(String delimiter, Object... params) {
return join(delimiter, Arrays.asList(params));
}
public static String join(String delimiter, Collection values) {
StringBuilder sb = new StringBuilder();
Iterator iter = values.iterator();
while (iter.hasNext()) {
Object next = iter.next();
sb.append(stringValueOf(next));
if (iter.hasNext()) {
sb.append(delimiter);
}
}
return sb.toString();
}
private static String stringValueOf(Object next) {
try {
return String.valueOf(next);
} catch (Throwable e) {
return "[toString failed]";
}
}
} SpecificDataPointsSupplier.java 0000664 0000000 0000000 00000006523 14011777271 0033750 0 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/theories/internal package org.junit.experimental.theories.internal;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.junit.experimental.theories.DataPoint;
import org.junit.experimental.theories.DataPoints;
import org.junit.experimental.theories.FromDataPoints;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.TestClass;
public class SpecificDataPointsSupplier extends AllMembersSupplier {
public SpecificDataPointsSupplier(TestClass testClass) {
super(testClass);
}
@Override
protected Collection getSingleDataPointFields(ParameterSignature sig) {
Collection fields = super.getSingleDataPointFields(sig);
String requestedName = sig.getAnnotation(FromDataPoints.class).value();
List fieldsWithMatchingNames = new ArrayList();
for (Field field : fields) {
String[] fieldNames = field.getAnnotation(DataPoint.class).value();
if (Arrays.asList(fieldNames).contains(requestedName)) {
fieldsWithMatchingNames.add(field);
}
}
return fieldsWithMatchingNames;
}
@Override
protected Collection getDataPointsFields(ParameterSignature sig) {
Collection fields = super.getDataPointsFields(sig);
String requestedName = sig.getAnnotation(FromDataPoints.class).value();
List fieldsWithMatchingNames = new ArrayList();
for (Field field : fields) {
String[] fieldNames = field.getAnnotation(DataPoints.class).value();
if (Arrays.asList(fieldNames).contains(requestedName)) {
fieldsWithMatchingNames.add(field);
}
}
return fieldsWithMatchingNames;
}
@Override
protected Collection getSingleDataPointMethods(ParameterSignature sig) {
Collection methods = super.getSingleDataPointMethods(sig);
String requestedName = sig.getAnnotation(FromDataPoints.class).value();
List methodsWithMatchingNames = new ArrayList();
for (FrameworkMethod method : methods) {
String[] methodNames = method.getAnnotation(DataPoint.class).value();
if (Arrays.asList(methodNames).contains(requestedName)) {
methodsWithMatchingNames.add(method);
}
}
return methodsWithMatchingNames;
}
@Override
protected Collection getDataPointsMethods(ParameterSignature sig) {
Collection methods = super.getDataPointsMethods(sig);
String requestedName = sig.getAnnotation(FromDataPoints.class).value();
List methodsWithMatchingNames = new ArrayList();
for (FrameworkMethod method : methods) {
String[] methodNames = method.getAnnotation(DataPoints.class).value();
if (Arrays.asList(methodNames).contains(requestedName)) {
methodsWithMatchingNames.add(method);
}
}
return methodsWithMatchingNames;
}
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/suppliers/ 0000775 0000000 0000000 00000000000 14011777271 0026130 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/experimental/theories/suppliers/TestedOn.java 0000664 0000000 0000000 00000001751 14011777271 0030524 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories.suppliers;
import static java.lang.annotation.ElementType.PARAMETER;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.experimental.theories.ParametersSuppliedBy;
/**
* Annotating a {@link org.junit.experimental.theories.Theory Theory} method int
* parameter with @TestedOn causes it to be supplied with values from the
* ints array given when run as a theory by the
* {@link org.junit.experimental.theories.Theories Theories} runner. For
* example, the below method would be called three times by the Theories runner,
* once with each of the int parameters specified.
*
*
* @Theory
* public void shouldPassForSomeInts(@TestedOn(ints={1, 2, 3}) int param) {
* ...
* }
*
*/
@ParametersSuppliedBy(TestedOnSupplier.class)
@Retention(RetentionPolicy.RUNTIME)
@Target(PARAMETER)
public @interface TestedOn {
int[] ints();
}
junit4-r4.13.2/src/main/java/org/junit/experimental/theories/suppliers/TestedOnSupplier.java 0000664 0000000 0000000 00000001553 14011777271 0032250 0 ustar 00root root 0000000 0000000 package org.junit.experimental.theories.suppliers;
import java.util.ArrayList;
import java.util.List;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.PotentialAssignment;
/**
* @see org.junit.experimental.theories.suppliers.TestedOn
* @see org.junit.experimental.theories.ParameterSupplier
*/
public class TestedOnSupplier extends ParameterSupplier {
@Override
public List getValueSources(ParameterSignature sig) {
List list = new ArrayList();
TestedOn testedOn = sig.getAnnotation(TestedOn.class);
int[] ints = testedOn.ints();
for (final int i : ints) {
list.add(PotentialAssignment.forValue("ints", i));
}
return list;
}
}
junit4-r4.13.2/src/main/java/org/junit/function/ 0000775 0000000 0000000 00000000000 14011777271 0021410 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/function/ThrowingRunnable.java 0000664 0000000 0000000 00000000673 14011777271 0025551 0 ustar 00root root 0000000 0000000 package org.junit.function;
/**
* This interface facilitates the use of
* {@link org.junit.Assert#assertThrows(Class, ThrowingRunnable)} from Java 8. It allows method
* references to void methods (that declare checked exceptions) to be passed directly into
* {@code assertThrows}
* without wrapping. It is not meant to be implemented directly.
*
* @since 4.13
*/
public interface ThrowingRunnable {
void run() throws Throwable;
}
junit4-r4.13.2/src/main/java/org/junit/internal/ 0000775 0000000 0000000 00000000000 14011777271 0021377 5 ustar 00root root 0000000 0000000 junit4-r4.13.2/src/main/java/org/junit/internal/ArrayComparisonFailure.java 0000664 0000000 0000000 00000004015 14011777271 0026663 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
/**
* Thrown when two array elements differ
*
* @see Assert#assertArrayEquals(String, Object[], Object[])
*/
public class ArrayComparisonFailure extends AssertionError {
private static final long serialVersionUID = 1L;
/*
* We have to use the f prefix until the next major release to ensure
* serialization compatibility.
* See https://github.com/junit-team/junit4/issues/976
*/
private final List fIndices = new ArrayList();
private final String fMessage;
private final AssertionError fCause;
/**
* Construct a new ArrayComparisonFailure with an error text and the array's
* dimension that was not equal
*
* @param cause the exception that caused the array's content to fail the assertion test
* @param index the array position of the objects that are not equal.
* @see Assert#assertArrayEquals(String, Object[], Object[])
*/
public ArrayComparisonFailure(String message, AssertionError cause, int index) {
this.fMessage = message;
this.fCause = cause;
initCause(fCause);
addDimension(index);
}
public void addDimension(int index) {
fIndices.add(0, index);
}
@Override
public synchronized Throwable getCause() {
return super.getCause() == null ? fCause : super.getCause();
}
@Override
public String getMessage() {
StringBuilder sb = new StringBuilder();
if (fMessage != null) {
sb.append(fMessage);
}
sb.append("arrays first differed at element ");
for (int each : fIndices) {
sb.append("[");
sb.append(each);
sb.append("]");
}
sb.append("; ");
sb.append(getCause().getMessage());
return sb.toString();
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
return getMessage();
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/AssumptionViolatedException.java 0000664 0000000 0000000 00000011641 14011777271 0027756 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.IOException;
import java.io.ObjectOutputStream;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.SelfDescribing;
import org.hamcrest.StringDescription;
/**
* An exception class used to implement assumptions (state in which a given test
* is meaningful and should or should not be executed). A test for which an assumption
* fails should not generate a test case failure.
*
* @see org.junit.Assume
*/
public class AssumptionViolatedException extends RuntimeException implements SelfDescribing {
private static final long serialVersionUID = 2L;
/*
* We have to use the f prefix until the next major release to ensure
* serialization compatibility.
* See https://github.com/junit-team/junit4/issues/976
*/
private final String fAssumption;
private final boolean fValueMatcher;
private final Object fValue;
private final Matcher fMatcher;
/**
* @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
*/
@Deprecated
public AssumptionViolatedException(String assumption, boolean hasValue, Object value, Matcher matcher) {
this.fAssumption = assumption;
this.fValue = value;
this.fMatcher = matcher;
this.fValueMatcher = hasValue;
if (value instanceof Throwable) {
initCause((Throwable) value);
}
}
/**
* An assumption exception with the given value (String or
* Throwable) and an additional failing {@link Matcher}.
*
* @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
*/
@Deprecated
public AssumptionViolatedException(Object value, Matcher matcher) {
this(null, true, value, matcher);
}
/**
* An assumption exception with the given value (String or
* Throwable) and an additional failing {@link Matcher}.
*
* @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
*/
@Deprecated
public AssumptionViolatedException(String assumption, Object value, Matcher matcher) {
this(assumption, true, value, matcher);
}
/**
* An assumption exception with the given message only.
*
* @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
*/
@Deprecated
public AssumptionViolatedException(String assumption) {
this(assumption, false, null, null);
}
/**
* An assumption exception with the given message and a cause.
*
* @deprecated Please use {@link org.junit.AssumptionViolatedException} instead.
*/
@Deprecated
public AssumptionViolatedException(String assumption, Throwable e) {
this(assumption, false, null, null);
initCause(e);
}
@Override
public String getMessage() {
return StringDescription.asString(this);
}
public void describeTo(Description description) {
if (fAssumption != null) {
description.appendText(fAssumption);
}
if (fValueMatcher) {
// a value was passed in when this instance was constructed; print it
if (fAssumption != null) {
description.appendText(": ");
}
description.appendText("got: ");
description.appendValue(fValue);
if (fMatcher != null) {
description.appendText(", expected: ");
description.appendDescriptionOf(fMatcher);
}
}
}
/**
* Override default Java object serialization to correctly deal with potentially unserializable matchers or values.
* By not implementing readObject, we assure ourselves of backwards compatibility and compatibility with the
* standard way of Java serialization.
*
* @param objectOutputStream The outputStream to write our representation to
* @throws IOException When serialization fails
*/
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
ObjectOutputStream.PutField putField = objectOutputStream.putFields();
putField.put("fAssumption", fAssumption);
putField.put("fValueMatcher", fValueMatcher);
// We have to wrap the matcher into a serializable form.
putField.put("fMatcher", SerializableMatcherDescription.asSerializableMatcher(fMatcher));
// We have to wrap the value inside a non-String class (instead of serializing the String value directly) as
// A Description will handle a String and non-String object differently (1st is surrounded by '"' while the
// latter will be surrounded by '<' '>'. Wrapping it makes sure that the description of a serialized and
// non-serialized instance produce the exact same description
putField.put("fValue", SerializableValueDescription.asSerializableValue(fValue));
objectOutputStream.writeFields();
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/Checks.java 0000664 0000000 0000000 00000002105 14011777271 0023440 0 ustar 00root root 0000000 0000000 package org.junit.internal;
/** @since 4.13 */
public final class Checks {
private Checks() {}
/**
* Checks that the given value is not {@code null}.
*
* @param value object reference to check
* @return the passed-in value, if not {@code null}
* @throws NullPointerException if {@code value} is {@code null}
*/
public static T notNull(T value) {
if (value == null) {
throw new NullPointerException();
}
return value;
}
/**
* Checks that the given value is not {@code null}, using the given message
* as the exception message if an exception is thrown.
*
* @param value object reference to check
* @param message message to use if {@code value} is {@code null}
* @return the passed-in value, if not {@code null}
* @throws NullPointerException if {@code value} is {@code null}
*/
public static T notNull(T value, String message) {
if (value == null) {
throw new NullPointerException(message);
}
return value;
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/Classes.java 0000664 0000000 0000000 00000002730 14011777271 0023641 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import static java.lang.Thread.currentThread;
/**
* Miscellaneous functions dealing with classes.
*/
public class Classes {
/**
* Do not instantiate.
* @deprecated will be private soon.
*/
@Deprecated
public Classes() {
}
/**
* Returns Class.forName for {@code className} using the current thread's class loader.
* If the current thread does not have a class loader, falls back to the class loader for
* {@link Classes}.
*
* @param className Name of the class.
* @throws ClassNotFoundException
*/
public static Class getClass(String className) throws ClassNotFoundException {
return getClass(className, Classes.class);
}
/**
* Returns Class.forName for {@code className} using the current thread's class loader.
* If the current thread does not have a class loader, falls back to the class loader for the
* passed-in class.
*
* @param className Name of the class.
* @param callingClass Class that is requesting a the class
* @throws ClassNotFoundException
* @since 4.13
*/
public static Class getClass(String className, Class callingClass) throws ClassNotFoundException {
ClassLoader classLoader = currentThread().getContextClassLoader();
return Class.forName(className, true, classLoader == null ? callingClass.getClassLoader() : classLoader);
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/ComparisonCriteria.java 0000664 0000000 0000000 00000011752 14011777271 0026045 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.lang.reflect.Array;
import java.util.Arrays;
import org.junit.Assert;
/**
* Defines criteria for finding two items "equal enough". Concrete subclasses
* may demand exact equality, or, for example, equality within a given delta.
*/
public abstract class ComparisonCriteria {
/**
* Asserts that two arrays are equal, according to the criteria defined by
* the concrete subclass. If they are not, an {@link AssertionError} is
* thrown with the given message. If expecteds and
* actuals are null, they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (
* null okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
public void arrayEquals(String message, Object expecteds, Object actuals)
throws ArrayComparisonFailure {
arrayEquals(message, expecteds, actuals, true);
}
private void arrayEquals(String message, Object expecteds, Object actuals, boolean outer)
throws ArrayComparisonFailure {
if (expecteds == actuals
|| Arrays.deepEquals(new Object[] {expecteds}, new Object[] {actuals})) {
// The reflection-based loop below is potentially very slow, especially for primitive
// arrays. The deepEquals check allows us to circumvent it in the usual case where
// the arrays are exactly equal.
return;
}
String header = message == null ? "" : message + ": ";
// Only include the user-provided message in the outer exception.
String exceptionMessage = outer ? header : "";
if (expecteds == null) {
Assert.fail(exceptionMessage + "expected array was null");
}
if (actuals == null) {
Assert.fail(exceptionMessage + "actual array was null");
}
int actualsLength = Array.getLength(actuals);
int expectedsLength = Array.getLength(expecteds);
if (actualsLength != expectedsLength) {
header += "array lengths differed, expected.length="
+ expectedsLength + " actual.length=" + actualsLength + "; ";
}
int prefixLength = Math.min(actualsLength, expectedsLength);
for (int i = 0; i < prefixLength; i++) {
Object expected = Array.get(expecteds, i);
Object actual = Array.get(actuals, i);
if (isArray(expected) && isArray(actual)) {
try {
arrayEquals(message, expected, actual, false);
} catch (ArrayComparisonFailure e) {
e.addDimension(i);
throw e;
} catch (AssertionError e) {
// Array lengths differed.
throw new ArrayComparisonFailure(header, e, i);
}
} else {
try {
assertElementsEqual(expected, actual);
} catch (AssertionError e) {
throw new ArrayComparisonFailure(header, e, i);
}
}
}
if (actualsLength != expectedsLength) {
Object expected = getToStringableArrayElement(expecteds, expectedsLength, prefixLength);
Object actual = getToStringableArrayElement(actuals, actualsLength, prefixLength);
try {
Assert.assertEquals(expected, actual);
} catch (AssertionError e) {
throw new ArrayComparisonFailure(header, e, prefixLength);
}
}
}
private static final Object END_OF_ARRAY_SENTINEL = objectWithToString("end of array");
private Object getToStringableArrayElement(Object array, int length, int index) {
if (index < length) {
Object element = Array.get(array, index);
if (isArray(element)) {
return objectWithToString(componentTypeName(element.getClass()) + "[" + Array.getLength(element) + "]");
} else {
return element;
}
} else {
return END_OF_ARRAY_SENTINEL;
}
}
private static Object objectWithToString(final String string) {
return new Object() {
@Override
public String toString() {
return string;
}
};
}
private String componentTypeName(Class arrayClass) {
Class componentType = arrayClass.getComponentType();
if (componentType.isArray()) {
return componentTypeName(componentType) + "[]";
} else {
return componentType.getName();
}
}
private boolean isArray(Object expected) {
return expected != null && expected.getClass().isArray();
}
protected abstract void assertElementsEqual(Object expected, Object actual);
}
junit4-r4.13.2/src/main/java/org/junit/internal/ExactComparisonCriteria.java 0000664 0000000 0000000 00000000407 14011777271 0027025 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import org.junit.Assert;
public class ExactComparisonCriteria extends ComparisonCriteria {
@Override
protected void assertElementsEqual(Object expected, Object actual) {
Assert.assertEquals(expected, actual);
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/InexactComparisonCriteria.java 0000664 0000000 0000000 00000001211 14011777271 0027346 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import org.junit.Assert;
public class InexactComparisonCriteria extends ComparisonCriteria {
public Object fDelta;
public InexactComparisonCriteria(double delta) {
fDelta = delta;
}
public InexactComparisonCriteria(float delta) {
fDelta = delta;
}
@Override
protected void assertElementsEqual(Object expected, Object actual) {
if (expected instanceof Double) {
Assert.assertEquals((Double) expected, (Double) actual, (Double) fDelta);
} else {
Assert.assertEquals((Float) expected, (Float) actual, (Float) fDelta);
}
}
} junit4-r4.13.2/src/main/java/org/junit/internal/JUnitSystem.java 0000664 0000000 0000000 00000000336 14011777271 0024502 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.PrintStream;
public interface JUnitSystem {
/**
* Will be removed in the next major release
*/
@Deprecated
void exit(int code);
PrintStream out();
}
junit4-r4.13.2/src/main/java/org/junit/internal/MethodSorter.java 0000664 0000000 0000000 00000004562 14011777271 0024670 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Comparator;
import org.junit.FixMethodOrder;
public class MethodSorter {
/**
* DEFAULT sort order
*/
public static final Comparator DEFAULT = new Comparator() {
public int compare(Method m1, Method m2) {
int i1 = m1.getName().hashCode();
int i2 = m2.getName().hashCode();
if (i1 != i2) {
return i1 < i2 ? -1 : 1;
}
return NAME_ASCENDING.compare(m1, m2);
}
};
/**
* Method name ascending lexicographic sort order, with {@link Method#toString()} as a tiebreaker
*/
public static final Comparator NAME_ASCENDING = new Comparator() {
public int compare(Method m1, Method m2) {
final int comparison = m1.getName().compareTo(m2.getName());
if (comparison != 0) {
return comparison;
}
return m1.toString().compareTo(m2.toString());
}
};
/**
* Gets declared methods of a class in a predictable order, unless @FixMethodOrder(MethodSorters.JVM) is specified.
*
* Using the JVM order is unwise since the Java platform does not
* specify any particular order, and in fact JDK 7 returns a more or less
* random order; well-written test code would not assume any order, but some
* does, and a predictable failure is better than a random failure on
* certain platforms. By default, uses an unspecified but deterministic order.
*
* @param clazz a class
* @return same as {@link Class#getDeclaredMethods} but sorted
* @see JDK
* (non-)bug #7023180
*/
public static Method[] getDeclaredMethods(Class clazz) {
Comparator comparator = getSorter(clazz.getAnnotation(FixMethodOrder.class));
Method[] methods = clazz.getDeclaredMethods();
if (comparator != null) {
Arrays.sort(methods, comparator);
}
return methods;
}
private MethodSorter() {
}
private static Comparator getSorter(FixMethodOrder fixMethodOrder) {
if (fixMethodOrder == null) {
return DEFAULT;
}
return fixMethodOrder.value().getComparator();
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/RealSystem.java 0000664 0000000 0000000 00000000503 14011777271 0024330 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.PrintStream;
public class RealSystem implements JUnitSystem {
/**
* Will be removed in the next major release
*/
@Deprecated
public void exit(int code) {
System.exit(code);
}
public PrintStream out() {
return System.out;
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/SerializableMatcherDescription.java 0000664 0000000 0000000 00000003556 14011777271 0030371 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.Serializable;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.StringDescription;
/**
* This class exists solely to provide a serializable description of a matcher to be serialized as a field in
* {@link AssumptionViolatedException}. Being a {@link Throwable}, it is required to be {@link Serializable}, but most
* implementations of {@link Matcher} are not. This class works around that limitation as
* {@link AssumptionViolatedException} only every uses the description of the {@link Matcher}, while still retaining
* backwards compatibility with classes compiled against its class signature before 4.14 and/or deserialization of
* previously serialized instances.
*/
class SerializableMatcherDescription extends BaseMatcher implements Serializable {
private final String matcherDescription;
private SerializableMatcherDescription(Matcher matcher) {
matcherDescription = StringDescription.asString(matcher);
}
public boolean matches(Object o) {
throw new UnsupportedOperationException("This Matcher implementation only captures the description");
}
public void describeTo(Description description) {
description.appendText(matcherDescription);
}
/**
* Factory method that checks to see if the matcher is already serializable.
* @param matcher the matcher to make serializable
* @return The provided matcher if it is null or already serializable,
* the SerializableMatcherDescription representation of it if it is not.
*/
static Matcher asSerializableMatcher(Matcher matcher) {
if (matcher == null || matcher instanceof Serializable) {
return matcher;
} else {
return new SerializableMatcherDescription(matcher);
}
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/SerializableValueDescription.java 0000664 0000000 0000000 00000002703 14011777271 0030053 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.Serializable;
/**
* This class exists solely to provide a serializable description of a value to be serialized as a field in
* {@link AssumptionViolatedException}. Being a {@link Throwable}, it is required to be {@link Serializable}, but a
* value of type Object provides no guarantee to be serializable. This class works around that limitation as
* {@link AssumptionViolatedException} only every uses the string representation of the value, while still retaining
* backwards compatibility with classes compiled against its class signature before 4.14 and/or deserialization of
* previously serialized instances.
*/
class SerializableValueDescription implements Serializable {
private final String value;
private SerializableValueDescription(Object value) {
this.value = String.valueOf(value);
}
/**
* Factory method that checks to see if the value is already serializable.
* @param value the value to make serializable
* @return The provided value if it is null or already serializable,
* the SerializableValueDescription representation of it if it is not.
*/
static Object asSerializableValue(Object value) {
if (value == null || value instanceof Serializable) {
return value;
} else {
return new SerializableValueDescription(value);
}
}
@Override
public String toString() {
return value;
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/TextListener.java 0000664 0000000 0000000 00000005323 14011777271 0024677 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.PrintStream;
import java.text.NumberFormat;
import java.util.List;
import org.junit.runner.Description;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunListener;
public class TextListener extends RunListener {
private final PrintStream writer;
public TextListener(JUnitSystem system) {
this(system.out());
}
public TextListener(PrintStream writer) {
this.writer = writer;
}
@Override
public void testRunFinished(Result result) {
printHeader(result.getRunTime());
printFailures(result);
printFooter(result);
}
@Override
public void testStarted(Description description) {
writer.append('.');
}
@Override
public void testFailure(Failure failure) {
writer.append('E');
}
@Override
public void testIgnored(Description description) {
writer.append('I');
}
/*
* Internal methods
*/
private PrintStream getWriter() {
return writer;
}
protected void printHeader(long runTime) {
getWriter().println();
getWriter().println("Time: " + elapsedTimeAsString(runTime));
}
protected void printFailures(Result result) {
List failures = result.getFailures();
if (failures.isEmpty()) {
return;
}
if (failures.size() == 1) {
getWriter().println("There was " + failures.size() + " failure:");
} else {
getWriter().println("There were " + failures.size() + " failures:");
}
int i = 1;
for (Failure each : failures) {
printFailure(each, "" + i++);
}
}
protected void printFailure(Failure each, String prefix) {
getWriter().println(prefix + ") " + each.getTestHeader());
getWriter().print(each.getTrimmedTrace());
}
protected void printFooter(Result result) {
if (result.wasSuccessful()) {
getWriter().println();
getWriter().print("OK");
getWriter().println(" (" + result.getRunCount() + " test" + (result.getRunCount() == 1 ? "" : "s") + ")");
} else {
getWriter().println();
getWriter().println("FAILURES!!!");
getWriter().println("Tests run: " + result.getRunCount() + ", Failures: " + result.getFailureCount());
}
getWriter().println();
}
/**
* Returns the formatted string of the elapsed time. Duplicated from
* BaseTestRunner. Fix it.
*/
protected String elapsedTimeAsString(long runTime) {
return NumberFormat.getInstance().format((double) runTime / 1000);
}
}
junit4-r4.13.2/src/main/java/org/junit/internal/Throwables.java 0000664 0000000 0000000 00000023045 14011777271 0024360 0 ustar 00root root 0000000 0000000 package org.junit.internal;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.Method;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Miscellaneous functions dealing with {@code Throwable}.
*
* @author kcooney@google.com (Kevin Cooney)
* @since 4.12
*/
public final class Throwables {
private Throwables() {
}
/**
* Rethrows the given {@code Throwable}, allowing the caller to
* declare that it throws {@code Exception}. This is useful when
* your callers have nothing reasonable they can do when a
* {@code Throwable} is thrown. This is declared to return {@code Exception}
* so it can be used in a {@code throw} clause:
*
* try {
* doSomething();
* } catch (Throwable e} {
* throw Throwables.rethrowAsException(e);
* }
* doSomethingLater();
*
*
* @param e exception to rethrow
* @return does not return anything
* @since 4.12
*/
public static Exception rethrowAsException(Throwable e) throws Exception {
Throwables.rethrow(e);
return null; // we never get here
}
@SuppressWarnings("unchecked")
private static void rethrow(Throwable e) throws T {
throw (T) e;
}
/**
* Returns the stacktrace of the given Throwable as a String.
*
* @since 4.13
*/
public static String getStacktrace(Throwable exception) {
StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
exception.printStackTrace(writer);
return stringWriter.toString();
}
/**
* Gets a trimmed version of the stack trace of the given exception. Stack trace
* elements that are below the test method are filtered out.
*
* @return a trimmed stack trace, or the original trace if trimming wasn't possible
*/
public static String getTrimmedStackTrace(Throwable exception) {
List trimmedStackTraceLines = getTrimmedStackTraceLines(exception);
if (trimmedStackTraceLines.isEmpty()) {
return getFullStackTrace(exception);
}
StringBuilder result = new StringBuilder(exception.toString());
appendStackTraceLines(trimmedStackTraceLines, result);
appendStackTraceLines(getCauseStackTraceLines(exception), result);
return result.toString();
}
private static List getTrimmedStackTraceLines(Throwable exception) {
List stackTraceElements = Arrays.asList(exception.getStackTrace());
int linesToInclude = stackTraceElements.size();
State state = State.PROCESSING_OTHER_CODE;
for (StackTraceElement stackTraceElement : asReversedList(stackTraceElements)) {
state = state.processStackTraceElement(stackTraceElement);
if (state == State.DONE) {
List trimmedLines = new ArrayList(linesToInclude + 2);
trimmedLines.add("");
for (StackTraceElement each : stackTraceElements.subList(0, linesToInclude)) {
trimmedLines.add("\tat " + each);
}
if (exception.getCause() != null) {
trimmedLines.add("\t... " + (stackTraceElements.size() - trimmedLines.size()) + " trimmed");
}
return trimmedLines;
}
linesToInclude--;
}
return Collections.emptyList();
}
private static final Method getSuppressed = initGetSuppressed();
private static Method initGetSuppressed() {
try {
return Throwable.class.getMethod("getSuppressed");
} catch (Throwable e) {
return null;
}
}
private static boolean hasSuppressed(Throwable exception) {
if (getSuppressed == null) {
return false;
}
try {
Throwable[] suppressed = (Throwable[]) getSuppressed.invoke(exception);
return suppressed.length != 0;
} catch (Throwable e) {
return false;
}
}
private static List getCauseStackTraceLines(Throwable exception) {
if (exception.getCause() != null || hasSuppressed(exception)) {
String fullTrace = getFullStackTrace(exception);
BufferedReader reader = new BufferedReader(
new StringReader(fullTrace.substring(exception.toString().length())));
List causedByLines = new ArrayList