---
title: "Testing principles and testability"
subject: "Software Engineering"
chapter: 8
key: "semester_5/software_engineering:testing-principles"
source: https://www.bctengineer.com/q/semester_5/software_engineering/testing-principles
site: BCT Engineering
---

# Testing principles and testability

Software Engineering · Chapter 8: Software Testing and cost Estimation

- Asked in: year not given, 10 marks
- Video: [Seven Testing Principles: Software Testing](https://www.youtube.com/watch?v=rFaWOw8bIMM) — Guru99
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_5/software_engineering/testing-principles
- Whole chapter: https://www.bctengineer.com/md/semester_5/software_engineering/chapter-8

## Question

What are basic principles of testing? List characteristics of testability. List errors of black box testing.

## Short answer

Basic testing principles: trace tests to customer requirements, plan tests early, follow Pareto principle (80% defects in 20% components), test incrementally from small to large, exhaustive testing impossible, use independent testers. Testability characteristics: operability, observability, controllability, decomposability, simplicity, stability, understandability. Black-box errors: incorrect or missing functions, interface errors, data structure/database errors, behaviour/performance errors, initialization and termination errors.

## Answer

#### Basic principles of testing

Testing is the process of executing a program with the intent of finding errors. A good test has a high chance of finding an error not yet discovered. The basic principles (Pressman, based on Davis) are:

1. **All tests should be traceable to customer requirements.** The most severe defects are those that make the program fail to meet its requirements.
2. **Tests should be planned long before testing begins.** Test planning can start when the requirements model is complete, and detailed test cases when the design is ready.
3. **The Pareto principle applies.** About 80% of the errors are likely to be found in about 20% of the components; the task is to isolate and test those components thoroughly.
4. **Testing should begin "in the small" and progress toward "in the large".** First test individual components, then clusters of integrated components, then the whole system.
5. **Exhaustive testing is not possible.** Even a small program has too many path combinations, so tests must be selected to cover logic and conditions adequately.
6. **Testing is most effective when done by an independent third party.** The developer tends to test to show the program works, not to break it.

Other widely used principles:
- **Testing shows the presence of defects, not their absence.**
- **Early testing** saves cost, because defects found early are cheaper to fix.
- **Pesticide paradox:** running the same tests again and again stops finding new defects, so tests must be reviewed and updated.
- **Testing is context dependent:** a safety-critical system needs different testing from a web game.

#### Characteristics of testability

**Testability** is how easily a program can be tested. Pressman (after Bach) lists these characteristics:

| Characteristic | Meaning |
|---|---|
| Operability | "The better it works, the more efficiently it can be tested." Few bugs block the tests. |
| Observability | "What you see is what you test." Inputs, outputs, states and errors are visible. |
| Controllability | "The better we can control it, the more testing can be automated." All outputs can be produced by some input combination. |
| Decomposability | Software is built from independent modules that can be tested separately. |
| Simplicity | "The less there is to test, the more quickly we can test it." Simple functions, structure and code. |
| Stability | "The fewer the changes, the fewer the disruptions to testing." Changes are rare and controlled. |
| Understandability | "The more information we have, the smarter we will test." Design and documentation are clear and up to date. |

#### Errors found by black-box testing

Black-box (behavioural) testing tries to find errors in the following categories:

1. Incorrect or missing functions
2. Interface errors
3. Errors in data structures or external database access
4. Behaviour or performance errors
5. Initialisation and termination errors

For example, black-box testing of a library system may show that the "renew book" function is missing (category 1), that the system takes 20 seconds to search (category 4), or that the fine is not reset when a new day starts (category 5).

Black-box testing is less able to find errors in parts of the code that are never reached by specification-based inputs, such as dead code or wrong internal paths; those are found by white-box testing.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. According to the Pareto principle applied to testing, where are most errors found?
   A. Evenly across all components
   B. About 80% of errors in about 20% of components
   C. About 20% of errors in 80% of components
   D. Only in the user interface
   Answer: B. A small fraction of components holds most errors, so those should be isolated and tested thoroughly. (Key point: Pareto principle in testing)

2. Which describes the principle 'testing begins in the small and progresses toward the large'?
   A. Test the whole system first, then the units
   B. Test only small programs
   C. Test components first, then clusters of components, then the whole system
   D. Test only the most complex module
   Answer: C. Testing starts with individual components and moves to integrated clusters and finally the complete system. (Key point: Testing in the small to large)

3. Which testability characteristic means 'what you see is what you test'?
   A. Controllability
   B. Observability
   C. Simplicity
   D. Stability
   Answer: B. Observability means inputs, outputs, states and errors are visible so results can be checked. (Key point: Testability characteristics)

4. Which is NOT one of the error categories black-box testing looks for?
   A. Incorrect or missing functions
   B. Interface errors
   C. Initialisation and termination errors
   D. Wrong internal paths and dead code
   Answer: D. Dead code and wrong internal paths are found by white-box testing; black-box finds missing functions, interface, data, behaviour/performance and initialisation/termination errors. (Key point: Black-box error categories)

## Related in Software Engineering

- [Black-box testing](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Ablack-box-testing) — Software Engineering, chapter 8
- [Black-box versus white-box testing](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Ablack-box-vs-white-box) — Software Engineering, chapter 8

## Related in other subjects

- [White box and black box testing](https://www.bctengineer.com/question.md?key=semester_5%2Finstrumentation_ii%3Awhite-black-box) — Instrumentation II, chapter 9
- [EDM operation principles and errors](https://www.bctengineer.com/question.md?key=semester_3%2Fsurveying_i%3Aedm-operation-and-errors) — Surveying I, chapter 2, asked 2×