Unit IV SOFTWARE TESTING AND MAINTENANCE

Testing – Unit testing – Black box testing– White box testing – Integration
and System testing– Regression testing – Debugging - Program analysis –
Symbolic execution – Model Checking-Case Study
PART-A
1. Define Software Testing
Software testing is a comprehensive process of evaluating a software
application or system to ensure it functions as expected and meets all defined
requirements. It involves identifying and fixing defects or bugs to deliver
high-performing, reliable software that meets user needs.

2. What are the objectives of testing?

The primary objectives of testing, particularly in the context of software
development, are to identify and prevent defects, ensure quality, and validate
that the software meets user and business requirements. Testing also aims to
build confidence in the software's reliability and functionality.

3. What are the testing principles the software engineer must apply
while performing the software testing?
software engineer must apply the following key testing principles while
performing software testing:

1. Testing shows the presence of defects – Testing can show that defects are
present, but cannot prove that there are no defects.
2. Early testing – Testing should begin as early as possible in the software
development lifecycle to detect defects early and reduce cost.
These principles help ensure effective and efficient software testing.

4.List the levels of object oriented testing.

 Unit Testing – Tests individual classes and methods in isolation.
 Integration Testing – Tests interactions between objects and classes.
 System Testing – Tests the complete object-oriented system as a whole.
 Acceptance Testing – Validates the system against user requirements.

5. What are the two levels of testing

 Static Testing – Involves reviewing and analyzing the code or documents
without executing the program (e.g., code reviews, inspections).
  Dynamic Testing – Involves executing the code to validate the software’s
behavior and functionality (e.g., unit testing, system testing)

6. What are the reasons behind to perform white box testing?

 To verify internal logic and structure – Ensures that all internal
operations, paths, and conditions of the code work as intended.
 To achieve maximum code coverage – Helps identify untested paths,
unreachable code, and logical errors in the program.

7. Write short note on Black box testing.

Black box testing is a software testing method where the tester evaluates the
functionality of the software without knowing its internal code or structure.
It focuses on input-output behavior to verify if the system meets specified
requirements. Common techniques include equivalence partitioning, boundary
value analysis, and decision table testing.
8. Define integration testing.
Integration testing is the process of testing the interfaces and interaction between
integrated modules or components of a software system. It ensures that combined
parts work together as expected and data flows correctly between them.
9. What are the various testing strategies for conventional software
1. Unit Testing – Tests individual modules or components.
2. Integration Testing – Tests the interaction between integrated units.
3. Validation Testing – Ensures the software meets user requirements.
4. System Testing – Verifies the complete and integrated software system in its
environment.

10. Write about drivers and stubs.

 Drivers are dummy programs used to call and test lower-level modules
during bottom-up integration testing.
 Stubs are dummy modules that simulate the behavior of missing components
during top-down integration testing.
They help in testing incomplete systems by simulating missing parts.
11. Distinguish between verification and validation.
 Verification checks whether the software is built correctly (i.e., conforms to
design specifications).
 Validation checks whether the right software is built (i.e., meets user needs
and requirements).
Verification = Are we building the product right?
Validation = Are we building the right product?
12. What are the conditions exists after performing validation testing
 Validation Success – The software meets all user requirements and is ready
for delivery or deployment.
 Validation Failure – The software does not meet the specified requirements,
and necessary modifications or corrections must be made.
13. Distinguish between alpha testing and beta testing.
Alpha testing is an early-stage testing process conducted by internal teams
(developers, testers, etc.) to identify bugs and ensure core functionality before
releasing the product to external users.
Beta testing, on the other hand, involves releasing the software to a wider audience
of real users (beta testers) to gather feedback on usability, performance, and
identify any remaining issues in a real-world environment.
14. What are the various types of system testing
System testing encompasses a variety of testing types, broadly categorized
into functional and non-functional testing, with further specialized areas.
Functional testing ensures the system meets requirements, while non-functional
testing evaluates aspects like performance, security, and usability. Specific types
include load, stress, regression, recovery, compatibility, and usability testing.
15. Define debugging. What are the common approaches in debugging
Debugging is the process of identifying, analyzing, and correcting errors or bugs in
a software program.
Common Approaches in Debugging:
1. Brute Force Method – Using print statements or debuggers to trace and
locate errors.
2. Backtracking – Tracing the code backward from the point of failure to find
the cause of the bug.

