I love writting unit tests for my code. It makes it easy to test code that is very hard to test in a running system, just for checking the behavior of certain implementations. Besides that, is useful when trying to refactor some code, so we can assure that the behavior is not broken.
Well, I'll show you the java unit test frameworks that I currently use...
Junit
The
JUnit Platform serves as a foundation for launching testing frameworks on the JVM
JUnit 5 user guide is available as
documentation.
Nice features:
Parameterized tests make it possible to run a test multiple times with different arguments.
Supports annotations.
E.g.
import org.junit.*;
public class TestXXX {
@BeforeClass
public static void setUpClass() throws Exception {
// Code executed before the first test method
}
@Before
public void setUp() throws Exception {
// Code executed before each test
}
@Test
public void testOneThing() {
// Code that tests one thing
}
@After
public void tearDown() throws Exception {
// Code executed after each test
}
@AfterClass
public static void tearDownClass() throws Exception {
// Code executed after the last test method
}
}
EasyMock
EasyMock provides dynamically generated Mock objects (at runtime), without having to implement them.
Can be used in conjunction with Junit.
E.g.
public class XXXTest extends TestCase {
public void tesComputeValue(){
ClassUnderTest testObject = new ClassUnderTest();
ClassToMock mock = EasyMock.createMock(ClassToMock.class);
EasyMock.expect(mock.getSomething()).andReturn("Hello");
EasyMock.replay(mock);
assertEquals("Hello", testObject.saySomething(mock));
}
}
PowerMock
PowerMock is an extension to both Mockito and EasyMock that allows mocking of static methods, constructors, final classes and methods, private methods, removal of static initializers and more.
Allows the usage of the beneficts of PowerMock and the usage of Mockito to setup and verify expectations by using PowerMockito.
E.g.
@RunWith(PowerMockRunner.class)
@PrepareForTest(ClassUnderTest.class)
public class XXXTest {
private ClassToMock mock;
private ClassUnderTest testObject;
@Test
public void tesComputeValue() {
mock = PowerMockito.mock(ClassToMock.class);
PowerMockito.when(mock.getSomething()).thenReturn("Hello");
testObject = new ClassUnderTest(mockUserService);
assertEquals("Hello", testObject.saySomething());
}
}
Mockito
Mockito allows to verify the behavior of the system under test without establishing expectations beforehand, attempting to eliminate the expect-run-verify pattern, so the coupling is minimized.
Can be used in conjunction with Junit.
E.g.
public class XXXTest {
private ClassToMock mock;
private ClassUnderTest testObject;
@Before
public void setUp() {
mock = mock(ClassToMock.class);
testObject = new ClassUnderTest(mock);
}
@Test
public void testComputeValue() throws Exception {
when(mock.getSomething(any(String.class))).thenReturn("Hello");
testObject.saySomething();
verify(mock).getSomething(any(String.class));
}
}
Nice features:
Can define the behavior of the same method call to produce different results, in the same test.
More...
More java unit tests frameworks can be found in this wikipedia
listing.
