Java魔法堂：JUnit4使用详解

/**
 * 学生信息实体
 */
public class EStudent{
  String name;
   int age;
   // 一堆getter、setter

   /**
    * 注意：自定义类时要重写equals方法，否则默认equals方法会使用==方式来比较对象的内存地址是否相同，而不是内容是否相同。
    */
   @Override
   public boolean equals(Object obj){
     if (obj == null || obl.getClass() != this.getClass()) return false;
     
     EStudent other = (EStudent)obj;
     if (!this.getName().equals(other.getName())
              || this.getAge() != other.getAge()) return false;
     return true;
   }
}

/**
  * 学生数据操作接口
  */
public interface StudentDao{
  public EStudent getStudent(int id);
}

/**
 * 真实的数据操作类
 */
public class StudentDaoImpl 
  implements StudentDao{

  public EStudent getStudent(int id){
       EStudent ret = new EStudent();
       ret.setName("fsjohnhuang");
       ret.setAge(18);
    
       return ret;
  }
}

/**
 * 模拟的数据操作类
 */
public class MockStudentDaoImpl 
  implements StudentDao{

  public EStudent getStudent(int id){
       EStudent ret = new EStudent();
       ret.setName("fsjohnhuang");
       ret.setAge(18);
    
       return ret;
  }
}

/**
 * 由于下面采用参数化测试，因此将测试运行器更换为Parameterized
 */
@RunWith(Parameterized.class)
public class TestStudentDao{
  static StudentDao dao, mockDao;

  /**
   * 执行测试类中所有测试前执行一次
   * 用于前提条件的初始化
   */
  @BeforeClass
  public static void init(){
      dao = new StudentDaoImpl();
      mockDao = new MockStudentDaoImpl();
  }
  
  /**
   * 接收测试用数据
   */
  int id;
  public TestStudentDao(int id){
    this.id = id;
  }

  /**
   * 测试用例
   */
  @Test
  public void testGetStudent(){
    assertEquals("获取学生信息", mockDao.getStudent(id), dao.getStudent(id));
  }

  /**
   * 测试用数据提供方法
   */
  @Parameters
  public Collection dataFeed(){
    return Arrays.asList(new Object[][]{{1},{2},{3}});
  }
}

public class MyUT{
  int i, j;
  @BeforeClass public void static init(){
    System.out.println("init");
    i = 0;
    j = 0;
  }
  
  @Before public void invokeBefore(){
    System.out.println("invokeBefore" + ++i);
  }

  @Test public void testMyMethod1(){
    System.out.println("testMyMethod1");
  }

  @Test public void testMyMethod2(){
    System.out.println("testMyMethod2");
  }

  @After public void invokeAfter(){
    System.out.println("invokeAfter" + ++j);
  }

  @AfterClass public void static destroy(){
    System.out.println("destroy");
    i = 0;
    j = 0;
  }
}

// 输出结果
init
invokeBefore1
testMyMethod1
invokeAfter1
invokeBefore2
testMyMethod2
invokeAfter2
destroy

@Test(expected=ArithmeticException.class) 
public void calc(){
  int i = 1/0;
}

@Test(timeout=1000) 
public void wait(){
  while(true){}
}

// 需要使用Parameterized测试运行器才可以
@RunWith(Parameterized.class)
public class MyUT{
  // 成员变量，用于存放测试用数据和测试期望值
  int orig;
  int expected;
  public MyUT(int orig, int expected){
    this.orig = orig;
    this.expected = expected;
  }
  
  @Test public void testMyMethod(){
      assertEquals(expected, orig + 1);
  }

  /**
   * 测试数据和测试期望值的提供方法
   * 必须用注解@Parameters标注
   * 必须返回Collection类型数据
   */
  @Parameters public Collection dataFeed(){
    return Arrays.asList(new Object[][]{
      {1, 2},
      {2, 3},
      {3, 4}
    });
  }
}

// 测试类1
public class MyUT1{
  @Test public void testMyMehthod1(){
    assertEquals(1,1);
  }
}
// 测试类2
public class MyUT2{
  @Test public void testMyMehthod2(){
    assertEquals(2,2);
  }
}
// 套件测试类
@RunWith(Suite.class)
@SuiteClass({MyUT1.class, MyUT2.class})
public class SuiteTest{
  // 必须有一个public，无参数的构造函数。使用默认的构造函数也可以
  public SuiteTest(){}
}

/* assertThat语法
 * assertThat(T actual, Matcher<T> matcher);
 * assertThat(String reason, T actual, Matcher<T> matcher);
 * 入参actual为实际值，入参matcher为期待值的匹配符
 */

//测试变量是否大于指定值
assertThat(1, greaterThan(50));
//测试变量是否小于指定值
assertThat(1, lessThan(100));
//测试变量是否大于等于指定值
assertThat(1, greaterThanOrEqualTo(50));
//测试变量是否小于等于指定值
assertThat(1, lessThanOrEqualTo(100));
                  
//测试所有条件必须成立
assertThat(1, allOf(greaterThan(50),lessThan(100)));
//测试只要有一个条件成立
assertThat(1, anyOf(greaterThanOrEqualTo(50), lessThanOrEqualTo(100)));
//测试无论什么条件成立(还没明白这个到底是什么意思)
assertThat(1, anything());
//测试变量值等于指定值
assertThat(1, is(100));
//测试变量不等于指定值
assertThat(1, 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);
user.add(test2);
                  
//测试集合中是否还有指定元素
assertThat(user, hasItem(test1));
assertThat(user, hasItem(test2));
  
/**Map匹配**/
Map<String,User> userMap = new HashMap<String,User>();
userMap.put(test1.getUsername(), test1);
userMap.put(test2.getUsername(), test2);
                  
//测试map中是否还有指定键值对
assertThat(userMap, hasEntry(test1.getUsername(), test1));
//测试map中是否还有指定键
assertThat(userMap, hasKey(test2.getUsername()));
//测试map中是否还有指定值
assertThat(userMap, hasValue(test2));

assumeThat(1, is(0));
System.out.println("I‘m here"); // 这句不会被执