Testing Terminology & Glossary
Professional testers speak a precise language. Knowing the correct terminology is essential for communicating clearly with developers, product managers, and stakeholders — and for SDET job interviews. This topic covers the 20 most important testing terms you will encounter every single day.
Core Testing Terminology
- Bug / Defect / Fault: A flaw in the software that causes incorrect behavior. 'Bug' is informal; 'defect' is formal in documentation.
- Error: A human mistake made by a developer or analyst (e.g., misunderstanding a requirement).
- Failure: The observable incorrect behavior when the software runs — the symptom caused by a defect.
- Test Case: A documented set of conditions to verify a specific behavior (inputs, steps, expected result).
- Test Suite: A collection of related test cases grouped together (e.g., 'Login Test Suite').
- Test Plan: A document describing the scope, approach, resources, and schedule for testing activities.
- Test Oracle: The source used to determine whether the actual result matches expected result (spec, previous version, domain expert).
- Regression Testing: Re-running tests after code changes to ensure existing functionality isn't broken.
- Smoke Testing: A quick, shallow test run to verify the basic functions work before deeper testing begins.
- Sanity Testing: A narrow, focused test after a specific fix to confirm it works without running the full suite.
- Test Coverage: The degree to which the tests exercise the software (code coverage, requirement coverage, branch coverage).
- Flaky Test: A test that passes and fails intermittently without code changes — a reliability problem.
- Test Harness: The collection of software + test data + configuration used to run tests.
- Mock / Stub / Spy: Test doubles that replace real dependencies (mock = verifiable fake, stub = returns preset values, spy = records interactions).
- SUT (System Under Test): The component or system being tested.
- UAT (User Acceptance Testing): Final validation by actual users that the system meets business needs.
- Entry Criteria: The preconditions that must be met before testing begins.
- Exit Criteria: The conditions that define when testing is complete (e.g., 0 critical open bugs, 95% test pass rate).
- Severity: The technical impact of a bug on the system (Critical, Major, Minor, Trivial).
- Priority: The business urgency of fixing a bug (High, Medium, Low — set by product/business).
Try It — Bug Report Writer
Quick Quiz — Testing Terminology
Common Mistakes
- Using 'bug', 'defect', 'error', 'failure' interchangeably — in formal contexts they mean different things; imprecise language causes miscommunication.
- Confusing Severity and Priority — a cosmetic logo bug is Low Severity but could be High Priority before a product launch; a data corruption bug is Critical Severity but Low Priority on a deprecated module.
- Calling every test that fails 'flaky' — a consistently failing test has a real bug; a flaky test has non-deterministic behavior. Distinguish them.
- Writing test cases without a test oracle — without knowing what the expected result IS, you cannot determine pass or fail.
Tip
Tip
Practice Testing Terminology Glossary in small, isolated examples before integrating into larger projects. Breaking concepts into small experiments builds genuine understanding faster than reading alone.
Technical diagram.
Practice Task
Note
Practice Task — (1) Write a working example of Testing Terminology Glossary from scratch without looking at notes. (2) Modify it to handle an edge case (empty input, null value, or error state). (3) Share your solution in the Priygop community for feedback.
Common Mistake
Warning
A common mistake with Testing Terminology Glossary is skipping edge case testing — empty inputs, null values, and unexpected data types. Always validate boundary conditions to write robust, production-ready software testing code.
Key Takeaways
- Professional testers speak a precise language.
- Bug / Defect / Fault: A flaw in the software that causes incorrect behavior. 'Bug' is informal; 'defect' is formal in documentation.
- Error: A human mistake made by a developer or analyst (e.g., misunderstanding a requirement).
- Failure: The observable incorrect behavior when the software runs — the symptom caused by a defect.