Unit 4 Software Engineering mrsandy.

in

UNIT IV: Testing Fundamentals

1. Testing Fundamentals
1.1 Introduction
Software Testing is the process of evaluating and verifying that a software application or system
works as expected and meets the specified requirements. It aims to identify bugs or defects,
ensure quality, and validate the system's functionality, security, and performance. Testing is
essential for delivering reliable and robust software and involves various levels, methods, and
strategies.
1.2 Objectives of Testing
The main objectives of software testing are:
Ensure Quality: Verify that the software meets the specified requirements and is free of
defects.
Find Defects: Identify and fix bugs, errors, and vulnerabilities that may affect the software's
functionality.
Validate Requirements: Confirm that the software satisfies the customer's needs and the
business requirements.
Improve Software Reliability: Ensure that the software behaves consistently under various
conditions.
Assess Performance: Evaluate the software's efficiency in terms of speed, memory usage,
and scalability.

2. Principles of Testing
2.1 The Testing Process
The testing process involves the following stages:
Requirement Analysis: Understanding the functional and non-functional requirements of the
system.
Test Planning: Defining the test strategy, selecting the testing tools, and determining the
resources needed.
Unit 4 Software Engineering mrsandy.in

Test Design: Designing test cases, scenarios, and scripts based on requirements.
Test Execution: Running the test cases on the software.
Defect Reporting: Reporting and tracking defects found during testing.
Test Closure: Concluding the testing process after achieving the desired results.
2.2 Testing Principles
The key principles of software testing include:
Testing shows the presence of defects: Testing can prove that defects exist, but it cannot
prove their absence.
Exhaustive testing is impossible: Testing every possible input and scenario is impractical,
so testing must be selective.
Early testing: The earlier testing begins in the software development lifecycle, the more
effective it is in detecting defects.
Defect clustering: A small number of modules often contain the majority of defects.
Pesticide paradox: Repeating the same set of tests will not lead to new defects being
discovered. New tests need to be added.
Testing is context-dependent: Testing approaches and strategies must be chosen based
on the type of software being developed and its requirements.

3. Testability
Testability refers to the ease with which a software system can be tested. It is influenced by
factors such as the availability of clear requirements, the modularity of the code, and the use of
well-defined interfaces. A highly testable system is easier to validate and ensures that defects can
be identified quickly.
3.1 Factors Affecting Testability
Modularity: Well-structured, modular code is easier to test.
Simplicity: The simpler the design, the easier it is to test.
Observability: The system must provide sufficient feedback (logs, outputs) during testing.
Controllability: Testers must be able to control the system's behavior during testing, such as
setting conditions or inputs.
Isolation: Components should be loosely coupled to enable independent testing.
Unit 4 Software Engineering mrsandy.in

4. Test Cases
4.1 Test Cases Definition
A test case is a set of conditions or variables under which a tester evaluates the software to check
if it behaves as expected. Test cases are essential for verifying that a system functions correctly
and meets its requirements.
Components of a Test Case:
Test Case ID: Unique identifier for the test case.
Test Description: A brief description of what the test case does.
Preconditions: Any setup or conditions that must be satisfied before executing the test.
Test Steps: A sequence of actions to perform the test.
Expected Result: The anticipated outcome based on the test conditions.
Actual Result: The actual outcome after running the test.
Postconditions: The expected state of the system after the test has completed.
Status: Whether the test passed or failed.
Example of a Test Case:
Test Case ID: TC001
Test Description: Verify the login functionality
Preconditions: User is on the login page
Test Steps:
1. Enter a valid username.
2. Enter the correct password.
3. Click the "Login" button.
Expected Result: The user should be redirected to the dashboard page.
Actual Result: The user was redirected to the dashboard page.
Status: Pass

5. Testing Strategies
5.1 White Box Testing
White Box Testing, also known as Structural Testing or Glass Box Testing, involves testing
the internal workings of a system. Testers need to have knowledge of the code structure, logic,
and algorithms.
Unit 4 Software Engineering mrsandy.in

Features:
Code Coverage: Ensures that all branches, paths, and conditions are tested.
Focuses on Implementation: Focuses on how the system operates internally rather than its
external behavior.
Types of White Box Testing:
Statement Coverage: Ensures that every statement in the code is executed at least once.
Branch Coverage: Ensures that every branch (decision point) in the code is tested.
Path Coverage: Ensures that every possible path through the code is executed.
Advantages:
Allows detection of hidden errors in the code.
Helps in optimizing code performance and logic.
Disadvantages:
Requires knowledge of the code, making it more time-consuming.
May miss issues related to external interfaces or user inputs.

5.2 Black Box Testing

Black Box Testing is focused on testing the system’s functionality without knowing its internal
structure. Testers evaluate the system based on input-output behavior.
Features:
Test Based on Requirements: Black box testing focuses on validating the system’s
functionality against the specified requirements.
User-Focused: Tests the software from a user’s perspective, ensuring that the system
behaves as expected for various inputs.
Types of Black Box Testing:
Functional Testing: Verifies that the software behaves according to the functional
requirements.
Non-Functional Testing: Assesses aspects like performance, security, usability, and
reliability.
Unit 4 Software Engineering mrsandy.in

Advantages:
No knowledge of the internal code is required.
Can be done by non-developers (e.g., QA engineers or end users).
Disadvantages:
Cannot uncover code-level issues or logic flaws.
May not be exhaustive as it can miss certain edge cases.

6. Verification and Validation

6.1 Verification
Verification is the process of ensuring that the software is being built according to the
specifications and design documents. It answers the question, “Are we building the product right?”
Verification activities include reviews, inspections, and static analysis of the system’s design
and code.
6.2 Validation
Validation is the process of ensuring that the software meets the user's needs and requirements.
It answers the question, “Are we building the right product?”
Validation involves testing the software with actual data and scenarios to ensure it satisfies
the user’s expectations.

7. Levels of Testing
7.1 Unit Testing
Unit Testing involves testing individual units or components of the software in isolation, usually by
the developer. It focuses on validating the functionality of specific functions, methods, or classes.
Example:
Unit 4 Software Engineering mrsandy.in

def add(a, b):

return a + b

# Unit Test
def test_add():
assert add(2, 3) == 5

7.2 Integration Testing

Integration Testing focuses on testing the interactions between integrated units or modules. It
ensures that components work together as expected.
Types:
Big Bang: All components are integrated at once and tested together.
Incremental: Components are integrated one at a time and tested incrementally.
7.3 Validation Testing
Validation Testing verifies that the software meets the specified user requirements. It includes
user acceptance testing (UAT) to ensure the product is acceptable to the end users.
7.4 System Testing
System Testing evaluates the entire system’s functionality, performance, and security. It checks
whether the system works as intended in an integrated environment and meets both functional and
non-functional requirements.