SOFTWARE TESTING $$

a) “Debugging starts only after successful conduct of testing.” State true or false. Justify.

False. Debugging starts when a defect is found during testing. Testing identifies defects, while
debugging involves finding and fixing the root cause of those defects.

b) Define Regression Testing.

Regression testing ensures that recent code changes do not negatively affect the existing
functionality of the software. It helps maintain software stability.

c) Define Configuration Testing.

Configuration testing verifies the software’s performance on different hardware, operating systems,
networks, and software environments to ensure compatibility.

d) Define Stress Testing.

Stress testing evaluates the system’s ability to handle extreme loads, such as high traffic or data
processing, to check for crashes or performance issues.

e) Define Error.

An error is a mistake in the code, logic, or design of software that leads to incorrect results or
system failures.

f) List Any 2 Objectives of Software Testing.

1. To detect and fix bugs or defects in the software.

2. To ensure the software meets the requirements and works correctly.

g) What is Agile Methodology?

Agile methodology is an iterative and flexible software development approach that delivers small,
functional parts of software in short cycles, improving adaptability to changes.

h) Define Test Plan.

A test plan is a document that outlines the testing strategy, objectives, scope, resources, and
schedule for testing activities in a project.

i) Define Verification.

Verification ensures the correctness of software design and requirements before development,
confirming that the product is being built correctly.

j) Define Web Application.

A web application is a software program that runs in a web browser and is accessed via the
internet, such as Gmail, Facebook, or online banking systems.
a) Define software testing.

Software testing is the process of identifying and fixing bugs, errors, or any missing requirements in
a software application to ensure it works as expected and meets the user's needs.

b) What is mean by validation?

Validation is the process of checking whether the software meets the requirements and expectations
of the user and ensures that the final product is correct and useful.

c) What is stub?

A stub is a temporary program or piece of code that mimics the behavior of a module or component
in a system, allowing other parts to be tested when the real module is not yet ready.

d) Write goal of white box testing.

The main goal of white box testing is to verify the correctness of the internal structure, logic, and
code of the software by testing different paths, conditions, and loops.

e) Define regression testing.

Regression testing is a type of testing performed to ensure that recent changes, updates, or bug fixes
in the software do not negatively impact the existing functionality of the application.

f) List any 2 agile principles.

1. Deliver working software frequently, with a preference for shorter timescales.

2. Welcome changing requirements, even late in development, to provide a competitive
advantage.

g) List dimensions of quality.

1. Functionality: The software must meet the required features and provide the expected
output.
2. Reliability: The software should perform consistently and without failure under specified
conditions.

h) Define web application testing.

Web application testing is the process of testing a web-based application to ensure it functions
properly, is secure, performs well under different conditions, and is compatible with various devices
and browsers.

i) List levels of testing.

1. Unit testing: Testing individual components or modules of the software.

2. Integration testing: Testing the interaction between integrated modules.
3. System testing: Testing the complete system to check if it meets specified requirements.
4. Acceptance testing: Testing conducted to verify if the system is ready for delivery to the
customer.
j) What is test plan?

A test plan is a detailed document that describes the scope, approach, resources, schedule, and
objectives of the testing activities. It acts as a guide for testing and ensures that all required
functionalities are tested systematically.

a) Define the term errors.

Errors are mistakes in the software code or logic that cause incorrect or unexpected results. They
occur during development and must be fixed to ensure proper functioning.

b) What is stub?

A stub is a temporary code used during testing to simulate the behavior of a missing or incomplete
module. It allows other parts of the system to be tested.

c) Write a goal of white box testing.

The goal of white box testing is to verify the internal logic, code, and structure of the software to
ensure it works correctly.

d) What is test plan?

A test plan is a document that defines the testing approach, scope, objectives, and resources. It helps
organize and guide testing activities systematically.

e) Write two methods of Black Box Testing.

1. Equivalence Partitioning: Divides inputs into groups and tests one value from each group.
2. Boundary Value Analysis: Focuses on testing edge values of input ranges.

f) Write dimensions of quality.

1. Functionality: Ensures the software meets requirements.

2. Reliability: Ensures consistent performance without failure.

g) What do you mean by performance testing?

Performance testing checks how well software performs under normal and heavy workloads,
focusing on speed, stability, and responsiveness.

h) Write a goal of unit testing.

The goal of unit testing is to test individual components of the software to ensure they work as
expected before integration.

i) Which is a core agile principle?

Delivering working software frequently is a core agile principle, focusing on shorter development
cycles and faster feedback.
j) Define the term Regression Testing.

Regression testing ensures that recent changes or updates in the software do not break existing
features. It involves re-running previous test cases.

a) What is fault?

A fault is a defect or issue in the software code or system that causes it to produce incorrect or
unexpected results during execution.

b) Define verification.

Verification ensures that the software is built according to specified requirements and design. It
answers the question, "Are we building the product right?"

c) Define stub.

A stub is a temporary piece of code used in testing to mimic a module’s behavior when the actual
module is not ready or available.

d) Write methods of white box testing.

1. Control Flow Testing: Tests the logical flow of the program.

2. Data Flow Testing: Focuses on how data moves through the code.
3. Branch Testing: Ensures every branch in the code is executed.

e) Define regression testing.

Regression testing is the process of re-testing the software after changes to ensure existing
functionalities are not affected by updates or fixes.

f) What is Agile Methodology?

Agile methodology is a software development approach that emphasizes iterative progress,

