# Connexions

You are here: Home » Content » Principles of Object-Oriented Programming » Unit Testing with JUnit in DrJava

• #### Labs

• DrJava
• Unit Testing with JUnit in DrJava

### Lenses

What is a lens?

#### Definition of a lens

##### Lenses

A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

##### What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

##### Who can create a lens?

Any individual member, a community, or a respected organization.

##### What are tags?

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

#### Affiliated with (What does "Affiliated with" mean?)

This content is either by members of the organizations listed or about topics related to the organizations listed. Click each link to see a list of all content affiliated with the organization.
• OrangeGrove

This collection is included inLens: Florida Orange Grove Textbooks
By: Florida Orange Grove

Click the "OrangeGrove" link to see all content affiliated with them.

Click the tag icon to display tags associated with this content.

• Rice Digital Scholarship

This collection is included in aLens by: Digital Scholarship at Rice University

Click the "Rice Digital Scholarship" link to see all content affiliated with them.

• Bookshare

This collection is included inLens: Bookshare's Lens
By: Bookshare - A Benetech Initiative

"Accessible versions of this collection are available at Bookshare. DAISY and BRF provided."

Click the "Bookshare" link to see all content affiliated with them.

#### Also in these lenses

• Busbee's Compter Science

This collection is included inLens: Busbee's Computer Science Lens
By: Kenneth Leroy Busbee

"Texas Common Course Numbering: COSC1337 or COSC1437"

Click the "Busbee's Compter Science" link to see all content selected in this lens.

Click the tag icon to display tags associated with this content.

• eScience, eResearch and Computational Problem Solving

This collection is included inLens: eScience, eResearch and Computational Problem Solving
By: Jan E. Odegard

Click the "eScience, eResearch and Computational Problem Solving" link to see all content selected in this lens.

### Recently Viewed

This feature requires Javascript to be enabled.

### Tags

(What is a tag?)

These tags come from the endorsement, affiliation, and other lenses that include this content.

Inside Collection (Course):

Course by: Stephen Wong, Dung Nguyen. E-mail the authors

# Unit Testing with JUnit in DrJava

Module by: Stephen Wong, Dung Nguyen. E-mail the authors

Summary: Unit testing is a fundamental testing process in the development of object-oriented systems. The module is a primer on using the JUnit unit testing framework that is integrated into DrJava.

Object oriented systems derive great complexity through the interactions between the objects in the system. It is often impossible to test the entire range of the total complex behavior that a system is designed to exhibit. What one can say however is that if any given part of the system does not perform as desired, then one can make no assurances whatsoever about the integrity of the system as a whole. Thus the testing of these smaller parts, or "units" is a crucial element of developing any large-scale OO system. A unit test is a complete test of a small, atomic sub-system. Note that this is not the same from a partial test of some aspect of the whole system!

Unit tests are often performed at the individual class level, meaning that a test class that runs all the complete battery of tests on the tested class, is written for each class to be tested. In some cases however, certain systems of classes are not divisible into isolated, atomic units and in such must be tested as a whole. The key is to test as small a piece of the system as possible and to test it as thoroughly as possible.

## Using JUnit in DrJava

Suppose we have a class such as the following that we wish to test. Note that class is public and that the method we wish to test is also public.

In DrJava, select "File/New JUnit Test Case...". Enter a name that is descriptive of the test(s) you wish to make. A recommendation is to use the class name being tested prepended with "Test_", such as "Test_MyClass". This enables all your test classes to be easily identified, DrJava will then automatically create a valid JUnit test class, such as below. (Note that DrJava does not initially name the new class file, but the default name suggested by DrJava when you attempt to save it will be correct.)

Rename the auto-generated "testX()" method to something more descriptive of the particular test you'd like to perform. The new name must start with "test" and must return void and take no input parameters. You can create as many test methods as you wish to test your code. JUnit will automatically run all methods that begin with "test" as test methods. Typically, a single test method will test a single method on the class under test. There are situations however where a single method under test may require several test methods to properly test its full range of operation. In the code that follows, the testX() method has been renamed to "test_myMethod1()".

### assertEquals(...)

There are a number of ways in which one can test that the proper result is produced. The simplest method is to compare a single output value to an expected value. For instance, suppose you are testing a method that returns a result. One can compare the actual returned value to the value one expects for the given inputs. There are two methods supplied by the junit.framework.TestCase class, which is the superclass of the test class generated by DrJava. The first is void assertEquals(String failResponse, Object actual, Object expected). The actual input parameter is the actual result of the method under test. The expected parameter is the expected result. failResponse is a String that JUnit/DrJava will display if the actual value does not "equal" the expected value. The assertEquals(...) method is overridden such that actual and expected values can be either Objects or primitives. assertEquals(...) uses the equals(...) method of Object to makes it determination. For primitives, the usual == is used. For instance, we could write the test case below. If the actual value does not equal the expected value, assertEquals throws a exception that is caught by the JUnit framework and an error message will result. To test the code, first compile all the code then select the test class. Right-click the test class and select "Test Current Document "or click on "Tools/Test Current Document." The following result will be displayed, given the test code we wrote to purposely fail:

As shown on the screen shot, DrJava clearly indicates in red the test method that failed and the difference between the expected and actual values. It also highlights the line of code in the test method where the failure occured.

There is one exception to the syntax of assertEquals, and that is when the values being compared are doubles. This is because round-off errors in calculating floating point values means that it is almost always impossible to generate the same value from two different calculations, even if mathematically they are the same. For instance, compate 2.3*2.3 and 5.29. Mathematically identical, but on a PC running Windows, Java calculates them to be different by approximately 0.00000000000000089 (or 8.9e-16 in Java syntax). Thus, if the expected and actual values are to be of type double, then a 4'th input parameter is required. This last parameter is a tolerance value, a plus-or-minus amount within which one considers the expected and actual values to be equal. For instance:

assertEquals("Testing doubles: 5.29 vs. 2.3*2.3", 5.29, 2.3*2.3, 9e-16);
should pass, but assertEquals("Testing doubles: 5.29 vs. 2.3*2.3", 5.29, 2.3*2.3, 8e-16);should fail. Note that the tolerance value should always be a positive value.

### assertTrue(...)

 Another method provided by TestCase is void assertTrue(String failResponse, boolean result). This is a simplified version of assertEquals(...) used when the result can be expressed as a boolean true or false. Note that any test using assertTrue can also be written as assertEquals(failResponse, result, true). For instance we could write another test method to test the myMethod2() method of MyClass. The test class now has two test methods and JUnit will run both ot them when we click on "Test Current Document." Here, the second test method passes as shown in green below. The first method still fails and its error messages are still shown. Clicking on the error message will highlight the line where the error occured. Correcting the code in myMethod1(...) would result in all the test methods being listed in green with no error messages. 

### fail(...)

 For more complex testing, TestCase provides the void fail(String failResponse) method. Calling this method will immediately cause the test method to fail and the failResponse string will be displayed. Since this method does not know the actual or expected results, the failResponse string should contain more detailed information about what exactly failed and how it failed. In the next screen shot is an example of using fail(...) where the test code was written such that it would fail: 

### Additional Capabilities

 Note that any test method can call other methods if needed . This is useful when the testing procedure is complex and needs to be broken down into smaller pieces. Do not name these helper methods starting with "test" or they will be run separately as test cases! Using helper methods is also useful when certain types of tests are performed only under certain conditions. assertEquals(...), assertTrue(...) and fail(...) can be called from anywhere, but the DrJava will only highlight the line in the main test method that generated the error, i.e. the line that called the helper method. It will not highlight the line in the helper method where the actual call to assertEquals(...), assertTrue(...) or fail(...)was made. 

 Sometimes in complex testing scenarios, there is a significant amount of initialization work required to set up the system to be tested. This is often the case when testing a system of interdependent objects where the entire system must be set up before any single object can be tested. If the initialization code is the same for all the tests being conducted, the method protected void setup() can be declared and be used to execute the necessary initializations. To insure "clean" test runs, JUnit/DrJava re-instantiates the test class before running each test method. The setup() method, if it exists, is called before any test method is executed. This means that the test class cannot utilize any internal field values that one test method modifies and another test method expects to use as modified. 

 Likewise, in the event that after a test is run that significant amounts of common "clean-up" code is required, one can declare the method protected void tearDown(). This method runs after each test method and is useful for insuring, for instance, that files and network connections are properly closed and thus keep them from interfering with other tests. 

 The help system in DrJava has more detailed information on testing with JUnit, including how to create a test suite of multiple tests. 

 
 Collection Navigation « Previous module in collection DrJava Collection home: Principles of Object-Oriented Programming Next module in collection » Java Syntax Primer Content actions Share content Share module: Give feedback: E-mail the collection authors | E-mail the module authors Download: Collection as: PDF | More downloads ... Module as: PDF | EPUB (?) What is an EPUB file? EPUB is an electronic book format that can be read on a variety of mobile devices. Downloading to a reading device For detailed instructions on how to download this content's EPUB to your specific device, click the "(?)" link. | More downloads ... Add: Collection to: My Favorites Login Required (?) 'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'. | A lens I own Login Required (?) Definition of a lens Lenses A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust. What is in a lens? Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content. Who can create a lens? Any individual member, a community, or a respected organization. What are tags? Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens. | External bookmarks Module to: My Favorites Login Required (?) 'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'. | A lens I own Login Required (?) Definition of a lens Lenses A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust. What is in a lens? Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content. Who can create a lens? Any individual member, a community, or a respected organization. What are tags? Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens. | External bookmarks Footer More about this module: Metadata | Downloads | Version History How to reuse and attribute this content How to cite and attribute this content This work is licensed by Stephen Wong and Dung Nguyen under a Creative Commons Attribution License (CC-BY 1.0), and is an Open Educational Resource. Last edited by Stephen Wong on Nov 9, 2004 11:23 am +0000. 
 
 var _gaq = _gaq || []; function trackthisGoogleAnalytics(strCode) { try { _gaq.push(['user._setAccount', strCode]); _gaq.push(['user._trackPageview']); } catch(err) {} } var _gaq = _gaq || []; _gaq.push(['_setAccount', 'UA-7903479-1']); _gaq.push(['_setDomainName', '.cnx.org']); _gaq.push(['_trackPageview']); _gaq.push(['hewlett._setAccount', 'UA-5033010-1']); _gaq.push(['hewlett._setDomainName', '.cnx.org']); _gaq.push(['hewlett._trackPageview']);