1. Software Engineering 1 Object-oriented Analysis and Design Chap 21 Test-Driven Development and Refactoring

2. Software Engineering 2 Object-oriented Analysis and Design Test-Driven Development 1  The test is written first, imagining the code to be tested is written.  Advantages include m The unit tests actually get written m Programmer satisfaction leading to more consistent test  The psychological aspects of development can't be ignored programming is a human endeavor. m Clarification of detailed interface and behavior  That reflection improves or clarifies the detailed design. m Provable, repeatable, automated verification m The confidence to change things  When a developer needs to change existing code written by themselves, there is a unit test suite that can be run, providing immediate feedback if the change caused an error.

3. Software Engineering 3 Object-oriented Analysis and Design Test-Driven Development 2  The popular unit testing framework is the xUnit family m For Java, the popular version is JUnit. NUnit for.NET m JUnit is integrated into most of the Java IDEs, such as Eclipse.  Example fo Sale class, write a unit testing method in a SaleTest class m Create a Salethe thing to be tested (also known as the fixture). m Add some line items to it with the makeLineItem method (the makeLineItem method is the public method we wish to test). m Ask for the total, and verify that it is the expected value, using the assertTrue method. JUnit will indicate a failure if any assertTrue statement does not evaluate to true.  Each testing method follows this pattern: m Create the fixture. m Do something to it (some operation that you want to test). m Evaluate that the results are as expected.

4. Software Engineering 4 Object-oriented Analysis and Design Test-Driven Development 3  To use JUnit, to create a test class that extends the JUnit TestCase class; the test class inherits various unit testing behaviors. m create a separate testing method for each Sale method. m write unit testing methods for each public method of the Sale class.  To test method doFoo, it is an idiom to name the testing method testDoFoo. public class SaleTest extends TestCase { // … // test the Sale.makeLineItem method public void testMakeLineItem() { // STEP 1: CREATE THE FIXTURE // -this is the object to test // -it is an idiom to name it 'fixture' // -it is often defined as an instance field rather than // a local variable Sale fixture = new Sale(); // set up supporting objects for the test Money total = new Money( 7.5 ); Money price = new Money( 2.5 );

5. Software Engineering 5 Object-oriented Analysis and Design Test-Driven Development 4 ItemID id = new ItemID( 1 ); ProductDescription desc = new ProductDescription( id, price, "product 1" ); // STEP 2: EXECUTE THE METHOD TO TEST // NOTE: We write this code **imagining** there // is a makeLineItem method. This act of imagination // as we write the test tends to improve or clarify // our understanding of the detailed interface to // to the object. Thus TDD has the side-benefit of // clarifying the detailed object design. // test makeLineItem sale.makeLineItem( desc, 1 ); sale.makeLineItem( desc, 2 ); // STEP 3: EVALUATE THE RESULTS // there could be many assertTrue statements // for a complex evaluation // verify the total is 7.5 assertTrue( sale.getTotal().equals( total )); }

6. Software Engineering 6 Object-oriented Analysis and Design Refactoring 1  Refactoring m is a structured, disciplined method to rewrite or restructure existing code without changing its external behavior, applying small transformation steps combined with re- executing tests each step.  The essence of refactoring m applying small behavior preserving transformations (each called a 'refactoring'), one at a time. m After each transformation, the unit tests are re-executed to prove that the refactoring did not cause a regression (failure).

7. Software Engineering 7 Object-oriented Analysis and Design Refactoring 2  The activities and goals refactoring m remove duplicate code m improve clarity m make long methods shorter m remove the use of hard-coded literal constants  Some code smells include m duplicated code m big method m class with many instance variables m class with lots of code m strikingly similar subclasses m little or no use of interfaces in the design m high coupling between many objects

8. Software Engineering 8 Object-oriented Analysis and Design In Java, for example, replace using the new operator and constructor call with invoking a helper method that creates the object (hiding the details). Replace Constructor Call with Factory Method Put the result of the expression, or parts of the expression, in a temporary variable with a name that explains the purpose. Introduce Explaining Variable (specialization of Extract Local Variable) Replace a literal constant with a constant variable.Extract Constant Transform a long method into a shorter one by factoring out a portion into a private helper method. Extract Method DescriptionRefactoring Refactoring 3  Refactorings example

9. Software Engineering 9 Object-oriented Analysis and Design Refactoring 4  Before introducing an explaining variable. // good method name, but the logic of the body is not clear boolean isLeapYear( int year ) { return( ( ( year % 400 ) == 0 ) || ( ( ( year % 4 ) == 0 ) && ( ( year % 100 ) != 0 ) ) ); }  After introducing an explaining variable. // that's better! boolean isLeapYear( int year ) { boolean isFourthYear = ( ( year % 4 ) == 0 ); boolean isHundrethYear = ( ( year % 100 ) == 0); boolean is4HundrethYear = ( ( year % 400 ) == 0); return(is4HundrethYear||(isFourthYear&& !isHundrethYear)); }  IDE Support for Refactoring: Eclipse IDE