customer collaboration, and flexibility in adapting to changes during the development process.

g) List dimensions of quality.

1. Functionality
2. Reliability
3. Usability
4. Performance

h) Define strategy for web applications.

A strategy for web application testing involves testing functionality, performance, compatibility,
security, and user experience to ensure the application works correctly across all platforms and
devices.
i) Define acceptance testing.

Acceptance testing is conducted to verify if the software meets user requirements and is ready for
delivery. It is the final testing phase before release.

j) Black box testing is called glass box testing. Justify T/F.

False. Black box testing focuses on input and output without knowing internal code, while glass box
testing (white box testing) examines the internal structure and logic of the software.

a) Define debugging.

Debugging is the process of identifying, isolating, and fixing issues or defects (bugs) in the
software code to ensure the software functions as expected.

b) Black Box testing is known as glass box testing. Justify T/F.

False. Black Box testing focuses on testing the software's functionality based on inputs and
expected outputs without knowledge of the internal code. Glass Box testing (or White Box testing)
involves testing the internal structure, logic, and code.

c) Write advantages of Load Testing.

1. Identifies Performance Bottlenecks: Helps detect issues that slow down the application
under heavy load.
2. Ensures Scalability: Verifies if the system can handle increased user traffic and data load.

d) Write difference between Agile and Traditional testing.

1. Agile Testing: Involves continuous testing throughout the development process, with
iterative feedback and changes.
2. Traditional Testing: Follows a linear approach, testing after development phases like design
and coding are completed.

e) Write objective of Spike testing.

The objective of Spike testing is to test the system's response to sudden, extreme increases in load
or traffic. It helps assess how the system performs under stress or unexpected conditions.

f) List any 2 objectives of Software Testing.

1. Verify Correctness: Ensure the software behaves as expected and meets specified
requirements.
2. Detect Defects: Identify and fix bugs or issues in the software to improve its quality.

g) Define Cyclomatic complexity.

Cyclomatic complexity is a metric used to measure the complexity of a program’s control flow. It
is calculated based on the number of independent paths through the program, indicating how
complex or simple the code is.
h) Define Test plan.

A test plan is a detailed document that describes the scope, approach, resources, schedule, and
objectives for testing. It outlines the strategy and activities required to verify that the software meets
its requirements.

Q2 2 mark each

a) Describe Configuration Testing with Example.

Configuration testing checks software performance on different hardware, OS, networks, and
browsers to ensure compatibility.

Example:
A web application is tested on Windows, macOS, Linux, and browsers like Chrome, Firefox,
Edge to ensure proper functionality across all configurations.

b) Difference Between White Box and Black Box Testing.

Aspect White Box Testing Black Box Testing

Tests internal code, logic, and Tests software functionality without seeing
Focus
structure the code
Performed By Developers Testers
Knowledge
Requires coding knowledge No coding knowledge needed
Required
Testing a sorting algorithm’s Checking if a login form accepts valid
Example
logic credentials

c) Features of Agile Testing.

1. Continuous Testing: Testing is done throughout development.

2. Customer Involvement: Frequent feedback from users.
3. Flexibility: Adaptable to changes in requirements.
4. Faster Delivery: Ensures quick releases in short iterations (sprints).
5. Collaboration: Developers and testers work closely together.

d) What is Integration Testing? How It Works?

Integration testing ensures that multiple modules work together correctly after unit testing.

How It Works:

1. Combine individual modules.

2. Test data flow between them.
3. Identify interface and communication errors.

Example: Testing a banking app where login, balance check, and fund transfer modules interact
correctly.
e) What is Agile Manifesto?

The Agile Manifesto is a set of 4 values and 12 principles for Agile software development,
focusing on:

1. Individuals and interactions over processes and tools.

2. Working software over comprehensive documentation.
3. Customer collaboration over contract negotiation.
4. Responding to change over following a fixed plan.

It promotes flexibility, teamwork, and continuous improvement in software development.

a) Write 2 differences between bugs, faults & failures.

1. Bugs: Bugs are errors in the software's code or design that lead to unintended behavior or
incorrect results. They are usually introduced during development and can range from simple
coding mistakes to logic errors.
2. Faults: Faults are defects or imperfections in the software caused by bugs. A fault occurs
when the code behaves inappropriately or incorrectly due to a bug. Faults may not always
cause visible issues until the software is executed.

b) Write short note on black box testing.

Black Box Testing is a testing technique where the tester focuses solely on the functionality of the
software, examining its outputs based on different inputs, without any knowledge of the internal
code or structure. The aim is to verify if the software meets the specified requirements, ensuring that
the system behaves as expected. Test cases are designed based on functional specifications, and the
software's behavior is tested from the user’s perspective, without delving into how the system works
internally.

c) Explain equivalence partitioning.

Equivalence Partitioning is a black-box testing technique used to divide input data into classes or
partitions where all values in each class are considered equivalent. This method helps to reduce the
number of test cases by selecting one representative value from each partition, ensuring broad
coverage without testing every possible input. The partitions are usually divided into valid (where
inputs meet the criteria) and invalid (where inputs do not meet the criteria) classes, helping to
identify areas that could cause software failure or malfunction.

d) Explain performance testing.

Performance Testing is designed to assess how well a software application performs under varying
conditions. It measures factors such as response time, throughput, and stability when the system is
under different levels of load. The goal is to ensure that the software can handle expected and peak
traffic volumes efficiently, without experiencing slowdowns, crashes, or excessive delays.
Performance testing helps identify bottlenecks, such as areas where the application may slow down
or fail to respond under stress, allowing developers to optimize these areas for better scalability and
user experience.
e) Write features of agile testing.

