blocks|key|370606|text|首先，我要说的是，不要为了适应最新的时尚而重写所有的测试。Junit3工作得很好，而且在4中引入注释并不会给您带来太多好处(在我看来)。更重要的是你们写测试，而且听起来你们也是这样做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|370607|使用任何看起来最自然的东西，帮助你完成工作。|370608|我不能评论TestNG+b/c我还没有用过它。但我推荐unitils，无论您采用哪种方式，它都是一个很好的JUnit/TestNG/DBUnit/EasyMock包装器。(它支持上面提到的所有口味)|offset|length|370609|entityMap|0|LINK|mutability|MUTABLE|url|http://www.unitils.org/summary.html^0|0|0|R|7|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

First I would say, don't rewrite all your tests just to suit the latest fad. Junit3 works perfectly well, and the introduction of annotations in 4 doesn't buy you very much (in my opinion). It is much more important that you guys write tests, and it sounds like you do. 

Use whatever seems most natural and helps you get your work done.

I can't comment on TestNG b/c I haven't used it. But I would recommend <a href="http://www.unitils.org/summary.html" rel="noreferrer">unitils</a>, a great wrapper for JUnit/TestNG/DBUnit/EasyMock, regardless of which route you take. (It supports all the flavors mentioned above)

blocks|key|3376350|text|这两种测试我都用过，但我不得不同意Justin+Standard的观点，即你不应该真的考虑将现有测试重写为任何新的格式。不管是什么决定，同时运行这两个是相当微不足道的。TestNG努力使其比JUnit更具可配置性，但最终两者都能同样出色地工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3376351|TestNG有一个很好的特性，您可以将测试标记为特定的组，然后轻松运行特定组的所有测试，或者排除特定组的测试。因此，您可以将运行缓慢的测试标记为“慢”组，然后在需要快速结果时忽略它们。他们文档中的一个建议是将一些子集标记为"checkin“测试，这些测试应该在您签入新文件时运行。我从来没有在JUnit中看到过这样的特性，但是话又说回来，如果你没有它，你也不会错过它。|3376352|尽管它声称高配置，但我确实在几周前遇到了一个角落案例，在那里我无法做我想做的事情……我希望我能记住它是什么，但我想把它提出来，这样你就知道它并不完美。|3376353|TestNG最大的优势是注解...无论如何，JUnit在版本4中添加了它。|3376354|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I've used both, but I have to agree with Justin Standard that you shouldn't really consider rewriting your existing tests to any new format. Regardless of the decision, it is pretty trivial to run both. TestNG strives to be much more configurable than JUnit, but in the end they both work equally well.

TestNG has a neat feature where you can mark tests as a particular group, and then easily run all tests of a specific group, or exclude tests of a particular group. Thus you can mark tests that run slowly as in the "slow" group and then ignore them when you want quick results. A suggestion from their documentation is to mark some subset as "checkin" tests which should be run whenever you check new files in. I never saw such a feature in JUnit, but then again, if you don't have it, you don't REALLY miss it.

For all its claims of high configuration, I did run into a corner case the a couple weeks ago where I couldn't do what I wanted to do... I wish I could remember what it is, but I wanted to bring it up so you know that it's not perfect.

The biggest advantage TestNG has is annotations... which JUnit added in version 4 anyways.

blocks|key|365826|text|大约一年前，我们遇到了同样的问题。我花了一些时间考虑哪一步更好，最终我们意识到TestNG没有“杀手级功能”。它很不错，而且有一些JUnit+4没有的功能，但我们不需要它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|365827|我们不希望人们在了解TestNG的同时对编写测试感到不自在，因为我们希望他们继续编写大量的测试。|365828|此外，JUnit几乎是Java界的事实标准。没有一个像样的工具不支持它，你可以在网上找到很多帮助，他们在过去的一年里添加了很多新功能，这表明它是活跃的。|365829|我们决定坚持使用JUnit，再也不回头了。|365830|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

