Software Testing
Software testing is the process of evaluating a software application to identify any defects or errors. Its goal is to verify that the software meets technical specifications and validate that it fulfills end-user requirements, ultimately ensuring the quality of the final product.
First used·1950s
Definitions·1
Synonyms·2
Category·Software Development
Also known as
Definitions
What it means.
- 01
General Definition in Software Engineering
In the context of the Software Development Life Cycle (SDLC), Software Testing is a systematic process of evaluating and verifying that a software product or application does what it is supposed to do. The primary purpose is to identify defects, bugs, or errors to ensure the software meets the specified requirements, as well as the end-user's needs.
This process involves two key concepts: Verification and Validation. Verification checks if the software conforms to its design and specification ('Are we building the product right?'). Validation, on the other hand, ensures that the product meets the user's true needs and expectations ('Are we building the right product?').
Testing is typically categorized into different levels:
- Unit Testing: Testing individual components or modules of the software in isolation.
- Integration Testing: Testing the interaction and data flow between integrated components to expose faults in their interfaces.
- System Testing: Testing the complete and fully integrated software product to evaluate its compliance with the specified requirements.
- Acceptance Testing: A final level of testing where users or clients validate if the system meets their requirements and is ready for deployment.
Furthermore, testing can be classified by its objective:
- Functional Testing: Validates the software's actions and operations (e.g., testing if a login button works correctly).
- Non-Functional Testing: Evaluates performance, usability, security, and reliability (e.g., testing how quickly the application responds under load).
Origin
Where it comes from.
Etymology
The term combines 'Software', coined in the late 1950s to distinguish instructional programs from the physical 'hardware' of a computer, and 'Testing', which originates from the Old French 'test' (an earthen pot). This term was used in alchemy for assaying precious metals, metaphorically extending to the idea of assaying or evaluating the quality of software.
Historical context
The practice of Software Testing has evolved significantly alongside software development methodologies. In the early days of computing (1950s-1960s), testing was an informal activity, often indistinguishable from debugging and performed by the programmers themselves. It was largely an ad-hoc process aimed at making the program work.
The 1970s marked a turning point. Influential works, such as Glenford J. Myers' "The Art of Software Testing" (1979), established testing as a formal discipline. Myers argued that testing's goal should be to find errors, not to prove correctness, and advocated for the separation of testing from development, leading to the rise of dedicated Quality Assurance (QA) teams.
During the 1980s and 1990s, with the dominance of the Waterfall model, testing became a distinct phase that occurred after development was complete. This era formalized different levels of testing, such as unit, integration, and system testing, creating a structured but often lengthy and siloed process.
The advent of the Agile Manifesto in 2001 revolutionized the field. In Agile and DevOps environments, testing is no longer a final phase but a continuous activity integrated throughout the development lifecycle. This 'shift-left' approach emphasizes early and frequent testing, heavily relying on test automation to keep pace with rapid iterations. Methodologies like Test-Driven Development (TDD) and Behavior-Driven Development (BDD) emerged, further embedding testing into the core of development.
Usage
In context.
Our team dedicates a full sprint to rigorous Software Testing before any major release to ensure stability.
Effective Application Testing involves a mix of manual and automated scripts to cover all critical user paths.
While often used interchangeably, Software Testing is a key activity within the broader discipline of Quality Assurance (QA), which also includes process improvement and standard adherence.
FAQ
Common questions.
Verification is the process of checking that the software is built correctly according to its design and specifications. It answers the question, 'Are we building the product right?'.
Validation is the process of checking that the software meets the customer's actual needs and expectations. It answers the question, 'Are we building the right product?'.
A product can be verified (built to spec) but not validated (the spec was wrong and doesn't solve the user's problem).
Taxonomy
Filed under.
Categories
Tags