PART-B

1. Explain about Unit Testing.

TESTING
 Testing in software testing and maintenance refers to the process of
evaluating a software application or system to identify defects, errors,
or bugs.
 It is a crucial phase in the software development lifecycle (SDLC) and
plays a significant role in ensuring the quality and reliability of the
software product

UNIT TESTING
 Unit testing is a software testing technique where individual units or
components of a software application are tested independently to
ensure that they perform as expected.
 A unit is the smallest testable part of any software, typically a
function, method, or procedure.
 The purpose of unit testing is to validate that each unit of the software
behaves as designed and to identify any defects or errors early in the
development process.
Here's a detailed explanation of unit testing:
 1.Scope:
 Unit testing focuses on testing individual units or components in isolation
from the rest of the software.
 This means that each unit is tested independently, regardless of its
dependencies on other units or external systems.
 Unit testing ensures that each unit functions correctly and produces the
expected output when given specific inputs.

2.Testing Environment
 Unit tests are usually performed in a controlled environment, such as an
integrated development environment (IDE) or a unit testing framework.
 Developers write test cases that include specific inputs, expected outputs, and
assertions to verify the behavior of each unit.
 These tests can be automated and executed repeatedly to ensure consistent
results.

3.Isolation
 Unit testing requires isolating the unit being tested from its dependencies.
 This is typically achieved using techniques such as mocking or stubbing,
where fake implementations of dependencies are provided to simulate their
behavior.
 By isolating units, developers can identify defects within the unit itself
 without being affected by issues in other parts of the software.

4.Test Cases
 Test cases for unit testing are designed to cover various scenarios and edge
cases that the unit may encounter during execution.
 These test cases are based on the unit's specifications, requirements, and
expected behavior.
 Test cases should be comprehensive enough to validate all possible paths
through the unit's code, including both normal and exceptional conditions.

5.Test Frameworks
 Unit testing is facilitated by various testing frameworks and tools available
for different programming languages and platforms.
 These frameworks provide functionalities for defining and running tests, as
well as reporting test results. Examples of popular unit testing frameworks
include JUnit for Java, NUnit for .NET, PHPUnit for PHP, and for Python.

Benefits
 Early Detection of Defects:
Unit testing allows developers to identify and fix defects early in the
development process, reducing the cost and effort required for debugging
and maintenance later on.
 Improved Code Quality
Writing unit tests encourages developers to write modular, well−
structured, and maintainable code, leading to higher overall code
quality.
 Regression Testing
Unit tests serve as a safety net against regressions by ensuring that changes
to the codebase do not introduce new defects or break existing functionality.
 Documentation
Unit tests also serve as executable documentation, providing insights into the
intended behavior and usage of each unit within the software.
 2. Describe about Black Box Testing
 Black box testing is a software testing technique where the internal workings
or structure of the software being tested are not known to the tester.
 Instead, the tester focuses on examining the software's functionality based
solely on its inputs and outputs, without considering its internal
implementation.
 The term "black box" refers to the idea that the software is treated as an
opaque entity, similar to a sealed black box, where only the externally visible
behavior is considered.
Here's a detailed explanation of black box testing:

Objective
 The primary objective of black box testing is to validate the correctness and
functionality of the software from the perspective of the end−user.
 Testers do not have access to the source code or internal design details of the
software; instead, they interact with the software through its user interface or
API.

Testing Scenarios
 Black box testing encompasses various testing scenarios, including
functional testing, non−functional testing, and regression testing.
 Functional testing involves verifying that the software functions according to
its specifications and requirements, while non−functional testing evaluates
aspects such as performance, usability, reliability, and security.
 Regression testing ensures that recent changes or updates to the software do