About a year ago, we had the same problem. I spent sometime considering which move was better, and eventually we realized that TestNG has no 'killer features'. It's nice, and has some features JUnit 4 doesn't have, but we don't need them. 
We didn't want people to feel uncomfortable writing tests while getting to know TestNG because we wanted them to keep writing a lot of tests. 
Also, JUnit is pretty much the de-facto standard in the Java world. There's no decent tool that doesn't support it from the box, you can find a lot of help on the web and they added a lot of new features in the past year which shows it's alive.

We decided to stick with JUnit and never looked back.

blocks|key|370655|text|对我来说，TestNG最大的优势包括它的支持测试组，以及更重要的-测试组依赖关系(将测试标记为依赖于某个组会导致测试在依赖组失败时跳过运行)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|370656|对我来说，TestNG的其他重要功能包括测试参数、数据提供者、注释转换器，还有更多--充满活力和响应式的用户社区。|370657|虽然从表面上看，人们可能并不认为上面所有的TestNG功能都是不需要的，但一旦你开始理解为你的测试带来的灵活性，你会想知道你是如何应对JUnit的。|370658|(免责声明-我根本没有使用过JUnit+4.x，所以我无法真正评论那里的进步或新功能)。|370659|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

TestNG's biggest draw cards for me include its support test groups, and more importantly - test group dependencies (marking a test as being dependent of a group causes the tests to simply skip running when the dependent group fails).

TestNG's other big draw cards for me include test parameters, data providers, annotation transformers, and more than anything - the vibrant and responsive user community.

Whilst on the surface one might not think all of TestNGs features above might not be needed, once you start to understand the flexibility bring to your tests, you'll wonder how you coped with JUnit.

(disclaimer - I've not used JUnit 4.x at all, so am unable to really comment on advances or new features there).

blocks|key|3376470|text|对Mike+Stone的回复有几点补充：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3376471|1)当我想要在测试套件中运行单个测试方法时，我最常使用TestNG的组。我只需将此测试添加到组"phil“中，然后运行此组。当我使用JUnit+3时，我会注释掉所有方法的条目，但我想在"suite“方法中运行的方法除外，但在签入之前通常会忘记取消注释。对于组，我不再有这个问题。|3376472|2)根据测试的复杂性，可以使用sed自动完成从JUnit3到TestNG的测试迁移，并创建一个基类来替换静态导入所有TestNG+assert方法的TestCase。|3376473|我有关于从JUnit迁移到TestNG+here和here的信息。|offset|length|3376474|entityMap|0|LINK|mutability|MUTABLE|url|http://www.philvarner.com/blog/2008/01/30/testng-migration/|1|http://www.philvarner.com/blog/2008/02/10/testng-part-2/^0|0|0|0|K|4|0|P|4|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$H|X|I|Y|1|Z]|$H|10|I|11|1|12]]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

A couple of additions to Mike Stone's reply:

1) The most frequent thing I use TestNG's groups for is when I want to run a single test method in a test suite. I simply add this test to the group "phil" and then run this group. When I was using JUnit 3, I would comment out the entries for all methods but the one I wanted to run in the "suite" method, but then would commonly forget to uncomment them before checkin. With the groups, I no longer have this problem.

2) Depending on the complexity of the tests, migrating tests from JUnit3 to TestNG can be done somewhat automatically with sed and creating a base class to replace TestCase that static imports all of the TestNG assert methods.

I have info on my migration from JUnit to TestNG <a href="http://www.philvarner.com/blog/2008/01/30/testng-migration/" rel="noreferrer">here</a> and <a href="http://www.philvarner.com/blog/2008/02/10/testng-part-2/" rel="noreferrer">here</a>.

