CS410J: Advanced Java Programming Testing the Extreme Programming Extreme Objects

Transcription

1 CS410J: Advanced Java Programming Testing is one of the most, if not the most, important tasks of software engineering. When software is well-tested, it is easier to document, understand, and extend. JUnit provides a flexible and easy-to-use framework for developing unit tests for Java programs. Unit Testing Java Programs with JUnit Why test your code? Using JUnit Advanced assertions with Hamcrest Testing Everybody knows that they should test their code, but why don t they? There s not enough time! However, the less you test, the less confidence you have in your code How do you know it really works? Break the vicious cycle of untested code! Don t wait until you think your code is finished to write tests Write tests as you code Copyright c by David M. Whitlock. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and full citation on the first page. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or fee. Request permission to publish from whitlock@cs.pdx.edu. Last updated March 6, Every new piece of functionality should have a test ( unit test ) Run your tests every time you recompile 2 Extreme Programming Starting in the mid-1990s, Kent Beck and friends began evangelizing the concept of extreme programming Software needs to be developed quickly and needs to evolve even faster Software engineers should develop together: Pair Programming Testing code should be developed along with the code being tested It takes a village to write software: architect, programmer, manager, and customer Constant feedback from the customer ensures that the customer always gets what he wants The software must function, and function correctly, at all times, even if the functionality is limited Extreme Programming emphasizes simplicity and elegance in software engineering Get things working, then optimize Extreme Objects Extreme Programming works very well when developing Object-Oriented software Classes are extended to add functionality New tests are added for the new functionality The old tests for the old functionality still work Just like documenting as you code, testing as you code has many benefits You can feel confident that you code works You find bugs in your code before someone else does! You become a consumer of your own code (Is it easy to use?) If you run all of your tests every time you build, you know that your changes haven t broken anything 3 4