not adversely affect existing functionality.
Test Design
 Test cases for black box testing are designed based on the software's
requirements, specifications, and user documentation.
 Testers identify different inputs, actions, and conditions that the software
should handle and design test cases to validate these aspects.
 Test cases are created to cover both typical and boundary scenarios, as well
as error−handling and exception scenarios.

Techniques
 Various black box testing techniques are employed to maximize test
coverage and effectiveness.
 These include equivalence partitioning, boundary value analysis, decision
table testing, state transition testing, and use case testing.
 Each technique focuses on different aspects of the software's behavior and
helps identify potential defects or issues

Independence
 Black box testing promotes independence between testers and
developers. Testers do not need to have knowledge of the internal
implementation details or programming languages used in the software.
 This independence allows for unbiased testing and helps uncover
defects that might be overlooked by developers.

Advantages
 Encourages a user−centric approach to testing, ensuring that the software
meets user requirements and expectations.
 Facilitates early defect detection by focusing on the software's external
behavior and functionality.
 Allows for parallel testing efforts, where multiple testers can work
simultaneously on different aspects of the software.
 Promotes reusability of test cases across different versions or variations of
the software.

Disadvantages
 Limited coverage of internal logic or code paths, which may result in certain
defects remaining undetected.
  Relies heavily on the quality and accuracy of requirements and specifications
provided to testers.
 May overlook certain implementation−specific defects or performance issues
that require knowledge of internal workings.

3. Describe briefly about Program Analysis

 Program analysis is a broad term in computer science that refers to the
process of automatically analyzing software programs to gain insights into
their behavior, properties, and quality.
 Program analysis techniques aim to extract useful information about
programs, such as their correctness, performance, security vulnerabilities,
and other characteristics.
 Program analysis can be performed statically, by examining the source code
or binary without executing it, or dynamically, by observing program
behavior during execution. Here's an explanation of key aspects of program
analysis:

Static Analysis
 Static Analysis Techniques:
Static analysis techniques analyze software artifacts, such as source code,
bytecode, or binary executables, without executing them. Techniques
include data flow analysis, control flow analysis, abstract interpretation,
and symbolic execution.
 Code QualityStatic
analysis tools can assess code quality metrics, identify coding standards
violations, and detect potential bugs or defects in the code.

 Code Optimization
Static analysis can help identify opportunities for code optimization, such as
dead code elimination, loop unrolling, and inlining of functions.

Dynamic Analysis
 Runtime Behavior
Dynamic analysis observes the behavior of a program during execution.
Techniques include profiling, memory analysis, code coverage analysis, and
runtime monitoring.
  Performance Profiling
Dynamic analysis tools can measure program execution time, memory usage,
and other performance metrics to identify bottlenecks and optimize resource
utilization.
 Fault Localization
Dynamic analysis can help pinpoint the root cause of runtime errors,
crashes, or exceptions by tracing program execution and analyzing runtime
states.

Security Analysis
 Vulnerability Detection
Program analysis techniques can detect security vulnerabilities in software,
such as buffer overflows, injection attacks, race conditions, and privilege
escalation.
 Malware Detection
Program analysis tools can analyze software binaries to identify
characteristics of malware, such as suspicious code patterns, behavior, and
signatures.

Verification and Validation

 Formal Verification
Program analysis techniques, such as model checking and theorem proving,
can formally verify software correctness with respect to specified properties
or requirements.
 Testing Support
Program analysis tools can assist in test case generation, test coverage
analysis, and test result interpretation to support software testing efforts.

Program Understanding and Maintenance

 Code Understanding
Program analysis techniques provide insights into program structure,
dependencies, and relationships to aid in program comprehension and
maintenance tasks.
 Refactoring Support
Program analysis tools can identify opportunities for code refactoring, such
as code duplication, unused variables, and unreachable code.
Automated Program Repair
 Automated Bug Fixing
Program analysis techniques can automatically generate patches or fixes for
identified bugs or defects in software code.
 Code Synthesis
