JUnit

Junit

简介

JUnit是一个开源的java单元测试框架，它是XUnit测试体系架架构的一种体现

• 是Java语言事实上的标准单元测试库
• 真正的优势来自于JUnit所采作用的思想和技术，而不是框架本身。推动了单元测试、测试先行的编程和测试驱动的开发
• JUnit衍生了许多xUnit工具，将单元测试的优势应用与各种语言。影响了各种平台和语言上的程序员的测试工作
• 专门针对Java语言设计，使用广泛。
• JUnit是事实上的标准单元测试框架

优点

• 可以使用断言（Assertion）测试期望结果；
• 可以方便地组织和运行测试
• 可以方便地查看测试结果
• 常用IDE（例如IntelliJIdea、eclipse）都集成了JUnit
• 可以翻遍地集成到Maven

JUnit的设计

• TestCases：一个测试
• TestSuite：包含一组TestCases，表示一组测试
• TestFixture：测试环境
• TestResult：用于收集测试结果
• TestRunner：用于运行测试
• TestListener：用于监听测试过程，收集测试数据
• Assert：用于断言测试结果是否正确

Assert

使用Assert断言：

• 断言相等：assertEquals(100,x)
• 断言数组相等：assertArrayEquals({1,2,3},x)
• 浮点数断言相等：assertEquals(3.14,x,0.5)
• 断言为null：assertNull(x)
• 断言为true/false:assertTrue(x>0)/assertFalse(x<0)
• 其它：assertNotEquals/assertNotNull

总结

• 一个TestCase包含一组相关的测试方法
• 使用Assert断言测试结果（注意浮点数assertEquals要指定delta）
• 每个测试方法必须完全独立
• 测试代码必须非常简单
• 不能为测试代码再编写测试
• 测试需要覆盖各种输入条件，特别是边界条件

Assert

public static void assertEquals(double expected,double actual,double delta){//expecdted		预期值//actual		实际值//delta			误差值
}

//待测程序
public class Calculator{public double add(double number1,double number2){//返回两数之和return number1+number2;}
}

1.单元测试代码

import junit.framework.TestCase;//引入相应包
public class TestCalculator extends TestCase{public void testAdd(){Calculator calcuator = new Calculator();double result = calculator.add(10,15);Assert.assertEquals(60,result,0);}
}

assertTrue
assertFalse
assertEquals	支持boolean，long，int，String等等
assertNotNull
assertNull
assertSame	只支持Object类型（对象直接比较）
assertNotSame
fail

hamcrest

Hamcrest框架提供了一套匹配符Matcher，这些匹配符更接近自然语言，可读性高，更加灵活。

Hamcrest是一个书写匹配器对象时允许直接定义匹配规则的框架。

JUnit4.4引入了使用全新的断言语法：assertThat，结合Hamcest提供的匹配符，只用这一个方法，就可以实现所有的测试；

//assertThat语法如下
assertThat(T actulal,Matcher<T> matcher);
assertThat(String reson,T actual,Matcher<T> matcher);
//reson		失败提示信息
//actual	实际值
//matcher	匹配器

注意事项

1. 必须导入JUnit4.4之后的版本才能使用assertThat方法

2. 不需要继承TestCase类，但是需要测试方法前加@Test

3. 需要导入Hamcrest类库：hamcrest-core-1.3.0.jar和hamcrest-library-1.3.0.jar

4. 在eclipse或MyEclipse中使用时，建议使用自定义的Library。