1. Iterative Testing: Agile testing is performed in small, iterative cycles or sprints, where
testing is carried out frequently and in parallel with development. This allows for quick
identification and resolution of issues, as the product evolves in smaller increments.
2. Collaborative Approach: Agile testing emphasizes close collaboration between testers,
developers, and business stakeholders. This ensures that feedback is continuously
incorporated, promoting better product quality and alignment with user requirements. Testing
is not a separate phase but a continuous activity throughout the development cycle, ensuring
more flexibility and faster response to changes.

a) Write an advantage of white box testing.

Advantage of White Box Testing: One key advantage of white box testing is that it helps identify
hidden errors in the software’s internal structure and logic. By having access to the source code,
testers can verify all possible code paths, conditions, and branches. This ensures thorough testing,
potentially catching errors that may not be visible through external testing methods like black box
testing. It also helps in optimizing the code and improving its efficiency.

b) Explain the working of web application.

A web application works by having a client (typically a web browser) interact with a web server
over the internet. The client sends HTTP requests to the server, which processes these requests and
sends back appropriate responses, often in the form of HTML, CSS, and JavaScript to render the
content. The server handles business logic, databases, and application functions, while the front-end
(client-side) manages the user interface and presentation. Web applications rely on technologies like
HTML, CSS, JavaScript for the front-end, and server-side languages like PHP, Python, or Node.js
for backend logic.

c) Explain various forms of acceptance testing.

There are several forms of acceptance testing performed to validate the software’s functionality
and ensure it meets the user’s requirements.

1. Alpha Testing: Conducted by internal developers or testers in a controlled environment

before releasing the software to a group of users.
2. Beta Testing: Performed by a group of external users who test the software in real-world
environments. Feedback from beta testing helps to identify issues that weren’t found during
alpha testing.
3. User Acceptance Testing (UAT): The final phase of acceptance testing, where end-users
test the system to ensure it meets their needs and business requirements.
d) Write features of agile testing.

1. Continuous Feedback: Agile testing provides continuous feedback, allowing frequent

adjustments to be made based on stakeholder and user input throughout the development
cycle.
2. Collaboration: There is strong collaboration between developers, testers, and business
stakeholders, which ensures the final product aligns closely with the user’s needs.
3. Flexibility: Agile testing is flexible, allowing for changes to be incorporated even late in the
development process, based on evolving requirements or priorities.
4. Iterative Testing: Testing is done in iterative cycles, or sprints, ensuring the software is
tested frequently and issues are addressed early on.

e) Explain various types of system testing.

System Testing is a comprehensive testing process that verifies the entire system’s functionality as
a whole. It includes various types:

1. Functional Testing: Validates the functionality of the system against specified requirements,
ensuring the system works as intended.
2. Non-Functional Testing: Evaluates aspects such as performance, security, and usability to
ensure the system meets all non-functional requirements.
3. Integration Testing: Focuses on verifying that different modules of the system work
together correctly.
4. Security Testing: Ensures the system is secure from vulnerabilities, ensuring data protection
and privacy.
5. Usability Testing: Assesses how user-friendly and intuitive the system is for the end users.
6. Compatibility Testing: Verifies the system’s compatibility across different environments,
devices, and browsers.

a) Write short note on testing roles.

Testing Roles refer to the different responsibilities and tasks assigned to various individuals in the
software testing process. Common roles include:

1. Test Lead/Manager: Oversees the testing process, plans testing activities, and ensures the
team follows the testing strategy.
2. Test Engineer: Executes tests, reports defects, and ensures the system works as expected.
3. Automation Engineer: Develops and maintains automated test scripts to improve the
efficiency of testing.
4. Quality Analyst (QA): Focuses on ensuring overall product quality by validating
requirements, process adherence, and testing effectiveness.

b) Explain white box and black box testing.

White Box Testing: This is a testing technique where the internal structure, design, and code of the
software are tested. The tester needs knowledge of the code and logic to design test cases. It aims to
check the internal workings, paths, and control structures in the program to ensure correctness.
Black Box Testing: In black box testing, the tester focuses on testing the software’s functionality
without any knowledge of its internal structure or code. Testers validate the outputs based on given
inputs and compare them to the expected results, ensuring that the system meets the specified
requirements without considering its internal code.
c) Compare testing and debugging (any two points).

1. Purpose:
o Testing is the process of evaluating software to identify defects or bugs by checking if
it meets requirements.
o Debugging is the process of identifying and fixing the bugs or defects found during
testing.
2. Focus:
o Testing focuses on verifying functionality and finding defects in the system's
behavior.
o Debugging focuses on finding the root cause of a defect and fixing it in the code.

d) Explain performance of testing.

Performance Testing evaluates how well a software system performs under various conditions,
such as different user loads, stress, and data volumes. The main objectives include:

1. Response Time: Measuring how quickly the system responds to user requests.
2. Throughput: The amount of work the system can handle within a given time frame.
3. Scalability: Ensuring the system can handle an increased load without compromising
performance.
4. Stability: Verifying the system can perform well under sustained stress or usage.

a) Explain Top-down integration.

