junit-160729073220 eclipse software testing.pdf

HISTORY
• Kent Beck developed the first xUnit automated test tool for Smalltalk in mid-90’s
• Beck and Gamma (of design patterns Gang of Four) developed JUnit on a flight from
Zurich to Washington, D.C.
• Martin Fowler: “Never in the field of software development was so much owed by
so many to so few lines of code.”
• Junit has become the standard tool for Test-Driven Development in Java
• Junit test generators now part of many Java IDEs (Eclipse, BlueJ, Jbuilder, DrJava)
• Xunit tools have since been developed for many other languages (Perl, C++, Python,
Visual Basic, C#, …)

UNIT TESTING
• Unit Testing is one of the phase of software development process in which
units(smallest part of the application) are separately examined for proper operation.
• Generally programmers and occasionally white box testers created unit tests.
• Its implementation can vary from being very manual (pencil and paper) to being
formalized as part of build automation.

TESTS THAT ARE PERFORMED DURING THE UNIT
TESTING ARE EXPLAINED BELOW
• Module Interface test: In module interface test, it is checked whether the information is properly
flowing in to the program unit (or module) and properly happen out of it or not.
• Local data structures: These are tested to inquiry if the local data within the module is stored
properly or not.
• Boundary conditions: It is observed that much software often fails at boundary related conditions.
That’s why boundary related conditions are always tested to make safe that the program is properly
working at its boundary condition’s.
• Independent paths: All independent paths are tested to see that they are properly executing their task
and terminating at the end of the program.
• Error handling paths: These are tested to review if errors are handled properly by them or not.

FAMOUS JAVA UNIT TESTING TOOLS
• JMockit
• Artima SuiteRunner
• Cactus
• Checkstyle
• Cobertura
• Continuous Testing
• Daedalos JUnit Extensions
• Dbunit
• DDSteps
• Jete
• Jetif
• JFCUnit
• Jiffie
• jMock
• JOSIT
• JsTester
• JSystem
• DepUnit
• djUnit
• Dumbster
• EasyMock +
ClassExtension
• EclEmma
• Ejb3unit
• Emma
• Feed4JUnit
• Fest
• Findbugs
• Gretel
• GroboUtils
• Hansel 1.0
• Haste
• J2ME Unit
Testing Toolkit
• Jacareto

FAMOUS JAVA UNIT TESTING TOOLS
• JUnitPerf
• JXUnit
• Macker
• Mockito
• MockObjects
• Mockrunner
• MoMEUnit
• moreUnit
• NoUnit
• TestGen4J
• TestNG
• UISpec4J
• Unitils
• XHTMLUnit
• Xtest
• Fest
• Findbugs
• Gretel
• Pisces
• PMD
• Quilt
• Slim
• Sonar
• StrutsTestCase
for JUnit v1.9.5
• T2
• TagUnit
• Testare
• GroboUtils
• Hansel 1.0
• Haste
• J2ME Unit
Testing Toolkit
• Jailer
• JDepend
• JEasyTest
• JellyUnit
• Jester
• JTestCase
• Jumble
• JUnit
• JUnit-addons
• JUnitDoclet
• JUnitEE

JUNIT
• It is part of unit testing frameworks family collectively known as xUnit. Other examples are
CPPUnit, PHPUnit, JSUnit etc.
• JUnit is linked as a JAR at compile-time; the framework resides under packagesjunit.framework for
JUnit 3.8 and earlier and under org.junit for JUnit 4 and later.
• JUnit has now become the standard tool for Test-Driven Development in Java.
• JUnit test generators now part of many Java IDEs (Eclipse, BlueJ, Jbuilder, DrJava etc).

JUNIT (CONTD…)
• JUnit provides Annotation to identify the test methods and utility methods to assert expected results.
• JUnit has Test runners for running tests.
• JUnit tests can be organized into test suites which contains test cases and other test suites.
• JUnit Framework can be easily integrated with either of the followings:
• Eclipse
• Ant
• Maven

TESTING VIA JUNIT
• Can test JUnit by using Test Case & Test Suit .
• Test Case: A Test Case is a java class which is used to test a single class.
• Test Suite :A Test Suit is a java class which contains many test cases or java classes to test together in
a single run.

BENEFITS
• Simple framework for writing automated, self-verifying tests in Java
• Support for test assertions
• Test suite development
• Immediate test reporting

FEATURES
• Annotation to identify the test methods(After JUnit 4 ).
• Assertions for testing expected results.
• Test fixtures for sharing common test data.
• Test runners for running tests.
• Aggregating tests using suites.

NEED OF JUNIT
• JUnit tests allow you to write code faster while increasing quality.
• JUnit is elegantly simple. It is less complex & takes less time.
• JUnit tests can be run automatically and they check their own results and provide immediate feedback.
There's no need to manually comb through a report of test results.
• JUnit tests can be organized into test suites containing test cases and even other test suites.
• Writing JUnit tests is inexpensive.

JUNIT ANNOTATIONS
• @Test : The Test annotation tells JUnit that the public void method to which it is attached can be run
as a test case.
• @Before : Several tests need similar objects created before they can run. Annotating a public void
method with @Before causes that method to be run before each Test method.
• @After : If you allocate external resources in a Before method you need to release them after the test
runs. Annotating a public void method with @After causes that method to be run after the Test
method.
• @BeforeClass : Annotating a public static void method with @BeforeClass causes it to be run once
before any of the test methods in the class. This can be used to perform computationally expensive
setup (like logging into a database).
• @AfterClass : Will perform the method after all tests have finished. This can be used to perform clean-
up activities for example be used to disconnect to a database
• @Ignore : Sometimes you want to temporarily disable a test or a group of tests. Methods annotated
with Test that are also annotated with @Ignore will not be executed as tests. Also, you can annotate a
class containing test methods with @Ignore and none of the containing tests will be executed.

ASSERTION
• All the assertion are in the Assert class.
public class Assert extends java.lang.Object
• This class provides a set of assertion methods useful for writing tests.
• Only failed assertions are recorded.

ASSERTION METHODS
• void assertEquals(boolean expected, boolean actual) Check that two primitives/Objects are equal
• void assertTrue(boolean expected, boolean actual) Check that a condition is true
• void assertFalse(boolean condition) Check that a condition is false
• void assertNotNull(Object object) Check that an object isn't null.
• void assertNull(Object object) Check that an object is null

ASSERTION METHODS (CONTD…)
• void assertSame(boolean condition) The assertSame() methods tests if two object references
point to the same object
• void assertNotSame(boolean condition) The assertNotSame() methods tests if two object
references not point to the same object
• void assertArrayEquals(expectedArray, resultArray); The assertArrayEquals() method will test
whether two arrays are equal to each other.
• fail(String message) Fails a test with the given message.
• assertArrayEquals(String message,expected array,actual array) Asserts that two byte arrays are
equal. If they are not, an AssertionError is thrown with the given message.

JUNIT SET UP
• download the latest version of JUnit, referred as junit4.x.x.zip from given below link :
• http://sourceforge.net/projects/junit/files/

As step 2 Add the
downloaded junit jar
file and try to finish the
project creation
As step 1 Create a java
project

JAR FILES USED IN THE MENTIONED SAMPLES

API'S OF JUNIT
Class Name Functionality
Assert A set of assert methods.
TestCase A test case defines the fixture to run multiple tests.
TestResult A TestResult collects the results of executing a test case.
TestSuite A TestSuite is a Composite of Tests.

@TEST SAMPLE
package Test;
import static org.junit.Assert.*;
import org.junit.Test;
import Test.Pet;
public class PetTest {
@Test
public void testPet() {
}
@Test
public void testMeaow()
{
Pet testPet = new Pet();
assertTrue("Meaow".equals(testPet.meaow()));
}
}
package Test;
public class Pet {
public Pet() {}
public String meaow() {
return "Meaow";
}
}

junit-160729073220 eclipse software testing.pdf

CREATE A JAVA CLASS & TEST CLASS
• Create a class TestSamples.java
• Right click on TestSamples.java, select New ->others-->(Inside JUnit folder)JUnit Test case and select
Next button, the following window appears
package TestSamples;
public class TestSample {
public int multiply(int x, int y) {
return x * y;
}
}

Click Next
Select the check box
TestSample and click
Finish

• On clicking finish a new file named TestSampleTest.java gets created automatically and is as
follows
• Now edit the stub so as to make it assertive.
public class TestSampleTest {
@Test
public void test() {
fail("Not yet implemented");
}
}

• After editing the stub, now the class file and its test case looks something like this
public class TestSampleTest {
@Test
public void testMultiply() {
TestSample ts=new TestSample();
assertEquals(30,ts.multiply(5, 6));
}
}

EXECUTING A JUNIT TEST
• Right click on your new test class and select Run-As-> Junit Test.
• If the output shows green flag, your test is successful.
• If it shows red, it means class have some failures or errors.
• It will also show you the methods which has errors and the Failure Trace

• Both failure and successful scenarios are
displayed here for the same

CREATING A TEST SUITE
• Multiple tests can be combined into a test suite. All test in this test suite will then be executed if you
run the test suite.
• To create a new test suite, select your package, right mouse click->, select New->Others->Junit ->JUnit
Test Suite->next->Finish.

CREATING A TEST SUITE(CONTD…)
• As a result the following TestSuite is created
package Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({ PetTest.class, TestCase.class, TestCase1.class,
TestClassMain.class, TestSuite.class, UnitTest.class })
public class AllTests {
}

TESTCASE CLASS
• org.junit.TestCase class id declared as follows.
• A test case defines the fixture to run multiple tests.
public abstract class TestCase extends Assert implements Test

FREQUENTLY USED METHODS FROM TESTCASE CLASS
• int countTestCases() Counts the number of test cases.
• TestResult createResult() Creates a default TestResult object.
• String getName() Gets the name of a TestCase.
• TestResult run() A convenience method to run this test.
• void run(TestResult result) Runs the test case and collects the results in TestResult.
• void setName(String name) Sets the name of a TestCase.
• void setUp() Sets up the fixture, for example, open a database connection.
• void tearDown() Tears down the fixture, for example, close a database connection.
• String toString() Returns a string representation of the test case.

import junit.framework.TestCase;
import org.junit.Before;
public class TestJunit extends TestCase {
protected double fValue1;
protected double fValue2;
@Before
public void setUp() {
System.out.println("setup");
fValue1= 8.0;
fValue2= 9.0;
}
@Test
public void testCaseAdd() {
//count the number of test cases
System.out.println("No of Test Case = "+ this.countTestCases());
//test getName
String name= this.getName();
System.out.println("Test Case Name = "+ name);
//test setName
this.setName("testCaseAddNew");
String newName= this.getName();
System.out.println("Updated Test Case Name = "+ newName);
assertEquals(5.0, fValue1+fValue2);
}}
TESTCASE CLASS EXAMPLE

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class Main {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
Output:
setup
No of Test Case = 1
Test Case Name = testCaseAdd
Updated Test Case Name = testCaseAddNew
testCaseAddNew(TestSamples.TestJunit): expected:<5.0> but was:<17.0>
false

JUNIT TESTRESULT
• TestResult collects the results of executing a test case.
TestResult Class
• The declaration for org.junit.TestResult class:
• A failure is anticipated and checked for with assertions.
• Errors are unanticipated problems such as ArrayIndexOutOfBoundsException.
public class TestResult extends Object

FREQUENTLY USED METHODS FROM TESTRESULT CLASS.
• void addError(Test test, Throwable t) Adds an error to the list of errors.
• void addFailure(Test test, AssertionFailedError t) Adds a failure to the list of failures.
• void endTest(Test test) Informs the result that a test was completed.
• int errorCount() Gets the number of detected errors.
• Enumeration<TestFailure> errors() Returns an Enumeration for the errors.
• int failureCount() Gets the number of detected failures.
• void run(TestCase test) Runs a TestCase.
• int int runCount() Gets the number of run tests.
• void startTest(Test test) Informs the result that a test will be started.
• void stop() Marks that the test run should stop.

TESTING FOR EXCEPTIONS IN JUNIT
• The Test annotation supports 'expected' parameters which declares that a test method should
throw an exception. If it doesn't throw an exception or if it throws a different exception than the one
declared, the test fails.
• For example, the following test succeeds :

JUNIT ANNOTATION IMPLEMENTATION COMPLETE
EXAMPLE
• Junit Annotation Class : AnnotTest.java
• Test Runner Class : AnnotTestRunner.java
Source code and its out are displayed in the following slides

package Test;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
public class AnnotTest {
@BeforeClass
public static void beforeClass() {
System.out.println("in before class");
}
@AfterClass
public static void afterClass() {
System.out.println("in after class");
}
@Before
public void before() {
System.out.println("in before");
}
@After
public void after() {
System.out.println("in after");
}
@Test
public void test() {
System.out.println("in test");
}
@Ignore
public void ignoreTest() {
System.out.println("in ignore test");
}
}

package Test;
public class AnnotTestRunner {
Result result = JUnitCore.runClasses(AnnotTest.class);
}
}
}
Output:
in before class
in before
in test
in after
in after class
true

