JUnit

  Definition

•  Unit testing is a process of testing a single unit in isolation by passing inputs to it. A unit can be a single method or a combination of methods.
• In Junit we will pass different inputs to a unit and checking whether we are getting expected output.
• The test files should be in a different folder. We don’t want to mix test and the src files. Because we are not going to deploy test classes.
• We can use any name to test classes. Usually we will create test class like “className+Test”.
• JUnit always success unless there is no condition. Junit Failure means we have condition in test method and it  is failed.
• When a test method having multiple condition and the middle condition got failed. Then the remaining conditions will not process.
• If we made any changes in existing source code and we need to check whether it is working with all conditions. Then we just need to run JUnit and verify.

1.      Example        

      Class to be test(StringHelper.java)

public class StringHelper { public String truncateInFIrst2Positions(String str) { if (str.length() <= 2) { return str.replaceAll("A", ""); } String first2Charecters = str.substring(0, 2); String stringMinusFirst2Charecters = str.substring(2); return first2Charecters.replaceAll("A", "") + stringMinusFirst2Charecters; } public boolean areFirstAndLastTwoCharectersSame(String str) { boolean output = false; if (str.length() >= 4) { String first2Chaecters = str.substring(0, 2); String last2Charecters = str.substring(str.length() - 2); if (first2Chaecters.equals(last2Charecters)) { output = true; } } return output; } }      

The Test Class

public class StringHelperTest { private StringHelper helper=null; @Before public void before() { helper = new StringHelper(); System.out.println("Executes Before"); } @After public void After() { helper = null; System.out.println("Executes After"); } @BeforeClass public static void beforeClass() { System.out.println("Executes beforeClass"); } @AfterClass public static void AfterClass() { System.out.println("Executes AfterClass"); } @Test public void truncateInFIrst2PositionsTest() { System.out.println("truncateInFIrst2PositionsTest"); String expectedOutput = "RM"; String actualOutput = helper.truncateInFIrst2Positions("AARM"); Assert.assertEquals(expectedOutput, actualOutput); Assert.assertEquals("WERT", helper.truncateInFIrst2Positions("WERT")); Assert.assertEquals("WRM", helper.truncateInFIrst2Positions("AWRM")); Assert.assertEquals("RM", helper.truncateInFIrst2Positions("ARM")); Assert.assertEquals("AA", helper.truncateInFIrst2Positions("AAAA")); } @Test public void areFirstAndLastTwoCharectersSameTest() { System.out.println("areFirstAndLastTwoCharectersSameTest"); Assert.assertTrue(helper.areFirstAndLastTwoCharectersSame("WEERWE")); Assert.assertFalse(helper.areFirstAndLastTwoCharectersSame("WEERUE")); } @Test public void arraySortTest() { int[] arr = {2,4,5,3,1}; Arrays.sort(arr); int[] expectedOutput = {1,2,3,4,5}; Assert.assertArrayEquals(expectedOutput, arr); } @Test(expected=NullPointerException.class) public void chkExceptionTest() { int[] arr = null; Arrays.sort(arr); } @Test(timeout=10) public void arraySortPerformanceTest() { for(int i=0; i<100000 arr="" arrays.sort="" code="" i-1="" i="" int="">

Adding JUnit in Eclips
      Right click your project in Package Explorer > click Properties
      go to Java Build Path > Libraries tab
      click on 'Add Library' button
      select JUnit
      click Next.

Annatations
 @Test
     It  will tells the method is a test condition.
 @Test(expected=NullPointerException.class)
     Test will pass only if a NullPointerException has thrown.
 @Test(timeout=10)
     Test will pass only if the execution would complete within given timeout.
@Before
    The void method which is annotated with  @Before will execute before each test method.
@After
    The void method which is annotated with  @After will execute after each test method.
@BeforeClass
   The void method which is annotated with  @BeforeClass will execute before test class start execution.
@AfterClass
    The void method which is annotated with  @AfterClass will execute after test class execution.

Basic Asserts
 Assert.assertEquals(expectedOutput, actualOutput)
       Comparing expectedOutput vs actualOutput and pass only when both are equals.
Assert.assertArrayEquals(expectedOutput, actualOutput)
       Comparing both arrays  and pass only when both are equals.
 Assert.assertTrue(boolean arg)
       Pass condition only when the Boolean argument is true.
Assert.assertFalse(boolean arg)
       Pass condition only when the Boolean argument is false.

Spy vs Mock
    Mock

•         Mock always returns default values. It cannot do anything what actual arraylist does.
•         We can only stub the arrayList  to some values.
•         Mock is dummy implementation.
•          No logics from object can be used.
•          If we add one element then its size will not change.

@Test public void mockTest() { List mockList = Mockito.mock(ArrayList.class); Assert.assertEquals(0, mockList.size()); Mockito.stub(mockList.size()).toReturn(5); Assert.assertEquals(5, mockList.size()); }

    Spy

•      Spy will create an actual object and it will do all logical operations unlike mock does.
•       We are able to add element and increase size. But this size can be change to mock size using stub.
•       We can override actual values using stub. 
•        Spy will let the real logic to be done and also can be change real behavior when needed.

@Test public void spyTest() { List mockList = Mockito.spy(ArrayList.class); mockList.add("SONU"); Assert.assertEquals(1, mockList.size()); Mockito.stub(mockList.size()).toReturn(5); Assert.assertEquals(5, mockList.size()); }