Top-down integration is a software testing technique where testing begins with the top-level
modules of the system, and lower-level modules are gradually integrated and tested as the process
progresses. Initially, stubs (placeholders for missing modules) are used to simulate the behavior of
lower modules. As each module is integrated, it is tested in conjunction with the upper levels. This
approach allows early detection of high-level design issues and is useful for validating the overall
system structure.

b) Write difference between White and Black box testing.

1. Knowledge of Internal Structure:

o White Box Testing: Testers have access to the internal code and structure of the
application. They test the internal logic and paths within the software.
o Black Box Testing: Testers do not have knowledge of the internal workings of the
system and focus on testing the software’s functionality from the user’s perspective.
2. Focus of Testing:
o White Box Testing: Focuses on testing code, logic, and internal paths, such as
functions, loops, and conditions.
o Black Box Testing: Focuses on checking the correctness of system outputs based on
various inputs, ensuring the software meets user requirements.
d) Write short note on dimensions of quality.

Dimensions of Quality refer to the various aspects that define and measure the quality of a software
product. Key dimensions include:

1. Functionality: How well the software performs the required tasks and meets functional
requirements.
2. Reliability: The ability of the software to consistently perform without failure over time.
3. Usability: How easy and user-friendly the software is for the end-user.
4. Efficiency: The software’s ability to perform tasks with optimal use of resources (e.g., CPU,
memory).
5. Maintainability: How easy it is to modify and update the software when needed.
6. Portability: The software’s ability to run across different environments, platforms, or
devices.

e) Write advantages of regression testing.

1. Ensures Stability: Regression testing ensures that new changes (like bug fixes or feature
updates) do not negatively impact the previously working functionality of the software.
2. Early Bug Detection: By re-running previously executed test cases, regression testing helps
identify bugs that might have been inadvertently introduced during updates.
3. Improves Software Quality: It helps maintain a high level of software quality by verifying
that existing features continue to function properly even after changes.
4. Time Efficiency: Automated regression tests can be re-used across different software
versions, saving time and resources in repeated testing.

Q3

a) Explain V-Model in Detail.

The V-Model (Verification and Validation Model) is a software development and testing model
where each development phase has a corresponding testing phase. It follows a sequential approach
shaped like the letter "V".

Phases of V-Model:

1. Requirement Analysis → Acceptance Testing

o User requirements are gathered.
o Acceptance testing checks if software meets user expectations.
2. System Design → System Testing
o The overall system architecture is designed.
o System testing verifies the complete system's functionality.
3. High-Level Design → Integration Testing
o Modules and their interactions are designed.
o Integration testing checks communication between modules.
4. Low-Level Design → Unit Testing
o Detailed design of individual components is created.
o Unit testing verifies each component's correctness.
5. Coding (Implementation)
o Developers write code based on the design.
o No testing phase here, as coding is a part of development.
c) What is Internationalization Testing? Explain Its Phases Diagrammatically.

Internationalization Testing ensures a software application can support multiple languages,

regions, and cultural formats without modifying the code.

Phases of Internationalization Testing:

1. Requirement Analysis:
o Identify target languages, regions, and supported formats.
2. Design & Development:
o Ensure UI and database support different scripts and special characters.
3. Implementation & Testing:
o Test text expansion, layout adjustments, and encoding compatibility.
4. Execution & Bug Fixing:
o Verify language switching, correct date/currency display, and fix errors.
5. Final Validation & Deployment:
o Ensure software runs correctly in different locales before release.

Diagram Representation:
Requirement Analysis → Design & Development → Implementation & Testing → Execution
& Bug Fixing → Final Validation & Deployment

Example: A global e-commerce website adapting its interface for US, Japan, and Germany,
ensuring proper text alignment, currency symbols, and date formats.

b) Short Note on Dimensions of Quality.

Quality in software testing is measured through different dimensions, ensuring the software meets
user needs and expectations.

Key Dimensions:

1. Functionality: Ensures software works correctly and meets requirements.

2. Reliability: Checks if the software runs consistently without failure.
3. Usability: Tests if the software is easy to use for end users.
4. Performance: Ensures fast response time and scalability.
5. Security: Identifies vulnerabilities to prevent cyber threats.
6. Maintainability: Measures how easily the software can be updated or fixed.
7. Portability: Checks if the software can run on different environments.

A high-quality software product must satisfy all these dimensions.

a) With the help of a diagram explain V-model.

The V-Model (Verification and Validation Model) is a software development and testing model
where the process steps are bent upwards after the coding phase to form a "V" shape. It emphasizes
verification and validation at each stage of development, ensuring that testing is planned alongside
development.

Explanation:

1. Requirements Analysis: In this phase, user needs are gathered, and system requirements are
defined.
2. System Design: Based on the requirements, the system design is created, which includes
both high-level and detailed design.
3. Architecture Design: This is where the technical architecture is designed, defining how the
system components will interact.
4. Coding: The actual code is written based on the design specifications.
5. Unit Testing: Testing of individual components or modules to check if they work as
expected.
6. Integration Testing: Verifying the interactions between integrated modules and ensuring
they function correctly together.
7. System Testing: Checking the system as a whole to ensure it meets all the specified
requirements.
8. Acceptance Testing: Testing the system in the real-world environment to confirm that it
meets user needs.

Diagram:

Requirements Analysis ---> System Design ---> Coding

| | |
Unit Testing <--- Integration Testing <--- Acceptance Testing
System Testing

Each phase in the development process has a corresponding testing phase, ensuring that the software
is validated at every stage.
b) What is a test case? Explain with an example.