blocks|key|365903|text|此外，TestNG的另一个优势是支持并行测试。我认为，在我们的多核时代，这一点很重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|365904|我也使用了这两个框架。但我使用hamcrest进行断言。Hamcrest允许您轻松地编写自己的assert方法。因此，不是|365905|assertEquals(operation.getStatus(),+Operation.Status.Active);|code-block|syntax|javascript|365906|你可以写|365907|assertThat(operation,+isActive());|365908|这使您有机会在测试中使用更高级别的抽象。这会让你的测试更健壮。|365909|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Also one more advantage of TestNG is supporting of parallel testing. In our era of multicores it's important, i think.

I also used both frameworks. But i using hamcrest for assertations. Hamcrest allows you easily write your own assert method. So instead of

<pre><code>assertEquals(operation.getStatus(), Operation.Status.Active);
</code></pre>

You can write

<pre><code>assertThat(operation, isActive());
</code></pre>

That gives you opportunity to use higher level of abstraction in your tests. And this makes your tests more robust.

blocks|key|3376662|text|我想分享我今天遇到的一个。我发现与TestNG相比，内置的参数化运行器在Junit4中相当粗糙(我知道每个框架都有自己的优势，但仍然如此)。Junit4注释@parameters仅限于一组参数。在同一个测试类中测试功能的有效和无效行为时，我遇到了这个问题。因此，它找到的第一个公共的、带静态注释的方法将被使用，但它可能会以任何顺序找到它们。这会导致我们不必要地编写不同的类。但是，TestNG提供了一种简洁的方法，可以为每种方法提供不同类型的数据提供程序。因此，我们可以在同一测试类中以有效和无效的方式测试相同的代码单元，将有效/无效数据分开。我会选择TestNG。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3376663|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I wanted to share the one I encountered today. I found built-in Parameterized runner is quite crude in Junit4 as compare to TestNG (I know each framework has its strengths but still). The Junit4 annotation @parameters is restricted to one set of parameters. I encountered this problem while testing the valid and invalid behavior for functionality in same test class. So the first public, static annotated method that it finds will be used, but it may find them in any order. This causes us to write different classes unnecessarily. However TestNG provides clean way to provide different kind of data providers for each and every method. So we can test the same unit of code with valid and invalid way in same test class putting the valid/invalid data separately. I will go with TestNG.

blocks|key|370795|text|为以上的一切干杯。我个人发现在TestNG中我更喜欢的其他一些东西是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|370796|370797|+@BeforeClass+|ordered-list-item|offset|length|style|CODE|370798|+TestNG是在类创建之后发生的，所以你不会因为只能在其中调用类的静态方法而受到限制。|370799|并行和参数化测试，也许我的生活还不够……但我只需要编写一组Selenium测试，接受驱动程序名称作为参数。然后定义3个平行测试组，每个测试组1个，分别用于IE，FF和Chrome车手，并观看比赛！我最初做了4个，但由于这样或那样的原因，我处理的太多页面破坏了HtmlUnit驱动程序。|370800|370801|是啊，可能需要找到那种生活。;)|370802|entityMap^0|0|0|1|C|0|0|3L|8|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|U|8|@$F|V|G|W|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|Y|8|@$F|Z|G|10|H|I]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

Cheers to all the above. Some other things I've personally found I like more in TestNG are:

<ol>
<li>The <code>@BeforeClass</code> for TestNG takes place after class creation, so you aren't constrained by only being able to call static methods of your class in it.</li>
<li>Parallel and parameterized tests, maybe I just don't have enough of a life... but I just get a kick writing one set of Selenium tests, accepting a driver name as a parameter. Then defining 3 parallel test groups, 1 each for the IE, FF and Chrome drivers, and watching the race! I originally did 4, but way too many of the pages I've worked on break the <code>HtmlUnit</code> driver for one reason or another.</li>
</ol>

Yeah, probably need to find that life. ;)

