Junit

目录

• Assert 断言
• assertThat
• 导包
• JUnit 执行测试生命周期
• 超时测试
• 参数化测试
• 测试套件
• 优先级顺序
• Rule

Assert 断言

• 断言相等：assertEquals(100,x)

• 断言数组相等：assertArrayEquals({1,2,3},x)

• 断言浮点数相等：assertEquals(3.1416,x,0.0001)

• 断言为空：assertNull(x)

• 断言为 True/False：assertTrue(x>0) assertFalse(x<0)

• 其他：assertNotEquals/assertNotNull

assertThat

• 一般匹配

  • 测试变量是否大于指定值

    assertThat(test1.getShares(), greaterThan(50));

  • 测试变量是否小于指定值

    assertThat(test1.getShares(), lessThan(100));

  • 测试变量是否大于等于指定值

    assertThat(test1.getShares(), greaterThanOrEqualTo(50));

  • 测试变量是否小于等于指定值

    assertThat(test1.getShares(), lessThanOrEqualTo(100));

  • 测试所有条件必须成立

    assertThat(test1.getShares(), allOf(greaterThan(50),lessThan(100)));

  • 测试只要有一个条件成立

    assertThat(test1.getShares(),anyOf(greaterThanOrEqualTo(50), lessThanOrEqualTo(100)));

  • 测试变量值等于指定值

    assertThat(test1.getShares(), is(100));

  • 测试变量不等于指定值

    assertThat(test1.getShares(), not(50));

• 字符串匹配

  String url = "http://www.taobao.com";

  • 测试变量是否包含指定字符

    assertThat(url, containsString("taobao"));

  • 测试变量是否已指定字符串开头

    assertThat(url, startsWith("http://"));

  • 测试变量是否以指定字符串结尾

    assertThat(url, endsWith(".com"));

  • 测试变量是否等于指定字符串

    assertThat(url, equalTo("http://www.taobao.com"));

  • 测试变量再忽略大小写的情况下是否等于指定字符串

    assertThat(url, equalToIgnoringCase("http://www.taobao.com"));

  • 测试变量再忽略头尾任意空格的情况下是否等于指定字符串

    assertThat(url, equalToIgnoringWhiteSpace("http://www.taobao.com"));

• 集合匹配

  List<User> user = new ArrayList<User>();
  user.add(test1);
  

  • 测试集合中是否还有指定元素

    assertThat(user, hasItem(test1));

  • Map匹配

    Map<String,User> userMap = new HashMap<String,User>();
    userMap.put(test1.getUsername(), test1);
    

  • 测试map中是否还有指定键值对

    assertThat(userMap, hasEntry(test1.getUsername(), test1));

  • 测试map中是否还有指定键

    assertThat(userMap, hasKey(test1.getUsername()));

  • 测试map中是否还有指定值

    assertThat(userMap, hasValue(test1));

导包

• Before 方法的包

  import org.junit.Before;

• Test 方法的包

  import org.junit.Test;

• 普通断言的包

  import static org.junit.Assert.*;

• assertThat 的包

  CoreMatchers 和 Matchers 的区别在于 Matchers 包括了 CoreMatchers

  import static org.hamcrest.Matchers.*;

• 参数化测试需导的包

  // 注解测试类
  import org.junit.runner.RunWith;
  import org.junit.runners.Parameterized;
  // 输入数据
  import org.junit.runners.Parameterized.Parameters;
  import java.util.Collection;
  import java.util.Arrays;
  

JUnit 执行测试生命周期

1. @Before 用于初始化测试对象，测试对象以实例变量存放

2. @After 用于清理 @Before 创建的对象

3. @BeforeClass 用于初始化耗时资源，以静态变量存放

4. @AfterClass 用于清理 @BeforeClass 创建的资源

   @before 在每个测试方法之前都执行一次, 方法需要声明为 public
   @beforeclass 只在类中执行一次, 必须声明为 public static

超时测试

超时设置为 1 秒：@Test(timeout=1000)

小于设置的时间通过

参数化测试