A test case is a set of conditions or variables used to determine if a system or component is working
correctly. It includes the input data, execution steps, expected results, and an outcome that helps
evaluate if the software functions as intended.

Test Case Structure:

1. Test Case ID: A unique identifier for the test case.

2. Test Description: Brief explanation of what the test is verifying.
3. Input: Data provided to the system.
4. Execution Steps: Actions performed during the test.
5. Expected Results: What the system should do after the test.
6. Actual Results: What the system does during testing.
7. Pass/Fail Criteria: Outcome based on expected results.

Example:
Test Case ID: TC001
Test Description: Verify login functionality for valid user credentials.
Input:

• Username: "user1"
• Password: "password123"
Execution Steps:

1. Open the application login page.

2. Enter username and password in respective fields.
3. Click "Login" button.
Expected Result: The user should be logged in and redirected to the dashboard.
Actual Result: User logged in and redirected to the dashboard.
Pass/Fail: Pass
c) Explain Navigation testing in detail.

Navigation Testing ensures that a user can navigate through an application or website without
encountering any issues or broken links. This type of testing focuses on the flow between screens,
pages, or modules to verify that all links, buttons, and actions lead to the correct destination.

Key Points of Navigation Testing:

1. Link Functionality: Verify that every link, button, and menu item in the system is working
correctly and redirects the user to the appropriate page.
2. Page Transitions: Ensure that the transition from one page to another is smooth and occurs
without errors, such as broken links or incorrect page load.
3. Consistency: Check that the navigation structure remains consistent across different pages or
modules, providing a uniform experience for the user.
4. User Flow: Test that the system supports the user's expected flow and allows them to
navigate easily between the application’s features.
5. Back and Forward Navigation: Validate that users can move forward and backward
through pages without issues, and that pressing the "Back" button on a browser or mobile app
works as expected.

Example:
Consider testing an e-commerce website.

• Check if clicking on a product category takes the user to the list of products.
• Verify that clicking a product leads to its detailed page.
• Ensure that the "Add to Cart" button works and correctly updates the shopping cart.
• Test if the "Proceed to Checkout" button redirects to the checkout page.

The goal of Navigation Testing is to ensure that users can efficiently and error-free navigate
through the software or website, improving user experience.

a) Explain the difference between Testing and Debugging.

 Testing is the process of evaluating and verifying that a software application behaves as
expected. It involves executing the software with various inputs to ensure it produces the correct
outputs. The main goal of testing is to find defects or bugs in the software before it is released.
Testing can be performed at different stages of development, such as unit testing, integration testing,
system testing, and acceptance testing. During this phase, testers do not fix the problems but only
identify them. It helps ensure that the software meets the requirements and works as intended in
different scenarios.

 Debugging, on the other hand, is the process that comes after testing when a defect or bug has
been identified. Debugging involves diagnosing and fixing the root cause of the problem. It requires
reviewing the code, analyzing logs, and using debugging tools to trace the source of the issue. The
purpose of debugging is to resolve the identified issues, correct the errors, and make sure the system
works as expected after making the necessary changes. Debugging is a more technical task and
requires an in-depth understanding of the codebase
b) What is Cyclomatic Complexity and Graph Matrix? Explain with example.

Cyclomatic Complexity is a software metric that measures the complexity of a program’s control
flow by counting the number of linearly independent paths. It helps assess the risk of software, as
higher cyclomatic complexity indicates more complex and potentially error-prone code. The
formula for calculating cyclomatic complexity is: CC=E−N+2P

• Where:
• E = Number of edges (connections between statements)
• N = Number of nodes (statements/conditions)
• P= Number of independent parts (usually 1)

Example:
Consider the following code snippet:

if (x > 10):
if (y < 5):
print("Condition 1")
else:
print("Condition 2")
else:
print("Condition 3")

Here, we have three possible paths:

1. Path 1: x>10x > 10x>10 and y<5y < 5y<5

2. Path 2: x>10x > 10x>10 and y>=5y >= 5y>=5
3. Path 3: x<=10x <= 10x<=10

Thus, the cyclomatic complexity is 3, which indicates there are three independent paths.

Graph Matrix is a representation of a program’s control flow, where nodes represent program
statements, and edges represent the flow of control between them. It helps in visualizing the
program’s structure and calculating cyclomatic complexity.
c) Explain the process of stress testing with example.

Stress Testing is a type of software testing that evaluates how a system behaves under extreme or
abnormal conditions, typically beyond its specified capacity. The objective is to identify the
system’s breaking points, performance degradation, and how it recovers from failure. Stress testing
helps ensure that the software can handle unexpected high loads or situations where resources are
limited.

Process of Stress Testing:

1. Set Extreme Conditions: Create a test environment with more load than the system is
designed to handle, such as high traffic, large data volumes, or low memory.
2. Execute Tests: Run the system under these extreme conditions and monitor its performance,
stability, and responsiveness.
3. Monitor Performance: Check system resources like CPU, memory, and disk usage to
ensure the system does not crash and can handle the load.
4. Identify Failures: Observe how the system fails, if at all. This includes testing the system's
ability to recover from failures (e.g., automatic restarts or error handling).

Example:
Consider a website designed to handle 100 concurrent users. During stress testing, simulate 1,000
users accessing the site simultaneously. Monitor how the website performs under this load. If the
site crashes or becomes extremely slow, the test will reveal performance bottlenecks and
weaknesses, allowing developers to improve the system’s handling of heavy loads.

