Software Testing Chapter 8

Goal of Testing: To demonstrate that a program does what it is intended to do and to discover program defects before it is put into use.
Program Testing: Testing involves executing a program using artificial data and checking the results for errors, anomalies, or information about the program's non-functional attributes.

Demonstrate Correctness: To demonstrate to the developer and the customer that the software meets its requirements.
Discover Defects: To discover situations in which the behavior of the software is incorrect, undesirable, or does not conform to its specification.

Validation Testing: To demonstrate that the software meets its requirements, and a successful test shows that the system operates as intended.
Defect Testing: To discover defects, concerned with rooting out undesirable system behavior such as system crashes, unwanted interactions with other systems, incorrect computations, and data corruption.

Definition: Unit testing is the process of testing individual components in isolation.
Defect-Testing Process: It is a defect-testing process that tests individual functions, methods, object classes, and composite components.

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

Definition: TDD is an approach to program development in which you inter-leave testing and code development.
Tests Before Code: Tests are written before code, and 'passing' the tests is the critical driver of development.
Incremental Development: You develop code incrementally, along with a test for that increment, and you don't move on to the next increment until the code that you have developed passes its test.

Identify Increment: Identify the increment of functionality that is required.
Write Test: Write a test for this functionality and implement it as an automated test.
Run Test: Run the test, along with all other tests that have been implemented.
Implement Functionality: Implement the functionality and re-run the test.
Move On: Once all tests run successfully, you move on to implementing the next chunk of functionality.

Code Coverage: Every code segment that you write has at least one associated test.
Regression Testing: A regression test suite is developed incrementally as a program is developed.
Simplified Debugging: When a test fails, it should be obvious where the problem lies.
System Documentation: The tests themselves are a form of documentation that describes what the code should be doing.

Definition: Release testing is the process of testing a particular release of a system that is intended for use outside of the development team.
Primary Goal: The primary goal is to convince the supplier of the system that it is good enough for use.
Black-Box Testing: Release testing is usually a black-box testing process where tests are only derived from the system specification.

Release Testing: Release testing is a form of system testing.
Important Differences: A separate team should be responsible for release testing, and the objective of release testing is to check that the system meets its requirements and is good enough for external use.

Definition: User or customer testing is a stage in the testing process in which users or customers provide input and advice on system testing.
Essential: User testing is essential, even when comprehensive system and release testing have been carried out.
Influences: Influences from the user's working environment have a major effect on the reliability, performance, usability, and robustness of a system.

Alpha Testing: Users of the software work with the development team to test the software at the developer's site.
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.
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.

Integrated: In agile methods, the user/customer is part of the development team and is responsible for making decisions on the acceptability of the system.
Automatic Tests: Tests are defined by the user/customer and are integrated with other tests in that they are run automatically when changes are made.
No Separate Process: There is no separate acceptance testing process.

Testing Limitations: Testing can only show the presence of errors in a program, not their absence.
Development Testing: Development testing is the responsibility of the software development team.
Release Testing: A separate team should be responsible for testing a system before it is released to customers.
Testing Strategies: When testing software, you should try to 'break' the software by using experience and guidelines to choose types of test case that have been effective in discovering defects in other systems.