public interface HelloService {
 public void sayHello();
}

@RestController
public class HelloController {
 @RequestMapping(name="/hello")
 public String getHello() {
 return "hello web";
 }
}

.andExpect(content().string(containsString("hello")));;

String mvcResult= mockMvc.perform(MockMvcRequestBuilders.get("/messages")).andRetu
rn().getResponse().getContentAsString();
System.out.println("Result === "+mvcResult);

@Test
public void testHelloMore() throws Exception {
 final MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 params.add("id", "6");
 params.add("hello", "world");
 mockMvc.perform(
 MockMvcRequestBuilders.post("/hello")
 .params(params)
 .contentType(MediaType.APPLICATION_JSON_UTF8)
 .accept(MediaType.APPLICATION_JSON_UTF8))
 .andExpect(status().isOk())
 .andExpect(content().string(containsString("hello")));;
}

• @Test，把⼀个⽅法标记为测试⽅法
• @Before，每⼀个测试⽅法执⾏前⾃动调⽤⼀次
• @After，每⼀个测试⽅法执⾏完⾃动调⽤⼀次
• @BeforeClass，所有测试⽅法执⾏前执⾏⼀次，在测试类还没有实例化就已经被加载，因此⽤ static 修 饰
• @AfterClass，所有测试⽅法执⾏前执⾏⼀次，在测试类还没有实例化就已经被加载，因此⽤ static 修 饰
• @Ignore，暂不执⾏该测试⽅法
• @RunWith 当⼀个类⽤ @RunWith 注释或继承⼀个⽤ @RunWith 注释的类时，JUnit 将调⽤它所引⽤的

public class JUnit4Test {
 Calculation calculation = new Calculation();
 int result; //测试结果
 //在 JUnit 4 中使⽤ @Test 标注为测试⽅法
 @Test
 //测试⽅法必须是 public void 的
 public void testAdd() {
 System.out.println("---testAdd开始测试---");
 //每个⾥⾯只测⼀次，因为 assertEquals ⼀旦测试发现错误就抛出异常，不再运⾏后续代码
 result = calculation.add(1, 2);
 assertEquals(3, result);
 System.out.println("---testAdd正常运⾏结束---");
GitChat
 }
 //⼜⼀个测试⽅法
 //timeout 表示测试允许的执⾏时间毫秒数，expected 表示忽略哪些抛出的异常（不会因为该异常导
致测试不通过）
 @Test(timeout = 1, expected = NullPointerException.class)
 public void testSub() {
 System.out.println("---testSub开始测试---");
 result = calculation.sub(3, 2);
 assertEquals(1, result);
 throw new NullPointerException();
 //System.out.println("---testSub正常运⾏结束---");
 }
 //指示该[静态⽅法]将在该类的[所有]测试⽅法执⾏之[前]执⾏
 @BeforeClass
 public static void beforeAll() {
 System.out.println("||==BeforeClass==||");
 System.out.println("||==通常在这个⽅法中加载资源==||");
 }
 //指示该[静态⽅法]将在该类的[所有]测试⽅法执⾏之[后]执⾏
 @AfterClass
 public static void afterAll() {
 System.out.println("||==AfterClass==||");
 System.out.println("||==通常在这个⽅法中释放资源==||");
 }
 //该[成员⽅法]在[每个]测试⽅法执⾏之[前]执⾏
 @Before
 public void beforeEvery() {
 System.out.println("|==Before==|");
 }
 //该[成员⽅法]在[每个]测试⽅法执⾏之[后]执⾏
 @After
 public void afterEvery() {
 System.out.println("|==After==|");
 }
}

||==BeforeClass==||
||==通常在这个⽅法中加载资源==||
|==Before==|
---testAdd开始测试---
---testAdd正常运⾏结束---
|==After==|
|==Before==|
---testSub开始测试---
|==After==|
||==AfterClass==||
||==通常在这个⽅法中释放资源==||