c) Explain navigation testing in detail.

Navigation Testing ensures that users can move smoothly between pages and sections of a website
or application. The focus is on validating the functionality of links, buttons, menus, and page
transitions.

Key Areas:

1. Link Testing: Ensure all links (internal and external) point to the correct destinations
without errors.
2. Button Functionality: Test buttons (e.g., "Submit," "Next") to ensure they perform the
correct actions.
3. Menu and Navigation Bars: Check that menus and navigation options are consistent and
work properly.
4. Breadcrumbs: Verify breadcrumb links lead to the correct higher-level pages.
5. User Flow: Ensure users can move logically from one page to another, especially during
tasks like checkout on e-commerce sites.

Example:
On an e-commerce site, navigation testing includes verifying if clicking a product leads to the detail
page and if the "Add to Cart" button works correctly. It ensures the website is user-friendly and all
navigational elements function as intended.
b) Write a short note on V-model with diagram.

The V-Model (Verification and Validation Model) is a software development model where each
development phase has a corresponding testing phase. The process follows a "V" shape, with
development activities on the left side and corresponding testing activities on the right side. This
model emphasizes that testing should be planned in parallel with development, ensuring that errors
are caught early.

Phases:

1. Requirement Analysis: Gather user requirements.

2. System Design: Design the system to meet the requirements.
3. High-Level Design: Define system components.
4. Low-Level Design: Design individual modules.
5. Coding: Implement the code.

Corresponding Testing Phases:

1. Unit Testing: Test individual components.

2. Integration Testing: Ensure modules work together.
3. System Testing: Validate the entire system.
4. Acceptance Testing: Ensure the system meets user needs.

Diagram:

Requirements Analysis
|
System Design
|
High-Level Design
|
Low-Level Design
|
Coding
|
------------------------
| |
Unit Testing Integration Testing
| |
System Testing Acceptance Testing
b) Describe basic path testing with example.

Basic Path Testing is a white-box testing technique that involves selecting paths through the code
to ensure that every possible path in the program is covered by test cases. It ensures the program is
tested for all logical flows and checks for errors in decision-making and branching. This technique
is based on control flow graphs where each node represents a program statement, and edges
represent control flow between statements.

Steps in Basic Path Testing:

1. Identify all the possible paths in the program.

2. Choose a set of paths that will cover all possible decision points.
3. Design test cases to execute those paths.

Example:
Consider a simple program where a user can log in by providing a username and password:

sif (username == "admin") {

if (password == "1234") {
print("Login successful");
} else {
print("Incorrect password");
}
} else {
print("Incorrect username");
}

In this example:

• Path 1: Username is "admin" and password is "1234" (successful login).

• Path 2: Username is "admin" but password is incorrect (failure).
• Path 3: Username is incorrect (failure).
c) What is system testing? How it tests the system? Also, list its different types.

System Testing verifies the complete and integrated system to ensure it meets the requirements. It
is done after integration testing and checks the system as a whole, not individual components.

How System Testing Works: System testing evaluates the system’s functionality, performance,
security, and usability based on the requirements. It ensures that all parts of the system work
together correctly in a complete environment.

Types of System Testing:

1. Functional Testing: Tests if the system’s features work as expected.

2. Usability Testing: Checks how user-friendly the system is.
3. Performance Testing: Assesses how the system performs under load.
4. Security Testing: Validates if the system is secure.
5. Compatibility Testing: Verifies the system works on different devices, browsers, or OS.
6. Stress Testing: Tests the system under extreme conditions.

Example:
For an online banking system, system testing would include verifying that users can log in, transfer
money, check account balances, and that the system performs well even under heavy traffic, is
secure from unauthorized access, and is compatible with multiple devices and browsers

Q4

a) What is Performance Testing? Write Steps in Performance Testing.

Performance Testing is a type of software testing that evaluates how a system performs under
different conditions, such as load, stress, and scalability. It ensures that the application responds
efficiently and remains stable under expected and peak workloads.

Steps in Performance Testing:

1. Requirement Gathering: Define performance goals (response time, throughput, resource

utilization).
2. Test Environment Setup: Configure the hardware, software, and network as per production
conditions.
3. Test Plan and Design: Identify key scenarios, test cases, and data.
4. Test Execution: Run performance tests using tools like JMeter, LoadRunner.
5. Monitor and Analyze Results: Check CPU, memory, network, and response times.
6. Identify Bottlenecks: Detect slow-performing components and optimize them.
7. Retest: Execute tests again after optimizations to ensure improvements.
a) What is Alpha and Beta Testing? Differentiate Between Them.

Alpha Testing:

• Conducted internally by developers and testers before release.

• Identifies critical bugs and functional issues.
• Performed in a controlled environment.

Beta Testing:

• Conducted by real users in a live environment.

• Focuses on user feedback and usability issues.
• Helps improve the software before final release.

Difference Between Alpha and Beta Testing:

Aspect Alpha Testing Beta Testing

Conducted
Developers & internal testers Real users in a real environment
By

Gather user feedback & detect usability

Purpose Identify major bugs before release
issues

Environment Lab/test environment Real-world environment

Participation Limited testers Large user base

Testing a new game internally before Public beta version of a mobile app for
Example
release feedback

c) Difference Between System, Performance, and Load Testing

Testing
System Testing Performance Testing Load Testing
Type

Checks software speed,

Validates the entire system’s Evaluates system behavior
Purpose stability, and
functionality under high user load
responsiveness