2 JUnit Kent Beck and Erich Gamma (of Design Patterns fame) developed a unit testing framework for Java programs called JUnit The junit.framework package contains a simple class hierarchy for developing unit tests: Assert Configuring tests with annotations JUnit was very successful, but some things in the framework were awkward Subclassing TestCase meant that your test couldn t subclass any other class test method naming convention made it difficult to locate test methods JUnit 4.0 introduced annotations in the org.junit package for marking test code asserttrue(boolean) assertequals(object, Object) fail(string) Test run(testresult) for test methods Can have an expected exception and a timeout in milliseconds TestCase TestCase(String testname) setup() teardown() * TestSuite TestSuite(Class testclass) addtest(test) addtestsuite(class for setup methods for tear down for class-level setup ad tear down methods Test code subclasses TestCase and test methods are public, return void, and have names that begin with test for methods that shouldn t be run Static import for Assert methods 6 Example Classes To demonstrate writing unit tests, we are going to develop some classes for modeling Students that are enrolled in a Section of a Course Course String department int number int credits * int term int year Section addstudent(student) dropstudent(student) double averagegrade() int getclasssize() * * Student String id Map grades Writing a simple TestCase The below class tests that adding a Student increases the enrollment by one import org.junit.test; import static org.junit.assert.assertequals; import static org.junit.assert.fail; public class SectionTest { public void testaddstudent() { Student student = new Student(" "); Course course = new Course("CS", 410, 4); Section section = new Section(course, Section.SPRING, 2001); section.addstudent(student); assertequals(1, section.getclasssize()); The assertequals method is imported from the Assert class. If its arguments are not equal, then the test fails. 7 8

3 Running The Test Case The org.junit.runner.junitcore class runs the tests in a test class and prints out the result to standard out import org.junit.runner.junitcore; import org.junit.runner.runwith; CourseTest.class) public class AllTests { public static void main(string[] args) { JUnitCore.runClasses(AllTests.class); This class defines a suite of tests that run together $ java edu.pdx.cs410j.junit.alltests Testing Error Conditions Making sure that your program fails in a well-understood fashion is very important To test that the dropstudent method throws an IllegalArgumentException when you attempt to drop a student that isn t enrolled: (expected = IllegalArgumentException.class) public void testdropstudentnotenrolled() { Student student = new Student(" "); Course course = new Course("CS", 410, 4); Section section = new Section(course, Section.SPRING, 2001); section.dropstudent(student); The fail method is statically imported from Assert and causes the test to fail If some other problem occurs while the test is running (e.g. an uncaught exception), the test fails with an error. Remember that examples.jar and junit.jar must be on the classpath 9 10 The Assert class The Assert contains methods for validating that certain conditions are true assertequals: Two entities (objects, ints, etc.) should be equal (compares objects using equals()) assertnotnull: A value should not be null assertsame: Two object references should be the same (compare objects using ==) asserttrue: A boolean expression should be true fail: The test should fail When an assertion evaluates to false, the test fails Your test class Test code is just a regular Java class with methods Methods annotated methods are invoked before and after the test is run Establish/disconnect network resources, etc. Each of your test methods must be annotated with The TestSuite class Annotating a class specifies a suite of multiple test classes You ll also need to annotate the class to tell the JUnit runner that it is a suite Each assert method is overloaded to have a String message associated with it assertequals("wrong number of students", 1, section.getclasssize()); 11 12

4 Test Classes and Packages Should test classes be in the same package as the code they are testing? Pros: Test code can access package-protected methods and fields Easy to associate test code with domain code Cons: Don t want to test code to interfere with domain code More readable assertions JUnit provides some basic methods for validating the state of your tests (assertions), but the code and the failure messages can be hard to read asserttrue(mystring.contains("hello")); When the above fails, all you get is an expected true, but got false error message The Hamcrest library provides powerful matchers that provide readable assertion statements with detailed and specific failure messages Don t want to ship test code When I write JUnit tests, I often have a separate directory hierarchy for the test code: ~/tests/edu/pdx/cs410j/ Hamcrest assertion statements Hamcrest provides an assertthat method that asserts that some value matches a matcher Each matcher has a static factory method Matchers are composed to form complex assertions The is matcher is syntactic sugar that aids readability import org.junit.test; import static org.hamcrest.matchers.*; import static org.hamcrest.matcherassert.assertthat; public class HamcrestMatchersTest { Examples of Hamcrest assertions public void isnullvalue() { assertthat(null, is(nullvalue())); public void issameinstance() { Object o = new Object(); assertthat(o, is(sameinstance(o))); public void strings() { String s = "Hamcrest is awesome"; assertthat(s, startswith("hamcrest")); assertthat(s, endswith("awesome")); assertthat(s, containsstring("is")); assertthat(s, is(not(isemptystring()))); assertthat(s, is(equaltoignoringcase("hamcrest IS public void isequalto() { Integer int1 = new Integer("123"); Integer int2 = new Integer("123"); assertthat(int1, is(equalto(int2))); 15 16

5 Examples of Hamcrest assertions Summary Testing is a good thing! public void everyitemisnotnull() { List<String> list = Arrays.asList("a", "b", "c"); assertthat(list, Improves the quality of your software everyitem(is(notnullvalue(string.class)))); public void numbers() { double pi = ; assertthat(pi, is(greaterthan(2.0))); assertthat(pi, is(both(greaterthan(1.0)). and(lessthan(4.0)))); assertthat(pi, is(closeto(3.14, 0.01))); public void arrays() { Integer[] array = { 1, 2, 3, 4, 5; assertthat(array, hasiteminarray(4)); assertthat(array, is(arraywithsize(5))); assertthat(array, is(not(emptyarray()))); assertthat(4, isin(array)); Demonstrates that your software works as specified Test as you code Write your tests first (Test-Driven Development) When you make changes, you can verify that you didn t break anything Spending time writing tests reducing debugging time JUnit makes it easy to write and run test cases Testing will help you get an A in this course! 17 18