Software Testing Glossary

• CAST: Computer Aided Software Testing
• Code Coverage: An analysis method that determines which parts of the software have been executed (covered) by the test case suite and which parts have not been executed and therefore may require additional attention.
• Compatibility Testing: Testing whether the system is compatible with other systems with which it should communicate.
• Component Testing: The testing of individual software components.
• Concurrency Testing: Multi-user testing geared towards determining the effects of accessing the same application code, module or database records. Identifies and measures the level of locking, deadlocking and use of single-threaded code and locking semaphores.
• Conformance Testing / Compliance Testing / Standards Testing: Conformance testing or type testing is testing to determine whether a system meets some specified standard. To aid in this, many test procedures and test setups have been developed, either by the standard's maintainers or external organizations, specifically for testing conformance to standards. Conformance testing is often performed by external organizations, sometimes the standards body itself, to give greater guarantees of compliance. Products tested in such a manner are then advertised as being certified by that external organization as complying with the standard
• Context Driven Testing: The context-driven school of software testing is flavor of Agile Testing that advocates continuous and creative evaluation of testing opportunities in light of the potential information revealed and the value of that information to the organization right now.
• Conversion Testing / Migration Testing: Testing of programs or procedures used to convert data from existing systems for use in replacement systems.
• Coverage Testing: Coverage testing is concerned with the degree to which test cases exercise or cover the logic (source code) of the software module or unit. It is also a measure of coverage of code lines, code branches and code branch combinations
• Cyclomatic Complexity: A measure of the logical complexity of an algorithm, used in white-box testing .
• Data flow Testing: Testing in which test cases are designed based on variable usage within the code.
• Data integrity and Database integrity Testing: Data integrity and database integrity test techniques verify that data is being stored by the system in a manner where the data is not compromised by updating, restoration, or retrieval processing .
• Data-Driven Testing: Testing in which the action of a test case is parameterized by externally defined data values, maintained as a file or spreadsheet. A common technique in Automated Testing .
• Decision condition testing: A white box test design technique in which test cases are designed to execute condition outcomes and decision outcomes .
• Decision table testing: A black box test design techniques in which test cases are designed to execute the combinations of inputs and/or stimuli (causes) shown in a decision table .
• Decision testing: A white box test design technique in which test cases are designed to execute decision outcomes .
• Defect: An anomaly, or flaw, in a delivered work product. Examples include such things as omissions and imperfections found during early lifecycle phases and symptoms of faults contained in software sufficiently mature for test or operation. A defect can be any kind of issue you want tracked and resolved.
• Defect density: The number of defects identified in a component or system divided by the size of the component or system (expressed in standard measurement terms, e.g. lines-ofcode, number of classes or function points).
• Dependency Testing: Examines an application's requirements for pre-existing software, initial states and configuration in order to maintain proper functionality .
• Depth Testing: A test that exercises a feature of a product in full detail.
• Design based Testing: Designing tests based on objectives derived from the architectural or detail design of the software (e.g., tests that execute specific invocation paths or probe the worst case behaviour of algorithms).
• Development testing: Formal or informal testing conducted during the implementation of a component or system, usually in the development environment by developers .
• Documentation Testing: Testing concerned with the accuracy of documentation.
• Dynamic Testing: Testing software through executing it.
• Efficiency testing: The process of testing to determine the efficiency of a software product
• End-to-end Testing: Test activity aimed at proving the correct implementation of a required function at a level where the entire hardware/software chain involved in the execution of the function is available.
• Endurance Testing: Checks for memory leaks or other problems that may occur with prolonged execution .
• Equivalence Class: A portion of a component's input or output domains for which the component's behaviour is assumed to be the same from the component's specification .
• Equivalence partition Testing: A test case design technique for a component in which test cases are designed to execute representatives from equivalence classes.
• Equivalence Partitioning: A test case design technique for a component in which test cases are designed to execute representatives from equivalence classes ./
• Exhaustive Testing: Testing which covers all combinations of input values and preconditions for an element of the software under test .
• Exploratory Testing: This technique for testing computer software does not require significant advanced planning and is tolerant of limited documentation for the target-of-test. Instead, the technique relies mainly on the skill and knowledge of the tester to guide the testing, and uses an active feedback loop to guide and calibrate the effort. It is also known as ad hoc testing .
• Failure: The inability of a system or component to perform its required functions within specified performance requirements. A failure is characterized by the observable symptoms of one or more defects that have a root cause in one or more faults.
• Fault: An accidental condition that causes the failure of a component in the implementation model to perform its required behavior. A fault is the root cause of one or more defects identified by observing one or more failures.
• Fuzz Testing: Fuzz testing is a software testing technique. The basic idea is to attach the inputs of a program to a source of random data. If the program fails (for example, by crashing, or by failing built-in code assertions), then there are defects to correct.The great advantage of fuzz testing is that the test design is extremely simple, and free of preconceptions about system behavior.
• Gamma Testing: Gamma testing is a little-known informal phrase that refers derisively to the release of "buggy" (defect-ridden) products. It is not a term of art among testers, but rather an example of referential humor. Cynics have referred to all software releases as "gamma testing" since defects are found in almost all commercial, commodity and publicly available software eventually.
• Gorilla Testing: Testing one particular module,functionality heavily.
• Grey Box Testing: The typical grey box tester is permitted to set up or manipulate the testing environment, like seeding a database, and can view the state of the product after their actions, like performing a SQL query on the database to be certain of the values of columns. It is used almost exclusively of client-server testers or others who use a database as a repository of information,or who has to manipulate XML files (DTD or an actual XML file) or configuration files directly, or who know the internal workings or algorithm of the software under test and can write tests specifically for the anticipated results.
• GUI Testing: GUI testing is the process of testing a graphical user interface to ensure it meets its written specifications .
• Heuristic evaluations: Heuristic evaluations are one of the most informal method of usability inspection in the field of human-computer interaction. It helps identifying the usability problems in a user interface (UI) design. It specifically involves evaluators examining the interface and judging its compliance with recognized usability principles (the "heuristics").
• High Order Tests: Black-box tests conducted once the software has been integrated.
• Incremental Testing: "Integration testing where system components are integrated into the system one at a time until the entire system is integrated.
• Installation Testing: Installation testing can simply be defined as any testing that occurs outside of the development environment. Such testing will frequently occur on the computer system the software product will eventually be installed on. While the ideal installation might simply appear to be to run a setup program, the generation of that setup program itself and its efficacy in a variety of machine and operating system environments can require extensive testing before it can be used with confidence
• Integration Testing: Integration testing is the phase of software testing in which individual software modules are combined and tested as a group. It follows unit testing and precedes system testing.
• Interface Testing: Testing conducted to evaluate whether systems or components pass data and control correctly to each other.
• Interoperability testing: The process of testing to determine the interoperability of a software product .
• Invalid testing: Testing using input values that should be rejected by the component or system .
• Isolation Testing: Component testing of individual components in isolation from surrounding components, with surrounding components being simulated by stubs.
• Keyword driven Testing: A scripting technique that uses data files to contain not only test data and expected results, but also keywords related to the application being tested. The keywords are interpreted by special supporting scripts that are called by the control script for the test .