1. Fundamentals of Python: From First Programs Through Data Structures Chapter 12 Tools for Design, Documentation, and Testing

2. Fundamentals of Python: From First Programs Through Data Structures2 Objectives After completing this chapter, you will be able to: Write scenarios and use cases for the analysis phase of a simple software system Design a simple software system in which the classes have the relationships of aggregation, composition, and inheritance Use UML diagrams to depict use cases, relationships among classes, and collaborations among objects in a simple software system

3. Fundamentals of Python: From First Programs Through Data Structures3 Objectives (continued) Write preconditions and postconditions for methods Raise exceptions in methods when preconditions are violated Generate Web-based documentation of classes Write simple unit tests for classes

4. Fundamentals of Python: From First Programs Through Data Structures4 Introduction A program must be well designed, thoroughly documented, and carefully tested –A good design is essential to solving any complex problem –Well-designed and well-written code is, to a certain extent, self-documenting –No matter how carefully you design and document a program, you need to test it with equal care Computer Assisted Software Engineering (CASE) tools include debuggers, version trackers, profilers, and test beds

5. Fundamentals of Python: From First Programs Through Data Structures5 Software Design with UML Programmers use various graphical notations to represent analysis and design decisions UML: Unified Modeling Language –Dominant graphical scheme currently used in object- oriented software development An excellent and free UML authoring tool is available at http://argouml.tigris.org/

6. Fundamentals of Python: From First Programs Through Data Structures6 UML and Modeling UML diagrams come in handy during the initial phases of software development –Help programmer visualize, or model, the interactions of human users with proposed system, relationships among its classes, and interactions among its objects UML includes diagrams for almost any occasion –For example: Class diagrams Use case diagrams Collaboration diagrams

7. Fundamentals of Python: From First Programs Through Data Structures7 Use Case Diagrams A use case is a narrative, in English, of the steps a user takes to perform a single action

8. Fundamentals of Python: From First Programs Through Data Structures8 Use Case Diagrams (continued) Use cases should include narratives of exceptional conditions and corresponding responses

9. Fundamentals of Python: From First Programs Through Data Structures9 Use Case Diagrams (continued) Use case diagrams in UML translate narratives of use cases into a pictorial representation

10. Fundamentals of Python: From First Programs Through Data Structures10 Use Case Diagrams (continued) Use cases and use case diagrams enable the programmer to accomplish several things: –Result in a precise statement of the functional requirements of the software system, in other words, the “what it does,” from the users’ perspective –Serve as the basis for writing user documentation, in the form of manuals and online help systems for the software –Allow the programmer to determine which classes need to be chosen or developed to realize the requirements of the system

11. Fundamentals of Python: From First Programs Through Data Structures11 Class Diagrams During the discovery of classes for a system, their relationships can be modeled with class diagrams –The simplest such diagrams show a relationship of association between two classes

12. Fundamentals of Python: From First Programs Through Data Structures12 Class Diagrams (continued) Associations do not tell us how classes are related –Programmer can also specify a role that a class plays in relation to another

13. Fundamentals of Python: From First Programs Through Data Structures13 Class Diagrams (continued)

14. Fundamentals of Python: From First Programs Through Data Structures14 Class Diagrams (continued)

15. Fundamentals of Python: From First Programs Through Data Structures15 Class Diagrams (continued) The arrows representing directed associations can be dropped in favor of using edges with markers that indicate aggregation or composition

16. Fundamentals of Python: From First Programs Through Data Structures16 Collaboration Diagrams The attributes and operations of a given class are often designed to fit into a sequence of operations that perform a particular task –The actors in these scenarios are software objects or instances of the system’s classes –A system function or task is broken down into a set of method calls on objects, and coordinating these becomes the focus of design The interactions among objects can be documented in a collaboration diagram

17. Fundamentals of Python: From First Programs Through Data Structures17 Collaboration Diagrams (continued)

18. Fundamentals of Python: From First Programs Through Data Structures18 From Collaboration Diagram to Code

19. Fundamentals of Python: From First Programs Through Data Structures19 From Collaboration Diagram to Code (continued)