   否则抛出异常：java.lang.SecurityExcepiton

import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class CalculatorTest2{Calculator calc = new Calculator();@Testpublic void testAdd(){int result = calc.add(10,20);assertThat(result,is(30));}
}

Mathcers的一般匹配器

//所有条件必须都成立测试才能通过，相当于"与"(&&)
assertThat(n,allOf(greaterThan(1),lessThan(15));
//所有条件只要有一个成立测试通过，相当于”或"(||)
assertThat(n,anyOf(greaterThan(16),lessThan(8)));
//无论什么条件，永远为true
assertThat(n,anyThing());
//待测的object等于后面给出的object，则测试通过
assertThat(obj,is(obj));
//与is匹配符正好相反
assertThat(obj,not(obj));

Mathcers的字符串匹配器

//str包含子字符串“software”则测试通过
assertThat(str,containsString("software"));
//str以子字符串“software”结尾则测试通过
assertThat(str,endsWith("software"));
//str以子字符串“software”开始则测试通过
assertThat(str,startsWith("software"));
//相等则测试通过，可测数值，字符串和对象之间是否相等，相当于Object的equals方法
assertThat(n,equalTo(nExpected));
//字符串str在忽略大小写的情况下等于"software"则测试通过
assertThat(str,equalToIgnoringCase("software"));
//忽略头尾的的任意个空格的情况下是否相等。注意：字符串中的空格不能被忽略
assertThat(str,equalToIgnoringWhiteSpace("software"));

Matchers的数值型匹配器

//浮点型数d在20.0+_0.5范围之内则测试通过
assertThat(d,closeTo(20.0,0.5));
//数值d大于16.0则测试通过
assertThat(d,greaterThan(16.0));
//数值d小于16.0则测试通过
assertThat(d,lessThan(16.0));
//数值d大于等于16.0则测试通过
assertThat(d,greaterThanOrEqualTo(16.0));
//数值d小于等于16.0则测试通过
assertThat(d,lessThanOrEqualTo(16.0));

Matchers的集合匹配器

//Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项测试通过
assertThat(mapObject,hasEntry("key","value"));
//Map对象mapObject含有键值"key"则测试通过
assertThat(mapObject,hasKey("key"));
//Map对象mapObject含有元素值"value"则测试通过
assertThat(mapObject,hasValue("value"));
//迭代对象iterableObject含有元素"element"项则测试通过
assertThat(iterableObject,hasItem("element"));

@Test

对可能抛出的异常进行测试：

• 异常本身是方法签名的一部分：

  public static int parseInt(String s) throws NumberFormatException

• 测试错误的输入是否导致特定的异常：

  Integer.parseInt(null)

  Integer.parseInt(“”)

  Integer.parseInt(“xyz”)

在测试类中，并不是每一个方法都时用于测试的，你必须使用@Test注解来表命那些事测试方法

• 测试方法地声明要求

  • 返回必须为void
  • 不能有任何形参

• @Test(timeout=1000)

  • 测试逻辑复杂地循环，防止死循环，单位为毫秒

    @Test(timeout=1000)
    public void testSquareRoot(){calc.squareRoot(4);assertTaht(calc.getResult(),is(2));
    }
    

• @Test(expected=ArithmeticException.class)

  检测是否跑出来我们指定地异常，它若没抛出，则为bug

  @Test(expected=ArithmeticException.class)
  public void testDivide(){calc.divide(0);
  }
  

@Ignore

• 被忽略地测试方法

  • 某些方法尚未完成或方法已经过时，不参与此次测试

  • 在某些条件下才能测试该方法（如：需要一个数据库连接，而在本地测试的时候，数据库并没有连接

  • 测试结果会提示有几个测试被忽略，而不是失败

    @Ignore("方法还未实现")
    @Test
    public void testMultiply(){calc.multiply(2);
    }
    

Fixture

某些阶段必然被调用的代码

@Test

@Ignore

@Before

@After

@BeforeClass

@AfterClass

@RunWith

@Parameters

@Suite.SuiteClasses

@Before和@After

• 注解@Before
  • 在每个测试方法执行之前都要执行一次
  • 在每个测试执行之前需要进行的准备工作
• 注解@After
  • 在每个测试方法执行之后要执行一次
  • 在任何测试执行之后进行的收尾工作
• @Before和@After标示的方法只能各有一个

JUnit使用@Before和@After

• 在@Before方法中初始化测试资源
• 在@After方法中释放测试资源、

public class CalculatorTest{Calculator calc;@Beforepublic void setUp(){calc = new Calculator();}@Afterpublic void tearDown(){calc = null;}
}

JUnit对于每个@Test方法：

1. 实例化CalculatorTest
2. 执行@Before方法
3. 执行@Test方法
4. 执行@After方法

使用@Before和@After可以保证：

• 单个@Test方法执行前会创建新的XxxTest实例，实例变量的状态不会传递给下一个@Test方法
• 单个@Test方法执行前后会执行@Before和@After方法

@BeforeClass和@AfterClass静态方法：

1. 在执行所有@Test方法前执行@BeforeClass静态方法
2. 执行所有测试
3. 在执行所有@Test方法后执行@AfterClass静态方法

@BeforeClass和@AfterClass静态方法

public class CalculatorTest{static StringBuilder builder;@BeforeClasspublic static void beforeClass(){builder = new StringBuilder();}
}

• @BeforeClass静态方法初始化的对象只能存放在静态字段中
• 静态字段的状态会影响到所有@Test

@BeforeClass和@AfterClass

• 注解@BeforeClass

  所有测试开始之前运行

• 注解@AfterClass

  所有测试结束之后运行

• @BeforeClass和@AfterClass标示的方法只能各有一个

• 该方法必须是public static修饰

JUnit的执行逻辑

invokeBeforeClass(CalculatorTest.class);//@BeforeClass
for(Method testMethod : findTestMethods(CalculatorTest.class)){CalculatorTest test = new CalculatorTest();//newtest.setUp();//@BeforetestMethod.invoke(test);//@Testtest.tearDown();//@After
}
invokeAfterClass(CalculatorTest.class);//@AfterClass

总结

初始化资源称为Fixture

• @Before：初始化测试对象，例如：input = new FileInputStream();
• @After：销毁对象@Before创建的测试对象，例如：input。close()
• @BeforeClass：初始化非常耗时的资源，例如：创建数据库
• @AfterClass：清理@BeforeClass创建的资源，例如：删除数据库

public class SequenceTest {@BeforeClasspublic static void setUpBeforeClass() throws Exception{System.out.println("setUpBeforeClass");}@AfterClasspublic static void treaDownAfterClass() throws Exception{System.out.println("tearDownAfterClass");}public SequenceTest(){System.out.println("	new SequenceTest");}@Beforepublic void setUp() throws Exception{System.out.println("		setUp");}@Afterpublic void treaDown() throws Exception{System.out.println("		treaDown");}@Testpublic void test1001() {System.out.println("		test1001");}@Testpublic void test1002() {System.out.println("		test1002");}@Testpublic void test1003() {System.out.println("		tset1003");}
}

#执行结果
setUpBeforeClassnew SequenceTestsetUptest1001treaDownnew SequenceTestsetUptest1002treaDownnew SequenceTestsetUptset1003treaDown
tearDownAfterClass

• 理解JUnit执行测试的生命周期
• @Before用于初始化测试对象，测试对象以实例变量存放
• @After用于清理@Before创建的对象
• @BeforeClass用于初始化耗时资源，以静态变量存放
• @AfterClass用于清理@BeforeClass创建的资源

@RunWith

@Runwith放在测试类名之前，用来确定这个类怎么运行的。不标注时会使用默认运行器。

常见的JUnit运行器

当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器

1. 默认运行器

   @RunWith(Junit4.class)

2. 参数化运行器

   • @RunWith(Patammeterized.class)配合@Patameters使用junit的参数化功能
   • @RunWith(Suite.class)
   • @SuiteClass({ATest.class,BTest.class,CTest.class})
   • 配合使用测试集功能

3. 兼容junit3.8的运行器

   @RunWith(JUnit38ClassRunner.class)

4. 其他运行器

   例如@RunWith(SpringJUnit4ClassRunner.class)集成了spring的一些功能

//测试类必须标记为@RunWith(Patameterized.class)
@RunWith(Parameterized.class)
public class AbsTest(){private int input;private int expected;//参数必须由静态方法data()返回//返回类型为Collection<Object[]>//静态方法必须标记为@Patameters@Parameterspublic static Collection<?> data(){return arrays.asList(new Object[][]{{0,0},{1,1},{-1,1}})}//构造方法参数必须和测试参数对应public AbsTest(int input,int expected){this.input = input;this.expected = expected;}//测试Math@Testpublci void testAbs(){int result=Math.abs(this.input);Assert.asserEquals(this.expected,result)}
}

@RunWith(Patameterized.class)
public class SqureTest{private static Calclator calculator = new Calculator();private int param;private int result;@Parameterspublic static Collection data(){return Arrays.asList(new Object[][]{{2,4},{0,0},{-3,9}});}//构造方法，对变量进行初始化public SquareTest(int param,int result){this.param = param;this.result = result;}@Testpublic void squareTest(){calculator.square(param);assertEquals(result,calclulator.getResult());}
}

实现步骤

1. 为类指定运行器：@RunWith(Parameterized.class)
2. 创建提供数据的方法，加上@Parameters注解，方法必须是static的，并且返回一个集合Collection;
3. 在测试类的构造方法中为各个参数赋值
4. 编写测试方法，它会根据参数的组数来运行测试多次

• 注意
  1. 要为这种测试专门生成一个新的类
  2. 要为这个类指定一个Runner，而不能使用默认的Runner

JUnit为我们提供了打包测试的功能，将所有需要运行的测试类集中起来，一次性的运行完毕

@RunWith(Suite.class)
@Suite.SuiteClass({CalculatorTest.class,SquareTest.class
})
public class AllCalcculatorTests{//没有内容没关系
}

参数化测试

如果待测试的输入和输出是一组数据：

• 可以把测试数据组织起来
• 用不同的测试数据调用相同的测试方法

• 参数必须由静态方法data()返回
• 返回类型为Collection<Object[]>
• 静态方法必须标记为@Parameters
• 测试类必须标记为@RunWith()
• 构造方法参数必须和测试参数对应

//测试类必须标记为@RunWith(Patameterized.class)
@RunWith(Parameterized.class)
public class AbsTest{//参数必须由静态方法data()返回//返回类型为Collection<Object[]>//静态方法必须标记为@Patameters@Parameterspublic static Collection<?> data(){return Arrays.asList(new Object[][]{{0,0},{1,1},{-1,1}});}int input;int expected;//构造方法参数必须和测试参数对应public AbsTest(int input,int expected){this.input = input;this.expected = expected;}@Testpublic void testAbs(){int r = Math.abs(this.input);Assert.assertEquals(this.expected,r);}
}

超时测试

• @Time(timeout = 1000)可以设置超时
• timeout单位时毫秒
• 超时测试不能取代性能测试和压力测试

//计算圆周率
//PI/4 = 1 - 1/3  + 1/5 - 1/7 + 1/9 -…
public class PI {//PI/4 = 1 - 1/3  + 1/5 - 1/7 + 1/9 -…//PI = 4 - 4/3 + 4/5 - 4/7 + 4/9 -...public double calculate(int count){double sum = 0;boolean positive = true;int n = 0;for (int i = 1;;i += 2){sum = sum + (positive ? 4.0 : -4.0)/i;positive = !positive;n++;if(n == count){break;}}return sum;}
}

public class PITest {PI pi;@Beforepublic void setUp() {pi = new PI();}@Afterpublic void tearDown() {pi = null;}//超时时间为100ms@Test(timeout = 100)public void test1k(){//计算1000次double r = pi.calculate(1000);assertEquals(3.14,r,0.01);}//超时时间为500ms@Test(timeout = 500)public void test1m(){//计算1百万次double r = pi.calculate(1000000);assertEquals(3.1416,r,0.0001);}//超时时间为500ms@Test(timeout = 500)public void test100m() {//计算10亿次double r = pi.calculate(1000000000);assertEquals(3.14159,r,0.00001);}
}

示例

/*
填写快递单时通常需要确定接收人的姓名、手机号和地址。其中要求手机号是11位数字字符，地址为字母开头的10个（含10）以内字母或字母数字共同组成。填写正确则提示“OK”，否则根据实际情况提示“**不符合要求”（**为手机号或地址）,退出。编写程序实现此快递单信息的输入，并设计测试数据进行判定覆盖测试。输入数据打印出“输入手机号:”、“输入地址:”。
*/
public static main(String[]args){Scanner sc = new Scanner(System.in);System.out.println("请输入收件人手机号");String phone = sc.nextLine();System.out.println("请输入收件人地址");string address = sc.nextLine();boolean mphone = phone.matches("^\\d{11})$");boolean maddress = address.matches("^[a-zA-Z][a-zA-Z0-9]*$");if(!phmone){System.out.println("手机号不符合要求");}else if(!maddress){System.out.println("地址不符合要求");}else{System.out.println("OK");}
}

@RunWith(Parameterized.class)
public class ProgramTest(){private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();private final PrintStream originalOut = System.out;static Program program;String phone,address,expected;@Beforepublic void setUp(){program = new Program();System.setOut(new PrintStream(outContent));String inputMessage = phone + "\r\n" + address +"\r\n";System.setIn(new ByteArrayInputStream(inputMessage.getBytes()));}@Parameterspublic static Collection data(){return Array.asList(new Object[][]{{ "12345678900", "Asdfg12345", "OK" },{ "12345678900", "Asdfg12345a", "地址不符合要求" }, { "123456789001", "Asdfg12345", "手机号不符合要求" } })}public ProgramTest(String phone,String address,String expected){this.phone=phone;this.address=address;this.expected=expected;}@Testpublic void testMain(){program.main(null);String result = outContent.toString().split("\r\n")[2];assertThat(result,is(expected));}
}

@Test
public void test1001(){ByteArrayOutputStream outContent = new ByteArrayOutputStream();printStream originalout = System.out;Program progaram = new Program();System.setOut(new PrintStream(outContent));String inputMessage = "12345678900" + "\r\n" + "Asdfg12345" + "\r\n";System.setIn(new ByteArrayInputStream(inputMessage.getBytes()));program.main(null);String result = outContent.toString().split("\r\n")[2];assertThat(result,is("OK"));
}