JUnit起步

单元测试（unit testing）,是指对软件中的最小测试单元进行检查和验证，单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。

测试的分类

按照开发阶段划分：单元测试、集成测试、系统测试、确认测试、验收测试

按照测试实施组织划分：开发方测试、用户测试（β测试）、第三方测试

按照测试技术划分：白盒测试、黑盒测试、灰盒测试。也可划分为静态测试和动态测试

测试相关概念

白盒测试：把测试对象看作一个打开的盒子，程序内部的逻辑结构和其他信息对测试人员是公开的

回归测试：软件或环境的修复或更正以后的“再测试”，自动测试工具对这类测试非常有用

单元测试：是最小粒度的测试，以测试某个功能或代码块。一般由程序员来测试，是因为它需要知道内部程序设计和编码细节

JUnit:是一个开发源码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于Java语言）。主要用于白盒测试，回归测试

单元测试的好处：提高开发速度，提高软件代码质量，提升系统的可信赖度

Junit的特征：用于测试期望结果的断言（Assertion），用于共享共同测试数据的测试工具，用于方便的组织和运行测试的测试套件，图形和文本的测试运行器，JUnit可以用于程序开发人员或专业测试人员进行单元测试

实例:下面是需要测试的方法

public class Calculate {
	public int add(int a, int b) { return a + b; }
	public int sub(int a, int b) { return a - b; }
	public int mul(int a,int b) { return a*b; }
	public int div(int	 a, int  b) { return a/b; }
}

首先需要明确单元测试的本质就是对类中的方法的调用，看运行结果与预期结果是否一致

步骤：创建被测试的对象-->调用被测试的方法，输入对应的参数-->做断言，判断预期结果与真实结果是否一致

---

---

JUnit3语法：

import junit.framework.TestCase;
import junit.framework.Assert;

public class CalculateTestWithJunit3 extends TestCase {
    Calculate cal;
    public void setUp(){//在每个测试方法之前都会执行一次
        cal=new Calculate();
        System.out.println("setUp");
    }
    public void tearDown(){//在每个测试方法之前都会执行一次
        System.out.println("tearDown");
    }
    //在Jnuit3中所有的测试方法名称都要以“test”开头
    public void testAdd(){
        //Calculate cal=new Calculate();//1.构建对象
        int result=cal.add(1,3);//2.调用要测试的方法
        Assert.assertEquals(4,result);//3.做断言（比较）
        System.out.println("testAdd");
    }
    public void testSub(){
        //Calculate cal=new Calculate();
        int result=cal.sub(1,3);
        Assert.assertEquals(-2,result);
        System.out.println("testSub");
    }
    public void testMul(){
        //Calculate cal=new Calculate();
        int result=cal.mul(1,3);
        Assert.assertEquals(3,result);
        System.out.println("testMul");
    }
    public void testDiv(){
        //Calculate cal=new Calculate();
        int result=cal.div(1,3);
        Assert.assertEquals(0,result);
        System.out.println("testDiv");
    }
}

结论：在JUnit3中，所有的测试类都必须extends TestCase

在JUnit3中，所有的测试测试方法都必须以“test”开头

在JUnit3中，viod setUp()在每个测试方法测试之前都会执行一次，void tearDown()在每个测试方法执行 之后都会执行一次

---

---

JUnit4语法：

import junit.framework.Assert;
import org.junit.*;

public class CalculteTestWithJunit4 {
    Calculate cal;
    @BeforeClass //在测试之前执行，只执行一次
    public static void init(){
    }
    @AfterClass  //在测试之后执行，只执行一次
    public static void desty(){
    }
    @Before //声明的方法，在每个测试方法之前都会执行一次
    public void setUp(){
        cal=new Calculate();
    }
    @After //声明的方法，在每个测试方法之后都会执行一次
    public void tearDown(){
    }
    @Test //用于声明一个测试方法
    public void testAdd(){
        //Calculate cal = new Calculate();
        int result=cal.add(1,3);
        Assert.assertEquals(4,result);
    }
    @Test
    public void testSub(){
       //Calculate cal = new Calculate();
        int result=cal.sub(1,3);
        Assert.assertEquals(-2,result);
    }
    @Test
    public void testMul(){
        //Calculate cal = new Calculate();
        int result=cal.mul(1,3);
        Assert.assertEquals(3,result);
    }
    @Test
    public void testDiv(){
        //Calculate cal = new Calculate();
        int result=cal.div(1,3);
        Assert.assertEquals(0,result);
    }
}

在JUnit4中用的是注解，在JUnit4中有测试方法的类就是测试用例，用@Test声明的方法就是测试方法，方法体内部测试步骤和JUnit3是一样的,组要特别注意的十几个注解的作用：

•用@Test声明的方法就是测试方法

•@Before：初始化方法，在任何一个测试执行之前必须执行的代码;