20. Fundamentals of Python: From First Programs Through Data Structures20 Inheritance Subclassing helps eliminate redundant code in similar classes Inheritance relationship between classes is shown with an outlined arrowhead in a class diagram

21. Fundamentals of Python: From First Programs Through Data Structures21 Documentation In this section, we examine ways to make documentation more systematic and informative You will also learn about a tool, pydoc, which you can use to generate documentation that can be viewed with a Web browser

22. Fundamentals of Python: From First Programs Through Data Structures22 Writing APIs API: Application Programming Interface –Interfaces for a programming language’s built-in resources –Most interfaces also include documentation Browse the API for the current version of Python at Python’s Web site (http://docs.python.org/) Access information about an API from within a Python shell by using the help function

23. Fundamentals of Python: From First Programs Through Data Structures23 Writing APIs (continued) What information should an API include? –Module: its filename, a brief statement of its purpose, a summary of the resources that it includes –Class: name of class and superclass, a brief statement of its purpose Might also include a short list of the operations available to the client (the class’s interface) –Method: its header, a brief statement of what it does (not how it does it), the types of arguments it expects, and the type of value it returns –Function: same information included for a method

24. Fundamentals of Python: From First Programs Through Data Structures24 Revisiting the Student Class

25. Fundamentals of Python: From First Programs Through Data Structures25 Revisiting the Student Class (continued)

26. Fundamentals of Python: From First Programs Through Data Structures26 Revisiting the Student Class (continued) Most of the methods in the Student class are accessors –Accessors are generally the easiest to document, especially those that expect no arguments A simple statement about the type and meaning of the value returned by the method usually suffices setScore is the only mutator method getScore and setScore call for further attention –What happens if the reader misses the fact that the positions of the scores are counted from 1, not 0?

27. Fundamentals of Python: From First Programs Through Data Structures27 Preconditions and Postconditions Precondition: Statement of what must be true before a method is invoked if it is to run correctly –Usually describe the state of any parameters and instance variables that a method is about to access Example:

28. Fundamentals of Python: From First Programs Through Data Structures28 Preconditions and Postconditions (continued) Postcondition: Statement of what will be true after the method has finished execution –Describe the state of parameters and instance variables that the method has changed Example:

29. Fundamentals of Python: From First Programs Through Data Structures29 Enforcing Preconditions with Exceptions Preconditions in documentation do not prevent users from violating them –Avoid problems by guaranteeing that an exception will be raised if a precondition is violated Syntax for raising an exception: Must document that exceptions may be raised:

30. Fundamentals of Python: From First Programs Through Data Structures30 Enforcing Preconditions with Exceptions (continued) A programmer should try to raise a type of exception that is specifically related to the kind of condition being enforced

31. Fundamentals of Python: From First Programs Through Data Structures31 Web-Based Documentation with pydoc Programmer-authored documentation is always available in the Python shell: …

32. Fundamentals of Python: From First Programs Through Data Structures32 Web-Based Documentation with pydoc (continued) Documentation can be viewed in a Web browser –pydoc tool allows programmer to generate documentation from a module in form of a Web page To create this page: –Open a terminal window and navigate to the directory that contains your Python source file Example: student.py –At the terminal command prompt, run: pydoc –w student > student.html

33. Fundamentals of Python: From First Programs Through Data Structures33 Testing A great deal of time, effort, and money is spent trying to prevent software errors from ever happening In this section, we examine testing, the discipline that searches for program errors and builds confidence that software works correctly

34. Fundamentals of Python: From First Programs Through Data Structures34 What to Test There are several features of a program’s behavior that we might want to consider: –Is the program user friendly? –Is the program robust? –Is the program reliable? –Does the program provide acceptable performance? In this section we confine our attention to a more minimal sense of program correctness –A correct program produces the expected outputs when operating on inputs that fall within specified limits

35. Fundamentals of Python: From First Programs Through Data Structures35 Three Approaches to Choosing Test Data Haphazard: Bang on the program with a few inputs until it breaks, fix bugs, and call it correct –Not very effective Black-box: Partition inputs in clusters of equivalent data (if program works correctly on a set of values from a cluster, it works well for all values in cluster) –Also test for values on boundaries between clusters –Easy to overlook some clusters –Number of clusters can be so large that we cannot possibly consider them all

36. Fundamentals of Python: From First Programs Through Data Structures36 Three Approaches to Choosing Test Data (continued) White-box: Attempt to concoct test data that exercise all parts of our program –You examine the code closely and then formulate the test data, but the task can be difficult Code coverage Tip: Combine black-box testing with white-box testing

37. Fundamentals of Python: From First Programs Through Data Structures37 When to Test Four points during coding at which test data can be used: –Unit testing: Write code that instantiates an object of the desired type and then run a series of methods that subject it to a thorough workout –Integration testing: After classes have been tested in isolation, confirm that they work together properly –Acceptance testing: Test under conditions identical to those in which it will eventually be used –Regression testing: Keep test data for later use (e.g., to test modifications to program)

38. Fundamentals of Python: From First Programs Through Data Structures38 Proofs of Program Correctness Testing cannot actually demonstrate the program’s correctness We can prove that a program is correct in a strictly mathematical sense –Quite tedious –May lead to invalid proofs if not enough mathematical background Can we automate the process of determining program correctness? –It is impossible, not just difficult, to write a program that can solve the halting problem

39. Fundamentals of Python: From First Programs Through Data Structures39 Unit Testing in Python Kent Beck developed one of the first tools for the unit testing of classes (for Smalltalk) Beck and Erich Gamma wrote junit and pyunit A unit test consists of a set of test cases for a given class –Each test case is a method that runs tests on an individual method in the class –The tests take the form of assertions A test suite can be run whenever a change is made to the class under development

40. Fundamentals of Python: From First Programs Through Data Structures40 Unit Testing in Python (continued)

41. Fundamentals of Python: From First Programs Through Data Structures41 Unit Testing in Python (continued)

42. Fundamentals of Python: From First Programs Through Data Structures42 Unit Testing in Python (continued)

43. Fundamentals of Python: From First Programs Through Data Structures43 Unit Testing in Python (continued)

44. Fundamentals of Python: From First Programs Through Data Structures44 Unit Testing in Python (continued)

45. Fundamentals of Python: From First Programs Through Data Structures45 Unit Testing in Python (continued) The TestCase class includes a significant number of methods that you can use to make assertions about your code

46. Fundamentals of Python: From First Programs Through Data Structures46 Unit Testing in Python (continued) Although unit tests are ideal for testing individual classes, to a certain extent they can also be used during integration testing By developing and running a good unit test for each class, programmer can focus on writing code and leave the testing to an automated assistant Test-driven development encourages detection of errors early in the coding process and increases the likelihood of thorough white-box testing

47. Fundamentals of Python: From First Programs Through Data Structures47 Summary UML is the leading graphical notation for depicting the structure and behavior of OO software systems –A use case describes the steps performed during an single interaction of a user with a SW system –A class diagram shows the relationships among the classes of a software system –A collaboration diagram shows interactions among objects required to complete a task in a SW system Preconditions and postconditions form the subject of an agreement between the author of a method and its client

48. Fundamentals of Python: From First Programs Through Data Structures48 Summary (continued) You can enforce a precondition by raising an exception if that precondition is not satisfied Complete documentation of a method includes information about any preconditions, postconditions, and exceptions that it might raise Generate Web-based documentation for a Python resource by running the pydoc tool Black-box testing: Programmer selects test data that produce expected results for normal inputs and abnormal inputs

49. Fundamentals of Python: From First Programs Through Data Structures49 Summary (continued) White-box testing: Select test data that exercise all of the possible execution paths in a given resource Unit test: Subjects a class to a thorough workout – Pyunit provides a tool for automating unit tests Integration testing examines the behavior of cooperating classes that have been unit tested Acceptance testing subjects a software system to examination under realistic conditions Regression testing is performed when any part of a software system is repaired or extended