ORGANIZING TEST FIXTURES WITH SETUP/TEARDOWN AND
@BEFORE/ @AFTER
• JUnit test runners automatically invoke the setUp() method before running each test. This method
typically initializes fields, turns on logging, resets environment variables, and so forth.
• JUnit test runners automatically invoke the tearDown() method after running each test which
releases above mention resources after test.
• Annotating a public void method with @Before causes that method to be run before the Test
method.
• Annotating a public void method with @After causes that method to be run after the Test method.
• Annotating a public static void method with @BeforeClass causes it to be run once before any of the
test methods in the class.
• Annotating a public static void method with @AfterClass causes it to be run after all tests have
finished.

The methods will execute in the following order:
• oneTimeSetUp()
• setUp()
• testEmptyCollection()
• tearDown()
• setUp()
• testOneItemCollection()
• tearDown()
• OneTimeTearDown()

A COMPLETE EXAMPLE OF JUNIT TESTING
• Pojo class : Student.java
• Business Logic : StudentDetails.java
• Test Case class : StudentDetailsTest.java
• Main Class : StudentMain.java
package Testing;
public class Student {
private String name;
private String city;
private int age;
private int percentage;
}
package Testing;
public class StudentDetails {
public String calculatePercentage(Student student){
String status;
if(student.getPercentage() < 50){
status = "Fail";
}else{
status = "Pass";
}
return status;
}
}

