Other meanings of test
Software Engineering
Software testing is the process of evaluating and verifying that a software product or application does what it is supposed to do. The benefits of testing include preventing bugs, reducing development and maintenance costs, and improving performance. Testing is a critical part of the software development lifecycle, and it can be performed manually or with automated tools.
Software testing is the process of executing a program or application with the intent of finding software bugs (errors or other defects). It involves the operation of a system or component under specified conditions, observing or recording the results, and making an evaluation of some aspect of the system. The primary goals are to verify that the software meets requirements, to detect defects, and to ensure that the software is reliable, secure, and performant.1 Testing also provides confidence in the quality of the product and helps reduce the risk of failure in production.
The history of software testing dates back to the 1940s when computer scientist Tom Kilburn is credited with writing the first piece of software, which was tested by running it on the Manchester Baby computer in 1948. Early testing was largely ad hoc, involving debugging and manual verification. The term "software testing" became more formalized in the 1970s with the publication of Glenford Myers' book "The Art of Software Testing" (1979), which introduced fundamental concepts such as test cases and the idea that testing is an adversarial process aimed at finding errors. Over the decades, testing has evolved from a post-development activity to an integrated part of the development lifecycle, with the rise of agile methodologies and continuous testing.
Software testing is typically organized into levels that correspond to the development stages: unit testing (testing individual components), integration testing (testing interactions between components), system testing (testing the complete system), and acceptance testing (testing against user requirements).2 Additionally, there are various types of testing that focus on specific aspects: functional testing (verifying functions), performance testing (evaluating speed and responsiveness), security testing (identifying vulnerabilities), usability testing (assessing user-friendliness), and regression testing (ensuring changes don't break existing functionality). Each type serves a distinct purpose and is chosen based on the project's needs.
Testing can be categorized as static or dynamic. Static testing involves examining the code without executing it, such as code reviews, static analysis, and walkthroughs. It can detect defects early and is often automated with tools like linters. Dynamic testing involves executing the code with specific inputs and observing the outputs. Both approaches are complementary; static testing can find issues like syntax errors and potential bugs, while dynamic testing validates behavior under real conditions.
Effective testing relies on systematic test design techniques. Black-box testing designs tests based on requirements without knowledge of internal code, using methods like equivalence partitioning, boundary value analysis, and decision tables. White-box testing uses knowledge of the internal logic to design tests, covering statements, branches, and paths. Experience-based techniques, such as exploratory testing, rely on the tester's intuition and knowledge. These techniques help maximize coverage and defect detection.
Test automation involves using software tools to execute tests, compare expected outcomes, and report results. It is essential for regression testing and continuous integration. Popular open-source tools include Selenium for web applications, JUnit for Java unit tests, and pytest for Python. Commercial tools like HP UFT and IBM Rational offer comprehensive solutions. Automation reduces human error and speeds up testing, but it requires an initial investment and maintenance.3
Testing is integrated throughout the software development lifecycle. In the traditional waterfall model, testing occurs after implementation. In agile development, testing is continuous, with testers collaborating with developers and business stakeholders. DevOps practices emphasize continuous testing within CI/CD pipelines, where automated tests run on every code change. This shift-left approach aims to detect defects as early as possible, reducing cost and time to market.
Beyond the mainstream practices, there are several lesser-known facets of software testing. Mutation testing, for example, involves introducing small faults into the code to check if the test suite can detect them, thereby assessing test quality. Property-based testing, popularized by QuickCheck, generates random inputs to verify that certain properties hold. Fuzzing, or fuzz testing, automatically feeds malformed data to uncover vulnerabilities. Additionally, the concept of "test oracles" — the means to determine expected results — is a fundamental challenge, especially in complex systems. Historically, the first known software bug was a moth found in the Harvard Mark II computer in 1947, leading to the term "debugging." Another niche area is "exploratory testing," which emphasizes simultaneous learning, test design, and execution, often used in time-constrained projects.
This article focuses on the discipline of software testing as a verification and validation process.
Served from cache
Help improve the encyclopedia. Reports go straight to the site manager.