•@ After：释放资源，在任何测试执行之后需要进行的收尾工作。跟3.x中的tearDown()方法具有相同功能

•@BeforeClass：针对所有测试，在所有测试方法执行前执行一次，只执行一次 格式：@BeforeClass public static void method()

•@AfterClass：针对所有测试，在所有测试方法执行结束后执行一次，只执行一次 格式：@AfterClass public static void method()

•@Ignore：忽略的测试方法，标注的含义就是“某些方法尚未完成，暂不参与此次测试”

Junit 4 的单元测试用例执行顺序为：

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

•每一个测试方法的调用顺序为：

–@Before –> @Test –> @After。

---

---

JUnit3与4的差异

JUnit3	JUnit4
必须引入类junit.framework.TestCase	必须引入org.junit.Assert.*(static import)
必须继承类TestCase	不需要
测试方法必须以teat开头	不需要，但是必须加上@teat注解
都要通过assertxxxx()方法来判断结果

---

---

用JUnit编写测试套件

测试套件指一组测试，就是把多个测试用例组合到一起运行。当执行一个测试用例时并没有人为指定一个套件，JUnit会自动提供一个测试套件。当需要把多个测试用例组合在一起运行时需要把多个测试用例组合成测试套件再运行 ，测试套件的编写有Junit3和Junit4.

Junit3编写测试套件

Junit3编写套件的方式是写一个suite()方法，把要测试的测试用例或者测试套件加入到此方法中，形成一个新的测试套件。在Junit3中的suite()方法中有许多要求：首先方法必须是public，并且static，返回类型是Test方法的名称要求为suite()。在suite()方法中，要构建一个TestSuite的对象。TestSuite是一个测试套件的集成器，主要提供方法将相关的测试用例或测试套件组成测试套件

主要方法有：

public void addTestSuite( Class < TestCase > testClass )

用来添加测试用例到测试套件中：

public void addTest( Test test)
JUnit支持套件加套件：

suite. addTest( A.TestAllWithJunit3X. suite( )) ;

实例：

import junit.framework.Test;
import junit.framework.TestSuite；

public class TestSuitewithJunit3x {
    
  public static Test suite(){
    TestSuite suite =new TestSuite();
    suite.addTestSuite(TestCalculatorJUnit3x.class);
    suite.addTestSuite(TestCalculatorJUnit3x_2.class);
    return suite；}
}

运行结果：

---

JUnit4编写测试套件

在JUnit4编写测试套件时，用@RunWith(value = Suite.class)来指定测试运行器为套件(suite)运行器。并且用@SuiteClasses( value = { })组合测试套件所包括的测试用例和测试套件

例如：

package chapter_1;
import org.junit.runner.RunWith;
import org. junit.runners.Suite;
import org.junit.runners. Suite. SuiteClasses;
@RunWith(Suite.class)
@ SuiteClasses(value ={chapter_1.TestCalculatorJUnit3x.class,
                       chapter_1.TestCalculatorJUnit3X.class,
                       chapter_1.TestSuiteWithJUnit3x.class
                      })
public class TestSuiteWithJUnit4x{}

---

在了解测试核心类之前，得明白什么是测试用例，测试用例：包含一个或更多用@Test进行注释的测试方法的类。一个TsetCase把具有公共行为的测试归为一组。

核心测试类：

断言方法：

assertThat断言：junit4引入Hamcrest框架，Hamcrest提供了一套匹配符Mather；使用全新的断言方法：assertThat，结合Hamcrest提供的匹配符，只有这一个方法，就可以实现所有测试；

assertThat语法：

assertThat（T actual ，Mather <T> mather）；

assertThat（String reason,T actual,Mather<T> mather）;

测试运行器（Runner or test runner）

junit 4可以向后兼容junit 3 版本，junit 的最新版本中提供了不同的运行器

@RunWith:junit用例都是在Runner（运行器）来执行的。通过它，可以为这个测试类指定一个特定的Runner

当要运行某个方法不同的参数多次测试时，参数化运行期提供了很大的便利，例如

对Calculator类中add方向分别用三组不同的数据进行测试

{1,1},

{-20,-30},

{10,0}

@RunWith(value=Parameterized.class)//指定参数化运行器
public class ParameterizedTest {
	private int expected;
	private int valueone;
	private int valuetwo;
	@Parameters//指定参数化测试所有的测试数据
	public static List<Object[]>  data(){
		return Arrays.asList(new Object[][]{
				{2,1,1},
				{-50,-20,-30},
				{10,10,0}
		});
	}
    public ParameterizedTest(int expected,int  valueone,int valuetwo){//编写构造方法，指定参数的调用顺序
		this.expected=expected;
		this.valueone=valueone;
		this.valuetwo=valuetwo;
	}
	@Test
	public void testAdd(){
	   Calculator cal=new Calculator();
      assertEquals(expected,cal.add(valueone, valuetwo),0);//编写测试方法，调用参数
	}
}
	

运行结果如下：