Testing Michael Ernst CSE 140 University of Washington.

Slides:



Advertisements
Similar presentations
Chapter 5 Errors Bjarne Stroustrup
Advertisements

11-Jun-14 The assert statement. 2 About the assert statement The purpose of the assert statement is to give you a way to catch program errors early The.
The If Then Else Statement Using JavaScript TIP The If Statement is the fundamental control structure that allows branches in the flow of control in a.
A MATLAB function is a special type of M-file that runs in its own independent workspace. It receives input data through an input argument list, and returns.
Week 5: Loops 1.  Repetition is the ability to do something over and over again  With repetition in the mix, we can solve practically any problem that.
Programming with Alice Computing Institute for K-12 Teachers Summer 2011 Workshop.
Debugging Introduction to Computing Science and Programming I.
Chapter 6: User-Defined Functions I
 2007 Pearson Education, Inc. All rights reserved Introduction to C Programming.
CS 201 Functions Debzani Deb.
Introduction to C Programming
Functions and abstraction Michael Ernst UW CSE 190p Summer 2012.
Introduction to Python and programming Michael Ernst UW CSE 190p Summer 2012.
CMSC 104, Version 8/061L18Functions1.ppt Functions, Part 1 of 4 Topics Using Predefined Functions Programmer-Defined Functions Using Input Parameters Function.
Python quick start guide
More on Functions CSE 1310 – Introduction to Computers and Programming Vassilis Athitsos University of Texas at Arlington 1.
Fruitful functions. Return values The built-in functions we have used, such as abs, pow, int, max, and range, have produced results. Calling each of these.
Chapter 6: User-Defined Functions I Instructor: Mohammad Mojaddam
Lists in Python.
Functions Part I (Syntax). What is a function? A function is a set of statements which is split off into a separate entity that can be used like a “new.
Testing CSE 140 University of Washington 1. Testing Programming to analyze data is powerful It’s useless if the results are not correct Correctness is.
Week 5 - Wednesday.  What did we talk about last time?  Exam 1!  And before that?  Review!  And before that?  if and switch statements.
Control Structures – Selection Chapter 4 2 Chapter Topics  Control Structures  Relational Operators  Logical (Boolean) Operators  Logical Expressions.
Errors And How to Handle Them. GIGO There is a saying in computer science: “Garbage in, garbage out.” Is this true, or is it just an excuse for bad programming?
CPS120 Introduction to Computer Science Iteration (Looping)
Which program is better? Why? (define (prime? n) (= n (smallest-divisor n))) (define (smallest-divisor n) (find-divisor n 2)) (define (find-divisor n d)
Oct 15, 2007Sprenkle - CS1111 Objectives Creating your own functions.
© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved. Chapter 2 Chapter 2 - Introduction to C Programming.
Exceptions and assertions CSE 331 University of Washington.
Software Engineering Chapter 3 CPSC Pascal Brent M. Dingle Texas A&M University.
Functions. Built-in functions You’ve used several functions already >>> len("ATGGTCA")‏ 7 >>> abs(-6)‏ 6 >>> float("3.1415")‏ >>>
CS101 Computer Programming I Chapter 4 Extra Examples.
Python uses boolean variables to evaluate conditions. The boolean values True and False are returned when an expression is compared or evaluated.
Functions CSE 1310 – Introduction to Computers and Programming Vassilis Athitsos University of Texas at Arlington 1.
CS161 Topic #16 1 Today in CS161 Lecture #16 Prepare for the Final Reviewing all Topics this term Variables If Statements Loops (do while, while, for)
1 CS161 Introduction to Computer Science Topic #9.
Introduction to Python Dr. José M. Reyes Álamo. 2 Three Rules of Programming Rule 1: Think before you program Rule 2: A program is a human-readable set.
Decisions in Python Boolean functions. A Boolean function This is a function which returns a bool result (True or False). The function can certainly work.
Debugging, Escape Command, More Math. It’s your birthday!  Write a program that asks the user for their name and their age.  Figure out what their birth.
Functions Math library functions Function definition Function invocation Argument passing Scope of an variable Programming 1 DCT 1033.
Testing CSE 160 University of Washington 1. Testing Programming to analyze data is powerful It’s useless (or worse!) if the results are not correct Correctness.
© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved. 1 Chapter 2 - Introduction to C Programming Outline.
TESTING FUNDAMENTALS BY K.KARTHIKEYAN.
Controlling Program Flow with Decision Structures.
Chapter 1 The Phases of Software Development. Software Development Phases ● Specification of the task ● Design of a solution ● Implementation of solution.
Functions in C++ Top Down Design with Functions. Top-down Design Big picture first broken down into smaller pieces.
Defensive Programming. Good programming practices that protect you from your own programming mistakes, as well as those of others – Assertions – Parameter.
Today’s Agenda ML Development Workflow –Emacs –Using use –The REPL More ML –Shadowing Variables –Debugging Tips –Boolean Operations –Comparison Operations.
1 Lecture 2 - Introduction to C Programming Outline 2.1Introduction 2.2A Simple C Program: Printing a Line of Text 2.3Another Simple C Program: Adding.
Gator Engineering Copyright © 2008 W. W. Norton & Company. All rights reserved. 1 Chapter 9 Functions.
CS 5010 Program Design Paradigms “Bootcamp” Lesson 2.4
Which program is better? Why?
CS170 – Week 1 Lecture 3: Foundation Ismail abumuhfouz.
Chapter 2 - Introduction to C Programming
Testing UW CSE 160 Winter 2017.
The order in which statements are executed is called the flow of control. Most of the time, a running program starts at the first programming statement,
Chapter 2 - Introduction to C Programming
CSS 161: Fundamentals of Computing
User-Defined Functions
Control Structures – Selection
Testing UW CSE 160 Spring 2018.
Cracking the Coding Interview
Higher-Order Procedures
Conditions and Ifs BIS1523 – Lecture 8.
Testing UW CSE 160 Winter 2016.
CSC 143 Error Handling Kinds of errors: invalid input vs programming bugs How to handle: Bugs: use assert to trap during testing Bad data: should never.
CS 1111 Introduction to Programming Fall 2018
Data Types Every variable has a given data type. The most common data types are: String - Text made up of numbers, letters and characters. Integer - Whole.
Functions Taken from notes by Dr. Neil Moore & Dr. Debby Keen
Presentation transcript:

Testing Michael Ernst CSE 140 University of Washington

Testing Programming to analyze data is powerful It’s useless if the results are not correct Correctness is far more important than speed

Testing = double-checking results How do you know your program is right? – Compare its output to a correct output How do you know a correct output? – Real data is big – You wrote a computer program because it is not convenient to compute it by hand Use small inputs so you can compute by hand Example: standard deviation – What are good tests for std_dev ?

Testing ≠ debugging Testing: determining whether your program is correct – Doesn’t say where or how your program is incorrect Debugging: locating the specific defect in your program, and fixing it 2 key ideas: – divide and conquer – the scientific method

What is a test? A test consists of: – an input (sometimes called “test data”) – an oracle (a predicate (boolean expression) of the output) Example test for sum: – input: [1, 2, 3] – oracle: result is 6 – write the test as: sum([1, 2, 3]) == 6 Example test for sqrt: – input: 3.14 – oracle: result is within of – ways to write the test: sqrt(3.14) – < sqrt(3.14) – < math.abs(sqrt(3.14) – 1.772) <

Test results The test passes if the boolean expression evaluates to True The test fails if the boolean expression evaluates to False Use the assert statement: assert sum([1, 2, 3]) == 6 assert math.abs(sqrt(3.14) – 1.772) < assert True does nothing assert False crashes the program – and prints a message

Where to write test cases At the top level: is run every time you load your program def hypotenuse(a, b): … assert hypotenuse(3, 4) == 5 assert hypotenuse(5, 12) == 13 In a test function: is run when you invoke the function def hypotenuse(a, b): … def test_hypotenuse(): assert hypotenuse(3, 4) == 5 assert hypotenuse(5, 12) == 13

Assertions are not just for test cases Use assertions throughout your code Documents what you think is true about your algorithm Lets you know immediately when something goes wrong – The longer between a code mistake and the programmer noticing, the harder it is to debug

Assertions make debugging easier Common, but unfortunate, course of events: – Code contains a mistake (incorrect assumption or algorithm) – Intermediate value (e.g., in local variable, or result of a function call) is incorrect – That value is used in other computations, or copied into other variables – Eventually, the user notices that the overall program produces a wrong result – Where is the mistake in the program? It could be anywhere. Suppose you had 10 assertions evenly distributed in your code – When one fails, you can localize the mistake to 1/10 of your code (the part between the last assertion that passes and the first one that fails)

Where to write assertions Function entry: are arguments legal? – Place blame on the caller before the function fails Function exit: is result correct? Places with tricky or interesting code Assertions are ordinary statements; e.g., can appear within a loop: for n in myNumbers: assert type(n) == int() or type(n) == float()

Where not to write assertions Don’t clutter the code – (Same rule as for comments) Don’t write assertions that are certain to succeed – The existence of an assertion tells a programmer that it might possibly fail Don’t write an assertion if the following code would fail informatively assert type(name) == str() … “Hello, ” + name … Write assertions where they may be useful for debugging

What to write assertions about Results of computations Correctly-formed data structures assert 0 <= index < len(mylist) assert len(list1) == len(list2)

When to write tests Two possibilities: – Write code first, then write tests – Write tests first, then write code It’s best to write tests first If you write the code first, you remember the implementation while writing the tests – You are likely to make the same mistakes in the implementation If you write the tests first, you will think more about the functionality than about a particular implementation – You might notice some aspect of behavior that you would have made a mistake about

Write the whole test A common mistake: 1.Write the function 2.Make up test inputs 3.Run the function 4.Use the result as the oracle You didn’t write a test, but only half of a test – Created the tests inputs, but not the oracle The test does not determine whether the function is correct – Only determines that it continues to be as correct (or incorrect) as it was before

Tests are for specified behavior def roots(a, b, c): """Returns a list of the two roots of ax**2 + bx + c."""... Bad test of implementation-specific behavior: assert roots(1, 0, 1) == [1, -1] Assertions inside a routine can be for implementation-specific behavior

Tests prevent you from introducing errors when you change a function Abstraction: the implementation details do not matter Preventing introducing errors when you make a change is called “regression testing”

Write tests that cover all the functionality Think about and test “corner cases” – Empty list – Zero – int vs. float values

Tests might not reveal an error def mean(numbers): """Returns the average of the argument list. The argument must be a non-empty list of numbers.""" return sum(numbers)/len(numbers) # Tests assert mean([1, 2, 3, 4, 5]) == 3 assert mean([1, 2.1, 3.2]) == 2.1 This implementation is elegant, but wrong! mean([1,2,3,4])

Don’t write meaningless tests def mean(numbers): """Returns the average of the argument list. The argument must be a non-empty list of numbers.""" return sum(numbers)/len(numbers) Unnecessary tests. Don’t write these: mean([1, 2, “hello”]) mean(“hello”) mean([])