SOFTWARE TESTING

NOTES
Unit – I: Basics of Software Testing
and Testing Methods:

Q. What is Software Testing?

→
Explanation of the Topic:
Software testing is a systematic process used to assess the functionality of a software application. Its
primary goal is to determine whether the developed software meets the specified requirements and to
identify any defects that might exist. This process is crucial to ensure the quality and reliability of the
final product.
One common misconception about software testing is that it is solely about proving the absence of
errors. However, a more accurate definition is that testing involves executing the program with the
specific intention of finding errors. This proactive approach helps to identify and address issues early
in the development cycle, leading to a more robust and bug-free software product.

Q. Enlist Objectives of Software Testing

→
Explanation of the Topic:
1. Finding Errors:
Testing is the process of executing a program with the intention of finding errors. The goal is to
discover bugs before the software is released.
2. Creating Good Test Cases:
A good test case is one that has a high probability of uncovering previously undiscovered
errors. The more effective the test case, the better the testing process.
3. Quality Improvement:
When defects are identified and fixed by developers, the overall quality of the software
improves.
4. Satisfying Customer Requirements:
Testing demonstrates to the customer that the software works properly and meets the
specified requirements.

Page 1 of 9
Q. Define bug, error, fault and failure
→
Explanation of the Topic:
In software testing, the terms bug, error, fault, and failure are often used interchangeably, but they
have distinct meanings. Understanding these differences is important for accurate communication and
identifying issues within software.
• Bug: A bug is a general term used to refer to any flaw or problem in a software program that
causes it to behave incorrectly or unexpectedly. Bugs can be caused by errors in the code,
miscommunication in requirements, or environmental factors. Bugs are typically identified
through testing or by users after the software is deployed.
• Error: An error is a mistake made by a developer during the coding process. Errors often lead
to bugs, as they result in incorrect code or logic that causes the software to malfunction.
• Fault: A fault is a defect in the software that occurs due to an error in the code. It’s an
unintended or incorrect behavior in the software that arises from mistakes or oversights made
during development.
• Failure: A failure occurs when the software, due to a fault, does not perform as expected in a
live environment. It's when the software fails to meet the specified requirements or
expectations, often resulting in poor user experience or system crashes.

Real-life Example:
Imagine you’re testing a new app. If the app crashes when you try to open it, that’s a failure. You
investigate and find that the issue happened because the code was written incorrectly, which is an
error. The problem in the code creates a fault in the app’s ability to run, which causes the bug (the
crash) in the first place.

Key Terms for Memorization (In Order):

1. Bug – A flaw in the software causing unexpected behavior.
2. Error – A mistake made by the developer in the coding process.
3. Fault – A defect in the software resulting from an error.
4. Failure – When the software fails to meet expectations due to a fault.

Page 2 of 9
Q. Define verification and validation with respect to software
testing. Also Compare verification and validation (any two
points).
→
Explanation of the Topic:
Verification: Verification in software testing refers to the process of ensuring that the software is
being built correctly according to the specified requirements and design documents. It is a process-
oriented activity that focuses on checking if the software conforms to its specifications at various
stages of development, including the design and implementation phase. Verification is often done
through reviews, inspections, and walkthroughs.
Validation: Validation, on the other hand, is the process of ensuring that the software meets the user’s
needs and requirements. It checks if the right software has been built. Validation is performed to
confirm that the software actually works as expected in the real-world environment and provides the
correct outcomes when used.

Key Terms for Memorization (In Order):

1. Verification – Ensuring software is built correctly according to requirements and design.
2. Validation – Ensuring the software meets user needs and works as expected.
3. Requirements – The specified conditions the software must fulfill.
4. Design Documents – Detailed descriptions of how the software should be structured.
5. Process-Oriented – Focusing on the steps or methods used to build software.
6. Outcome-Oriented – Focusing on the end result of the software.

Verification vs Validation

Page 3 of 9
Q. Define static and dynamic testing.
→
Explanation of the Topic:
Static Testing: Static testing refers to the process of evaluating software without
executing it. It involves reviewing the code, documentation, and other software artifacts
to identify defects or ensure compliance with specified requirements. The goal is to
detect errors in the design and structure of the software before it's executed. Static
testing is often done through techniques such as code reviews, walkthroughs, and
inspections.
Dynamic Testing: Dynamic testing, on the other hand, involves executing the software
to validate its functionality and behavior. This type of testing is carried out during the
execution phase to check if the software works as intended under various conditions.
Dynamic testing includes testing activities like unit testing, integration testing, system
testing, and acceptance testing. It helps identify runtime errors, performance issues,
and functional flaws.
Comparison between Static and Dynamic Testing:
1. Nature of Testing:
o Static Testing: Involves reviewing the software artifacts without executing
the code.
o Dynamic Testing: Requires the software to be executed to observe its
behavior and identify issues.
2. Objective:
o Static Testing: Aims to find defects early in the development process,
focusing on structure, design, and requirements.
o Dynamic Testing: Aims to identify runtime defects and ensure that the
software functions correctly in real-world scenarios.
Both types of testing are crucial in ensuring software quality, but they target different
aspects of the development lifecycle.

Page 4 of 9
Q. Differentiate between static and dynamic testing tools. (any
four points).
→

