JUnit uses the first bullet

Knowledge Point-assertion

Assertions are the core implementation of writing test cases, that is, what the expected value is, and how much is the result of the test to determine whether the test passed.

1. Assert the core approach

Assertarrayequals (expecteds, actuals)	See if two arrays are equal.
Assertequals (expected, actual)	See if two objects are equal. The Equals () method, similar to the use of string comparisons
Assertnotequals (first, second)	See if two objects are not equal.
Assertnull (object)	View whether the object is empty.
Assertnotnull (object)	View whether the object is not empty.
Assertsame (expected, actual)	See if the references to two objects are equal. Similar to using "= =" to compare two objects
Assertnotsame (Unexpected, actual)	See if the references to two objects are not equal. Similar to using "! =" to compare two objects
Asserttrue (condition)	View whether the run result is true.
Assertfalse (condition)	See if the run result is false.
Assertthat (Actual, Matcher)	See if the actual value meets the specified criteria
Fail ()	Let the test fail

2. Example

2. Package test;
6. Import static org.hamcrest.corematchers.*;
8. Import static org.junit.assert.*;
12. Import Java.util.Arrays;
16. Import Org.hamcrest.core.CombinableMatcher;
18. Import Org.junit.Test;
22. Public class Asserttests {
26. @Test
28. public void Testassertarrayequals () {
30. byte[] Expected = "trial". GetBytes ();
32. byte[] actual = "trial". GetBytes ();
34. Org.junit.Assert.assertArrayEquals ("failure-byte arrays not Same", expected, actual);
36. }
40. @Test
42. public void Testassertequals () {
44. Org.junit.Assert.assertEquals ("failure-strings not Same", 5l, 5l);
46. }
50. @Test
52. public void Testassertfalse () {
54. Org.junit.Assert.assertFalse ("failure-should be false", false);
56. }
60. @Test
62. public void Testassertnotnull () {
64. Org.junit.Assert.assertNotNull ("should not is null", new Object ());
66. }
70. @Test
72. public void Testassertnotsame () {
74. Org.junit.Assert.assertNotSame ("should not being same object", new Object (), new Object ());
76. }
80. @Test
82. public void Testassertnull () {
84. Org.junit.Assert.assertNull ("should be null", null);
86. }
90. @Test
92. public void Testassertsame () {
94. Integer anumber = integer.valueof (768);
96. Org.junit.Assert.assertSame ("should be Same", anumber, Anumber);
98. }
102. //JUnit matchers assertthat
104. @Test
106. public void Testassertthatbothcontainsstring () {
108. Org.junit.Assert.assertThat ("albumen", Both (containsstring ("a")). and (Containsstring ("B"));
110. }
114. @Test
116. public void Testassertthathasitemscontainsstring () {
118. Org.junit.Assert.assertThat ("One", "Arrays.aslist", " three"), Hasitems ("One", "three");
120. }
124. @Test
126. public void Testassertthateveryitemcontainsstring () {
128. Org.junit.Assert.assertThat (Arrays.aslist (new string[] { "fun", "ban", "NET"}), Everyitem (  Containsstring ("n")));
130. }
134. //Core hamcrest matchers with Assertthat
136. @Test
138. public void Testassertthathamcrestcorematchers () {
140. Assertthat ("Good", AllOf (Equalto ("good"), StartsWith ("good"));
142. Assertthat ("Good", Not (AllOf (Equalto ("bad"), Equalto ("good")));
144. Assertthat ("Good", AnyOf (Equalto ("bad"), Equalto ("good"));
146. Assertthat (7, not (combinablematcher.<integer> either (Equalto (3)). or (Equalto (4)));
148. Assertthat (new Object (), not (Sameinstance (new Object ())));
150. }
152. }

Knowledge points--annotations

1. Description

@Before	Initialize method
@After	Freeing resources
@Test	Test method, where you can test for expected exceptions and time-outs
@Ignore	Ignored test methods
@BeforeClass	For all tests, execute only once and must be static void
@AfterClass	For all tests, execute only once and must be static void
@RunWith	Specifies that a test class uses a runner
@Parameters	To specify a test data collection for a test class
@Rule	Allows flexibility to add or redefine the behavior of each test method in a test class
@FixMethodOrder	Specify the order in which test methods are executed

2. Execution order

A Test class unit test is executed in the following order:

@BeforeClass –> @Before –> @Test –> @After –> @AfterClass

The order in which each test method is called is:

@Before –> @Test –> @After

3. Example

2. Package test;
6. Import static org.junit.assert.*;
10. Import org.junit.*;
14. Public class Jdemotest {
18. @BeforeClass
20. public static void Setupbeforeclass () throws Exception {
22. System.out.println ("in beforeclass================");
24. }
28. @AfterClass
30. public static void Teardownafterclass () throws Exception {
32. System.out.println ("in afterclass=================");
34. }
38. @Before
40. public Void before () {
42. System.out.println ("in Before");
44. }
48. @After
50. public Void after () {
52. System.out.println ("in after");
54. }
58. @Test (timeout = 10000)
60. public void Testadd () {
62. Jdemo a = new Jdemo ();
64. Assertequals (6, A.add (3, 3));
66. System.out.println ("in Test----Add");
68. }
72. @Test
74. public void Testdivision () {
76. Jdemo a = new Jdemo ();
78. Assertequals (3, A.division (6, 2));
80. System.out.println ("in Test----Division");
82. }
86. @Ignore
88. @Test
90. public void Test_ignore () {
92. Jdemo a = new Jdemo ();
94. Assertequals (6, A.add (1, 5));
96. System.out.println ("in Test_ignore");
98. }
102. @Test
104. public void Teest_fail () {
106. Fail ();
108. }
110. }
114. Class Jdemo extends Thread {
118. int result;
122. public int Add (int A, int b) {
124. try {
126. Sleep (1000);
128. result = a + B;
130. } catch (Interruptedexception e) {
132. }
134. return result;
136. }
140. Public int Division (int A, int b) {
142. return result = A/b;
144. }
146. }

Execution Result:

1. In beforeclass================
2. In Before
3. In Test----ADD
4. In after
5. In Before
6. In Test----Division
7. In after
8. In afterclass=================

The upper left red box in the figure represents the JUnit run result, 5 successes (one ignore), 1 errors, and 1 failures. (Note that errors and failures are not the same, the error indicates that the code has an error, and failure indicates that the test method test failed)

The lower left red box indicates the running state of each test method, and you can see that the respective icons for success, error, failure, and failure are different, and you can see the run time.

The right part is the exception stack, which allows you to view exception information.

JUnit uses first bullet