追求代码质量（6）: JUnit 4 与 TestNG 的对比 - ImportNew
| 标签： ,
经过长时间积极的开发之后，JUnit 4.0 于今年年初发布了。JUnit 框架的某些最有趣的更改 —— 特别是对于本专栏的读者来说 —— 正是通过巧妙地使用注释实现的。除外观和风格方面的显著改进外，新框架的特性使测试用例的编制从结构规则中解放出来。使原来僵化的 fixture 模型更为灵活，有利于采取可配置程度更高的方法。因此，JUnit 框架不再强求把每一项测试工作定义为一个名称以 test 开始的方法，并且现在可以只运行一次 fixture，而不是每次测试都需要运行一次。
虽然这些改变令人欣慰，但 JUnit 4 并不是第一个提供基于注释的灵活模型的 Java(TM) 测试框架。在修改 JUnit 之前很久，TestNG 就已建立为一个基于注释的框架。
事实上，是 TestNG 在 Java 编程中率先 实现了利用注释进行测试，这使它成为 JUnit 的有力竞争对手。然而，自从 JUnit 4 发布后，很多开发者质疑：二者之间还有什么差别吗？在本月的专栏中，我将讨论 TestNG 不同于 JUnit 4 的一些特性，并提议采用一些方法，使得这两个框架能继续互相补充，而不是互相竞争。
表面上的相似
JUnit 4 和 TestNG 有一些共同的重要特性。这两个框架都让测试工作简单得令人吃惊（和愉快），给测试工作带来了便利。二者也都拥有活跃的社区，为主动开发提供支持，同时生成丰富的文档。
两个框架的不同在于核心设计。JUnit 一直 是一个单元测试框架，也就是说，其构建目的是促进单个对象的测试，它确实能够极其有效地完成此类任务。而 TestNG 则是用来解决更高级别的测试问题，因此，它具有 JUnit 中所没有的一些特性。
一个简单的测试用例
初看起来，JUnit 4 和 TestNG 中实现的测试非常相似。为了更好地理解我的意思，请看一下清单 1 中的代码。这是一个 JUnit 4 测试，它有一个 macro-fixture（即仅在所有测试运行前调用一次的 fixture），这个 macro-fixture 由 @BeforeClass 属性表示：
清单 1. 一个简单的 JUnit 4 测试用例
.acme.dona.
import static org.junit.Assert.assertE
import static org.junit.Assert.assertNotN
import org.junit.BeforeC
import org.junit.T
public class DependencyFinderTest {
private static DependencyF
@BeforeClass
public static void init() throws Exception {
finder = new DependencyFinder();
public void verifyDependencies()
throws Exception {
String targetClss =
&.acme.dona.dep.DependencyFind&;
Filter[] filtr = new Filter[] {
new RegexPackageFilter(&java|junit|org&)};
Dependency[] deps =
finder.findDependencies(targetClss, filtr);
assertNotNull(&deps was null&, deps);
assertEquals(&should be 5 large&, 5, deps.length);
JUnit 用户会立即注意到：这个类中没有了以前版本的 JUnit 中所要求的一些语法成分。这个类没有 setUp() 方法，也不对 TestCase 类进行扩展，甚至也没有哪个方法的名称以 test 开始。这个类还利用了 Java 5 的一些特性，例如静态导入，很明显地，它还使用了注释。
更多的灵活性
在清单 2 中，您可以看到同一个 测试项目。不过这次是用 TestNG 实现的。这里的代码跟清单 1 中的测试代码有个微妙的差别。发现了吗？
清单 2. 一个 TestNG 测试用例
.acme.dona.
import static org.testng.Assert.assertE
import static org.testng.Assert.assertNotN
import org.testng.annotations.BeforeC
import org.testng.annotations.C
import org.testng.annotations.T
public class DependencyFinderTest {
private DependencyF
@BeforeClass
private void init(){
this.finder = new DependencyFinder();
public void verifyDependencies()
throws Exception {
String targetClss =
&.acme.dona.dep.DependencyFind&;
Filter[] filtr = new Filter[] {
new RegexPackageFilter(&java|junit|org&)};
Dependency[] deps =
finder.findDependencies(targetClss, filtr);
assertNotNull(deps, &deps was null& );
assertEquals(5, deps.length, &should be 5 large&);
显然，这两个清单很相似。不过，如果仔细看，您会发现 TestNG 的编码规则比 JUnit 4 更灵活。 里，在 JUnit 中我必须把@BeforeClass 修饰的方法声明为 static，这又要求我把 fixture，即 finder 声明为 static。我还必须把 init() 声明为 public。看看清单 2，您就会发现不同。这里不再需要那些规则了。我的 init() 方法既不是 static，也不是 public。
从最初起，TestNG 的灵活性就是其主要优势之一，但这并非它惟一的卖点。TestNG 还提供了 JUnit 4 所不具备的其他一些特性。
依赖性测试
JUnit 框架想达到的一个目标就是测试隔离。它的缺点是：人们很难确定测试用例执行的顺序，而这对于任何类型的依赖性测试都非常重要。开发者们使用了多种技术来解决这个问题，例如，按字母顺序指定测试用例，或是更多地依靠 fixture 来适当地解决问题。
如果测试成功，这些解决方法都没什么问题。但是，如果测试不成功，就会产生一个很麻烦的后果：所有 后续的依赖测试也会失败。在某些情况下，这会使大型测试套件报告出许多不必要的错误。例如，假设有一个测试套件测试一个需要登录的 Web 应用程序。您可以创建一个有依赖关系的方法，通过登录到这个应用程序来创建整个测试套件，从而避免 JUnit 的隔离机制。这种解决方法不错，但是如果登录失败，即使登录该应用程序后的其他功能都正常工作，整个测试套件依然会全部失败！
跳过，而不是标为失败
与 JUnit 不同，TestNG 利用 Test 注释的 dependsOnMethods 属性来应对测试的依赖性问题。有了这个便利的特性，就可以轻松指定依赖方法。例如，前面所说的登录将在某个方法之前 运行。此外，如果依赖方法失败，它将被跳过，而不是标记为失败。
清单 3. 使用 TestNG 进行依赖性测试
import net.sourceforge.jwebunit.WebT
public class AccountHistoryTest
private WebT
@BeforeClass
protected void init() throws Exception {
this.tester = new WebTester();
this.tester.getTestContext().
setBaseUrl(&:8185/ceg/&);
public void verifyLogIn() {
this.tester.beginAt(&/&);
this.tester.setFormElement(&username&, &admin&);
this.tester.setFormElement(&password&, &admin&);
this.tester.submit();
this.tester.assertTextPresent(&Logged in as admin&);
@Test (dependsOnMethods = {&verifyLogIn&})
public void verifyAccountInfo() {
this.tester.clickLinkWithText(&History&, 0);
this.tester.assertTextPresent(&GTG Data Feed&);
在清单 3 中定义了两个测试：一个验证登录，另一个验证账户信息。请注意，通过使用 Test 注释的 dependsOnMethods = {"verifyLogIn"}子句，verifyAccountInfo 测试指定了它依赖 verifyLogIn() 方法。
通过 TestNG 的 Eclipse 插件（例如）运行该测试时，如果 verifyLogIn 测试失败，TestNG 将直接跳过 verifyAccountInfo 测试，请参见图 1：
图 1. 在 TestNG 中跳过的测试
对于大型测试套件，TestNG 这种不标记为失败，而只是跳过的处理方法可以减轻很多压力。您的团队可以集中精力查找为什么百分之五十的测试套件被跳过，而不是去找百分之五十的测试套件失败的原因！更有利的是，TestNG 采取了只重新运行失败测试的机制，这使它的依赖性测试设置更为完善。
失败和重运行
在大型测试套件中，这种重新运行失败测试的能力显得尤为方便。这是 TestNG 独有的一个特性。在 JUnit 4 中，如果测试套件包括 1000 项测试，其中 3 项失败，很可能就会迫使您重新运行整个测试套件（修改错误以后）。不用说，这样的工作可能会耗费几个小时。
一旦 TestNG 中出现失败，它就会创建一个 XML 配置文件，对失败的测试加以说明。如果利用这个文件执行 TestNG 运行程序，TestNG 就只运行失败的测试。所以，在前面的例子里，您只需重新运行那三个失败的测试，而不是整个测试套件。
实际上，您可以通过清单 2 中的 Web 测试的例子自己看到这点。verifyLogIn() 方法失败时，TestNG 自动创建一个 testng-failed.xml 文件。该文件将成为如清单 4 所示的替代性测试套件：
清单 4. 失败测试的 XML 文件
&!DOCTYPE suite SYSTEM &http://testng.org/testng-1.0.dtd&&
&suite thread-count=&5& verbose=&1& name=&Failed suite [HistoryTesting]&
parallel=&false& annotations=&JDK5&&
&test name=&.acme.ceg.AccountHistoryTest(failed)& junit=&false&&
&class name=&.acme.ceg.AccountHistoryTest&&
&include name=&verifyLogIn&/&
&/methods&
&/classes&
运行小的测试套件时，这个特性似乎没什么大不了。但是如果您的测试套件规模较大，您很快就会体会到它的好处。
参数化测试
TestNG 中另一个有趣的特性是参数化测试。在 JUnit 中，如果您想改变某个受测方法的参数组，就只能给每个 不同的参数组编写一个测试用例。多数情况下，这不会带来太多麻烦。然而，我们有时会碰到一些情况，对其中的业务逻辑，需要运行的测试数目变化范围很大。
在这样的情况下，使用 JUnit 的测试人员往往会转而使用 FIT 这样的框架，因为这样就可以用表格数据驱动测试。但是 TestNG 提供了开箱即用的类似特性。通过在 TestNG 的 XML 配置文件中放入参数化数据，就可以对不同的数据集重用同一个测试用例，甚至有可能会得到不同的结果。这种技术完美地避免了只能 假定一切正常的测试，或是没有对边界进行有效验证的情况。
在清单 5 中，我用 Java 1.4 定义了一个 TestNG 测试，该测试可接收两个参数：classname 和 size。这两个参数可以验证某个类的层次结构（也就是说，如果传入 java.util.Vector，则 HierarchyBuilder 所构建的 Hierarchy 的值将为 2 ）。
清单 5. 一个 TestNG 参数化测试
import com.acme.da.hierarchy.H
import com.acme.da.hierarchy.HierarchyB
public class HierarchyTest {
* @testng.test
* @testng.parameters value=&class_name, size&
public void assertValues(String classname, int size) throws Exception{
Hierarchy hier = HierarchyBuilder.buildHierarchy(classname);
assert hier.getHierarchyClassNames().length == size: &didn't equal!&;
清单 5 列出了一个泛型测试，它可以采用不同的数据反复重用。请花点时间思考一下这个问题。如果有 10 个不同的参数组合需要在 JUnit 中测试，您只能写 10 个测试用例。每个测试用例完成的任务基本是相同的，只是受测方法的参数有所改变。但是，如果使用参数化测试，就可以只定义一个 测试用例，然后，（举例来说）把所需的参数模式加到 TestNG 的测试套件文件中。清单 6 中展示了这中方法：
清单 6. 一个 TestNG 参数化测试套件文件
&!DOCTYPE suite SYSTEM &/testng/testng-1.0.dtd&&
&suite name=&Deckt-10&&
&test name=&Deckt-10-test&&
&parameter name=&class_name& value=&java.util.Vector&/&
&parameter name=&size& value=&2&/&
&class name=&.acme.da.HierarchyTest&/&
&/classes&
清单 6 中的 TestNG 测试套件文件只对该测试定义了一个参数组（class_name 为 java.util.Vector，且 size 等于 2），但却具有无限的可能。这样做的一个额外的好处是：将测试数据移动到 XML 文件的无代码工件就意味着非程序员也可以指定数据。
高级参数化测试
尽管从一个 XML 文件中抽取数据会很方便，但偶尔会有些测试需要有复杂类型，这些类型无法用 String 或原语值来表示。TestNG 可以通过它的 @DataProvider 注释处理这样的情况。@DataProvider 注释可以方便地把复杂参数类型映射到某个测试方法。例如，清单 7 中的verifyHierarchy 测试中，我采用了重载的 buildHierarchy 方法，它可接收一个 Class 类型的数据, 它断言（asserting）Hierarchy 的getHierarchyClassNames() 方法应该返回一个适当的字符串数组：
清单 7. TestNG 中的 DataProvider 用法
import java.util.V
import static org.testng.Assert.assertE
import org.testng.annotations.DataP
import org.testng.annotations.T
import com.acme.da.hierarchy.H
import com.acme.da.hierarchy.HierarchyB
public class HierarchyTest {
@DataProvider(name = &class-hierarchies&)
public Object[][] dataValues(){
return new Object[][]{
{Vector.class, new String[] {&java.util.AbstractList&,
&java.util.AbstractCollection&}},
{String.class, new String[] {}}
@Test(dataProvider = &class-hierarchies&)
public void verifyHierarchy(Class clzz, String[] names)
throws Exception{
Hierarchy hier = HierarchyBuilder.buildHierarchy(clzz);
assertEquals(hier.getHierarchyClassNames(), names,
&values were not equal&);
dataValues() 方法通过一个多维数组提供与 verifyHierarchy 测试方法的参数值匹配的数据值。TestNG 遍历这些数据值，并根据数据值调用了两次 verifyHierarchy。在第一次调用时，Class 参数被设置为 Vector.class ，而 String 数组参数容纳 “java.util.AbstractList ” 和 “ java.util.AbstractCollection ” 这两个 String 类型的数据。这样挺方便吧？
为什么只选择其一？
我已经探讨了对我而言，TestNG 的一些独有优势，但是它还有其他几个特性是 JUnit 所不具备的。例如 TestNG 中使用了测试分组，它可以根据诸如运行时间这样的特征来对测试分类。也可在 Java 1.4 中通过 javadoc 风格的注释来使用它，如
正如我在本文开头所说，JUnit 4 和 TestNG 在表面上是相似的。然而，设计 JUnit 的目的是为了分析代码单元，而 TestNG 的预期用途则针对高级测试。对于大型测试套件，我们不希望在某一项测试失败时就得重新运行数千项测试，TestNG 的灵活性在这里尤为有用。这两个框架都有自己的优势，您可以随意同时使用它们。
您可以参阅本文在 developerWorks 全球站点上的
“”（Filippo Diotalevi，developerWorks，2005 年 1 月）：TestNG 不仅仅是性能强大、富于创新、易于扩充、使用灵活，它也展示了 Java 注释的一种有趣应用方式。
“”（Elliotte Rusty Harold，developerWorks，2005 年 9 月）：软件测试人员 Elliotte Harold 兴趣盎然地试用了 JUnit 4 并详细介绍了如何在您的工作中使用这个新的框架。
（Andrew Glover，，2006 年 3 月）：某个框架声称它是 JUnit 扩展并不表示它可以在 TestNG 中使用。
（Cedric Beust，，2006 年 2 月）：使用 TestNG 进行高级测试，本文由该项目的创始人编写。
“”（Andrew Glover，，2006 年 4 月）：关于如何在 TestNG 中重新运行失败测试的深入分析。
（Andrew Glover，developerWorks，2006 年 2 月）：有利于加强商业客户和开发者沟通的集成测试框架。
（Fabiano Cruz，Fabiano Cruz’s Blog，2006 年 6 月)：关于 JUnit 4 的生态系统支持的有趣内容。
（改善代码质量论坛， 2006 年 3 月)：请参与关于在 TestNG 中集成代码覆盖工具的讨论。
（Andrew Glover，developerWorks）：查看本系列从代码度量到测试框架和的所有文章。
：查阅数百篇关于 Java 编程各个方面的文章。
获得产品和技术
：试用 TestNG。
：体验 JUnit 4 的新特性。
写的真好，点赞
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
– 好的话题、有启发的回复、值得信赖的圈子
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– UI,网页，交互和用户体验
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
& 2017 ImportNewRobotFramework这么好用，为什么招聘的都是用testng、junit的？ - 知乎6被浏览3123分享邀请回答0添加评论分享收藏感谢收起0添加评论分享收藏感谢收起查看更多回答关注51Testing
怎样选择Java测试框架 JUnit还是TestNG？
发表于： 16:03 &作者：Tom Wheeler,Meera Su & 来源：JavaEye
推荐标签：
　　Martin Fowler曾说过，领域中此前从没有过这样的事情：很少几行代码对大量的代码起了如此重要的作用。过去直到如今依然是的一个标准，是最流行的开源工具。当然现在我们有许多有别于JUnit的其他的开源工具。我自己，除了使用JUnit外，还用　　自动测试成为你Java项目中的一部分了吗？你最爱的是什么哪？使用的又是哪一种标准？　　本文的4名开发者将和你一起分享他们在自动测试领域中的观点和经验。当你的项目面临测试阶段的时候，希望这些观点能对你有所帮助。如果你也想要分享自己的观点，请回帖参与讨论。我们真挚的希望我们能够为这个领域中新手提供一些有用建议和标准。　　最后列出了文章的作者和提到的测试框架。　　论自动测试——Tom Wheeler　　当我给那些有经验的开发者上课时，我发现只有40%左右的人写测试。大约还有40%的人甚至从来没听说过JUnit，这其中更有一般人完全没有单元测试的概念。开发者通常处于在项目经理制定的紧促计划的压力中——而那些项目经理同样处于客户的压力之下，客户希望他们的软件能够被快速的开发出。不幸的是，测试是项目中的一个重要部分而很多人却轻易的将它砍掉。真是目光短浅，那种做法只会让你的应用成为bug的乐园而且会大大超出你的计划时间。　　为什么会这样？因为写自动测试实际上省下了大量的运行时间。每个开发者都会出错而通过测试可以帮助找到这些错误。可能手工测试在某些方面要比自动测试更快一些，但是手工测试需要用户界面。手工测试的结果并不一致，因为测试者和开发者一样都会犯错。而一个自动测试总会保持结果的一致性。　　也许更重要的是，当一个旧bug被修复或者新特性被添加时会引入更多的bug。你需要在改变系统后重新运行所有的测试。这也是自动测试的价值体现，因为对比手工测试的开销，自动测试的开销是微不足道的。如果开发者经常测试，他们可以更容易地发现并修改问题，这可以保证代码质量并保证团队开发的进度。　　比较JUnit和TestNG——Meera Subbraro　　Martin Fowler曾说过，软件开发领域中此前从没有过这样的事情：很少几行代码对大量的代码起了如此重要的作用。JUnit过去直到如今依然是单元测试的一个标准。它是最流行的开源工具。当然现在我们有许多有别于JUnit的其他的开源工具。我自己，除了使用JUnit外，我还是用TestNG。下面我们来谈谈下这两个框架。　　JUnit和TestNG都使用Annotation，都使得测试简单有趣。如果你写两个测试类，一个使用JUnit一个使用TestNG，除非你看到它们import语句，否则你几乎看不到他们之间的差别。　　如果你是一个TDD的信徒，通过运行测试来完成你的持续集成过程。TestNG可能更加适合。重新运行失败的测试这样的机制对于每天都进行编译来说非常有帮助。而这个特性只有TestNG才有。　　TestNG的另一个亮点是支持参数化。在JUnit中如果你要测试不同的参数，你需要写不同的来覆盖不同参数。而在TestNG，通过使用xml配置文件做到。开发者可能会抱怨XML文件”这下好了，除了要维护那些测试用例，我还要维护那么一堆xml文件”。（译者按：JUnit4也已经支持参数化测试了）　　JUnit生成的HTML格式的报告非常好。我使用TestNG和Java 6，生成的报告远没有JUnit那么漂亮。　　最后，两个框架都有自己的长处和弱处，必要时我们可以同时使用。让我们使用这两个伟大的框架，享受编写测试的快乐吧。　　我为什么从JUnit换到了TestNG上——Andres Almiray　　当我开始编写测试程序时候，我选择了JUnit3.x。因为那个时候它是唯一的开源选择，而且有着相当详尽的文档和成堆的书供我参考。在此基础上还有许多扩展如dbUnit,xmlUnit帮助测试一些大型组件。但是如果我们需要面对更多复杂的测试，通常是集成/功能测试，很明显JUnit会力不从心。那就是为什么我换到TestNG上。Cedric和Alexandru TestNG的作者从一开始就很明确,TestNG是为更广的测试场合而设计，而不仅是单元测试。TestNG可以运行没有修改过的JUnit测试，这使得两者的转换非常平滑。　　稍后发布的JUnit4.x在细节上非常类似TestNG，这也弥补了这两个框架的裂痕。TestNG仍然是我最喜欢的，而且它仍然保持更新。现在在开源的Java测试框架中仍然有新进者，easyb，一个基于Groovy行为驱动开发的测试工具，为Java和Groovy测试。通过编写合理的测试或是假定一个任务，它可以视为一种规范尽管它是可执行代码。如果你在世界中使用Rspec一样。　　为什么JUnit仍然是首选——Aslam Khan　　像许多人开始测试驱动开发和单元测试一样，我也是从JUnit3.x起步的。我发现JUnit是最广泛的工具，出现在各种不同的地方（ANT,Maven,Eclipse,IntelliJ IDEA, 等）。它也很容易介绍给那些新团队。我也使用TestNG对它的多样性同样印象深刻。然而，JUnit的大量插件（dbUnit,xmlUnit等）使得Junit仍然是首选的。如果你花大量的时间在Spring上，那么基于Junit的Srping ApplicationContext aware测试用例会带来优势。为了测试前台，我几乎只使用。我曾经涉足过Canoo和其他的框架，但是发现这些途径都是反TDD模式的。使用Selenium，我可以处理Selenium测试脚本和记录，给任何需要的人并日后处理。　　如果我们谈论的是纯粹的TDD，即书写良好的代码（不仅仅是良好的测试）需要增加一个mock测试。对于mocking，我使用Jmock，它和Junit配合良好，通过基于mock的方式和程序内部边界，我得到了设计良好的，互相通信的对象。这在可读性和可维护性上迈出了重要的一步。EasyMock也不错，但是Jmock是我个人的首选。　　从Java世界上溯到Ruby世界中，RSpec很优秀而且也有DSL来描述场景。既然Rbehave已经融合进了Rspec,这样的整合将成为Ruby世界的首选。有趣的是，Rbehave是从Jbehave衍生来来，它是一个行为驱动开发测试框架。如果你喜欢BDD模式来收集和确定需求，你会喜欢Jbehave和RSpec.
搜索风云榜
51Testing官方微信
51Testing官方微博
测试知识全知道1、安装jdk
2、环境变量配置：JAVA_HOME=C:\Program Files\Java\jdk1.8.0_45;PATH=%JAVA_HOME%\bin
3、下载安装python2.7
4、环境变量设置：path=C:\Python27;C:\Python27\Scripts
5、安装robotframework：pip install robotframework
robotframework Ride
1、安装WxPython
2、安装RIDE：pip install robotframework-ride
3、启动：C:\Python27\Scripts&python ride.py
robotframework-requests，用于写API接口测试脚本
1、安装python的request模块：pip install requests
2、安装第三方类库：pip install -U robotframework-requests
robotframework-selenium，用于写UI测试脚本
1、安装：pip install robotframework-selenium2library
2、chromedriver.exe放至system32目录下
数据库连接
1、安装DatabaseLibrary：pip install robotframework-databaselibrary
使用pymysql连接数据库
1、安装python连接mysql驱动：pip install PyMySQL
import DatabaseLibrary
Connect To Database Using Custom Params
host=&#.0.1′,port=3306,user=’root’,passwd=’xxx’,db=’xxx’
select * from xxx where code=’pxq’
使用pyodbc连接数据库
1、安装VCForPython27.msi
2、安装pyodbc：pip install pyodbc
3、安装mysql-connector-odbc-5.3.4-winx64.msi
4、配置mysql odbc：控制面板=&管理工具=&数据源（ODBC）=&MySQL ODBC 5.3 Unicode Driver
Connect To Database Using Custom Params
“Driver={MySQL ODBC 5.3 ANSI Driver};Server=192.168.0.1;Port=3306;Database=User=Password=xxx”
select * from xxx where code=’pxq’
python IDE
1、pycharm：/pycharm/
2、pycharm执行robot
a、Go to File & Settings & External Tools
b、Click ‘+’ button under ‘External Tools’ panel
c、In the ‘Create Tool’ dialog, enter the below values:
Name: Robot
Program: [Path of Pybot.bat e.g.C:\Python27\Scripts\Pybot.bat]
Parameters: $FileName$
Working Directory: $FileDir$
d、Click OK
3、代码高亮
a、安装插件：robot-plugin-0.12
b、脚本文件后缀命名为.robot追求代码质量: JUnit 4 与 TestNG 的对比 - 为程序员服务
追求代码质量: JUnit 4 与 TestNG 的对比
经由长时辰积极的垦荒之后，JUnit 4.0 于今年事首?年月宣布了。JUnit 框架的某些最幽默的更改 —— 特殊是对本专栏的读者来说 —— 恰是经由进程奇妙地行使正文完成的。除外不雅观不雅观和气势气宇方面的显著改良外，新框架的特色使测试用例的编制从组织划定礼貌中约束出来。使副本僵化的 fixture 模子加倍无邪，无益于收受接管可设置配备铺排水平更高的方法。是以，JUnit 框架不再强求把每项测试责任界说为一个称号以 test 最先的方法，而且现在可以只运转一次 fixture，而不是每次测试都需求运转一次。
虽然这些修改使人欣喜，但 JUnit 4 并非第一个供应基于正文的无邪模子的 Java™ 测试框架。在改削 JUnit 之前很久，TestNG 就已竖立为一个基于正文的框架。
现实上，是 TestNG 在 Java 编程中率先 完成了行使正文中止测试，这使它成为 JUnit 的无力竞争对手。然则，自从 JUnit 4 宣布后，许多垦荒者质疑：两者之间还有什么差异吗？在本月的专栏中，我将谈论 TestNG 不合于 JUnit 4 的一些特色，并提议收受接管一些方法，使得这两个框架能连续互相弥补，而不是互相竞争。
您晓得吗？
在 Ant 中运转 JUnit 4 测试比估量的要名贵多。现实上，一些团队已发明，独一的处置方法是晋级到 Ant 1.7。
里面上的相反
JUnit 4 和 TestNG 有一些合营的主要特色。这两个框架都让测试责任庞杂得使人受惊（和愉快），给测试责任带来了便当。两者也都具有生动的社区，为自动垦荒供应支持，同时生成雄厚的文档。
提高代码质量
要找到您最迫切成就的谜底，请不要错过 Andrew 的 。
两个框架的不合在于焦点设计。JUnit 一贯 是一个单元测试框架，也就是说，其构建目的是增进单个对象的测试，它真实可以极为有用地完成此类责任。而 TestNG 则是用来处置更高 级其他测试成就，是以，它具有 JUnit 中所没有的一些特色。
一个庞杂的测试用例
初看起来，JUnit 4 和 TestNG 中完成的测试异常相反。为了更好地舆解我的意思，请看一下清单 1 中的代码。这是一个 JUnit 4 测试，它有一个 macro-fixture（即仅在一切测试运转前挪用一次的 fixture），这个 macro-fixture 由 @BeforeClass 属性泄漏表现：
清单 1. 一个庞杂的 JUnit 4 测试用例
.acme.dona.
import static org.junit.Assert.assertE
import static org.junit.Assert.assertNotN
import org.junit.BeforeC
import org.junit.T
public class DependencyFinderTest {
private static DependencyF
@BeforeClass
public static void init() throws Exception {
finder = new DependencyFinder();
public void verifyDependencies()
throws Exception {
String targetClss =
".acme.dona.dep.DependencyFind";
Filter[] filtr = new Filter[] {
new RegexPackageFilter("java|junit|org")};
Dependency[] deps =
finder.findDependencies(targetClss, filtr);
assertNotNull("deps was null", deps);
assertEquals("should be 5 large", 5, deps.length);
JUnit 用户会立刻留意到：这个类中没有了之前版本的 JUnit 中所要求的一些语法成份。这个类没有 setUp() 方法，也纰谬 TestCase 类中止扩展年夜，甚至也没有哪一个方法的称号以 test 最先。这个类还行使了 Java 5 的一些特色，例如静态导入，很显著地，它还行使了正文。
更多的无邪性
在清单 2 中，您可以看到不合个 测试项目。不外此次是用 TestNG 完成的。这里的代码跟清单 1 中的测试代码有个奇妙的差异。发明了吗？
清单 2. 一个 TestNG 测试用例
.acme.dona.
import static org.testng.Assert.assertE
import static org.testng.Assert.assertNotN
import org.testng.annotations.BeforeC
import org.testng.annotations.C
import org.testng.annotations.T
public class DependencyFinderTest {
private DependencyF
@BeforeClass
private void init(){
this.finder = new DependencyFinder();
public void verifyDependencies()
throws Exception {
String targetClss =
".acme.dona.dep.DependencyFind";
Filter[] filtr = new Filter[] {
new RegexPackageFilter("java|junit|org")};
Dependency[] deps =
finder.findDependencies(targetClss, filtr);
assertNotNull(deps, "deps was null" );
assertEquals(5, deps.length, "should be 5 large");
显著，这两个清单很相反。不外，假定仔细看，您会发明 TestNG 的编码划定礼貌比 JUnit 4 更无邪。 里，在 JUnit 中我必需把 @BeforeClass 修饰的方法声明为 static，这又要求我把 fixture，即 finder 声明为 static。我还必需把 init() 声明为 public。看看清单 2，您就会发明不合。这里不再需求那些划定礼貌了。我的 init() 方法既不是 static，也不是 public。
从最初起，TestNG 的无邪性就是其次要优势之一，但这并非它独一的卖点。TestNG 还供应了 JUnit 4 所不具有的其他一些特色。
依托性测试
JUnit 框架想抵达的一个目的就是测试隔离。它的瑕玷是：人们很难一定测试用例实行的递次，而这对任何类型的依托性测试都异常主要。垦荒者们行使了多种手艺来处置这个成就，例如，按字母递次指定测试用例，或是更多地依托 fixture 来适合地处置成就。
假定测试胜利，这些处置方法都没什么成就。然则，假定测试不胜利，就会发生发火一个很费事的效果：一切 后续的依托测试也会丢失落败。在某些情形下，这会使除夜型测试套件申报出许多没需求要的缺陷。例如，假定有一个测试套件测试一个需求登录的 Web 运用轨范。您可以树立一个有依托关系的方法，经由进程登录到这个运用轨范来树立悉数测试套件，从而避免 JUnit 的隔离机制。这类处置方法不错，然则假定登录丢失落败，即便登录该运用轨范后的其他功用都正常责任，悉数测试套件仍然会悉数丢失落败！
跳过，而不是标为丢失落败
与 JUnit 不合，TestNG 行使 Test 正文的
dependsOnMethods
属性来应对测试的依托性成就。有了这个便当的特色，就可以轻松指定依托方法。例如，后面所说的登录将在某个方法之前 运转。其余，假定依托方法丢失落败，它将被跳过，而不是符号为丢失落败。
清单 3. 行使 TestNG 中止依托性测试
import net.sourceforge.jwebunit.WebT
public class AccountHistoryTest
private WebT
@BeforeClass
protected void init() throws Exception {
this.tester = new WebTester();
this.tester.getTestContext().
setBaseUrl(":8185/ceg/");
public void verifyLogIn() {
this.tester.beginAt("/");
this.tester.setFormElement("username", "admin");
this.tester.setFormElement("password", "admin");
this.tester.submit();
this.tester.assertTextPresent("Logged in as admin");
@Test (dependsOnMethods = {"verifyLogIn"})
public void verifyAccountInfo() {
this.tester.clickLinkWithText("History", 0);
this.tester.assertTextPresent("GTG Data Feed");
在清单 3 中界说了两个测试：一个验证登录，其他一个验证账户信息。请留意，经由进程行使 Test 正文的 dependsOnMethods = {"verifyLogIn"} 子句，verifyAccountInfo 测试指定了它依托
verifyLogIn() 方法。
经由进程 TestNG 的 Eclipse 插件（例如）运转该测试时，假定 verifyLogIn 测试丢失落败，TestNG 将直接跳过
verifyAccountInfo
测试，请拜见图 1：
图 1. 在 TestNG 中跳过的测试
对除夜型测试套件，TestNG 这类不符号为丢失落败，而只是跳过的处置责罚方法可以加重许多压力。您的团队可以集中肉体查找为什么百分之五十的测试套件被跳过，而不是去找百分之五十的测试套件丢失落败的启事！更无益的是，TestNG 收受接管了只从新运转丢失落败测试的机制，这使它的依托性测试设置加倍完善。
丢失落败和重运转
在除夜型测试套件中，这类从新运转丢失落败测试的能力显得特殊随意。这是 TestNG 独有的一个特色。在 JUnit 4 中，假定测试套件包括 1000 项测试，个中 3 项丢失落败，极可以就会迫使您从新运转悉数测试套件（改削缺陷往后）。不必说，这样的责任可以会花消几个小时。
一旦 TestNG 中泛起丢失落败，它就会树立一个 XML 设置配备铺排文件，对丢失落败的测试加以声名。假定行使这个文件实行 TestNG 运转轨范，TestNG 就只 运转丢失落败的测试。所以，在后面的例子里，您只需从新运转那三个丢失落败的测试，而不是悉数测试套件。
理想上，您可以经由进程清单 2 中的 Web 测试的例子本人看到这点。verifyLogIn() 方法丢失落败时，TestNG 自动树立一个 testng-failed.xml 文件。该文件将成为如清单 4 所示的交流性测试套件：
清单 4. 丢失落败测试的 XML 文件
&!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd"&
&suite thread-count="5" verbose="1" name="Failed suite [HistoryTesting]"
parallel="false" annotations="JDK5"&
&test name=".acme.ceg.AccountHistoryTest(failed)" junit="false"&
&class name=".acme.ceg.AccountHistoryTest"&
&include name="verifyLogIn"/&
&/methods&
&/classes&
运转小的测试套件时，这个特色恍如没什么除夜不了。然则假定您的测试套件局限较除夜，您很快就会体味到它的优点。
参数化测试
TestNG 中其他一个幽默的特色是参数化测试。在 JUnit 中，假定您想修改某个受测方法的参数组，就只能给每一个 不合的参数组编写一个测试用例。多半情形下，这不会带来太多费事。然则，我们有时会碰着一些情形，对个中的营业逻辑，需求运转的测试数目转变局限很除夜。
在这样的情形下，行使 JUnit 的测试人员经常会转而行使 FIT 这样的框架，因为这样就可以用表格数据驱动测试。然则 TestNG 供应了开箱即用的相反特色。经由进程在 TestNG 的 XML 设置配备铺排文件中放入参数化数据，就可以对不合的数据集重用不合个测试用例，甚至有可以会获得不合的效果。这类手艺完善地避免了只能 假定一切正常的测试，或是没有对界限中止有用验证的情形。
在清单 5 中，我用 Java 1.4 界说了一个 TestNG 测试，该测试可领受两个参数：classname 和 size。这两个参数可以验证某个类的条理组织（也就是说，假定传入 java.util.Vector，则
HierarchyBuilder
的值将为 2 ）。
清单 5. 一个 TestNG 参数化测试
import com.acme.da.hierarchy.H
import com.acme.da.hierarchy.HierarchyB
public class HierarchyTest {
* @testng.test
* @testng.parameters value="class_name, size"
public void assertValues(String classname, int size) throws Exception{
Hierarchy hier = HierarchyBuilder.buildHierarchy(classname);
assert hier.getHierarchyClassNames().length == size: "didn't equal!";
清单 5 列出了一个泛型测试，它可以收受接管不合的数据一再重用。请花点时辰思虑一下这个成就。假定有 10 个不合的参数组合需求在 JUnit 中测试，您只能写 10 个测试用例。每一个测试用例完成的责任根抵是沟通的，只是受测方法的参数有所修改。然则，假定行使参数化测试，就可以只界说一个 测试用例，然后，（举例来说）把所需的参数方法加到 TestNG 的测试套件文件中。清单 6 中展现了这中方法：
清单 6. 一个 TestNG 参数化测试套件文件
&!DOCTYPE suite SYSTEM "/testng/testng-1.0.dtd"&
&suite name="Deckt-10"&
&test name="Deckt-10-test"&
&parameter name="class_name" value="java.util.Vector"/&
&parameter name="size" value="2"/&
&class name=".acme.da.HierarchyTest"/&
&/classes&
清单 6 中的 TestNG 测试套件文件只对该测试界说了一个参数组（class_name 为 java.util.Vector，且 size 等于 2），但却具有无限的可以。这样做的一个额定的优点是：将测试数据挪动到 XML 文件的无代码工件就意味着正当式员也可以指天命据。
初级参数化测试
虽然从一个 XML 文件中抽取数据会很随意，但偶然会有些测试需求有庞杂类型，这些类型没法用 String 或原语值来泄漏表现。TestNG 可以经由进程它的 @DataProvider 正文处置责罚这样的情形。@DataProvider 正文可以随意地把庞杂参数类型映照到某个测试方法。例如，清单 7 中的
verifyHierarchy
测试中，我收受接管了重载的 buildHierarchy 方法，它可领受一个 Class 类型的数据, 它断言（asserting）Hierarchy 的
getHierarchyClassNames() 方法理应前往一个适合的字符串数组：
清单 7. TestNG 中的 DataProvider 用法
import java.util.V
import static org.testng.Assert.assertE
import org.testng.annotations.DataP
import org.testng.annotations.T
import com.acme.da.hierarchy.H
import com.acme.da.hierarchy.HierarchyB
public class HierarchyTest {
@DataProvider(name = "class-hierarchies")
public Object[][] dataValues(){
return new Object[][]{
{Vector.class, new String[] {"java.util.AbstractList",
"java.util.AbstractCollection"}},
{String.class, new String[] {}}
@Test(dataProvider = "class-hierarchies")
public void verifyHierarchy(Class clzz, String[] names)
throws Exception{
Hierarchy hier = HierarchyBuilder.buildHierarchy(clzz);
assertEquals(hier.getHierarchyClassNames(), names,
"values were not equal");
dataValues() 方法经由进程一个多维数组供授与 verifyHierarchy 测试方法的参数值婚配的数据值。TestNG 遍历这些数据值，并凭证数据值挪用了两次 verifyHierarchy。在第一次挪用时，Class 参数被设置为
Vector.class ，而 String
数组参数原谅 “java.util.AbstractList ” 和 “ java.util.AbstractCollection ” 这两个 String 类型的数据。这样挺随意吧？
为什么只选择其一？
我已商酌了对我而言，TestNG 的一些独有优势，然则它还有其他几个特色是 JUnit 所不具有的。例如 TestNG 中行使了测试分组，它可以凭证诸如运转时辰这样的特色来对测试分类。也可在 Java 1.4 中经由进程 javadoc 气势气宇的正文来行使它，如
正如我在本文开首所说，JUnit 4 和 TestNG 在里面上是相反的。然则，设计 JUnit 的目的是为了剖析代码单元，而 TestNG 的预期用途则针对初级测试。对除夜型测试套件，我们不进展在某一项测试丢失落败时就得从新运转数千项测试，TestNG
的无邪性在这里特殊有用。这两个框架都有本人的优势，您可以随意同时行使它们。
原文地址：, 感谢原作者分享。
您可能感兴趣的代码}