Page 5 of 9
Q. Describe Boundary value analysis with suitable example
→
Boundary Value Analysis (BVA)
Explanation of the Topic: Boundary Value Analysis (BVA) is a software testing
technique that focuses on testing the boundaries or edge cases of input values. The
primary idea behind BVA is that errors often occur at the boundaries of input ranges
rather than in the middle. This technique is widely used in functional and system
testing, where inputs are constrained to a range (e.g., between two values). The
technique involves testing at the extreme ends of input ranges as well as just inside and
just outside these boundaries to ensure that the software handles all possible edge
cases.
Key Concepts in Boundary Value Analysis:
• Boundary Values: These are the minimum and maximum values that the system
allows as valid inputs.
• Test Cases: The test cases should cover the boundary values as well as values just
inside and outside the valid range.
Example of Boundary Value Analysis: Let's consider an application where the valid
input range for a user’s age is between 18 and 60 (inclusive).
In Boundary Value Analysis, the following values would be tested:
1. Boundary values:
o 18 (lower boundary): Test if the system accepts the minimum valid age.
o 60 (upper boundary): Test if the system accepts the maximum valid age.
2. Values just inside the boundaries:
o 19 (just above the lower boundary): Check if the system accepts values
just above the minimum.
o 59 (just below the upper boundary): Check if the system accepts values
just below the maximum.
3. Values just outside the boundaries:
o 17 (just below the lower boundary): Ensure that the system rejects
values below the minimum.
o 61 (just above the upper boundary): Ensure that the system rejects
values above the maximum.

Page 6 of 9
Test Cases:
• Valid cases: 18, 19, 59, 60
• Invalid cases: 17, 61
Alternate Easy Explanation: Boundary Value Analysis is like checking the door frames
to see if they are wide enough to let you through without bumping your head. You test
not only the edges of the door (the boundaries) but also a bit inside and a bit outside to
make sure the door works for everyone, even if you're just a little taller or shorter than
the typical person.
Real-Life Example: Imagine you’re trying to enter a movie theater where tickets are
sold to anyone between the ages of 18 and 60. If you're 17 or 61, you can’t get in. BVA
helps ensure that anyone exactly 18 or 60 can get in, and anyone outside those ages is
turned away.
Interactive Task:
Google Search: Boundary value analysis examples in software testing.
Key Terms for Memorization:
1. Boundary Values: The edges of a valid input range.
2. Valid Input: The acceptable values that lie within the specified range.
3. Invalid Input: Values outside the acceptable range.
4. Test Cases: Specific inputs chosen to test boundary conditions.
Mnemonics for Memorization:
Mnemonic: "BVA WINS"
• B - Boundary Values
• V - Valid Input
• A - Acceptable Range
• W - With Boundary
• I - Invalid Input
• N - Near Boundary
• S - System Testing
Story for the Mnemonic: A ninja named BVA runs to the Warehouse where Inspectors
are looking for New shipments. They have to be careful about the Shipping deadline,
ensuring everything fits within the accepted size (valid range) and not exceeding the
boundaries!

Page 7 of 9
Q. Differentiate between Quality Assurance and Quality Control
→
Explanation of the Topic:
Quality Assurance (QA) and Quality Control (QC) are both critical components of quality
management in software development, but they focus on different aspects of the process:
• Quality Assurance (QA): QA is a proactive, process-oriented practice aimed at ensuring the
development and maintenance processes are effective and efficient. The goal is to prevent
defects from occurring in the first place by improving and optimizing the processes that lead to
the creation of the product. QA is focused on the entire software development lifecycle (SDLC)
and aims to implement best practices, standards, and methodologies.
• Quality Control (QC): QC, on the other hand, is a reactive, product-oriented practice that
focuses on identifying and fixing defects in the final product. It involves activities like testing,
inspections, and reviews to ensure that the software meets the required quality standards. QC
is about detecting problems in the software before it is released.

Page 8 of 9
Q. State the Entry and Exit criteria’s for the software testing
→
Explanation of the Topic:
Entry Criteria and Exit Criteria in software testing define the specific conditions under which testing
activities can begin and end. These criteria ensure that testing is performed effectively and that
software is tested thoroughly before release.
1. Entry Criteria: These are the conditions that must be met before testing can begin. The
purpose of entry criteria is to ensure that the testing process starts only when the software is
ready to be tested. This helps prevent unnecessary delays and ensures that testing is carried
out under optimal conditions.
Common entry criteria include:
o Requirements and design documents are complete and available.
o The test environment is set up and ready.
o Test cases are created and reviewed.
o The build is stable and has passed initial development stages (unit testing).
o Test data is prepared.
2. Exit Criteria: These are the conditions that must be met before testing can be concluded. The
exit criteria ensure that testing is thorough and that the software has been tested according to
the defined requirements. Testing cannot be considered complete unless all exit criteria are
met.
Common exit criteria include:
o All planned test cases have been executed.
o All critical and high-priority defects have been resolved.
o The software meets the acceptance criteria.
o The test coverage is deemed adequate (e.g., sufficient functional, integration, and system
testing).
o Test results are documented, and reports are reviewed.
o The test team is satisfied that the product is stable and ready for release.

Page 9 of 9