Software Testing Fundamentals
Software testing is the structured work of evaluating software and related materials to find defects, assess quality, and reduce risk. It includes reviews and analysis as well as running the software.
itSoftware engineering | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Software Testing Fundamentals
Software testing is the organized business of asking software a precise question, watching what it does, and writing down whether that answer is useful for a decision. This sounds less glamorous than launching a rocket, which is fortunate: rockets are expensive, and a password field is already quite capable of producing surprises.
The central object is evidence. A test does not prove software is perfect. It shows what happened when a particular test object met particular inputs, in a particular environment, against an expected result. That limit is not a flaw in testing. It is why the work starts with risk: some failures are more likely, more harmful, or more expensive to leave unexplored.
Keep the small but argumentative family of terms apart. An error is a human mistake. A defect is the flaw that enters a work product. A failure is the incorrect behavior observed when that defect runs under the wrong conditions. Debugging then finds and removes the defect; testing provides the evidence that sent everyone looking. The words are not interchangeable, even when a meeting is trying very hard to make them so.
Two routes produce that evidence. Static testing examines requirements, designs, code, or documents without running software. Dynamic testing runs it, supplies inputs, and compares actual results with expected results. One can expose an unclear requirement before there is runnable code; the other can expose behavior that emerges when components and environments meet. Neither is the other wearing a different hat.
The next important distinction is scope versus question. A test level says whether attention is on a component, an interface, a whole system, or acceptance. A test type asks what matters: function, security, performance, internal structure, or something else. A security test can exist at several levels, because software enjoys being inconveniently multidimensional.
Start with the Intro for the evidence loop and the relationship between testing, debugging, and quality assurance. Use the Slides when the terms need a compact map. Keep the Cheatsheet nearby when selecting partitions, boundaries, test levels, and reporting anchors. Then use the Practice Reference and Exercise to turn one written rule into inspectable cases. The goal is not a heroic pile of green checks. It is a clear account of what was tested, what it means, and what remains uncertain.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://istqb.org/wp-content/uploads/2024/11/ISTQB_CTFL_Syllabus_v4.0.1.pdf
Supports
- Testing objectives, verification, validation, and the limits of testing
- Testing, debugging, quality assurance, error, defect, failure, and root cause
- Seven testing principles and context-dependent test activities
- Static and dynamic testing
- Component, component integration, system, system integration, and acceptance test levels
- Functional, non-functional, black-box, and white-box test types
- Equivalence partitioning, boundary value analysis, decision table, state transition, white-box, experience-based, exploratory, and checklist-based techniques
- Confirmation testing, regression testing, product risk, test reporting, configuration management, defect management, and tool support
- https://www.istqb.org/certifications/certified-tester-foundation-level-ctfl-v4-0/
Supports
- Official CTFL learning outcomes, syllabus downloads, and sample exams
- https://tbok.istqb.org/help
Supports
- Search across published ISTQB syllabi
- Official ISTQB Glossary integration for authoritative testing terminology
- https://committee.iso.org/sites/jtc1sc7/home/projects/flagship-standards/isoiecieee-29119-series.html
Supports
- ISO/IEC/IEEE 29119 scope across general concepts, test processes, documentation, and test design techniques
- Static reviews covered by ISO/IEC 20246
- ISO/IEC/IEEE 29119 series as a common structure for testing concepts, processes, documentation, and techniques
- https://owasp.org/www-project-web-security-testing-guide/
Supports
- Web Security Testing Guide as a structured resource for web application and web service security testing
- https://github.com/sindresorhus/awesome
Supports
- Starting index used to discover relevant curated technology lists
- https://github.com/atinfo/awesome-test-automation/blob/master/general-purpose-test-automation-tools.md
Supports
- Curated discovery of Robot Framework, Postman and Newman, k6, and Schemathesis
- Tool categories spanning acceptance, API, and performance test automation
- https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html
Supports
- Robot Framework as a Python-based, extensible, keyword-driven framework
- Acceptance testing, acceptance test-driven development, and behavior-driven development use
- https://learning.postman.com/docs/reference/newman-cli/installing-running-newman
Supports
- Installation and command-line execution of Postman collections with Newman
- Nonzero exit behavior for failed collection tests
- https://grafana.com/docs/k6/latest/get-started/resources/
Supports
- Official k6 learning resources, tutorial, workshop, examples, integrations, and safe test environments
- https://schemathesis.readthedocs.io/en/stable/
Supports
- Property-based test generation from OpenAPI and GraphQL schemas
- Command-line, pytest, and continuous integration support
- https://www.alanturing.net/turing_archive/archive/l/l32/L32-001.html
Supports
- Turing's 1949 treatment of checking a large routine
- https://homepages.cs.ncl.ac.uk/brian.randell/NATO/nato1968.PDF
Supports
- 1968 NATO Software Engineering Conference and the software crisis
- https://dl.acm.org/doi/10.1145/800179.810194
Supports
- 1972 Program Test Methods symposium
- https://archive.org/details/artofsoftwaretes0000myer
Supports
- 1979 publication of The Art of Software Testing
- https://dl.acm.org/doi/10.1145/62065.62077
Supports
- 1988 history of changing software-testing goals
- https://junit.org/junit4/
Supports
- JUnit as a framework for writing repeatable automated tests
- https://www.selenium.dev/history/
Supports
- Selenium's origin at ThoughtWorks in 2004 and its browser-automation history
- https://testing.googleblog.com/2015/04/just-say-no-to-more-end-to-end-tests.html
Supports
- Costs and limitations of an end-to-end-test-heavy strategy
- https://testing.googleblog.com/2007/10/automating-tests-vs-test-automation.html
Supports
- Maintenance costs and failure modes of automating manual UI steps
- https://testing.googleblog.com/2008/11/partial-automation-keeping-humans-in.html
Supports
- Tradeoffs between automation, human investigation, and diagnostics
- https://www.etsy.com/pl/codeascraft/debriefing-facilitation-guide
Supports
- Practitioner account of automated test-result visibility in postmortem work
- https://www.selenium.dev/
Supports
- Selenium browser-automation project
- https://playwright.dev/
Supports
- Playwright browser automation and multi-browser execution
- https://www.cypress.io/
Supports
- Cypress browser, component, API, and accessibility testing offerings
- https://www.browserstack.com/
Supports
- BrowserStack remote browser and device testing infrastructure
- https://www.testrail.com/
Supports
- TestRail test-case and test-run management
- https://www.postman.com/
Supports
- Postman API lifecycle and testing platform
