junit 测试出错 求助_百度知道
junit 测试出错 求助
我有更好的答案
junit 测试出错1、Failure一般由单元测试使用的断言方法判断失败所引起的，这经表示 测试点发现了问题 ，就是说程序输出的结果和我们预期的不一样。2、error是由代码异常引起的，它可以产生于测试代码本身的错误，也可以是被测试代码中的一个隐藏的bug你这个是JUnit测试类没有生成，不知道你的是web项目还是普通java项目。如果是web项目你可以去你的服务器的webapps/项目名/web-Inf/classes下看你的项目的java文件是不是部署了，是不是有class文件生成。 这个问题的引起都是class文件没有生成
采纳率：89%
来自团队：
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。本人初学者，想询问下junit 测试和 在每个类里写main方法测试有什么差别呢，或者说哪一种更加频繁_百度知道
本人初学者，想询问下junit 测试和 在每个类里写main方法测试有什么差别呢，或者说哪一种更加频繁
junit的不太会用
我有更好的答案
如果你的类里有多个方法，用main方法测试的话就很不方便，想测试全部方法的话就得把测试代码全部写到main里，或者你测一个重写一次。且更重要的是，这样会使测试代码与运行逻辑代码混在一起，不规范。
在一个正规的java项目中（尤其是使用了SSH之类的框架），几乎是不会写main方法的，写了就是无用代码，会被经理骂……
使用junit就方便多了，这是单元测试，你想测哪个方法就写一个对应的测试方法，然后用junit运行。每个方法之间是独立的，非常灵活。而且测试方法一般不会直接写在原类中，而是单独的测试类，这样测试代码就完全与逻辑代码分开了。
如果使用了maven之类的工具来管理项目，则junit的好处又会进一步体现出来：你可以编写好一大批测试类，然后用maven的一个简单命令来自动执行，想想看，全部自动测试，且测试结果自动生成文档，方便吧。
其实junit一点也不难学，用一两次就大体懂了。祝你学习顺利。
采纳率：100%
为您推荐：
其他类似问题
junit的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。o(╥﹏╥)o
页面找不到了
推荐阅读：详解Spring Boot Junit单元测试
转载 &更新时间：日 15:32:55 & 作者：catoop
本篇文章主要介绍了详解Spring Boot Junit单元测试，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Junit这种老技术，现在又拿出来说，不为别的，某种程度上来说，更是为了要说明它在项目中的重要性。
凭本人的感觉和经验来说，在项目中完全按标准都写Junit用例覆盖大部分业务代码的，应该不会超过一半。
刚好前段时间写了一些关于SpringBoot的帖子，正好现在把Junit再拿出来从几个方面再说一下，也算是给一些新手参考了。
那么先简单说一下为什么要写测试用例
1. 可以避免测试点的遗漏，为了更好的进行测试，可以提高测试效率
2. 可以自动测试，可以在项目打包前进行测试校验
3. 可以及时发现因为修改代码导致新的问题的出现，并及时解决
那么本文从以下几点来说明怎么使用Junit，Junit4比3要方便很多，细节大家可以自己了解下，主要就是版本4中对方法命名格式不再有要求，不再需要继承TestCase，一切都基于注解实现。
1、SpringBoot Web项目中中如何使用Junit
创建一个普通的Java类，在Junit4中不再需要继承TestCase类了。
因为我们是Web项目，所以在创建的Java类中添加注解：
@RunWith(SpringJUnit4ClassRunner.class) // SpringJUnit支持，由此引入Spring-Test框架支持！
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class) // 指定我们SpringBoot工程的Application启动类
@WebAppConfiguration // 由于是Web项目，Junit需要模拟ServletContext，因此我们需要给我们的测试类加上@WebAppConfiguration。
接下来就可以编写测试方法了，测试方法使用@Test注解标注即可。
在该类中我们可以像平常开发一样，直接@Autowired来注入我们要测试的类实例。
下面是完整代码：
package org.springboot.
import static org.junit.Assert.assertArrayE
import org.junit.T
import org.junit.runner.RunW
import org.springboot.sample.service.StudentS
import org.springframework.beans.factory.annotation.A
import org.springframework.boot.test.SpringApplicationC
import org.springframework.test.context.junit4.SpringJUnit4ClassR
import org.springframework.test.context.web.WebAppC
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class)
@WebAppConfiguration
public class StudentTest {
@Autowired
private StudentService studentS
public void likeName() {
assertArrayEquals(
new Object[]{
studentService.likeName("小明2").size() & 0,
studentService.likeName("坏").size() & 0,
studentService.likeName("莉莉").size() & 0
new Object[]{
assertTrue(studentService.likeName("小明2").size() & 0);
接下来，你需要新增无数个测试类，编写无数个测试方法来保障我们开发完的程序的有效性。
2、Junit基本注解介绍
//在所有测试方法前执行一次，一般在其中写上整体初始化的代码
@BeforeClass
//在所有测试方法后执行一次，一般在其中写上销毁和释放资源的代码
@AfterClass
//在每个测试方法前执行，一般用来初始化方法（比如我们在测试别的方法时，类中与其他测试方法共享的值已经被改变，为了保证测试结果的有效性，我们会在@Before注解的方法中重置数据）
//在每个测试方法后执行，在方法执行完成后要做的事情
// 测试方法执行超过1000毫秒后算超时，测试将失败
@Test(timeout = 1000)
// 测试方法期望得到的异常类，如果方法执行没有抛出指定的异常，则测试失败
@Test(expected = Exception.class)
// 执行测试时将忽略掉此方法，如果用于修饰类，则忽略整个类
@Ignore(“not ready yet”)
在JUnit中有很多个Runner，他们负责调用你的测试代码，每一个Runner都有各自的特殊功能，你要根据需要选择不同的Runner来运行你的测试代码。
如果我们只是简单的做普通Java测试，不涉及spring Web项目，你可以省略@RunWith注解，这样系统会自动使用默认Runner来运行你的代码。
3、参数化测试
Junit为我们提供的参数化测试需要使用 @RunWith(Parameterized.class)
然而因为Junit 使用@RunWith指定一个Runner，在我们更多情况下需要使用@RunWith(SpringJUnit4ClassRunner.class)来测试我们的Spring工程方法，所以我们使用assertArrayEquals 来对方法进行多种可能性测试便可。
下面是关于参数化测试的一个简单例子：
package org.springboot.
import static org.junit.Assert.assertT
import java.util.A
import java.util.C
import org.junit.T
import org.junit.runner.RunW
import org.junit.runners.P
import org.junit.runners.Parameterized.P
@RunWith(Parameterized.class)
public class ParameterTest {
* 该构造方法的参数与下面@Parameters注解的方法中的Object数组中值的顺序对应
* @param name
* @param result
public ParameterTest(String name, boolean result) {
this.name =
this.result =
public void test() {
assertTrue(name.contains("小") == result);
* 该方法返回Collection
* @author SHANHY
* @create 日
@Parameters
public static Collection&?& data(){
// Object 数组中值的顺序注意要和上面的构造方法ParameterTest的参数对应
return Arrays.asList(new Object[][]{
{"小明2", true},
{"坏", false},
{"莉莉", false},
4、打包测试
正常情况下我们写了5个测试类，我们需要一个一个执行。
打包测试，就是新增一个类，然后将我们写好的其他测试类配置在一起，然后直接运行这个类就达到同时运行其他几个测试的目的。
代码如下：
@RunWith(Suite.class)
@SuiteClasses({ATest.class, BTest.class, CTest.class})
public class ABCSuite {
// 类中不需要编写代码
5、使用Junit测试HTTP的API接口
我们可以直接使用这个来测试我们的Rest API，如果内部单元测试要求不是很严格，我们保证对外的API进行完全测试即可，因为API会调用内部的很多方法，姑且把它当做是整合测试吧。
下面是一个简单的例子：
package org.springboot.
import static org.junit.Assert.assertNotN
import static org.junit.Assert.assertT
import static org.junit.Assert.assertT
import java.util.regex.M
import java.util.regex.P
import org.hamcrest.M
import org.junit.A
import org.junit.AfterC
import org.junit.B
import org.junit.BeforeC
import org.junit.I
import org.junit.T
import org.junit.runner.RunW
import org.springframework.beans.factory.annotation.V
import org.springframework.boot.test.SpringApplicationC
import org.springframework.boot.test.TestRestT
import org.springframework.boot.test.WebIntegrationT
import org.springframework.test.context.junit4.SpringJUnit4ClassR
import org.springframework.util.LinkedMultiValueM
import org.springframework.util.MultiValueM
import org.springframework.web.client.RestT
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class)
//@WebAppConfiguration // 使用@WebIntegrationTest注解需要将@WebAppConfiguration注释掉
@WebIntegrationTest("server.port:0")// 使用0表示端口号随机，也可以具体指定如8888这样的固定端口
public class HelloControllerTest {
private String dateR
private RestTemplate template = new TestRestTemplate();
@Value("${local.server.port}")// 注入端口号
public void test3(){
String url = "http://localhost:"+port+"/myspringboot/hello/info";
MultiValueMap&String, Object& map = new LinkedMultiValueMap&String, Object&();
map.add("name", "Tom");
map.add("name1", "Lily");
String result = template.postForObject(url, map, String.class);
System.out.println(result);
assertNotNull(result);
assertThat(result, Matchers.containsString("Tom"));
6、捕获输出
使用 OutputCapture 来捕获指定方法开始执行以后的所有输出，包括System.out输出和Log日志。
OutputCapture 需要使用@Rule注解，并且实例化的对象需要使用public修饰，如下代码：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = SpringBootSampleApplication.class)
//@WebAppConfiguration // 使用@WebIntegrationTest注解需要将@WebAppConfiguration注释掉
@WebIntegrationTest("server.port:0")// 使用0表示端口号随机，也可以具体指定如8888这样的固定端口
public class HelloControllerTest {
@Value("${local.server.port}")// 注入端口号
private static final Logger logger = LoggerFactory.getLogger(StudentController.class);
// 这里注意，使用@Rule注解必须要用public
public OutputCapture capture = new OutputCapture();
public void test4(){
System.out.println("HelloWorld");
logger.info("logo日志也会被capture捕获测试输出");
assertThat(capture.toString(), Matchers.containsString("World"));
关于Assert类中的一些断言方法，都很简单，本文不再赘述。
但是在新版的Junit中，assertEquals 方法已经被废弃，它建议我们使用assertArrayEquals，旨在让我们测试一个方法的时候多传几种参数进行多种可能性测试。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具JUnit 单元测试 - 文章 - 伯乐在线
& JUnit 单元测试
JUnit 单元测试解析
1.首先看看什么是 JUnit：
JUnit官网对JUnit的简单解释：
JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.
JUnit是一个简单的可复用的测试框架，是xUnit测试框架的一个子集。
xUnit 又是什么呢？
xUnit是一套基于测试驱动开发的测试框架。
xUnit包括：PythonUnit、CppUnit等等。JUnit应该算是xUnit家族最成功的一个了。
2.为什么要使用 JUnit
使用JUnit能够帮助我们减少在开发过程中的错误，把Bug扼杀在萌芽之中，有利于代码的后期维护和检查。做好了单元测试可以缩短开发周期，提高代码质量。这样我们就可以把更多的时间用到我们应该干的事情上来而不是去解决项目后期发现的越来越多的令人头疼的问题。
测试不是用来证明你是对的，而是用来证明你没有错。
3.下载安装 JUnit
JUnit官网：
首先访问JUnit官网，找到welcome模块：
然后点击下载相应版本的JUnit就OK了。
4.使用 JUnit（这里使用的 JUnit4，IDE 为 MyEclipse）
4.1首先创建一个使用 JUnit 进行单元测试的 Java 项目：
准守一定的规则会使我们的项目和代码看起来更加的和谐。
一般来说规则是这样的：
a. 在Java项目（这里为JUnitTest）中创建一个名为test的source folder。
b. 在test目录中创建和src目录下相同的包名，在其中存放对应的测试类。
c. 不要忘了引入JUnit及其依赖jar包。
等项目完成之后把test测试源码文件删除即可，不影响其他的代码。
项目的结构目录看起来应该是这样的：
这样我们就可以来进行测试代码的编写了。
4.2一个简单的例子
a.首先在src/util包下创建Calculator.java，编写一个简单的加法运算器。
*被测试的类
*@author wxisme
上午9:52:24
public class Calculator {
public int add(int a, int b) {
return a +
1234567891011121314
package util;&/** *被测试的类 *@author wxisme *@ time
上午9:52:24 */public class Calculator {&&&&&&&&public int add(int a, int b) {&&&&&&&&return a + b;&&&&}&}
b. 在test/util包下创建CalculatorTest.java作为Calculator的测试类。
import junit.framework.A
import org.junit.B
import org.junit.T
import util.C
*@author wxisme
下午8:44:15
public class CalculatorTest {
private static C
@BeforeClass
public static void BuildCalculator() {
calculator = new Calculator();
public void testAdd() {
Assert.assertEquals(8, calculator.add(3, 5));
12345678910111213141516171819202122232425262728293031
package util;&import junit.framework.Assert;&import org.junit.Before;import org.junit.Test;&import util.Calculator;&/** * *@author wxisme *@ time
下午8:44:15 */public class CalculatorTest {&&&&&&&&private static Calculator calculator;&&&&&&&&@BeforeClass&&&&public static void BuildCalculator() {&&&&&&&&calculator = new Calculator();&&&&}&&&&&&&&@ Test&&&&public void testAdd() {&&&&&&&&&&&&&&&&Assert.assertEquals(8, calculator.add(3, 5));&&&&&&&&&&&&}&}
上面的程序JUnit4提供的注解和方法。
首先看@Test注解，见名知意，是标注testAdd()方法为一个测试方法。
Assert.assertEquals(8, calculator.add(3, 5));方法是JUnit中Assert类提供的断言方法。能够判断我们的预期结果和程序的输出结果是否是一致的。
我们来测试一下：选中testAdd()方法,右键选择run as JUnit test：
上面程序运行的结果应该是这样的：
看到有绿色的条，并且Error和Failure的值都为零，说明我们的测试通过。程序运行结果与我们所期望的是一致的。
那如果把testAdd()方法中的断言改成：
Assert.assertEquals(8, calculator.add(3, 5));
Assert.assertEquals(8, calculator.add(3, 5));
运行结果会是怎样的呢？
应该是这样的：
从红色圈起来的地方我们可以得知，测试没有通过，并且错误在于，我们期望的值为7，但是程序的输出结果为8.
c. 通过上面的例子我们可以有一下总结：
测试方法必须使用@Test修饰
测试方法必须使用public void修饰
新建test源代码目录来存放测试代码
测试类的包名应该和被测试类的报名保持一致
测试单元中的每个方法必须可以独立测试，测试方法之间不能有任何依赖
测试类一般使用Test作为后缀
测试方法一般使用test作为前缀
4.3系统的来看 JUnit 中注解和某些方法的用法
JUnit4中提供的常用注解大致包括：
@BeforeClass
@AfterClass
我们通过一个例子来了解他们的用法：
编写一个MethodTest来测试注解的用法。
import org.junit.A
import org.junit.AfterC
import org.junit.B
import org.junit.BeforeC
import org.junit.T
*@author wxisme
上午11:28:29
public class MethodTest {
@BeforeClass
//用static修饰
public static void setUpBeforeClass() throws Exception {
System.out.println("beforeClass...");
@AfterClass
//用static修饰
public static void tearDownAfterClass() throws Exception {
System.out.println("afterClass...");
public void setUp() throws Exception {
System.out.println("before...");
public void tearDown() throws Exception {
System.out.println("after...");
public void test1() {
System.out.println("test1...");
fail("Not yet implemented");
public void test2() {
System.out.println("test2...");
fail("Not yet implemented");
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748
package util;&import org.junit.After;import org.junit.AfterClass;import org.junit.Before;import org.junit.BeforeClass;import org.junit.Test;&/** * *@author wxisme *@ time
上午11:28:29 */public class MethodTest {&&&&&@BeforeClass&& //用static修饰&&&&public static void setUpBeforeClass() throws Exception {&&&&&&&&System.out.println("beforeClass...");&&&&}&&&&&@AfterClass&&&&&&&&//用static修饰&&&&public static void tearDownAfterClass() throws Exception {&&&&&&&&System.out.println("afterClass...");&&&&}&&&&&@Before&&&&public void setUp() throws Exception {&&&&&&&&System.out.println("before...");&&&&}&&&&&@After&&&&public void tearDown() throws Exception {&&&&&&&&System.out.println("after...");&&&&}&&&&&@ Test&&&&public void test1() {&&&&&&&&System.out.println("test1...");//&&&&&&&&fail("Not yet implemented");&&&&}&&&&&&&&@ Test&&&&public void test2() {&&&&&&&&System.out.println("test2...");//&&&&&&&&fail("Not yet implemented");&&&&}&}
测序的运行后再Console的中输出如下：
beforeClass...
afterClass...
beforeClass...before...test1...after...before...test2...after...afterClass...
其中我们可以总结出这几个注解的执行顺序和作用：
@Test将一个普通的方法修饰为一个测试方法
@BeforeClass会在所有方法运行前执行，static修饰
@AfterClass会在所有方法运行结束后执行，static修饰
@Before会在每个测试方法运行前执行一次
@After会在每个测试方法运行后被执行一次
这就是为什么在第一个例子中我会这么干了（所有的测试方法只使用一个Calculator就行了）：
@BeforeClass
public static void BuildCalculator() {
calculator = new Calculator();
private Calculator calculator;&&&&&&&&@BeforeClass&&&&public static void BuildCalculator() {&&&&&&&&calculator = new Calculator();&&&&}
@Test注解还可以带有参数。像这样：
@Test(expected=xx.class)
@Test(timeout=毫秒)
timeout参数很容易理解，就是指定程序运行的超时时间，单位为毫秒。
我们来看一下expected参数。
看一个例子：
在第一个例子里面加一个Exception异常属性，在testAdd()方法中抛出。
import junit.framework.A
import org.junit.B
import org.junit.T
import util.C
*@author wxisme
下午8:44:15
public class CalculatorTest {
private static C
private static E
@BeforeClass
public static void BuildCalculator() {
calculator = new Calculator();
ex = new Exception("手动抛出的异常！");
public void testAdd() throws Exception {
Assert.assertEquals(8, calculator.add(3, 5));
123456789101112131415161718192021222324252627282930313233
package util;&import junit.framework.Assert;&import org.junit.Before;import org.junit.Test;&import util.Calculator;&/** * *@author wxisme *@ time
下午8:44:15 */public class CalculatorTest {&&&&&&&&private static Calculator calculator;&&&&private static Exception ex;&&&&&&&&@BeforeClass&&&&public static void BuildCalculator() {&&&&&&&&calculator = new Calculator();&&&&&&&&ex = new Exception("手动抛出的异常！");&&&&}&&&&&&&&@ Test&&&&public void testAdd() throws Exception {&&&&&&&&&&&&&&&&Assert.assertEquals(8, calculator.add(3, 5));&&&&&&&&throw ex;&&&&}&}
结果会是这样的：
发现测试没有通过，并且抛出了一个异常，使我们手动抛出的异常。
那么把上面的程序总@Test注解加上这样的参数：
@Test(expected=Exception.class)
再看结果：
发现测试通过了。
是不是突然就明白expected参数的作用了呢？
其他几个注解的功能可以类比。
再来看@Ignore和@RunWith
@Ignore见名知意，作用是让测试运行器忽略其修饰的测试方法。@Ignore所修饰的方法不会执行。
自行测试。
@RunWith可以用来更改运行测试器org.junit.runner.Runner。
下面的两个例子都是通过@RunWith注解来实现的。
1）测试套件试想如果项目中有100个测试类需要测试，你会怎么做呢？每个类运行一次？运行100次？
JUnit当然不会只允许有这一个愚蠢的方法。答案就是测试套件。
测试套件用来组织批量运行测试类。看一个例子。
首先来创建3个测试类模拟需要批量运行的测试类群。
public class DemoTest1 {
public void test() {
System.out.println("DemoTest1...");
public class DemoTest2 {
public void test() {
System.out.println("DemoTest2...");
public class DemoTest3 {
public void test() {
System.out.println("DemoTest3...");
123456789101112131415161718192021222324
public class DemoTest1 {&&&&&@ Test&&&&public void test() {&&&&&&&&System.out.println("DemoTest1...");&&&&}&}public class DemoTest2 {&&&&&@ Test&&&&public void test() {&&&&&&&&System.out.println("DemoTest2...");&&&&}&}public class DemoTest3 {&&&&&@ Test&&&&public void test() {&&&&&&&&System.out.println("DemoTest3...");&&&&}&}
然后创建一个名为SuiteTest的测试类，并加上@RunWith注解和@Suite.SuiteClasses注解。（该类中没有其他测试方法）
import org.junit.runner.RunW
import org.junit.runners.S
*@author wxisme
下午7:37:56
@RunWith(Suite.class)
@Suite.SuiteClasses({DemoTest1.class,DemoTest2.class,DemoTest3.class})
public class SuiteTest {
12345678910111213141516
package util;&import org.junit.runner.RunWith;import org.junit.runners.Suite;&/** *测试套件 *@author wxisme *@ time
下午7:37:56 */&@RunWith(Suite.class)@Suite.SuiteClasses({DemoTest1.class,DemoTest2.class,DemoTest3.class})public class SuiteTest {&}
测试程序总首先用@RunWith来修改测试运行器。
然后使用@Suite.SuiteClasses来指定要批量执行的测试类（数组的形式）
程序的运行结果应该是这样的（通过测试并且在Console中输出）：
可见我们的批量运行生效了。
2）JUnit 参数化设置
再试想一个场景：如果一个测试方法中需要测试100组数据是否和期望值一致，你会怎么做呢？手动copy+change100次？
JUnit也不会只允许使用这么愚蠢的方法。这就用到了JUnit的参数化设置。
看一个例子：
a.首先创建一个名为ParameterTest的测试类，并用RunWith注解来改变测试运行器。
b.声明变量来存放预期值和结果值。
c.声明一个返回值为Collection的公共静态方法，并使用 @Parameters进行修饰。
d.为测试类声明一个带有参数的公共构造方法，并在其中为之声明变量赋值。
代码应该是这样的：
import java.util.A
import java.util.C
import junit.framework.A
import org.junit.BeforeC
import org.junit.T
import org.junit.runner.RunW
import org.junit.runners.P
import org.junit.runners.Parameterized.P
*JUnit参数化设置
*@author wxisme
下午8:03:47
@RunWith(Parameterized.class)
public class ParameterTest {
private static C
@BeforeClass
public static void setUpBeforeClass() {
calculator = new Calculator();
private int input1;
private int input2;
@Parameters
public static Collection&Object[]& setParameters() {
Object[][] objs = {{8,3,5},{5,3,2}};
return Arrays.asList(objs);
public ParameterTest(int expected, int input1, int input2) {
this.expected =
this.input1 = input1;
this.input2 = input2;
public void testParameters() {
Assert.assertEquals(expected, calculator.add(input1, input2));
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
package util;&import java.util.Arrays;import java.util.Collection;&import junit.framework.Assert;&import org.junit.BeforeClass;import org.junit.Test;import org.junit.runner.RunWith;import org.junit.runners.Parameterized;import org.junit.runners.Parameterized.Parameters;&/** *JUnit参数化设置 *@author wxisme *@ time
下午8:03:47 */@RunWith(Parameterized.class)public class ParameterTest {&&&&&&&&private static Calculator calculator;&&&&&&&&@BeforeClass&&&&public static void setUpBeforeClass() {&&&&&&&&calculator = new Calculator();&&&&}&&&&&&&&private int expected;&&&&private int input1;&&&&private int input2;&&&&&&&&@Parameters&&&&public static Collection&Object[]& setParameters() {&&&&&&&&Object[][] objs = {{8,3,5},{5,3,2}};&&&&&&&&&&&&&&&&return Arrays.asList(objs);&&&&}&&&&&&&&public ParameterTest(int expected, int input1, int input2) {&&&&&&&&this.expected = expected;&&&&&&&&this.input1 = input1;&&&&&&&&this.input2 = input2;&&&&}&&&&&&&&&@ Test&&&&public void testParameters() {&&&&&&&&Assert.assertEquals(expected, calculator.add(input1, input2));&&&&}&}
然后我们运行这个测试类（要在类的级别上运行，如果在方法上运行就会有初始化错误）。
结果应该是这样的：
运行结果显示两组测试数据均测试通过。
到此JUnit的基本用法就介绍完了，关于JUnit的其他用法以及断言的API请参考官方提供的document（如果你不想自己找的话，在评论区留下邮箱，我会发给你的哦）。
JUnit带给我们的不仅是开发效率、代码质量的提高，更是一种思想的提高，现在都在讲测试驱动开发、回归质量大概就是这种思想。
JUnit使用起来不仅简单方便，其源码更是短小精悍，Erich Gamma 是著名的 GoF 之一，在JUnit中设计模式的使用堪称经典，有优良的扩展性和可重用性。值得细细品味。
打赏支持我写出更多好文章，谢谢！
打赏支持我写出更多好文章，谢谢！
任选一种支付方式
关于作者：
可能感兴趣的话题
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2018 伯乐在线