Junit

Content
• Unit tests and unit testing
• Unit testing with JUnit
• Available JUnit annotations
• Assertions
• Test Suites
• Rules
• Mocking libraries
• EasyMock
• Code coverage libraries
• Cobertura

Unit tests and unit testing
• a unit test is a piece of code written by a developer that executes a
specific functionality in the code to be tested.
• a unit test targets a small unit of code, e.g., a method or a class
• it ensures that code works as intended, (code still works as
intended in case you need to modify code for fixing a bug or
extending functionality).

Unit tests and unit testing
• the percentage of code which is tested by unit tests is typically
called test coverage.
• having a high test coverage of your code allows you to
continue developing features without having to perform lots
of manual tests.

Unit testing with JUNIT
• JUnit (http://junit.org/) is a test framework which uses
annotations to identify methods that specify a test. Typically
these test methods are contained in a class which is only used
for testing. It is typically called a Test class.
• current stable version: 4.11

Example:
package bogcon.dbintruder.tests.core;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import bogcon.dbintruder.core.Parameters;
/**
* ParametersTest class.<br />
* Test cases for {@link Parameters} class.
*
* @author Bogdan Constantinescu <bog_con@yahoo.com>
*/
public class ParametersTest {
@Test
public void testGeneralOperations() {
Parameters p = new Parameters();
p.add("param1", "param1Value");
assertEquals(p.getCount(), 1);
assertTrue(p.get("param1").contains("param1Value"));
}
}

- to run the test:
java -cp .:/path/to/junit.jar org.junit.runner.JUnitCore [test class name]
- all tests methods are annotated with @Test, no need too
prefix methods name with test as in JUnit3
- no need to extend anything (junit.framework.TestCase as in
JUnit3)

Available JUnit annotations
Annotation Description
@Test
public void method()
The @Test annotation identifies a method as a test
method.
@Test (expected =
Exception.class)
Fails if the method does not throw the named
exception.
@Test(timeout=100) Fails if the method takes longer than 100 milliseconds.
@Before
This method is executed before each test. It is used to
prepare the test environment (e.g., read input data,
initialize the class).
@After
This method is executed after each test. It is used to
cleanup the test environment (e.g., delete temporary
data, restore defaults). It can also save memory by
cleaning up expensive memory structures.

Available JUnit annotations
Annotation Description
@BeforeClass
public static void
method()
This method is executed once, before the start of all tests. It is
used to perform time intensive activities, for example, to
connect to a database. Methods marked with this annotation
need to be defined as static to work with JUnit.
@AfterClass
public static void
method()
This method is executed once, after all tests have been
finished. It is used to perform clean-up activities, for example,
to disconnect from a database. Methods annotated with this
annotation need to be defined as static to work with JUnit.
@Ignore Ignores the test method. This is useful when the underlying
code has been changed and the test case has not yet been
adapted. Or if the execution time of this test is too long to be
included.

Assertions
Statement Description
fail(String) Let the method fail. Might be used to check that a certain
part of the code is not reached or to have a failing test
before the test code is implemented. The String
parameter is optional.
assertTrue([message],
boolean condition)
Checks that the boolean condition is true.
assertFalse([message],
boolean condition)
Checks that the boolean condition is false.
assertEquals([String
message], expected,
actual)
Tests that two values are the same. Note: for arrays the
reference is checked not the content of the arrays.
assertEquals([String
message], expected,
actual, tolerance)
Test that float or double values match. The tolerance is
the number of decimals which must be the same.

Assertions
Statement Description
assertNull([message], object) Checks that the object is null.
assertNotNull([message],
object)
Checks that the object is not null.
assertSame([String],
expected, actual)
Checks that both variables refer to the same object.
assertNotSame([String],
expected, actual)
Checks that both variables refer to different objects.
assertArrayEquals([String],
expected, actual)
Checks both array contains same values

Test Suites
• combine multiple tests into a test suite
• a test suite executes all test classes in that
suite in the specified order
• Example:
package bogcon.dbintruder.tests.core;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({ ParametersTest.class, SqlErrorsTest.class, UtilsTest.class,
WebTechnologyTest.class, HttpClientTest.class, AnalyzerTest.class,
OsETest.class })
public class AllNonLiveTests {
}

Rules
Example how to specify which exception message you expect during
execution of your test code:
import org.junit.Rule;
import org.junit.rules.ExpectedException;
public class RuleExceptionTesterExample {
@Rule
public ExpectedException exception = ExpectedException.none();
@Test
public void throwsIllegalArgumentExceptionIfIconIsNull() {
exception.expect(IllegalArgumentException.class);
exception.expectMessage("Negative value not allowed"); ClassToBeTested t =
new ClassToBeTested(); t.methodToBeTest(-1);
}
}

Rules
Example how setup files & folders which are automatically removed after
a test:
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import org.junit.Rule;
import org.junit.rules.TemporaryFolder;
public class RuleTester {
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@Test
public void testUsingTempFolder() throws IOException {
File createdFolder = folder.newFolder("newfolder");
File createdFile = folder.newFile("myfilefile.txt");
assertTrue(createdFile.exists());
}
}

Mocking libraries
• Jmockit https://code.google.com/p/jmockit/
• EasyMock
http://easymock.org/
• Mockito
https://code.google.com/p/mockito/
• PowerMock
https://code.google.com/p/powermock/

EasyMock
• is a mock framework which can be easily used in conjunction with Junit
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createMockBuilder;
...
HttpClient mock = createMockBuilder(HttpClient.class)
.addMockedMethod("get")
.addMockedMethod("getLastResponse")
.createMock();
HttpClient mockHC = createMock(HttpClient.class);
expect(mockHC.get(url)).andReturn(this.response1).once();
expect(mockHC.get(url)).andThrow(new DBIntruderException("")).times(2);
expect(mockHC.get(matches(Pattern.quote("http://www.agenda.dev/index.php?id=") + "[0-9a-zA-
Z_-]+" + Pattern.quote("&param=blabla"))))
.andReturn(this.response2).once();

Code coverage libraries
• Clover
https://www.atlassian.com/software/clover/overview
• EMMA
http://emma.sourceforge.net/index.html
• Cobertura
http://cobertura.github.io/cobertura/

Cobertura
• Cobertura is a free Java tool that calculates the percentage of
code accessed by tests. It can be used to identify which parts
of your Java program are lacking test coverage.

THANK YOU!
Bogdan Constantinescu
INNOBYTE

Junit

More Related Content

What's hot (20)

Similar to Junit (20)

Recently uploaded (20)

Junit