blocks|key|3376750|text|你的问题对我来说似乎有两重含义。一方面你想比较两个测试框架，另一方面你想轻松地实现测试，拥有自然的断言，等等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3376751|好的，首先，JUnit在功能方面一直在追赶TestNG，他们已经弥补了v4的一些差距，但在我看来还不够好。像注释和数据提供程序这样的东西在TestNG中仍然要好得多。此外，它们在测试执行方面也更加灵活，因为TestNG具有测试依赖性、分组和排序。|3376752|JUnit仍然要求某些之前/之后的方法是静态的，这限制了您在运行测试之前可以做的事情，TestNG从来没有这个问题。|3376753|顺便说一句，这两个框架之间的差异通常意义不大，除非你专注于集成/自动化测试。根据我的经验，JUnit是为单元测试从头开始构建的，现在正被推向更高级别的测试，这使得它不适合这项工作。TestNG在单元测试方面做得很好，由于其健壮的数据提供和强大的测试执行能力，在集成/自动化测试级别上工作得更好。|3376754|现在，我认为是另一个问题，如何编写结构良好、可读和可维护的测试。其中大部分我相信你都知道，但是像工厂模式，命令模式和PageObjects+(如果你的测试网站)是至关重要的，在你的测试(SUT)和实际测试(业务逻辑的断言)之间有一个抽象层是非常重要的。为了获得更好的断言，您可以使用Hamcrest。使用javas继承/接口来减少重复并加强通用性。|offset|length|style|BOLD|3376755|几乎忘记了，还使用了测试数据生成器模式，这与TestNG的dataprovider注释结合在一起非常有用。|3376756|entityMap|0|LINK|mutability|MUTABLE|url|https://code.google.com/p/hamcrest/^0|0|0|0|0|1C|4|1H|4|1M|B|3X|8|0|0|A|9|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@$J|12|K|13|L|M]|$J|14|K|15|L|M]|$J|16|K|17|L|M]]|9|@$J|18|K|19|1|1A]]|A|$]]|$1|N|3|O|5|6|7|1B|8|@$J|1C|K|1D|L|M]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

Your question seems two folded to me. On one had you would like to compare two test frameworks, on the other hand you would like to implement tests easily, have natural assertions, etc...

Ok, firstly JUnit has been playing catchup with TestNG in terms of functionality, they have bridged the gap some what with v4, but not well enough in my opinion. Things like annotations and dataproviders are still much better in TestNG. Also they are more flexible in terms of test execution, since TestNG has test dependency, grouping and ordering.

JUnit still requires certain before/after methods to be static, which limits what you can do prior to the running of tests, TestNG never has this issue.

TBH, mostly the differences between the two frameworks don't mean much, unless your focusing on integration/automation testing. JUnit from my experience is built from the ground up for unit testing and is now being pushed towards higher levels of testing, which IMO makes it the wrong tool for the job. TestNG does well at unit testing and due to its robust dataproviding and great test execution abilities, works even better at integration/automation test level.

Now for what I believe is a separate issue, how to write well structured, readable and maintainable tests. Most of this I am sure you know, but things like Factory Pattern, Command Pattern and PageObjects (if your testing websites) are vital, it is very important to have a layer of abstraction between what your testing (SUT) and what the actual test is (assertions of business logic). In order to have much nicer assertions, you can use <a href="https://code.google.com/p/hamcrest/" rel="nofollow" title="hamcrest">Hamcrest</a>. Make use of javas inheritance/interfaces to reduce repetition and enforce commonality.

Almost forgot, also use the Test Data Builder Pattern, this coupled with TestNG's dataprovider annotation is very useful.

blocks|key|367968|text|我的观点是，是什么让TestNG真正变得更加强大：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|367969|1.++JUnit+still+requires+the+before/after+class+methods+to+be+static,+which+limits
++++what+you+can+do+prior+to+the+running+of+tests,+TestNG+never+has+this+issue.

2.++TestNG+@Configuration+methods+can+all+take+an+optional+argument+to+their+
++++annotated+methods+in+the+form+of+a+ITestResult,+XmlTest,+Method,+or+
++++ITestContext.++This+allows+you+to+pass+things+around+that+JUnit+wouldn't+
++++provide+you.++JUnit+only+does+this+in+listeners+and+it+is+limited+in+use.

