JUnit 4 与 TestNG 对比 - ImportNew
| 分类： ,
| 标签： ,
这两天在看一本书，作者是 TestNG 的创始人，了解了不少关于 TestNG 的知识，看了一篇文章基本把这本书的几个观点都体现了，那我就直接翻译原文就好，省得自己总结。这两天要不是等原作者的授权的话可能周末本文就发布了，没经过人家许可翻译人家文章应该的确也不是什么光彩的事情，等等无妨。原文链接，非常感谢作者写出好文，不过先生写了的确好多文章，经常搜个文章 google 第一篇总是他的。如果有翻译问题，请拍砖。
————————————————————————————————————————————
Junit 4 和 TestNG 都是 Java 方面非常流行的单元测试框架。在功能上两个框架都非常类似。到底哪个比较好？在Java项目中我们应该选择哪个框架？
下图将会对Junit 4 和 TestNG 做个功能特征的对比。
Junit 4 和 TestNG 在注解方面的实现非常相似。
测试套件在执行之前需要执行的
@BeforeSuite
测试套件在执行之后需要执行的
@AfterSuite
在测试之前需要执行的
@BeforeTest
在测试之后需要执行的
@AfterTest
在一个测试方法所属于的任意一个组的第一个方法被调用之前执行
@BeforeGroups
在一个测试方法所属于的任意一个组的最后一个方法被调用之后执行
@AfterGroups
在当前类的第一个测试方法调用之前执行
@BeforeClass
@BeforeClass
在当前类的最后一个测试方法调用之后执行
@AfterClass
@AfterClass
每个测试方法之前需要执行
@BeforeMethod
每个测试方法之后需要执行
@AfterMethod
@Test(enbale=false)
@Test(expected = ArithmeticException.class)
@Test(expectedExceptions = ArithmeticException.class)
@Test(timeout = 1000)
@Test(timeout = 1000)
JUnit 4 和 TestNG 之间注解方面的区别主要有以下几点：
在Junit 4 中，如果我们需要在方法前面使用@BeforeClass和@AfterClass，那么该测试方法则必须是静态方法。TestNG 在方法定义部分则更加的灵活，它不需要类似的约束。
3个附加的setUp/tearDown级别：套件和分组（@Before/AfterSuite, @Before/AfterTest, @Before/AfterGroup）。想了解详细的请看
@BeforeClass
public static void oneTimeSetUp() {
// one-time initialization code
System.out.println(&@BeforeClass - oneTimeSetUp&);
@BeforeClass
public void oneTimeSetUp() {
// one-time initialization code
System.out.println(&@BeforeClass - oneTimeSetUp&);
在Junit 4中，注解的命名是比较令人困惑的，例如 Before, After and Expected，我们不是很确切的能理解在方法前面有Before和After这样的注解是做什么的，同样Expected也如此。TestNG在这方面做的就好很多，注解使用了BeforeMethod，AfterMethod和ExpectedException，这样的名字就非常好理解了。
异常测试的意思是在单元测试中应该抛出什么异常是合理的，这个特性在两个框架都已经实现。
@Test(expected = ArithmeticException.class)
public void divisionWithException() {
int i = 1/0;
@Test(expectedExceptions = ArithmeticException.class)
public void divisionWithException() {
int i = 1/0;
忽略测试意思是在单元测试哪些是可以被忽略的，这个特性在两个框架都已经实现。
@Ignore(&Not Ready to Run&)
public void divisionWithException() {
System.out.println(&Method is not ready yet&);
@Test(enabled=false)
public void divisionWithException() {
System.out.println(&Method is not ready yet&);
时间测试意思是如果一个单元测试运行的时间超过了一个指定的毫秒数，那么测试将终止并且标记为失败的测试，这个特性在两个框架都已经实现。
@Test(timeout = 1000)
public void infinity() {
while (true);
@Test(timeOut = 1000)
public void infinity() {
while (true);
套件测试就是把几个单元测试组合成一个模块，然后运行，这个特性两个框架均已实现。然而却是用了两个不同的方式来实现的。
@RunWith 和 @Suite注解被用于执行套件测试。下面的代码是所展示的是在JunitTest5被执行之后需要JunitTest1 和 JunitTest2也一起执行。所有的声明需要在类内部完成。
@RunWith(Suite.class)
@Suite.SuiteClasses({
JunitTest1.class,
JunitTest2.class
public class JunitTest5 {
执行套件测试是使用XML文件配置的方式来做。下面的 XML 的文件可以使得TestNGTest1和TestNGTest2一起执行。
&!DOCTYPE suite SYSTEM &/testng/testng-1.0.dtd& &
&suite name=&My test suite&&
&test name=&testing&&
&class name=&com.fsecure.demo.testng.TestNGTest1& /&
&class name=&com.fsecure.demo.testng.TestNGTest2& /&
&/classes&
TestNG可以在这块做的更好，使用了组的概念，每个方法都可以被分配到一个组里面，可以根据功能特性来分组。例如：
这是一个有4个方法，3个组(method1, method2 和 method4)的类
@Test(groups=&method1&)
public void testingMethod1() {
System.out.println(&Method - testingMethod1()&);
@Test(groups=&method2&)
public void testingMethod2() {
System.out.println(&Method - testingMethod2()&);
@Test(groups=&method1&)
public void testingMethod1_1() {
System.out.println(&Method - testingMethod1_1()&);
@Test(groups=&method4&)
public void testingMethod4() {
System.out.println(&Method - testingMethod4()&);
下面XML文件定义了一个只是执行methed1的组的单元测试
&!DOCTYPE suite SYSTEM &/testng/testng-1.0.dtd& &
&suite name=&My test suite&&
&test name=&testing&&
&include name=&method1&/&
&class name=&com.fsecure.demo.testng.TestNGTest5_2_0& /&
&/classes&
使用分组的概念，集成测试就会更加强大。例如，我们可以只是执行所有测试中的组名为DatabaseFuntion的测试。
参数化测试
参数化测试意思是给单元测试传多个参数值。这个特性在JUnit 4 和TestNG。然后两个框架实现的方式却完全不同。
@RunWith 和 @Parameter 注解用于为单元测试提供参数值，@Parameters必须返回 List，参数将会被作为参数传给类的构造函数。
@RunWith(value = Parameterized.class)
public class JunitTest6 {
public JunitTest6(int number) {
this.number =
@Parameters
public static Collection&Object[]& data() {
Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
return Arrays.asList(data);
public void pushTest() {
System.out.println(&Parameterized Number is : & + number);
它在使用上有许多的限制；我们必须遵循 JUnit 的方式去声明参数，参数必须通过构造函数的参数去初始化类的成员来用于测试。返回的参数类型必须是List []，数据已经被限定为String或者是一个原始值。
使用XML文件或者@DataProvider注解来给测试提供参数。
XML文件配置参数化测试
只是在方法上声明@Parameters注解，参数的数据将由 TestNG 的 XML 配置文件提供。这样做之后，我们可以使用不同的数据集甚至是不同的结果集来重用一个测试用例。另外，甚至是最终用户，QA 或者 QE 可以提供使用 XML 文件来提供他们自己的数据来做测试。
public class TestNGTest6_1_0 {
@Parameters(value=&number&)
public void parameterIntTest(int number) {
System.out.println(&Parameterized Number is : & + number);
&!DOCTYPE suite SYSTEM &/testng/testng-1.0.dtd& &
&suite name=&My test suite&&
&test name=&testing&&
&parameter name=&number& value=&2&/&
&class name=&com.fsecure.demo.testng.TestNGTest6_0& /&
&/classes&
@DataProvider 注解做参数化测试
使用XML文件初始化数据可以很方便，但是测试偶尔需要复杂的类型，一个String或原始值并不能完全满足。 TestNG 的@ DataProvider的注解，可以更好的把复杂的参数类型映射到一个测试方法来处理这种情况。
@DataProvider 可以使用 Vector, String 或者 Integer 类型的值作为参数
@Test(dataProvider = &Data-Provider-Function&)
public void parameterIntTest(Class clzz, String[] number) {
System.out.println(&Parameterized Number is : & + number[0]);
System.out.println(&Parameterized Number is : & + number[1]);
//This function will provide the patameter data
@DataProvider(name = &Data-Provider-Function&)
public Object[][] parameterIntTestProvider() {
return new Object[][]{
{Vector.class, new String[] {&java.util.AbstractList&, &java.util.AbstractCollection&}},
{String.class, new String[] {&1&, &2&}},
{Integer.class, new String[] {&1&, &2&}}
@DataProvider 作为对象的参数
P.S “TestNGTest6_3_0” 是一个简单的对象，使用了get和set方法。
@Test(dataProvider = &Data-Provider-Function&)
public void parameterIntTest(TestNGTest6_3_0 clzz) {
System.out.println(&Parameterized Number is : & + clzz.getMsg());
System.out.println(&Parameterized Number is : & + clzz.getNumber());
//This function will provide the patameter data
@DataProvider(name = &Data-Provider-Function&)
public Object[][] parameterIntTestProvider() {
TestNGTest6_3_0 obj = new TestNGTest6_3_0();
obj.setMsg(&Hello&);
obj.setNumber(123);
return new Object[][]{
TestNG的参数化测试使用起来非常的友好和灵活 (不管是XML配置还是在类里面注解的方式). 它可以使用许多复杂的数据类型作为参数的值，并且没有什么限制。如上面的例子所示， we even can pass in our own object (TestNGTest6_3_0) for parameterized test
参数化测试意味着测试的方法是有依赖的，也就是要执行的的方法在执行之前需要执行的部分。如果依赖的方法出现错误，所有的子测试都会被忽略，不会被标记为失败。
JUnit 框架主要聚焦于测试的隔离，暂时还不支持这个特性。
它使用dependOnMethods来实现了依赖测试的功能，如下：
public void method1() {
System.out.println(&This is method 1&);
@Test(dependsOnMethods={&method1&})
public void method2() {
System.out.println(&This is method 2&);
如果method1()成功执行，那么method2()也将被执行，否则method2()将会被忽略。
当我们做完所有特性的对比以后，我建议使用 TestNG 作为 Java 项目的主要单元测试框架，因为 TestNG 在参数化测试、依赖测试以及套件测试（组）方面功能更加强大。TestNG 意味着高级的测试和复杂的集成测试。它更加的灵活，特别是对大的套件测试。另外，TestNG 也涵盖了 JUnit4 的全部功能。那就没有任何理由使用 Junit了。
TestNG VS JUnit
——————
老师，您好，我想请教一下“JDBC链接配置”改变参数是在哪里改变呀。
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
– 好的话题、有启发的回复、值得信赖的圈子
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– UI,网页，交互和用户体验
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
& 2017 ImportNew2827人阅读
java_webdriver学习（17）
自动化的框架选择webdriver+TestNG+Ant，是因为便于Daily
Build&和Ant的集成，而单元测试框架选择TestNG是由于具有以下优势，最主要体现&直接用Excel做为数据源&和&在xml中定义测试任务&
1.对于注解类的支持
标注为类/方法为测试类和方法
标注为在suite中所有测试之前运行
@BeforeSuite
标注为在suite中所有测试之后运行
@AfterSuite
标注为在测试之前运行
@BeforeTest
标注为在测试之后运行
@AfterTest
标注为在测试Group中第一个测试方法之前运行
@BeforeGroups
标注为在测试Group中最后一个测试方法之后运行
@AfterGroups
标注为当前测试类中第一个测试方法之前运行
@BeforeClass
@BeforeClass
标注为当前测试类中最后一个测试方法之后运行
@AfterClass
@AfterClass
标注为在每次测试方法之前运行
@BeforeMethod
标注为在每次测试方法之后运行
@AfterMethod
忽略某测试，让其不执行
@Test(enable=false)
期待测试抛出什么异常
@Test(expected=XXXException.class)
@Test(exceptedExceptions=XXXException.class)
测试超时，如果测试的执行时间超过了毫秒为单位设置的时间，那么就停止测试并且标记为失败
@Test(timeout=1000)
@Test(timeout=1000)
Junit的执行顺序：
)&& test1( )&&& tearDown( )&&&&& Setup( )&&&& test2( )&&&&& tearDown( )
TestNG的执行顺序：
)&& test1( ) & &test2( )&&&&& tearDown( )
2.定义测试任务
Junit中要定义测试任务是要写TestSuit的，居然要写硬编码，而TestNG全部写在testng.xml（名字可以自定义的）中的，然后可以通过ant来调用。
3.测试参数化
Junit是不带任何参数的，不论是测试方法还是配置方法，而TestNG都是可以添加参数的，有2种方法
（1）使用Parameter参数（试用的场景比较少）：
public class TestNGTest6_1_0 {
@Parameters(value=&number&)
public void parameterIntTest(int number) {
System.out.println(&Parameterized Number is : & + number);
然后，在我们的Testng.xml文件中，我们把参数的具体值设置进来，如下：
&!DOCTYPE suite SYSTEM &/testng/testng-1.0.dtd& &
&suite name=&My test suite&&
&test name=&testing&&
&parameter name=&number& value=&2&/&
&class name=&com.fsecure.demo.testng.TestNGTest6_0& /&
&/classes&
（2）DataProvider（实际应用场景可参考博客：解析Excel，通过Excel驱动测试数据参数化）
我们用一个DataProvider属性来给被测试的方法上声明它需要的数据，然后平行的，用@DataProvider注解来标注一个方法，让这个方法的返回值返回具体的数据
@Test(dataProvider = &Data-Provider-Function&)
public void parameterIntTest(TestNGTest6_3_0 clzz) {
System.out.println(&Parameterized Number is : & + clzz.getMsg());
System.out.println(&Parameterized Number is : & + clzz.getNumber());
然后相应的我们用@DataProvider来标注一个方法，这个方法提供了数据：
@DataProvider(name = &Data-Provider-Function&)
public Object[][] parameterIntTestProvider() {
TestNGTest6_3_0 obj = new TestNGTest6_3_0();
obj.setMsg(&Hello&);
obj.setNumber(123);
return new Object[][]{
4.测试依赖性
对于JUnit 来说，所有的测试彼此之间都是独立的，毫无依赖性。
但是对于 TestNG来说，我们完全可以让测试彼此之间有依赖性，做法就是dependsOnMethods属性来标识一个被依赖的测试方法:
public void method1() {
System.out.println(&This is method 1&);
@Test(dependsOnMethods={&method1&})
public void method2() {
System.out.println(&This is method 2&);
自动化测试过程中的实用性不是很强，用例之间尽量保持独立性
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：71348次
积分：1076
积分：1076
排名：千里之外
原创：34篇
转载：22篇
(1)(2)(1)(1)(1)(1)(1)(1)(4)(3)(3)(3)(1)(2)(1)(3)(2)(2)(2)(1)(6)(3)(2)(10)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'&&&&&&&&&&&&&&&&&&
posts - 32,comments - 75,trackbacks - 0
我的msn的blog
积分与排名
阅读排行榜
评论排行榜
JDK 5 Annotations (JDK 1.4 JavaDoc).
import junit.framework.TestC
public class Jtest extends TestCase {
&&&&&& protected void setUp() throws Exception {
&&&&&&&&&&&&& super.setUp();
&&&&&&&&&&&&&&&&&&&& //some initial code
&&& protected void tearDown() throws Exception {
&&&&&&& super.tearDown ();
&&&&&&& //release resource and rollback
public void testFunction {
&&&&&& //test code
public class NGtest{
&&& @Configuration(beforeTestClass=true)
&&& public void setUp() {
&&&&&&& //some initial code
@Configuration(afterTestClass = true)
&&& public void tearDown (){
&&&& &&//release resource and rollback
&&& @Test( )
&&& public void testFunction (){
&&&&&& //test code
TestNGJunitJunitTestNGJunit
lJDK 5 Annotations
test configuration
Setup( )&& test1( )&&& tearDown( )&&&&& Setup( )&&&& test2( )&&&&& tearDown( )
beforeSuiteafterSuiteEJBTestNG
阅读(3616)博客分类：
在TestNG中，直接使用@DataProvider进行参数化测试：
import org.testng.annotations.DataP
import org.testng.annotations.T
import static org.testng.Assert.*;
public class Addition {
public int add(int a, int b) {
@DataProvider(name = "addition")
public Object[][] createData(){
return new Object[][] {{1,2,3},{0,0,1},{-1,1,0},{-1,-2,-3}};
@Test(dataProvider = "addition")
public void addtionTest(int a1, int a2, int result){
Addition ad = new Addition();
assertEquals(ad.add(a1, a2), result);
而在Junit中一定要新建一个类，在构造函数中初始化数据：
import static org.junit.Assert.*;
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 AdditionTest {
private int d1, d2;
public AdditionTest(int d1, int d2, int result) {
this.d1 = d1;
this.d2 = d2;
this.result =
@Parameters
@SuppressWarnings("unchecked")
public static Collection getParamters(){
Object [][] object = {{1,2,3},{0,0,0},{-1,1,0},{-1,-2,-3}};
return Arrays.asList(object);
public void testAddition(){
Addition ad = new Addition();
assertEquals(this.result, ad.add(this.d1, this.d2));
结论：相较之下，用TestNG去实现可以让代码更加简单一些
lijingshou
浏览: 599151 次
来自: 杭州
good point!
Selenium自动化测试从入门到精通(Java版)百度网盘地 ...
请问$Proxy0的.class文件 您是怎么提出来的？
好用,写的详细,给个赞,就是不知道&设置jad的可执 ...
Eclipse Java SE版本,这个插件在我的电脑上始终装 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'