package Testing;
import static org.junit.Assert.assertEquals;
public class StudentDetailsTest {
StudentDetails studentDetails =new StudentDetails();
Student student = new Student();
@Test
public void CalculatePercentage() {
student.setName("Derick");
student.setAge(25);
student.setCity("Agra");
student.setPercentage(79);
String status=studentDetails.calculatePercentage(student);
assertEquals("Fail", status, "Fail");
}
}

package Testing;
public class StudentMain {
Result result = JUnitCore.runClasses(StudentDetailsTest.class);
}
}
}

JUNIT TIME TEST
• Junit has a handy option of Timeout.
• If a test case takes more time than specified milliseconds then Junit will automatically mark it as failed.
• The timeout parameter is used along with @Test annotation.

package Test;
import Test.Pet;
public class PetTest {
@Test
public void testPet() {
}
@Test (timeout=5000)
public void testMeaow()
{
Pet testPet = new Pet();
assertTrue("Meaow".equals(testPet.meaow()));
}
}
package Test;
public class AnnotTestRunner {
Result result =
JUnitCore.runClasses(PetTest.class);
for (Failure failure :
result.getFailures()) {
}
}
}
Output: true

junit-160729073220 eclipse software testing.pdf

More Related Content

Similar to junit-160729073220 eclipse software testing.pdf (20)

More from KomalSinghGill (11)

Recently uploaded (20)

junit-160729073220 eclipse software testing.pdf