Chapter 8_Software Testing

Requirements-based testing

involves examining each requirement and developing a test or tests for it.

Performance test

usually involve planning a series of tests where the load is steadily increased until the system performance becomes unacceptable.

Interface misunderstanding

A calling component embeds assumptions about the behaviour of the called component which are incorrect.

Beta testing

A release of the software is made available to users to allow them to experiment and to raise problems that they discover with the system developers.

Alpha testing

Users of the software work with the development team to test the software at the developer's site.

Verification VS Validation

Verification -"Are we building the product right" -The software should conform to its specification Validation -"Are we building the right product" -The software should do what the user really requires

Partition testing

testing where you identify groups of inputs that have common characteristics and should be processed in the same way

Unit testing

where individual program units or object classes are tested; focuses on testing the functionality of objects or methods

System testing

where some or all of the components in a system are integrated and the system is tested as a whole; focuses on testing component interactions

Guideline-based testing

testing where you use testing guidelines to choose test cases

General testing guidelines

-Choose inputs that force the system to generate all error messages -Design inputs that cause input buffers to overflow -Repeat the same input or series of inputs numerous times -Force invalid outputs to be generated -Force computation results to be too large or too small.

Benefits of test-driven development

-Code coverage : Every code segment that you write has at least one associated test so all code written has at least one test. -Regression testing: developed incrementally as a program is developed; testing the system to check that changes have not 'broken' previously working code. -Simplified debugging: it should be obvious where the problem lies. The newly written code needs to be checked and modified. -System documentation: The tests themselves are a form of documentation that describe what the code should be doing.

System test vs release test

-System testing by the development team should focus on discovering bugs in the system (defect testing) -Release testing is to check that the system meets its requirements and is good enough for external use (validation testing).

Test-driven development (TDD)

-an approach to program development in which you inter-leave testing and code development. -Tests are written before code and 'passing' the tests is the critical driver of development. -TDD was introduced as part of agile methods such as Extreme Programming. However, it can also be used in plan-driven development processes.

Release testing

-where a separate testing team test a complete version of the system before it is released to users. -primary goal of this testing is to convince the supplier of the system that it is good enough for use.

Component testing

-where several individual units are integrated to create composite components; focuses on testing component interfaces

Development testing

-where the system is tested during development to discover bugs and defects -includes all testing activities that are carried out by the team developing the system such as Unit testing, Component testing, and system testing

User testing

-where users or potential users of a system test the system in their own environment. -users or customers provide input and advice on system testing

Interface misuse

A calling component calls another component and makes an error in its use of its interface e.g. parameters in the wrong order.

Acceptance testing

Customers test a system to decide whether or not it is ready to be accepted from the system developers and deployed in the customer environment. Primarily for custom systems.

Stages in the acceptance testing process

Define acceptance criteria Plan acceptance testing Derive acceptance tests Run acceptance tests Negotiate test results Reject/accept system

Stages of testing

Development testing, Release testing, user testing

Timing errors

The called and the calling component operate at different speeds and out-of-date information is accessed.