Functional and non- Response time, resource Handling of concurrent users

Focus
functional requirements usage, and scalability and data loads

Checking if an e-commerce Checking how a website

Testing if a web page
Example website allows transactions performs with 10,000 users
loads within 2 seconds
smoothly simultaneously

• System Testing ensures the software works as a whole.

• Performance Testing ensures the software runs efficiently under different conditions.
• Load Testing checks if the system can handle a high number of users or requests.
b) Differentiate Between Alpha & Beta Testing

Alpha Testing Beta Testing

Conducted by internal testers before release. Conducted by real users in a real environment.
Performed in a controlled lab setting. Performed in a live environment.
Aims to identify major bugs before public release. Helps gather user feedback for improvements.
Conducted by developers and testers. Conducted by end-users.
Less real-world impact. Provides real-world usage insights.

c) What is Integration Testing? Explain Top-Down Integration.

Integration Testing is a type of testing where multiple modules of a software application are
combined and tested as a group to check data flow and communication between them. It ensures
that different components work together as expected.

Top-Down Integration Testing:

• Testing starts from the topmost module and moves downward.

• Stubs (dummy modules) are used to simulate lower-level modules that are not yet
developed.
• Step-by-step, lower modules are integrated and tested until the full system is complete.
• Helps detect major design flaws early in the development cycle.

a) Define Navigation Testing. How to Test Navigation Syntax and Semantics?

Navigation Testing is a type of usability testing that ensures users can move smoothly between
different pages, sections, or features of an application without any confusion or broken links. It
focuses on verifying menus, buttons, hyperlinks, and overall workflow to provide a seamless user
experience.

Testing Navigation Syntax and Semantics:

1. Syntax Testing: This ensures that all navigation elements are correctly implemented,
meaning:
o Hyperlinks are not broken and lead to the correct destinations.
o Buttons work as expected and perform the right actions.
o Navigation elements (like menus) are displayed correctly on different screen sizes.
2. Semantics Testing: This verifies whether the navigation structure is logical and user-
friendly by checking:
o Whether links and buttons follow a clear naming convention (e.g., "Home" should
lead to the homepage).
o Whether users can easily find what they are looking for without confusion.
o Whether the flow between pages follows a natural order without unnecessary
redirections.
b) Define the Term Test Case. Explain with an Example.

A test case is a detailed document that specifies a set of actions, input values, and expected
outcomes to verify whether a specific feature of a software system works as intended.

Characteristics of a Good Test Case:

• Clearly defined objective and test steps.

• Covers both positive and negative test scenarios.
• Includes expected results to compare with actual results.
• Reproducible under different conditions.

Example Test Case:

Field Description
Test Case ID TC_001
Test Scenario Verify User Login Functionality
Preconditions User must be registered in the system
1. Open the login page.
Test Steps 2. Enter a valid username and password.
3. Click the ‘Login’ button.
Expected Result User should be redirected to the dashboard.
Actual Result As expected (Pass) / Login fails (Fail)
Status Pass / Fail

Test cases ensure system reliability and help in identifying defects before deployment.

c) Compare Verification and Validation.

Verification and Validation are two essential steps in software testing that ensure software quality
before release.

Aspect Verification Validation

Ensures that the product is built correctly as Ensures that the right product is built
Definition
per the specified requirements. and meets user needs.
To check if the software conforms to design To check if the software functions
Purpose
specifications. correctly in real-world scenarios.
When During the development phase before After verification, during the testing
Done? testing starts. phase.
Methods Reviews, Walkthroughs, Inspections, Static Functional Testing, UAT (User
Used Testing. Acceptance Testing), System Testing.
Checking if a login page design meets UI Testing if users can successfully log in
Example
guidelines. and access their account.

Both processes work together to ensure software meets functional, performance, and usability
expectations.
a) Write a Short Note on Alpha & Beta Testing.

Alpha Testing:

• Conducted before the product is released to the public.

• Performed in a controlled environment by internal testers (developers and QA team).
• Helps identify critical defects and usability issues early in development.
• Uses white-box and black-box testing techniques.

Beta Testing:

• Conducted after alpha testing but before the final release.

• Performed by real users in a real-world environment.
• Helps collect user feedback and uncover issues that may not have appeared in controlled
testing.
• Provides insights into performance, compatibility, and user experience.

Example: A software company might conduct alpha testing in-house and then release a beta
version to selected users for further feedback before launching the final version.

b) Explain Integration Testing. What is Bottom-Up Integration?

Integration Testing is the process of testing the interaction between different modules of a
software system. It ensures that combined components work together as expected.

Types of Integration Testing Approaches:

1. Top-Down Integration – Testing starts from the main module and moves down.
2. Bottom-Up Integration – Testing starts from the lower-level modules and integrates
upwards.

Bottom-Up Integration Testing:

• The lower-level modules (smallest units) are tested first.

• Uses drivers (dummy components) to simulate higher modules that are not yet developed.
• Once the lower modules are tested, they are combined and tested with the next higher
module.
• Helps identify defects in foundational components early.

Example: In a banking application, bottom-up integration might start by testing transaction

processing, then integrating it with account management, and finally connecting it to the user
interface.
c) What is a Web Application? How Does It Work? Explain with a Diagram.

A web application is a software program that runs on a web server and is accessed through a web
browser. Unlike desktop applications, web apps do not need to be installed on a user’s device.

How a Web Application Works:

