@RunWith(value = Parameterized.class)
public class ParameterizedTest {
  private double expected, valueOne, valueTwo;


  @Parameterized.Parameters
  public static Collection<Integer[]> getTestParameters() {
    return Arrays.asList(new Integer[][]{
      {2, 1, 1}, //expected, valueOne, valueTwo
      {3, 2, 1}, //expected, valueOne, valueTwo
      {4, 3, 1}, //expected, valueOne, valueTwo
    });
  }

  public ParameterizedTest(double expected, double valueOne, double valueTwo) {
    this.expected = expected; this.valueOne = valueOne; this.valueTwo = valueTwo;
  }

  @Test
  public void sum() {
    Assert.assertEquals(expected, new Calculator().add(valueOne, valueTwo), 0);
  }

  private class Calculator{
    double add(double i, double j){ return i+j; }
  }
}

import org.junit.Test;
import java.util.List;
import static org.junit.Assert.*
import static org.mockito.Mockito.*;

public class MockitoTest {
    @Test public void testVerify() {
        List<String> mockedList = mock(List.class);
        mockedList.add("once");
        mockedList.add("twice");
        mockedList.add("twice");
        mockedList.add("three times");
        mockedList.add("three times");
        mockedList.add("three times");

        //following two verifications work exactly the same - times(1) is used by default
        verify(mockedList).add("once");
        verify(mockedList, times(1)).add("once");

        //exact number of invocations verification
        verify(mockedList, times(2)).add("twice");
        verify(mockedList, times(3)).add("three times");

        //verification using never(). never() is an alias to times(0)
        verify(mockedList, never()).add("never happened");

        //verification using atLeast()/atMost()
        verify(mockedList, atLeastOnce()).add("three times");
        verify(mockedList, atLeast(2)).add("three times");
        verify(mockedList, atMost(5)).add("three times");
    }
}

@Test public void stubbing() {
        //Arrange - Act - Assert Pattern
        Iterator i = mock(Iterator.class);
        //when next() method is called, return "Hello" first and on 2nd invocation return "World"
        when(i.next()).thenReturn("Hello").thenReturn("World"); //Arrange
        String result = i.next() + " " + i.next(); //Act
        assertThat("Hello World", is(result)); //Assert
    }

@Test(expected = IOException.class)
    public void voidMethodCalls() throws IOException {
        OutputStream stream = mock(OutputStream.class);
        doThrow(new IOException()).when(stream).close(); //when close() method is called throw exception
        stream.close();
    }
}

@Test(expected = NullPointerException.class)
    public void throwException() {
        Comparable c = mock(Comparable.class);
        when(c.compareTo("Test")).thenReturn(1);
        when(c.compareTo(null)).thenThrow(new NullPointerException("Null...."));//when input is null, throw NPE
        assertThat(1, is(c.compareTo("Test")));
        assertThat(0, is(c.compareTo("Something")));
        assertThat(0, is(c.compareTo(null))); //throws NPE

        when(c.compareTo(anyString())).thenReturn(100);//regardless of the input, return 100. anyString() is called Argument Matchers
        assertThat(100, is(c.compareTo("Test")));
    }
}

import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;

public class HamcrestTest {
    @Test public void simpleAssertions(){
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
        assertThat(nums.size(), is(5)); //Assert equals
        assertThat(nums.size(), is(equalTo(5)));//Assert equals
        assertThat(nums, allOf(notNullValue(), instanceOf(List.class)));//AND operation
        assertThat(nums, anyOf(nullValue(), instanceOf(List.class)));//OR operation
        assertThat(nums, not(equalTo(Arrays.asList(1))));//NOT operation
    }
}

 def setup(){} //run before every feature method
 def cleanup(){} //run after every feature method
 def setupSpec(){} //run before the first feature method
 def cleanupSpec(){} //run after the first feature method

setup: OR given: "setup and init of..." //must be first and only. label is optional
def stack = new Stack()
def elem = "push me"

when/then blocks
when: //stimulus
stack.push(elem)

then: //response
!stack.empty //leverages Groovy truthy feature. Implicitly asserts the collection is not null and not empty
stack.size() == 1
stack.peek() == elem

when:
stack.pop()

then:
thrown(EmptyStackException)
stack.empty

when:
stack.pop()

 then:
 EmptyStackException e = thrown()
 e.cause == null

 when:
 stack.pop()

 then:
 notThrown(EmptyStackException)