JUnit 4 Vs TestNG

1. Annotation @Test is used in both JUnit4 and TestNG but from different class:

1. import org.junit.Test; // JUnit 4
2. ... or
3. import org.testng.annotations.Test; // TestNG
5. public class MyTestClass {
7.     @Test
8.     public void aTestMethod() throws ... { ... }
9. }

2. According to Annotation Support:

Feature	JUnit 4	TestNG
Test annotation	@Test	@Test
Run before all tests in this suite have run	–	@BeforeSuite
Run after all tests in this suite have run	–	@AfterSuite
Run before the test	–	@BeforeTest
Run after the test	–	@AfterTest
Run before the first test method that belongs to any of these groups is invoked	–	@BeforeGroups
Run after the last test method that belongs to any of these groups is invoked	–	@AfterGroups
Run before the first test method in the current class is invoked	@BeforeClass	@BeforeClass
Run after all the test methods in the current class have been run	@AfterClass	@AfterClass
Run before each test method	@Before	@BeforeMethod
Run after each test method	@After	@AfterMethod
Ignore test	@ignore	@Test(enbale=false)
Expected exception	@Test(expected = ArithmeticException.class)	@Test(expectedExceptions = ArithmeticException.class)
Timeout	@Test(timeout = 1000)	@Test(timeout = 1000)

3. Exception Test

---

It says what exception will throw from the unit test.
//JUnit4

1. @Test(expected = ArithmeticException.class)  
2.     public void divisionByZeroException() {  
3.       int i = 1/0;
4.     }

//TestNG

1. @Test(expectedExceptions = ArithmeticException.class)  
2.     public void divisionByZeroException() {  
3.       int i = 1/0;
4.     }

4. Ignore Test

---

It says how to ignore the unit test.
//JUnit

1. @Ignore("Not Ready to Run")  
2. @Test
3. public void IgnoreTest() {  
4.     System.out.println("Method is not ready yet");
5. }

//TestNG

1. @Test(enabled=false)
2. public void IgnoreTest() {  
3.     System.out.println("Method is not ready yet");
4. }

5. Suite Test

---

It says how to bundle a few unit test and run together.
//JUnit4
The "@RunWith" and "@Suite" are use to run the suite test. The below class means both unit test "JunitTest1" and "JunitTest2" run together after "JunitTest3" executed. All the declaration is define inside the class.

1. @RunWith(Suite.class)
2. @Suite.SuiteClasses({
3.         JunitTest1.class,
4.         JunitTest2.class
5. })
6. public class JunitTest3 {
7. }

//TestNG
XML file is use to run the suite test. The below XML file means both unit test “TestNGTest1” and “TestNGTest2” will run it together.

1. <suite name="My test suite">
2.   <test name="My test">
3.     <classes>
4.        <class name="example.test.TestNGTest1" />
5.        <class name="example.test.TestNGTest2" />
6.     </classes>
7.   </test>
8. </suite>

6. Dependency Test

---

It says which test will execute after what test. If the dependent method fails, then all subsequent tests will be skipped, not marked as failed.
//JUnit4
JUnit framework is focus on test isolation; it did not support this feature at the moment.
//TestNG
It use "dependOnMethods" to implement the dependency testing as following

1. @Test
2. public void testMethod1() {
3.     System.out.println("This is method 1");
4. }
6. @Test(dependsOnMethods={"testMethod1"})
7. public void testMethod2() {
8.     System.out.println("This is method 2");
9. }

7. Parameterized Test

---

It says how to pass parameters to an unit test dynamically.
//JUnit4
The "@RunWith" and "@Parameter" is use to provide parameter value for unit test, @Parameters have to return List[], and the parameter will pass into class constructor as argument.

1. @RunWith(value = Parameterized.class)
2. public class JunitTest {
4.      private int number;
6.      public JunitTest(int number) {
7.         this.number = number;
8.      }
10.      @Parameters
11.      public static Collection<Object[]> data() {
12.        Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
13.        return Arrays.asList(data);
14.      }
16.      @Test
17.      public void pushTest() {
18.        System.out.println("Parameterized Number is : " + number);
19.      }
20. }

It has many limitations here; we have to follow the “JUnit” way to declare the parameter, and the parameter has to pass into constructor in order to initialize the class member as parameter value for testing. The return type of parameter class is “List []”, data has been limited to String or a primitive value for testing.
//TestNG
XML file or “@DataProvider” is used to provide vary parameter for testing.
(see the post: Parameterized Test TestNG and observe the difference)

Parameterized Test TestNG

Sometimes in TestNG test we need various parameter values for the unit test,we call the test as 'Parameterized Test'.
In TestNG there are two ways by which we can pass parameters to a test.They are,

1. By TestNG's XML configuration files(testng.xml)
2. By @DataProvider

1.By TestNG's XML configuration files(testng.xml):

---

Declare "@Parameters" annotation in method which needs parameter testing, the parametric data will be provide by testng.xml(TestNG's XML configuration files). By doing this, you can reuse a single test case with different data sets easily. In addition, even end user, QA can provide their own data sets for testing.
//TestNGParameterizedTest

1. package example.test;
3. import org.testng.annotations.*;
5. /**
6.  * TestNG Parameterized Test
7.  *
8.  */
9. public class TestNGParameterizedTest {
11.     @Test
12.     @Parameters(value="input")
13.     public void parameterTest(int input) {
14.        System.out.println("Parameterized input is : " + input);
15.     }
16. }

//testng.xml

1. <suite name="My test suite">
2.   <test name="Parameterized test">
3.     <parameter name="input" value="7"/>      
4.     <classes>
5.        <class name="example.test.TestNGParameterizedTest" />
6.     </classes>
7.   </test>
8. </suite>

2 .By @DataProvider:

---

In the 1st way,while pulling data values into an XML file can be quite handy, but test cases occasionally may require complex data types, which can’t be represented as a String or a primitive value in XML file. TestNG handles this scenario with "@DataProvider" annotation, which facilitates the mapping of complex parameter types to a test method.
//CharASCII.java

1. package sourse;
3. public class CharASCII {
4.    
5.     public static int CharToASCII(final char character){
6.         return (int)character;
7.     }
9.     public static char ASCIIToChar(final int ascii){
10.         return (char)ascii;    
11.     }
12. }

//CharASCIITest.java

1. package example.test;
3. import org.testng.*;
4. import org.testng.annotations.DataProvider;
5. import org.testng.annotations.Test;
7. import sourse.CharASCII;
9. public class CharASCIITest  {
10.     @DataProvider
11.     public Object[][] ValidDataProvider() {
12.         return new Object[][]{ { 'A', 65 },{ 'B', 66 },{ 'C', 67 },{ 'D', 68 },  { 'Z', 90 } };
13.     }
15.     @Test(dataProvider = "ValidDataProvider")
16.     public void CharToASCIITest(final char character, final int ascii) {
17.         System.out.println("ASCII of "+character+" is "+ascii);
18.         int result = CharASCII.CharToASCII(character);
19.         Assert.assertEquals(result, ascii);
20.     }
22.     @Test(dataProvider = "ValidDataProvider")
23.     public void ASCIIToCharTest(final char character, final int ascii) {
24.         System.out.println("Char of "+ascii+" is "+character);
25.         char result = CharASCII.ASCIIToChar(ascii);
26.         Assert.assertEquals(result, character);
27.     }  
28. }