3.++TestNG+comes+with+some+pre-made+report+generation+classes+that+you+can+copy
+++++and+edit+and+make+into+your+own+beautiful+test+output+with+very+little+
+++++effort.+Just+copy+the+report+class+into+your+project+and+add+a+listener+
+++++to+run+it.++Also,+ReportNG+is+available.

4.++TestNG+has+a+handful+of+nice+listeners+that+you+can+hook+onto+so+you+can+do
+++++additional+AOP+style+magic+at+certain+phases+during+testing.|code-block|syntax|javascript|367970|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My opinion about what makes TestNG truly far more powerful:

<pre><code>1. JUnit still requires the before/after class methods to be static, which limits
 what you can do prior to the running of tests, TestNG never has this issue.

2. TestNG @Configuration methods can all take an optional argument to their 
 annotated methods in the form of a ITestResult, XmlTest, Method, or 
 ITestContext. This allows you to pass things around that JUnit wouldn't 
 provide you. JUnit only does this in listeners and it is limited in use.

3. TestNG comes with some pre-made report generation classes that you can copy
 and edit and make into your own beautiful test output with very little 
 effort. Just copy the report class into your project and add a listener 
 to run it. Also, ReportNG is available.

4. TestNG has a handful of nice listeners that you can hook onto so you can do
 additional AOP style magic at certain phases during testing.
</code></pre>

blocks|key|3376948|text|JUnit+4与TestNG+-+mkyong.com的比较(2013年更新)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3376949|结论:我建议使用TestNG作为Java项目的核心单元测试框架，因为TestNG在参数化测试、依赖测试和套件测试(分组概念)方面更具先进性。|3376950|TestNG用于功能、高级测试和复杂的集成测试。它的灵活性对于大型测试套件尤其有用。|3376951|此外，TestNG还涵盖了整个核心JUnit4功能。我再也没有理由使用JUnit了。|3376952|3376953|简而言之，TestNG+=+JUnit+%2B更多。那么，为什么要争论呢？去抓取TestNG+:-)|blockquote|3376954|3376955|3376956|你可以找到更详细的比较here。|3376957|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mkyong.com/unittest/junit-4-vs-testng-comparison/^0|0|14|0|0|0|3|M|0|0|5|J|0|0|0|B|4|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|T|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]]]

JUnit 4 Vs TestNG – Comparison by mkyong.com ( updated on 2013).

Conclusion: I suggest to use TestNG as core unit test framework for Java project, because TestNG is more advance in parameterize testing, dependency testing and suite testing (Grouping concept). 

TestNG is meant for functional, high-level testing and complex integration test. Its flexibility is especially useful with large test suites. 

In addition, TestNG also cover the entire core JUnit4 functionality. It’s just no reason for me to use JUnit anymore.

<blockquote>
 In simple terms, TestNG = JUnit + lot more. So, Why debate ? go and
 grab TestNG :-)
</blockquote>

You can find more detailed comparison <a href="http://www.mkyong.com/unittest/junit-4-vs-testng-comparison/" rel="nofollow noreferrer">here</a>.

