University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 1 Lecture 23: Course Summary Course Goals Summary of what we.

Slides:



Advertisements
Similar presentations
Object Oriented Analysis And Design-IT0207 iiI Semester
Advertisements

Test process essentials Riitta Viitamäki,
Lecture 8: Testing, Verification and Validation
EEE 243B Applied Computer Programming Software engineering Life cycle and when to test.
Software Engineering CSE470: Process 15 Software Engineering Phases Definition: What? Development: How? Maintenance: Managing change Umbrella Activities:
The software process A software process is a set of activities and associated results which lead to the production of a software product. This may involve.
Software Modeling SWE5441 Lecture 3 Eng. Mohammed Timraz
1 Software Engineering Lecture 11 Software Testing.
Integration testing Satish Mishra
Chapter 15 Design, Coding, and Testing. Copyright © 2005 Pearson Addison-Wesley. All rights reserved Design Document The next step in the Software.
Illinois Institute of Technology
1 Testing. 2 About Testing  The reason the program is in testing is that it probably doesn’t work!  We test to find bugs before our users and hope that.
1 CMSC 132: Object-Oriented Programming II Nelson Padua-Perez William Pugh Department of Computer Science University of Maryland, College Park.
1 CMSC 132: Object-Oriented Programming II Software Development III Department of Computer Science University of Maryland, College Park.
Outline Types of errors Component Testing Testing Strategy
CSC230 Software Design (Engineering)
University of Toronto Department of Computer Science CSC444 Lec04- 1 Lecture 4: Software Lifecycles The Software Process Waterfall model Rapid Prototyping.
University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec22 1 Lecture 22: Software Measurement Basics of software measurement.
By the end of this session you should be able to...
ECE 355: Software Engineering
Software Quality Assurance Lecture #8 By: Faraz Ahmed.
1 Shawlands Academy Higher Computing Software Development Unit.
SOFTWARE TESTING STRATEGIES CIS518001VA : ADVANCED SOFTWARE ENGINEERING TERM PAPER.
Dillon: CSE470: SE, Process1 Software Engineering Phases l Definition: What? l Development: How? l Maintenance: Managing change l Umbrella Activities:
Chapter 8: Systems analysis and design
University of Toronto Department of Computer Science CSC444 Lec08 1 Lecture 8: Testing Verification and Validation testing vs. static analysis Testing.
INT-Evry (Masters IT– Soft Eng)IntegrationTesting.1 (OO) Integration Testing What: Integration testing is a phase of software testing in which.
1 University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444F Software Engineering I Prof. Paulo Pacheco
Testing Basics of Testing Presented by: Vijay.C.G – Glister Tech.
Testing E001 Access to Computing: Programming. 2 Introduction This presentation is designed to show you the importance of testing, and how it is used.
1 The Software Development Process  Systems analysis  Systems design  Implementation  Testing  Documentation  Evaluation  Maintenance.
Object-Oriented Software Engineering Practical Software Development using UML and Java Chapter 1: Software and Software Engineering.
1 CS 501 Spring 2002 CS 501: Software Engineering Lecture 23 Reliability III.
Testing. 2 Overview Testing and debugging are important activities in software development. Techniques and tools are introduced. Material borrowed here.
Intermediate 2 Software Development Process. Software You should already know that any computer system is made up of hardware and software. The term hardware.
Historical Aspects Origin of software engineering –NATO study group coined the term in 1967 Software crisis –Low quality, schedule delay, and cost overrun.
1 Design and Integration: Part 2. 2 Plus Delta Feedback Reading and lecture repeat Ambiguous questions on quizzes Attendance quizzes Boring white lecture.
Software Engineering - Abdul Majeed. What is software? Definition of Software Engineering Software Process Generic view of Software Engineering Software.
The Software Development Process
Chapter 8 Lecture 1 Software Testing. Program testing Testing is intended to show that a program does what it is intended to do and to discover program.
CSC 480 Software Engineering Test Planning. Test Cases and Test Plans A test case is an explicit set of instructions designed to detect a particular class.
Software Engineering Issues Software Engineering Concepts System Specifications Procedural Design Object-Oriented Design System Testing.
1 Software Testing Strategies: Approaches, Issues, Testing Tools.
CS451 Software Implementation and Integration Yugi Lee STB #555 (816) Note: This lecture was designed.
Chapter 1 Software Engineering Principles. Problem analysis Requirements elicitation Software specification High- and low-level design Implementation.
1 The Software Development Process ► Systems analysis ► Systems design ► Implementation ► Testing ► Documentation ► Evaluation ► Maintenance.
HNDIT23082 Lecture 09:Software Testing. Validations and Verification Validation and verification ( V & V ) is the name given to the checking and analysis.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 23 Slide 1 Software testing.
Testing Overview Software Reliability Techniques Testing Concepts CEN 4010 Class 24 – 11/17.
Lecturer: Eng. Mohamed Adam Isak PH.D Researcher in CS M.Sc. and B.Sc. of Information Technology Engineering, Lecturer in University of Somalia and Mogadishu.
Testing and Evolution CSCI 201L Jeffrey Miller, Ph.D. HTTP :// WWW - SCF. USC. EDU /~ CSCI 201 USC CSCI 201L.
Copyright 2015, Robert W. Hasker. Classic Model Gathering Requirements Specification Scenarios Sequences Design Architecture Class, state models Implementation.
Software Design and Development Development Methodoligies Computing Science.
Software Testing. Software Quality Assurance Overarching term Time consuming (40% to 90% of dev effort) Includes –Verification: Building the product right,
Advanced Higher Computing Science
Software Testing Strategies for building test group
PREPARED BY G.VIJAYA KUMAR ASST.PROFESSOR
Software Testing Basics
CSE 403 Software Engineering
Applied Software Implementation & Testing
Lecture 09:Software Testing
Verification and Validation Unit Testing
Practical Software Engineering
CSE 303 Concepts and Tools for Software Development
Test Case Test case Describes an input Description and an expected output Description. Test case ID Section 1: Before execution Section 2: After execution.
CS310 Software Engineering Lecturer Dr.Doaa Sami
Chapter 11: Integration- and System Testing
CSE 1020:Software Development
Overview Activities from additional UP disciplines are needed to bring a system into being Implementation Testing Deployment Configuration and change management.
Software Testing Strategies
Presentation transcript:

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 1 Lecture 23: Course Summary Course Goals Summary of what we covered Feedback questions for you Sample Exam Question

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 2 Course Rationale The goals for this course were: introduce the main ideas of software engineering offer practical experience of developing large software systems especially evaluating and modifying software developed by others raise awareness of the need for a disciplined approach build on your existing experience with programming Approach Typical Software Engineering courses generally: introduce the issues of software engineering at a high (theoretical) level follow a waterfall lifecycle through the main phases introduce one analysis and design method in detail with a team project Problems with these courses students do not get sufficient experience of the difficulties of large scale software development and maintenance students learn how to use the techniques, but don’t gain an appreciation of why they are useful Hence, the trading game…

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 3 Course Outline Introductory stuff Case Studies Software Lifecycles Project Management, Risk Management Program Design Decomposition and Abstraction Procedural Abstraction Data Abstraction Software qualities; modularity Design Representations Verification & Validation Testing Reviews & Fagan Inspections Formal verification Debugging and exception handling Software in the large Requirements Engineering Structured Analysis Object Oriented Analysis Formal Analysis Specifications Software Architectures Software Maintenance evolution reengineering reuse Software Process Modeling process improvement capability maturity Software Measurement

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 4 Conclusions Key lessons software development is far more than just writing programs communication is more important than coding testing and inspection are vital for quality assurance software engineers need to reflect upon their own development processes and seek to improve them continuously Key skills judging software quality reading/modifying other people’s code working with vague or incomplete specifications working to tight (impossible!) deadlines working with changing requirements/constraints communicating about technical work negotiating contracts to buy (and sell) software working in teams learning from mistakes (and learning to reflect on your experiences) deciding how much and what types of documentation are helpful deciding what is important (because perfect software is impossible)

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 5 Feedback Questions Did the course meet your expectations? How useful do you think the course was to you? What do you feel you have learned? What did you not learn, that you had hoped to? What was the best part of the course? What was the worst part of the course? How might the course be improved in the future?

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 6 Sample Exam Question a) Why is random testing insufficient even for relatively small programs? [2 marks] b) Unit testing is the process of testing a single program unit (e.g. a procedure) in isolation from the rest of the program. How would you go about choosing test cases for unit testing?[4 marks] c) Integration testing can be tackled top-down or bottom-up. Describe each of these strategies. Why is integration testing harder than unit testing? [4 marks] d) Explain the purpose of each of the following. What types of error is each likely to find? i)Endurance testing ii) Recoverability testing iii) Regression testing [6 marks] e) The company you work for develops internet applications. To reduce time to market, the company is considering dispensing altogether with integration testing. Instead, the company plans to rely on Beta testing, in which free trial versions of new software will be sent to existing, trusted customers to try out, with the agreement that they will report any problems they encounter. What are the advantages and disadvantages of this approach? [4 marks] 1

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 7 How we grade it... a) Why is random testing insufficient even for relatively small programs?[2 marks] 2 marks for a detailed explanation, 1 mark for a partial answer. Several possible reasons: Each decision point in the code represents a branch. As the number of decision points grows, the number of possible paths through the code grows exponentially. Random choices of test data is unlikely to cover all paths. Most of the interesting errors in software occur for particular data points, e.g. on the boundaries between different input ranges. Choosing test data randomly is unlikely to hit the boundary conditions. To properly test software, you need to define its operational profile (i.e. how frequently it is likely to see each type of input/behaviour). Random selection of test cases is unlikely to match the operational profile. b) Unit testing is the process of testing a single program unit (e.g. a procedure) in isolation from the rest of the program. How would you go about choosing test cases for unit testing?[4 marks] 4 marks for four different ways of choosing test cases OR two different ways of choosing test cases together with a good explanation of why each approach is good. Can give one mark for talking about the difference between black and white box testing, but needs more specific ways of choosing test cases to get more marks: Boundary conditions Normal behaviours Off-nominal cases (inputs that the program is not supposed to be able to handle) Parameters in the wrong order Different ‘paths’ through the specification Test each branch Test each conditional statement

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 8 How we grade it... c) Integration testing can be tackled top-down or bottom-up. Describe each of these strategies. Why is integration testing harder than unit testing?[4 marks] 1 mark for describing each strategy. 1 extra mark for making the difference clear, or for describing advantages of each. 1 mark for saying why integration testing is harder. Top-down: test the top level (‘main’) procedure first, with stubs for each procedure it calls. Stubs should check whether parameters passed downs are okay, and return some test data. Then integrate the next level of procedures and test again, repeat until you’ve integrated the bottom level procedures Bottom-up: first test those procedures that don’t call any others. Then integrate & test the procedures that call the ones you’ve tested, repeat until you reach the top level (main) procedure. Integration testing is harder because it is impossible to ensure every path through the integrated system is tested, it’s much harder to track down errors, and interface errors that show up in integration testing tend to be more subtle.

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 9 How we grade it... d) Explain the purpose of each of the following. What types of error is each likely to find? i) Endurance testing ii) Recoverability testing iii) Regression testing[6 marks] 1 mark for explaining each of three types, 1 mark for describing the types of error each will find. Endurance testing means leaving the system running for long periods of time. It will catch errors that show up only after a long run, e.g. memory leaks. Recoverability testing tests how well the software can recover from bad data, from hardware failure, from failure of systems it interacts with, from failure of components within the software. Type of error found are where data (e.g. file system) gets corrupted and cannot be recovered, program can’t be re-started after a crash, etc. Regression testing means running all the tests again (even those that already passed) each time the software is modified. This catches errors that are introduced as the result of fixing other errors.

University of Toronto Department of Computer Science © 2001, Steve Easterbrook CSC444 Lec23 10 How we grade it... e) The company you work for develops internet applications. To reduce time to market, the company is considering dispensing altogether with integration testing. Instead, the company plans to rely on Beta testing, in which free trial versions of new software will be sent to existing, trusted customers to try out, with the agreement that they will report any problems they encounter. What are the advantages and disadvantages of this approach?[4 marks] 2 marks for good advantages. E.g: Cheaper May be able to get the software to market quicker Generates early interest in the software, lets users know its on the way. Real users are more likely to try out typical patterns of usage Real users are more likely to try doing dumb things to the software Real users will try out the software on all sorts of weird hardware configurations 2 marks for good disadvantages. E.g: Cannot control the testing Cannot guarantee anything about how thoroughly the software was tested Competitors may get hold of your software quicker Cannot guarantee the beta testers will report all errors they find Beta testers will report all sorts of things that are not errors