Assert 使⽤

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestAssert {
 @Autowired
 private UserService userService;
 @Test
 public void TestAssert(){
 //验证结果是否为空
 Assert.assertNotNull(userService.getUser());
 //验证结果是否相等
 Assert.assertEquals("i am neo!", userService.getUser());
 //验证条件是否成⽴
 Assert.assertFalse(1+1>3);
 //验证对象是否相等
 Assert.assertSame(userService,userService);
 int status=404;
 //验证结果集，提示
 Assert.assertFalse("错误，正确的返回值为200", status != 200);
 String[] expectedOutput = {"apple", "mango", "grape"};
 String[] methodOutput = {"apple", "mango", "grape1"};
 //验证数组是否相同
 Assert.assertArrayEquals(expectedOutput, methodOutput);
 }
}

assertThat( [value], [matcher statement] );

// allOf 匹配符表明如果接下来的所有条件必须都成⽴测试才通过，相当于“与”（&&）
assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) );
// anyOf 匹配符表明如果接下来的所有条件只要有⼀个成⽴则测试通过，相当于“或”（||）
assertThat( testedNumber, anyOf( greaterThan(16), lessThan(8) ) );
// anything 匹配符表明⽆论什么条件，永远为 true
assertThat( testedNumber, anything() );
// is 匹配符表明如果前⾯待测的 object 等于后⾯给出的 object，则测试通过
assertThat( testedString, is( "developerWorks" ) );
// not 匹配符和 is 匹配符正好相反，表明如果前⾯待测的 object 不等于后⾯给出的 object，则测试通
过
assertThat( testedString, not( "developerWorks" ) );

// containsString 匹配符表明如果测试的字符串 testedString 包含⼦字符串"developerWorks"则
测试通过
assertThat( testedString, containsString( "developerWorks" ) );
// endsWith 匹配符表明如果测试的字符串 testedString 以⼦字符串"developerWorks"结尾则测试通
过
assertThat( testedString, endsWith( "developerWorks" ) ); 
// startsWith 匹配符表明如果测试的字符串 testedString 以⼦字符串"developerWorks"开始则测试
通过
assertThat( testedString, startsWith( "developerWorks" ) ); 
// equalTo 匹配符表明如果测试的 testedValue 等于 expectedValue 则测试通过，equalTo 可以测
试数值之间的字
//符串之间和对象之间是否相等，相当于 Object 的 equals ⽅法
assertThat( testedValue, equalTo( expectedValue ) ); 
// equalToIgnoringCase 匹配符表明如果测试的字符串 testedString 在忽略⼤⼩写的情况下等于
//"developerWorks"则测试通过
assertThat( testedString, equalToIgnoringCase( "developerWorks" ) ); 
// equalToIgnoringWhiteSpace 匹配符表明如果测试的字符串 testedString 在忽略头尾的任意个空
格的情况下等
//于"developerWorks"则测试通过，注意，字符串中的空格不能被忽略
assertThat( testedString, equalToIgnoringWhiteSpace( "developerWorks" ) );

// closeTo 匹配符表明如果所测试的浮点型数 testedDouble 在 20.0±0.5 范围之内则测试通过
assertThat( testedDouble, closeTo( 20.0, 0.5 ) );
// greaterThan 匹配符表明如果所测试的数值 testedNumber ⼤于 16.0 则测试通过
assertThat( testedNumber, greaterThan(16.0) );
// lessThan 匹配符表明如果所测试的数值 testedNumber ⼩于 16.0 则测试通过
assertThat( testedNumber, lessThan (16.0) );
// greaterThanOrEqualTo 匹配符表明如果所测试的数值 testedNumber ⼤于等于 16.0 则测试通过
assertThat( testedNumber, greaterThanOrEqualTo (16.0) );
// lessThanOrEqualTo 匹配符表明如果所测试的数值 testedNumber ⼩于等于 16.0 则测试通过
assertThat( testedNumber, lessThanOrEqualTo (16.0) );

// hasEntry 匹配符表明如果测试的 Map 对象 mapObject 含有⼀个键值为"key"对应元素值为"value"
的 Entry 项则
//测试通过
assertThat( mapObject, hasEntry( "key", "value" ) );
// hasItem 匹配符表明如果测试的迭代对象 iterableObject 含有元素“element”项则测试通过
assertThat( iterableObject, hasItem ( "element" ) );
// hasKey 匹配符表明如果测试的 Map 对象 mapObject 含有键值“key”则测试通过
assertThat( mapObject, hasKey ( "key" ) );
// hasValue 匹配符表明如果测试的 Map 对象 mapObject 含有元素值“value”则测试通过
assertThat( mapObject, hasValue ( "key" ) );