Which of the following testing methods verifies the interfaces between components against a
software design?

A.
Regression testing

B.
Integration testing

C.
Black-box testing

D.
Unit testing

Explanation:
Integration testing is a software testing that seeks to verify the interfaces between
components against a software design. Software components may be integrated in an iterative
way or all together (“big bang”). Normally the former is considered a better practice since it allows
interface issues to be localized more quickly and fixed. Integration testing works to expose defects
in the interfaces and interaction between the integrated components (modules). Progressively
larger groups of tested software components corresponding to elements of the architectural design

testing focuses on finding defects after a major code change has occurred. Specifically, it seeks to
uncover software regressions, or old bugs that have come back. Such regressions occur
whenever software functionality that was previously working correctly stops working as intended.
Typically, regressions occur as an unintended consequence of program changes, when the newly
Unit testing refers to tests that verify the functionality of a specific section of code, usually at the
function level. In an object-oriented environment, this is usually at the class level, and the minimal
unit tests include the constructors and destructors. These types of tests are usually written by
developers as they work on code (white-box style), to ensure that the specific function is working
as expected. One function might have multiple tests, to catch corner cases or other branches in
the code. Unit testing alone cannot verify the functionality of a piece of software, but rather is used
is incorrect. The black-box testing uses external descriptions of the software, including
specifications, requirements, and design to derive test cases. These tests can be functional or
non-functional, though usually functional. The test designer selects valid and invalid inputs and
determines the correct output. There is no knowledge of the test object’s internal structure. This
method of test design is applicable to all levels of software testing: unit, integration, functional
testing, system and acceptance. The higher the level, and hence the bigger and more complex the
box, the more one is forced to use black box testing to simplify. While this method can uncover
unimplemented parts of the specification, one cannot be sure that all existent paths are tested.