1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
package org.junit;
import static java.util.Arrays.asList;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import org.hamcrest.Matcher;
import org.junit.internal.AssumptionViolatedException;
import org.junit.internal.matchers.Each;
/**
* 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.
* The default JUnit runner treats tests with failing assumptions as ignored. Custom runners may behave differently.
*
* For example:
* <pre>
* // only provides information if database is reachable.
* \@Test public void calculateTotalSalary() {
* DBConnection dbc = Database.connect();
* assumeNotNull(dbc);
* // ...
* }
* </pre>
* These methods can be used directly: <code>Assume.assumeTrue(...)</code>, however, they
* read better if they are referenced through static import:<br/>
* <pre>
* import static org.junit.Assume.*;
* ...
* assumeTrue(...);
* </pre>
*/
public class Assume {
/**
* If called with an expression evaluating to {@code false}, the test will halt and be ignored.
* @param b
*/
public static void assumeTrue(boolean b) {
assumeThat(b, is(true));
}
/**
* If called with one or more null elements in <code>objects</code>, the test will halt and be ignored.
* @param objects
*/
public static void assumeNotNull(Object... objects) {
assumeThat(asList(objects), Each.each(notNullValue()));
}
/**
* Call to assume that <code>actual</code> satisfies the condition specified by <code>matcher</code>.
* If not, the test halts and is ignored.
* Example:
* <pre>:
* assumeThat(1, is(1)); // passes
* foo(); // will execute
* assumeThat(0, is(1)); // assumption failure! test halts
* int x = 1 / 0; // will never execute
* </pre>
*
* @param <T> 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 <T> void assumeThat(T actual, Matcher<T> matcher) {
if (!matcher.matches(actual))
throw new AssumptionViolatedException(actual, matcher);
}
/**
* Use to assume that an operation completes normally. If {@code t} is non-null, the test will halt and be ignored.
*
* For example:
* <pre>
* \@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);
* }
* // ...
* }
* </pre>
* @param t if non-null, the offending exception
*/
public static void assumeNoException(Throwable t) {
assumeThat(t, nullValue());
}
}
|