blocks|key|366214|text|为什么我们使用TestNG而不是JUnit?|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|366215|366216|+@BeforeClass和@AfterClass方法的声明在JUnit中必须是静态的，而TestNG在方法声明中有更多的灵活性，它没有这些constraints.|ordered-list-item|CODE|366217|In+TestNG，我们可以使用两种方式来参数化测试。@Parameter或@DataProvider批注。|366218|366219|i)+@参数，用于简单情况，需要键值映射。(数据通过xml文件提供)|366220|ii)复杂情况下的@DataProvider。在TestNG中，由于@DataProvider方法不需要是静态的，所以我们可以在同一个测试中使用多个数据提供程序方法进行class.|366221|Dependency测试：在TestNG中，如果初始测试失败，那么所有后续的依赖测试将被跳过，不会被标记为失败。但是failed.|unordered-list-item|366222|
|366223|Grouping:+JUnit标记了它，单个测试可以属于多个组，然后在不同的上下文中运行(比如慢速或快速测试)。类似的特性存在于JUnit类别中，但缺少允许初始化测试/撕裂测试的@BeforeGroups+/+@AfterGroups+TestNG批注。如果你想在多个线程上并行运行同一个测试，TestNG为你提供了一个简单易用的批注，而JUnit没有提供一个简单的方法来实现这一点@DataProvider还可以支持TestNG馈入数据，CSV，甚至纯文本files.|366224|366225|TestNG允许你声明测试之间的依赖关系。如果依赖性测试没有通过，则跳过它们。|366226|366227|测试@+|366228|+(dependsOnMethods={+"dependOnSomething“})|blockquote|366229|366230|366231|此功能在JUnit中不存在|366232|366233|Reporting:+|366234|366235|默认情况下，TestNG报告被生成到一个测试输出文件夹中，该文件夹包含所有测试数据(通过/失败/跳过)、它们运行了多长时间、使用了哪些输入以及完整的测试日志。此外，它还将所有内容导出到一个XML文件，该文件可用于构建您自己的报告模板。|366236|在JUnit方面，所有这些数据也可以通过XML获得，但是没有现成的报告，您需要依赖插件。|366237|资源链接：|366238|366239|A+Quick+JUnit+vs+TestNG+Comparison|366240|JUnit+vs.+TestNG:+Which+Testing+Framework+Should+You+Choose?|366241|366242|本教程并排给出了一个很好的区别：TestNG+Vs+JUnit:+What's+the+Difference?|366243|entityMap|0|LINK|mutability|MUTABLE|url|http://www.baeldung.com/junit-vs-testng|1|https://dzone.com/articles/junit-vs-testng-which-testing-framework-should-you|2|https://www.guru99.com/junit-vs-testng.html^0|0|M|0|0|1|C|E|B|0|0|K|0|0|3|3|0|9|D|0|0|D|0|0|0|9|0|0|0|0|0|0|0|0|0|0|0|A|0|0|0|0|0|0|0|Y|0|0|0|1O|1|0|0|G|13|2|0^^$0|@$1|2|3|4|5|6|7|25|8|@$9|26|A|27|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|28|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|29|8|@$9|2A|A|2B|B|J]|$9|2C|A|2D|B|J]]|D|@]|E|$]]|$1|K|3|L|5|I|7|2E|8|@$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|2H|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|2I|8|@$9|2J|A|2K|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|2L|8|@$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|R|3|S|5|T|7|2O|8|@$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2R|8|@]|D|@]|E|$]]|$1|W|3|X|5|T|7|2S|8|@$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|Y|3|V|5|6|7|2V|8|@]|D|@]|E|$]]|$1|Z|3|10|5|T|7|2W|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|2X|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2Y|8|@]|D|@]|E|$]]|$1|14|3|15|5|16|7|2Z|8|@]|D|@]|E|$]]|$1|17|3|-4|5|6|7|30|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|31|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|32|8|@]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|33|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|I|7|34|8|@$9|35|A|36|B|C]]|D|@]|E|$]]|$1|1E|3|-4|5|6|7|37|8|@]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|38|8|@]|D|@]|E|$]]|$1|1H|3|1I|5|6|7|39|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|6|7|3A|8|@]|D|@]|E|$]]|$1|1L|3|-4|5|6|7|3B|8|@]|D|@]|E|$]]|$1|1M|3|1N|5|I|7|3C|8|@]|D|@$9|3D|A|3E|1|3F]]|E|$]]|$1|1O|3|1P|5|I|7|3G|8|@]|D|@$9|3H|A|3I|1|3J]]|E|$]]|$1|1Q|3|-4|5|6|7|3K|8|@]|D|@]|E|$]]|$1|1R|3|1S|5|6|7|3L|8|@]|D|@$9|3M|A|3N|1|3O]]|E|$]]|$1|1T|3|-4|5|6|7|3P|8|@]|D|@]|E|$]]]|1U|$1V|$5|1W|1X|1Y|E|$1Z|20]]|21|$5|1W|1X|1Y|E|$1Z|22]]|23|$5|1W|1X|1Y|E|$1Z|24]]]]

<h2>Why we use TestNG instead of JUnit?</h2>

<ol>
<li>The declaration of <code>@BeforeClass</code> and <code>@AfterClass</code> method has to be static in JUnit whereas, there is more flexibility in TestNG in the method declaration, it does not have these constraints.</li>
<li>In TestNG, we can parametrize tests using 2 ways. @Parameter or @DataProvider annotation.

i) @Parameter for simple cases, where key value mapping is required.(data is provided through xml file)

ii) @DataProvider for complex cases. Using 2 dimensional array, It can provide data.</li>
<li>In TestNG, since @DataProvider method need not be static, we can use multiple data provider methods in the same test class.</li>
<li>Dependency Testing: In TestNG, if the initial test fails, then all subsequent dependent tests will be skipped, not marked as failed. But JUnit marked it failed.</li>
<li>Grouping: Single tests can belong to multiple groups and then run in different contexts (like slow or fast tests). A similar feature exists in JUnit Categories but lacks the @BeforeGroups / @AfterGroups TestNG annotations that allow initializing the test / tearing it down.</li>
<li>Parallelism: If you’d like to run the same test in parallel on multiple threads, TestNG has you covered with a simple to use annotation while JUnit doesn’t offer a simple way to do so out of the box.</li>
<li>TestNG @DataProvider can also support XML for feeding in data, CSVs, or even plain text files.</li>
<li>TestNG allows you to declare dependencies between tests, and skip them if the dependency test didn’t pass. </li>
</ol>

