Course contentsShow
← Computer Science
Lesson 2239 of 2,87250. Software TestingFree lesson

Bottom-Up Integration Testing

Beginning with low-level modules and building upward, using drivers to simulate higher-level calls.

Bottom-Up Integration Testing

What you'll learn: How to test software by starting with the smallest components and progressively assembling them into larger subsystems.

The Core Idea

Bottom-Up Integration Testing is an incremental testing strategy where you begin with the lowest-level modules (those with no dependencies on other internal modules) and gradually integrate upward toward higher-level components. Unlike Top-Down testing which starts at the top of the call hierarchy, Bottom-Up builds from the foundation.

Since low-level modules often need to be called by higher-level code that doesn't exist yet during testing, you create drivers—temporary test programs that simulate the calls and inputs that higher-level modules would normally provide.

How It Works

  1. Test low-level modules individually (essentially unit testing)
  2. Group related modules into clusters
  3. Write drivers to exercise these clusters as if higher-level code were calling them
  4. Integrate the next layer up, using the tested clusters below
  5. Replace drivers as real higher-level modules become ready
  6. Repeat until the entire system is integrated

Analogy

Think of constructing a building: you start by testing the foundation, then integrate the ground floor structure, then the second floor, and so on. Before the upper floors exist, you use scaffolding (drivers) to support and test the lower levels independently.

When It's Useful

Bottom-Up works well when:

  • Lower-level modules are critical or complex (utilities, database layers, APIs)
  • The system architecture is naturally hierarchical from the bottom
  • You want core functionality validated early

The main drawback? You don't see the complete system behavior until late in integration.

Key Takeaway: Bottom-Up Integration Testing builds confidence from the foundation upward, using drivers to simulate missing higher-level calls until the real components are ready to integrate.