ST - Kumolika S
Uploaded by
kumolikagowda2620ST - Kumolika S
Uploaded by
kumolikagowda2620CHRIST ACADEMY INSTITUTE FOR ADVANCED STUDIES
SUBJECT : SOFTWARE TESTING
TOPIC : TOP-DOWN AND BOTTOM-UP
INTEGRATION TESTING
PRESENTED BY :
KUMOLIKA S
U03BV22S0018
VI SEM BCA ‘A’
🔍 WHAT IS INTEGRATION TESTING
• INTEGRATION TESTING CHECKS HOW DIFFERENT MODULES OR COMPONENTS
OF A SYSTEM WORK TOGETHER AFTER UNIT TESTING EACH MODULE
INDIVIDUALLY.
• THE GOAL IS TO DETECT INTERFACE DEFECTS AND ENSURE THAT THE
INTEGRATED COMPONENTS FUNCTION CORRECTLY AS A WHOLE.
• AFTER UNIT TESTING, WHERE EACH MODULE IS TESTED SEPARATELY, WE DO
INTEGRATION TESTING TO ENSURE THE MODULES WORK TOGETHER AS
EXPECTED.
TYPES OF INTEGRATION TESTING
THERE ARE TWO POPULAR INCREMENTAL APPROACHES:
• TOP-DOWN INTEGRATION TESTING
• BOTTOM-UP INTEGRATION TESTING
🔼 TOP-DOWN INTEGRATION TESTING
• IN TOP-DOWN INTEGRATION TESTING, HIGHER-LEVEL MODULES ARE TESTED
FIRST, AND THEN LOWER-LEVEL MODULES ARE INTEGRATED AND TESTED ONE
BY ONE.
📌 CHARACTERISTICS:
• INTEGRATION BEGINS FROM THE MAIN CONTROL MODULE.
• SUBMODULES ARE ADDED IN A DEPTH-FIRST OR BREADTH-FIRST MANNER.
• HEAVILY RELIES ON STUBS TO SIMULATE LOWER-LEVEL MODULES.
• 📈 WHEN TO USE:
• WHEN THE MAIN DESIGN STRUCTURE IS READY BUT INTERNAL DETAILS ARE
STILL BEING DEVELOPED.
• WHEN DATA FLOW AND DECISION LOGIC NEED EARLY VALIDATION.
• IDEAL FOR USER INTERFACE-HEAVY SYSTEMS.
• 📋 BENEFITS:
• EARLY VERIFICATION OF APPLICATION ARCHITECTURE AND CONTROL FLOW.
• HIGH-LEVEL DESIGN ERRORS ARE IDENTIFIED SOONER.
• PRIORITIZES MODULES THAT USERS INTERACT WITH FIRST.
EXAMPLE MODULE STRUCTURE
[A] ← TOP (MAIN) MODULE
/ \
[B] [C] ← SUBMODULES
/ \ \
[D] [E] [F] ← LEAF MODULES
🔄 HOW IT WORKS
• START TESTING FROM MODULE A.
• IF B, C, OR OTHERS ARE NOT READY, USE STUBS TO SIMULATE THEIR
BEHAVIOUR.
• ONCE B AND C ARE READY, REPLACE THE STUBS WITH REAL MODULES AND
CONTINUE TESTING.
• PROCEED DOWNWARD UNTIL ALL MODULES ARE INTEGRATED AND TESTED.
🔧 WHAT ARE STUBS ?
• A STUB IS A DUMMY PROGRAM/MODULE THAT SIMULATES THE BEHAVIOUR OF
A MODULE THAT ISN’T READY.
• IT IS USED TO RECEIVE DATA FROM THE CALLING MODULE AND RETURN A
FIXED RESPONSE.
🧠 REAL-LIFE ANALOGY
IMAGINE A BOSS (MODULE A) ASKING TWO TEAM LEADS (B AND C) TO GIVE
REPORTS. IF B AND C ARE NOT YET WORKING, SOMEONE PRETENDS TO BE THEM
(STUBS) AND GIVES A MOCK RESPONSE. LATER, WHEN THE ACTUAL TEAM LEADS
ARE READY, THE REAL RESPONSES ARE USED.
Step 1:
[A]
/ \
Stub Stub ← B & C not
developed yet
Step 2:
[A]
/ \
[B] Stub ← B ready, C is
still a stub
Step 3:
[A]
/ \
[B] [C]
/ \ \
[D][E] [F] ← All
modules integrated
PRO’S & CON’S
✅ ADVANTAGES:
• EARLY TESTING OF MAIN CONTROL LOGIC.
• HELPFUL TO IDENTIFY DESIGN FLAWS IN EARLY STAGES.
❌ DISADVANTAGES:
• NEED TO CREATE MANY STUBS.
• LOW-LEVEL MODULES TESTED LATE.
• INTERFACE ERRORS MAY GO UNDETECTED UNTIL LOWER MODULES ARE ADDED.
🔽 BOTTOM-UP INTEGRATION TESTING
✅ DEFINITION:
BOTTOM-UP INTEGRATION TESTING IS AN APPROACH WHERE TESTING STARTS
FROM THE LOWEST MODULES (LEAF MODULES), AND THEN HIGHER-LEVEL
MODULES ARE INTEGRATED AND TESTED UPWARDS.
• IN BOTTOM-UP INTEGRATION TESTING, LOWER-LEVEL MODULES ARE
TESTED FIRST, AND THEN HIGHER-LEVEL MODULES ARE ADDED AND TESTED.
📌 CHARACTERISTICS:
• TESTING BEGINS FROM LEAF-LEVEL (CHILD) MODULES.
• THESE MODULES ARE TESTED AND INTEGRATED TO FORM HIGHER-LEVEL
SUBSYSTEMS.
• USES DRIVERS TO SIMULATE CALLS FROM NOT-YET-AVAILABLE UPPER MODULES.
📈 WHEN TO USE:
• WHEN CORE FUNCTIONALITIES AND UTILITIES ARE COMPLETED BEFORE THE
INTERFACE.
• SUITABLE WHEN REUSABLE MODULES FORM THE BASE OF THE SYSTEM.
• GREAT FOR DATA-PROCESSING SYSTEMS OR SYSTEMS WITH LAYERED LOGIC.
MODULE STRUCTURE:
[A] ← MAIN MODULE
/ \
[B] [C]
/ \ \
[D] [E] [F] ← LEAF
MODULES
🔄 HOW IT WORKS:
• START TESTING FROM THE LOWEST MODULES LIKE D, E, AND F.
• IF HIGHER MODULES LIKE B OR C ARE NOT READY, USE DRIVERS TO CALL AND
TEST THE LOWER MODULES.
• GRADUALLY COMBINE THE LOWER MODULES INTO THEIR PARENT MODULES.
• INTEGRATE UPWARDS UNTIL THE TOP-LEVEL MODULE (A) IS TESTED.
🔧 WHAT ARE DRIVERS?
• A DRIVER IS A DUMMY MODULE THAT SIMULATES A CALLING MODULE (E.G.,
SIMULATES HOW A USER WOULD CALL THE MODULE UNDER TEST).
• IT IS USED TO CALL LOWER-LEVEL MODULES BEFORE THE REAL UPPER
MODULES ARE READY.
BOTTOM-UP TESTING FLOW:
STEP 1:
STUB [D] STUB [F] ← USING DRIVERS TO TEST LEAF MODULES
STEP 2:
[B] [C]
/ \ \
[D] [E] [F] ← MID-LEVEL INTEGRATION
STEP 3:
[A]
/ \
[B] [C] ← FULL INTEGRATION
PRO’S & CON’S
✅ ADVANTAGES:
• NO STUBS ARE REQUIRED.
• TESTING STARTS WITH CRITICAL UTILITY MODULES.
• EASY TO TEST AND DEBUG SMALLER PARTS FIRST.
❌ DISADVANTAGES:
• NEED TO CREATE MANY DRIVERS.
• MAIN LOGIC IS TESTED LATE.
• CAN MISS HIGH-LEVEL CONTROL FLOW ISSUES UNTIL FINAL STAGES.
📊 COMPARISON TABLE
Feature Top-Down Integration Bottom-Up Integration
Start From Top/Main Module Bottom/Leaf Modules
Uses Stubs Drivers
Control Logic Tested Early Late
Utility Modules Tested Late Early
Focus Application Flow Internal Functionality
Integration Direction Downward Upward
🎯 CONCLUSION
• USE TOP-DOWN IF:
• YOU WANT TO TEST THE OVERALL APPLICATION FLOW EARLY.
• YOUR MAIN MODULE IS STABLE AND READY.
• USE BOTTOM-UP IF:
• YOU WANT TO VERIFY UTILITY MODULES AND FOUNDATIONAL LOGIC EARLY.
• YOUR TOP-LEVEL DESIGN DEPENDS ON BOTTOM FUNCTIONALITY.
🧠 TIP TO REMEMBER: