---
title: "Component, integration and release testing"
subject: "Software Engineering"
chapter: 8
key: "semester_5/software_engineering:component-release-integration"
source: https://www.bctengineer.com/q/semester_5/software_engineering/component-release-integration
site: BCT Engineering
---

# Component, integration and release testing

Software Engineering · Chapter 8: Software Testing and cost Estimation

- Asked in: year not given, 3+4 marks
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_5/software_engineering/component-release-integration
- Whole chapter: https://www.bctengineer.com/md/semester_5/software_engineering/chapter-8

## Question

Establish chronology among component, release unit and integration testing. Write distinctive notes on their testing.

## Short answer

The testing order is unit, component, integration, then release. Unit testing checks a single function/class by developers; component testing checks a group of units through its interface; integration testing combines components to expose interface defects; release testing is black-box validation of the whole version by an independent team.

## Answer

#### Chronology

Testing moves from the smallest parts to the complete system:

```text
Unit testing -> Component testing -> Integration
 testing -> Release testing -> (Acceptance testing)
```

1. **Unit testing** comes first: individual functions and methods are tested.
2. **Component testing** follows: units grouped into a component (a class or a composite component) are tested through their interface.
3. **Integration testing** comes next: components are combined step by step into the system and tested together.
4. **Release testing** comes last before delivery: a complete version of the system is tested by an independent team before it is given to customers.

#### Distinctive notes

**Unit testing**
- Tests the smallest testable piece of code (a function, method or object class) in isolation.
- Done by the developer, usually white-box, using drivers and stubs.
- Aim: find logic, boundary and calculation errors, e.g. testing `calculateInterest()` with zero, normal and maximum balances.

**Component testing**
- Tests a component made of several units through its **interface**.
- Focus on interface errors: misuse, misunderstanding and timing errors.
- Done by developers; test the component's specified behaviour, e.g. testing a "Payment" component's `pay()`, `refund()` and `status()` operations together.

**Integration testing**
- Tests interactions between components as they are combined, to find defects in their interfaces and data flow.
- Strategies: top-down (with stubs), bottom-up (with drivers), sandwich, or big-bang; incremental integration makes faults easy to locate.
- Done by the development team; regression tests are run after each new component is added.
- Aim is **defect testing**: find faults.

**Release testing**
- Tests a particular release of the whole system that is intended for use outside the development team.
- Done by a **separate testing team**; black-box, based on requirements, scenarios and performance (load and stress) tests.
- Aim is **validation**: show the system meets its requirements and is good enough to release, not mainly to find bugs.

| Point | Unit | Component | Integration | Release |
|---|---|---|---|---|
| Scope | Function/class | Group of units | Combined components | Whole system version |
| By | Developer | Developer | Dev team | Independent team |
| Method | White-box | Interface-based | Interface/flow | Black-box |
| Goal | Unit correctness | Interface correctness | Find defects | Validate for release |

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. What is the correct order of testing before delivery?
   A. Unit, integration, component, release
   B. Component, unit, integration, release
   C. Release, integration, component, unit
   D. Unit, component, integration, release
   Answer: D. Testing goes from smallest to whole: unit, component, integration, then release testing. (Key point: Chronology)

2. What is the main focus of component testing?
   A. Whole-system load behaviour
   B. Interface errors of a component made of several units, tested through its interface
   C. Customer acceptance of the product
   D. Only the syntax of each unit
   Answer: B. Component testing exercises the component via its interface and looks for misuse, misunderstanding and timing errors. (Key point: Component testing focus)

3. Which is true of integration testing?
   A. It is done by an independent team and aims at validation
   B. It combines components step by step, and its aim is defect testing
   C. It tests the smallest unit in isolation
   D. It is done by the customer at their site
   Answer: B. Integration testing is done by the development team to find interface and data-flow faults as components are combined. (Key point: Integration testing aim)

4. What distinguishes release testing?
   A. It is white-box and done by the developer
   B. It tests a single function with drivers
   C. It is black-box, done by a separate team, and aims to validate the system for release
   D. It is done before component testing
   Answer: C. Release testing checks a version meant for outside use against requirements, by an independent team, mainly for validation. (Key point: Release testing)

## Related in Software Engineering

- [Top-down integration problems; regression testing](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Atop-down-integration-regression) — Software Engineering, chapter 8
- [Failure after acceptance testing; integration testing](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Afail-after-acceptance) — Software Engineering, chapter 8

## Related in other subjects

- [Steps to establish small scale unit](https://www.bctengineer.com/question.md?key=semester_7%2Forganization_and_management%3Aentrepreneurship-small-scale-steps) — Organization and Management, chapter 8
- [Load sharing among three generators](https://www.bctengineer.com/question.md?key=semester_7%2Fpower_plant_equipment%3Aload-sharing-three-generators) — Power Plant Equipment, chapter 2, asked 3×