Instructions: Answer all questions.

1. a. Distinguish between functional testing and structural testing. (2 Marks)

Functional Testing: This type of testing focuses on verifying the functionality of the software against its specified requirements. It treats the software as a "black box," meaning the internal structure, design, and implementation details are not considered. The primary goal is to check if the software performs its intended functions correctly based on the inputs provided and the expected outputs. Examples include unit testing, integration testing, system testing, and acceptance testing when performed from a functional perspective.

• Focus: What the system does.
• Methodology: Black-box approach.
• Basis: Requirements specification, user stories.
• Goal: Validate functionality against requirements.

Structural Testing: This type of testing, also known as "white-box" or "glass-box" testing, focuses on the internal structure, design, and code of the software. Testers examine the code to ensure that specific paths, branches, statements, and conditions are executed and tested. It requires knowledge of the software's internal workings. Examples include statement coverage, branch coverage, and path coverage testing.

• Focus: How the system works (internal logic).
• Methodology: White-box approach.
• Basis: Source code, design documents.
• Goal: Ensure internal code paths and logic are exercised and correct.

Key Differences:

1. b. Explain about interface, integration, and system bugs. (3 Marks)

Software bugs can be categorized based on the context in which they appear. Interface, integration, and system bugs represent different levels of issues encountered during software development and testing.

Interface Bugs: These bugs occur when two or more software components, modules, or systems fail to communicate or interact correctly with each other. An interface is the point of interaction between different entities. Interface bugs can arise due to:

• Incorrect data formats or types passed between components.
• Mismatched protocols or communication methods.
• Incorrect API (Application Programming Interface) usage or implementation.
• Timing issues in data exchange.
• Security vulnerabilities at the interface points.

Integration Bugs: These bugs are discovered when different software modules or components are combined and tested together. Integration testing aims to expose defects in the interfaces and interactions between integrated units. Integration bugs typically manifest when:

• Modules that worked correctly in isolation fail when combined.
• Data flow between modules is corrupted or lost.
• Control flow between modules is incorrect.
• Assumptions made by one module about another are violated.
• The overall behavior of the integrated system deviates from expectations.

System Bugs: These bugs are defects found in the complete, integrated software system. System testing evaluates the system's compliance with specified requirements as a whole. System bugs are often higher-level issues that may stem from the interaction of multiple components or subsystems, or from fundamental design flaws. They can include:

• Failures to meet overall functional requirements.
• Performance issues (e.g., slow response times, high resource consumption).
• Security vulnerabilities in the complete system.
• Usability problems.
• Reliability issues (e.g., frequent crashes, data corruption).
• Bugs that arise from the interaction of the software with its environment (hardware, operating system, other software).

In essence, interface bugs are about communication failures, integration bugs are about combined module failures, and system bugs are about failures of the entire system to meet its objectives.