<blockquote>
 @Test(dependsOnMethods = { "dependOnSomething" })
</blockquote>

This functionality doesn’t exist in JUnit

<ol start="9">
<li>Reporting: </li>
</ol>

TestNG reports are generated by default to a test-output folder that includes HTML reports with all of the test data, passed/failed/skipped, how long did they run, which input was used and the complete test logs. In addition, it also exports everything to an XML file which can be used to construct your own report template.

On the JUnit front, all of this data is also available via XML, but there’s no out of the box report and you need to rely on plugins.

<h2>Resource Link:</h2>

<ol>
<li><a href="http://www.baeldung.com/junit-vs-testng" rel="noreferrer">A Quick JUnit vs TestNG Comparison</a></li>
<li><a href="https://dzone.com/articles/junit-vs-testng-which-testing-framework-should-you" rel="noreferrer">JUnit vs. TestNG: Which Testing Framework Should You Choose?</a></li>
</ol>

A good difference is given in this tutorial side by side: <a href="https://www.guru99.com/junit-vs-testng.html" rel="noreferrer">TestNG Vs JUnit: What's the Difference?</a>

At work we are currently still using JUnit 3 to run our tests. We have been considering switching over to JUnit 4 for new tests being written but I have been keeping an eye on TestNG for a while now. What experiences have you all had with either JUnit 4 or TestNG, and which seems to work better for very large numbers of tests? Having flexibility in writing tests is also important to us since our functional tests cover a wide aspect and need to be written in a variety of ways to get results.

Old tests will not be re-written as they do their job just fine. What I would like to see in new tests though is flexibility in the way the test can be written, natural assertions, grouping, and easily distributed test executions.

JUnit vs TestNG

单元测试

集成测试

Java

在工作中，我们目前仍在使用JUnit 3来运行我们的测试。我们一直在考虑为正在编写的新测试切换到JUnit 4，但我已经关注TestNG有一段时间了。你们都有过使用JUnit 4或TestNG的经验吗?哪一种似乎更适合于大量的测试？编写测试的灵活性对我们来说也很重要，因为我们的功能测试涵盖了广泛的方面，需要以各种方式编...

问JUnit vs TestNG
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JUnit vs TestNGEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JUnit vs TestNG
EN