Program analysis tools can synthesize code snippets or templates to automate
repetitive programming tasks or generate code that satisfies specified
requirements.

Challenges and Limitations

 Scalability
Program analysis techniques may face scalability challenges when
analyzing large− scale or complex software systems due to the
exponential growth of analysis paths.
 Precision and Soundness
Balancing precision and soundness in program analysis is a challenge, as
overly conservative analyses may miss real defects, while overly aggressive
analyses may report false positives.

4. Build the process of Model Checking.

 Model checking is a formal verification technique used to systematically

check whether a model of a system satisfies a given specification or
property. It involves exhaustively exploring all possible states and
transitions of the model to verify whether certain properties, such as safety
or liveness, hold under all possible conditions.
 Model checking is commonly used in the verification of hardware and
software systems, protocol validation, and formal analysis of concurrent and
distributed systems.

1. Modeling the System:

 System Representation
The first step in model checking is to create a formal model of the system
being analyzed. The system is typically represented as a mathematical or
computational model, such as a finite−state machine, transition system,
Petri net, or temporal logic formula.
  State Space Representation
The model captures the system's states, transitions, and behavior. The state
space represents all possible states of the system, and transitions define
how the system moves from one state to another based on its actions or
inputs.

2.Specifying Properties
 Property Formulation
Model checking requires specifying formal properties or requirements that
the system should satisfy. Properties can be expressed using temporal logic
formulas, such as Linear Temporal Logic (LTL) or Computation Tree Logic
(CTL), to specify safety, liveness, fairness, or other properties.

 Safety vs. Liveness

Safety properties specify that certain undesirable states or behaviors are not
reachable in the system, while liveness properties ensure that desirable
states or behaviors will eventually occur.

3.Verification Process

 State Space Exploration

Model checking systematically explores all possible states and transitions
of the system's model to verify whether the specified properties hold. This
exploration is typically performed using algorithms that traverse the state
space in a systematic and efficient manner.

 Property Verification
At each state visited during the exploration, model checking checks
whether the properties specified in the specification hold. If a violation is
detected, the model checker provides a counterexample demonstrating how
the property is violated.

 Completeness and Soundness

Model checking algorithms are designed to be complete and sound,
meaning that they explore all reachable states of the system and produce
correct results regarding property satisfaction.
4. Tools and Techniques
 Model Checking Algorithms
Various model checking algorithms, such as breadth−first search, depth−first
search, symbolic model checking, and bounded model checking, are used to
explore the state space efficiently and verify properties.

 Model Checking Tools

There are numerous model checking tools and frameworks available, such as
NuSMV, SPIN, PRISM, and Alloy, that provide support for specifying
models, properties, and performing verification.

Advantages of build process modeling

 Automated and systematic verification technique.
 Guarantees completeness and correctness of results.
 Can verify complex systems with large state spaces.
1. **State Space Representation**: The model captures the system's states, transitions, and
behavior. The state space represents all possible states of the system, and transitions define how the
system moves from one state to another based on its actions or inputs.
 .### 5. **Program Understanding and Maintenance**:

− **Code Understanding**: Program analysis techniques provide insights into program structure,
dependencies, and relationships to aid in program comprehension and maintenance tasks.

− **Refactoring Support**: Program analysis tools can identify opportunities for code refactoring,
such as code duplication, unused variables, and unreachable code.

### 6. **Automated Program Repair**:

− **Automated Bug Fixing**: Program analysis techniques can automatically generate patches or
fixes for identified bugs or defects in software code.

− **Code Synthesis**: Program analysis tools can synthesize code snippets or templates to
automate repetitive programming tasks or generate code that satisfies specified requirements.

### 7. **Challenges and Limitations**:

− **Scalability**: Program analysis techniques may face scalability challenges when analyzing
large− scale or complex software systems due to the exponential growth of analysis paths.

− **Precision and Soundness**: Balancing precision and soundness in program analysis is a

challenge, as overly conservative analyses may miss real defects, while overly aggressive analyses
may report false positives.