1. User Request: The user enters a URL or interacts with the web app through a browser.
2. Web Server Processing: The request is sent to the web server, which processes it.
3. Database Interaction: If necessary, the web server retrieves or stores data from a database
server.
4. Response Generation: The web server sends back the required HTML, CSS, JavaScript,
or data.
5. Rendering: The user’s browser renders the response and displays the result.

User → Web Browser → Internet → Web Server → Application Logic → Database →

Response Back to User

b) What is Unit Testing? How It Works? Explain with Example.

Definition of Unit Testing:

Unit testing is a type of software testing where individual components or functions of a program
are tested in isolation to verify their correctness. It ensures that each unit (smallest testable part of
the software) works as expected before integrating them into the larger system.

How Unit Testing Works:

1. Identify Units: Developers identify the smallest testable parts, such as functions, methods,
or modules.
2. Write Test Cases: Each unit is tested using predefined test cases that provide input and
check expected output.
3. Execute Tests: Unit tests are executed using testing frameworks like JUnit (Java), PyTest
(Python), or NUnit (.NET).
4. Check Results: The actual output is compared with the expected output. If they match, the
test passes; otherwise, it fails.
5. Fix and Retest: If a test fails, developers fix the unit and rerun the tests to ensure
correctness.
Q5

a) Write a Short Note on Automated Tests.

Automated testing is a process where software tests are executed automatically using testing tools
instead of manual testing. It helps save time, reduce errors, and improve efficiency.

Key Features:

• Uses tools like Selenium, JUnit, TestNG, PyTest for execution.

• Runs test cases quickly and repeatedly without human effort.
• Useful for regression testing, where tests are rerun after code changes.

Example: Running an automated test to check if a website's login works after every update.

b) What is Internationalization Testing? Explain with Types.

Internationalization Testing ensures that a software application can support multiple languages,
regions, and cultures without requiring changes in code.

Types of Internationalization Testing:

1. Language Testing: Verifies if the software correctly supports different languages (e.g.,
English, French, Chinese).
2. UI Layout Testing: Checks if text expansion in different languages fits properly in the
interface.
3. Currency & Date Format Testing: Ensures correct display of date, time, currency, and
number formats based on region (e.g., $10.00 vs. €10,00).
4. Encoding Testing: Ensures correct character encoding (e.g., UTF-8) to display different
scripts properly.

Example: A global e-commerce website adapting its interface for US, Japan, and Germany with
different currencies and languages.
a) Explain the Various Phases of Internationalization Testing.

Internationalization testing is conducted in multiple phases to ensure the software supports different
languages, regions, and cultures without modifying its code.

Phases of Internationalization Testing:

1. Planning Phase:
o Identify target languages, regions, and cultural aspects.
o Define test strategy, tools, and test cases.
2. Design Phase:
o Ensure the UI and database can handle different languages, scripts, and special
characters (e.g., Arabic, Chinese).
o Plan for date, time, and currency format variations.
3. Implementation Phase:
o Execute test cases for different languages, layouts, and formats.
o Validate text expansion, encoding, and alignment.
4. Execution Phase:
o Use automated tools or manual testing to check how the application behaves in
different locales.
o Ensure no hardcoded text and verify translation accuracy.
5. Analysis and Reporting Phase:
o Identify and fix bugs related to localization.
o Validate that the software works properly in all targeted regions.

Example: A global e-commerce website ensuring that prices, dates, and text alignment are
displayed correctly in English, Japanese, and Arabic versions.

b) Difference Between Alpha and Beta Testing.

Aspect Alpha Testing Beta Testing

Conducted
Developers & internal testers Real users in a real environment
By

Environment In a controlled lab setting In a real-world setting

Gather user feedback & identify usability

Purpose Find critical bugs before release
issues

Large group (public users or selected

Participants Limited team (internal testers)
testers)

A software company testing a new Users testing the beta version of an app
Example
mobile app before release before its official launch

Alpha testing ensures basic functionality, while beta testing helps in real-world validation before
the final release.
a) Different Layers of Automated Tests

1. Unit Testing: Tests individual functions to ensure they work correctly.

o Example: Checking if a login function returns the correct output.
2. Integration Testing: Verifies if different modules work together properly.
o Example: Checking if the login module connects to the database.
3. UI Testing: Tests visual elements like buttons and forms.
o Example: Ensuring the login button redirects correctly.
4. End-to-End Testing: Ensures the entire application workflow functions correctly.
o Example: Testing an online purchase from product selection to payment.
5. Performance Testing: Checks how the system performs under high load.
o Example: Testing if a website handles heavy traffic.
6. Security Testing: Identifies vulnerabilities and protects data.
o Example: Ensuring unauthorized users cannot access restricted pages.

b) Agile Testing Quadrants

The Agile Testing Quadrants help teams plan testing in Agile development.

1. Quadrant 1: Unit & Component Tests (Automated)

o Tests individual functions for correctness.
o Example: Unit tests using JUnit, PyTest.
2. Quadrant 2: Functional & Story Tests (Automated & Manual)
o Ensures features meet business requirements.
o Example: Automated functional testing.
3. Quadrant 3: Exploratory & Usability Testing (Manual)
o Focuses on user experience and interface usability.
o Example: Checking if a mobile app is easy to use.
4. Quadrant 4: Performance & Security Testing (Automated)
o Tests speed, security, and scalability.
o Example: Load testing a banking app.

These quadrants ensure full software quality coverage in Agile development.