COMP10001 Foundations of Computing Testing and Debugging

Transcription

1 COMP10001 Foundations of Computing Testing and Debugging Semester 1, 2017 Tim Baldwin & Egemen Tanin version: 1103, date: March 30, The University of Melbourne

2 Reminders Grok Worksheets 8 11 due at the end of this week Advanced/revision lecture tomorrow; revision lecture to be held in: Herbert Wilson Theatre, Doug McDonell (9 10) Latham Theatre, Redmond Barry (3:15 4:15) Project 1 due on Friday of next week

3 Lecture Agenda Last lecture: PEP8 Modules File access This lecture: Python tips/tricks Testing and debugging Commenting

4 Lecture Outline 1 How Far have We Come? 2 Python Tips/Tricks 3 Software Bugs and Debugging 4 Testing

5 Remember This? Source(s):

6 Lecture Outline 1 How Far have We Come? 2 Python Tips/Tricks 3 Software Bugs and Debugging 4 Testing

7 defaultdict I When using dictionaries as accumulators you need to initialise every value for new keys... def count_digits ( num ): ''' Count the digits in number num. ''' digit_count = {} for digit in str ( num ): if digit in digit_count : digit_count [ digit ] += 1 else : digit_count [ digit ] = 1 return digit_count

8 defaultdict II Alternatively, simplify your life with defaultdict: from collections import defaultdict def count_digits ( num ): ''' Count the digits in a number ''' digit_count = defaultdict ( int ) for digit in str ( num ): digit_count [ digit ] += 1 return digit_count

9 Python Tips: List Comprehensions We are often constructing lists in Python using for loops, e.g.: mylist = [] for key, val in mydict. items (): mylist. append (val, key ) A list comprehension allows us to do this in a single line: [ val, key for key, val in mydict. items ()] It also allows us to filter elements in a list: [i for i in range ( -9,10,2) if not (i %3)]

10 Python Tips: Assignment We often apply some operation to a variable and assign the result back to that variable: i = i - 1 j = j * 2 mystr = mystr + letter There is a family of convenient shorthands for this, one for each binary operator: i -= 1 j *= 2 mystr += letter

11 Lecture Outline 1 How Far have We Come? 2 Python Tips/Tricks 3 Software Bugs and Debugging 4 Testing

12 Bugs A (software) bug is an error/flaw in a piece of code that leads to a malfunction The first attested computer bug (Grace Cooper, Harvard Mark II): So what s the big deal?

13 A Bug in Action: Mars Climate Orbiter Ideal: establish an orbit around Mars, and study the weather, climate, etc of Mars in tandem with the Mars Polar Lander Actuality: attempted to orbit too low and crashed as a result Cause: metric vs. Imperial conversion in calculations Cost: US$165m

14 Other Famous Bugs Y2K HAL 9000 (2001: A Space Odyssey) Estimate that software bugs cost the US economy 0.6% of the GDP Over 50% of the development cost of software is on testing and debugging No general way of proving that a given piece of software implements a given spec

15 Debugging Bugs are inevitable: Fact: even the most carefully-engineered software will include at least 5 errors/1000 lines of code Fact: Windows 10 contained 50 60M lines of code... Bug/error types: syntax errors = incompatibility with the syntax of the programming language run-time errors = errors at run-time, causing the code to crash logic errors = design error, such that the code runs but doesn t do what it is supposed to do Debugging = the process of systematically finding and fixing bugs

16 Class Exercise: Spot and Fix the Bugs Spot and fix the bug(s) in the following code, and classify each as a syntax, run-time or logic error: 1 def substrn (sup, sub ) 2 sub_len = len ( Sub ) 3 for i in range ( len ( sup ) - sub_len ): 4 if sup [i:i + sub_len ] == sub : 5 n += 1 6 print ("n")

17 Comments Job much easier if there was a description of what the function should do. 1 def substrn (sup, sub ) 2 ''' 3 Return the number of times `sub ` 4 occurs in `sup ` 5 ''' 6 sub_len = len ( Sub ) 7 for i in range ( len ( sup )- sub_len ): 8 if sup [i:i+ sub_len ] == sub : 9 n += 1 10 print ("n")

18 Functions and Docstring-style Commenting I A docstring is a string literal that occurs as the first statement in a module, function, class, or method definition. Such a docstring becomes the doc special attribute of that object. def Celcius2Fahrenheit ( n): """ Return the ( float ) Fahrenheit equivalent of a temperature in Celcius """ return 9.0* n/5 + 32

19 Functions and Docstring-style Commenting II It is possible to access the doc for a function via help, e.g. given: def seconds_in_year ( days =365): """ Calculate seconds in a year """ return days *24*60*60 >>> help ( seconds_in_year ) Help on function seconds_in_year in module seconds_in_year ( days =365) Calculate seconds in a year

20 Wrong: Comments def f(x): ''' This is a function of parameter x that calculates the length of x squared. ''' return len (x )**2 Don t describe Python syntax; the reader knows Python: Right: def len_sqr (x): ''' Return the square of the length of x. '' return len (x )**2

21 Wrong: Comments c = 0 # a variable to count for i in word : # a loop if i in ' aeiou ': # is i in aeiou c += 1 # add one to count Succint description of logic for a block in English. Meaningful variable names help readability. Right: # set ` count ` to no. of vowels in ` word ` count = 0 for character in word : if character in ' aeiou ': count += 1

22 Comments # set ` count ` to no. of vowels in ` word ` count = 0 for character in word : if character in ' aeiou ': count += 1 Use functions. def count_vowels ( word ): ''' return the no. of vowels in `word ` ''' count = 0 for character in word : if character in ' aeiou ': count += 1 return count

23 Prevention Rather than Cure: Defensive Programming Build up your code bit by bit, using functions copiously, testing as you go against known inputs/outputs Log each step of your progress Use comments to remind you about any assumptions made by the code/corners cut along the way Always be on the lookout for common gotchas Above all, remember that the program code must communicate with humans, not just machines

24 Common Python Gotchas Equality (==) vs. assignment (=) Printing vs. returning from functions Correct use of types (e.g. False vs. "False") Incorrect use of function/method (e.g. return list.sort()) Spelling and capitalisation Loops and incrementing Conditionals and indentation Namespace problems

25 A General Approach to Debugging Reproduce the bug Determine exactly what the problem is Eliminate obvious causes (e.g. Is it plugged in?) Divide the process, separating out the parts that work from the part(s) that don t ( isolate the problem) When you reach a dead end, reassess your information; then step through the process again As you proceed, make predictions about what should happen and verify the outcome

26 Lecture Outline 1 How Far have We Come? 2 Python Tips/Tricks 3 Software Bugs and Debugging 4 Testing

27 The Actuality of Software Testing Execution-based verification: generate and execute test cases, and check the correctness of the output generally impossible to enumerate all possible inputs/use cases, so instead focus on developing a set of representative inputs to test the code over in addition to integration testing (between system components), unit test the components of the system Non-execution-based verification detect bugs by eyeballing the code directly e.g., code review or pair programming

28 Test Cases Test cases should be designed independently of the software implementation, and (ideally) be designed to: test one thing each (e.g. one use case per input type) test over the spectrum of use cases for the software (often based on the boundaries of inputs) (in part) identify and test corner case inputs

29 Lecture Summary What is defaultdict and why is it useful? What are list comprehensions and why are they useful? What do += and *= mean? What are docstrings? What is a bug/debugging? Why do bugs occur? What different types of bugs are there? What is the basic procedure for identifying bugs?