1. 使用@RunWith(Parameterized.class)注解测试类。

   @RunWith(Parameterized.class)
   	public class T4Test {
           // zhi：实际值	yqzhi：预期值
   	    private String zhi;
   	    private String yqzhi;
   	    
   	    public T4Test(String zhi, String yqzhi){
   	        this.zhi = zhi;
   	        this.yqzhi = yqzhi;
   	    }
       }
   

2. 在测试类中创建一个使用@Parameters注解的公共静态方法，并返回一个包含测试数据对象的集合。

   @Parameters
   	    public static Collection<Object[]> initTestData(){
   	        return Arrays.asList(new Object[][] {
                   // 参数1：输入的值	参数2：预期值
   	            {"ababc", "替换前缀后的字符串为：efabc"},
   	            {"acdcd", "替换cd后的字符串为：aghgh"},
   	            {"asd", "大写字母的字符串为：ASD"}
   	        });
   	    }
   

3. 创建一个测试类的公共构造函数，其接受的入参和测试数据对象相互对应。

4. 编写测试方法，测试方法中可以使用测试类的变量（变量数据来自构造函数接受的测试数据）。

   @Test
   	    public void test() {
   	    	T4 t = new T4();
               // 断言预期值与实际值是否相等
   	    	assertEquals(this.yqzhi, t.f(this.zhi));
   	    }
   

5. JUnit执行测试时，自动会为测试数据对象集合中的每一列数据创建一个测试实例，测试实例中的变量会作为测试方法的测试数据来源。

测试套件

我们需要为我将要进行测试的类添加注释@RunWith(Suite.class)，以及@SuiteClasses(TestClass1.class, TestClass2.class)的注释才可以进行批量测试，在测试套件运行时在@SuiteClasses注释中的所有的类都可以进行测试，不需要分别测试。

package test.SUites;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({OneTest.class,TwoTest.class})
public class Suites {

}

优先级顺序

JUnit是通过@FixMethodOrder注解(annotation)来控制测试方法的执行顺序的

• MethodSorters.JVM

  按照JVM得到的方法顺序，也就是代码中定义的方法顺序

• MethodSorters.DEFAULT

  默认的顺序 以确定但不可预期的顺序执行

• MethodSorters.NAME_ASCENDING

  按方法名字母顺序执行

@FixMethodOrder(MethodSorters.JVM) // 指定测试方法按定义的顺序执行

Rule

• TestName 可以很方便获取当前测试执行的方法的名称

  package jiangbo.java.junit;
  
  import static org.junit.Assert.assertEquals;
  
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.TestName;
  
  public class TestNameTest {
  
      @Rule
      public final TestName name = new TestName();
  
      @Test
      public void testAdd() {
  
          System.out.println(name.getMethodName());
          int number = Caculator.add(1, 1);
          assertEquals(2, number);
      }
  
      @Test
      public void testSubtract() {
  
          System.out.println(name.getMethodName());
          int number = Caculator.subtract(1, 1);
          assertEquals(0, number);
      }
  }
  

• TemporaryFolder 可以创建临时文件，在测试执行完成后，会自动删除。

  package jiangbo.java.junit;
  
  import static org.junit.Assert.assertTrue;
  
  import java.io.File;
  import java.io.IOException;
  
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.TemporaryFolder;
  
  public class TemporaryFolderTest {
  
      @Rule
      public final TemporaryFolder folder = new TemporaryFolder();
  
      @Test
      public void testUsingTempFolder() throws IOException {
  
          File file = folder.newFile("myfile.txt");
          assertTrue(file.exists());
      }
  }
  

• ExternalResource ⽤于在测试之前创建资源，并在测试完成后销毁

  File tempFile;
  @Rule
  public ExternalResource extResource = new ExternalResource() {
  //每个测试执⾏之前都会调⽤该⽅法创建⼀个临时⽂件
  @Override
  protected void before() throws Throwable {
  tempFile = File.createTempFile("test", ".txt");
  }
  //每个测试执⾏之后都会调⽤该⽅法删除临时⽂件
  @Override
  protected void after() {
  tempFile.delete();
  }
  };
  @Test
  public void testExtResource() throws IOException {
  System.out.println(tempFile.getCanonicalPath());
  }