UNIT-4

Software Testing
Software testing is the process of assessing the functionality of a software program. The process
checks for errors and gaps and whether the outcome of the application matches desired
expectations before the software is installed and goes live.

Or

Software testing is the process of evaluating and verifying that a software application or system
behaves as intended. The goal is to identify any defects, errors, or bugs in the software and ensure
that it meets the specified requirements. The testing process involves the execution of the software
or its components with the intent of finding discrepancies between expected and actual results.

Here are some key aspects of software testing:

1. Verification: Checking whether the product is being developed according to the

requirements.
2. Validation: Ensuring that the software meets the specified requirements and serves its
intended purpose.
3. Error Detection: Identifying defects, errors, or bugs in the software.
4. Quality Assurance: Ensuring the overall quality of the software by implementing processes
and standards.
5. Types of Testing: Includes functional testing (ensuring the software functions as intended),
performance testing (evaluating speed, responsiveness, and stability), security testing
(checking for vulnerabilities), and more.
6. Levels of Testing: Ranging from unit testing (testing individual components) to integration
testing (testing interactions between components) to system testing (testing the entire
system).
7. Test Cases: Sets of conditions or variables used to determine whether the software is
working correctly.
8. Regression Testing: Ensuring that new changes or updates do not negatively impact existing
functionalities.

Software Testing Process:

It involves a systematic evaluation of a software application to find and fix bugs and ensure it
behaves as expected. The process includes planning, test case development, execution, and result
analysis.

Software testing is the process of assessing the functionality of a software program. The process
checks for errors and gaps and whether the outcome of the application matches desired
expectations before the software is installed and goes live.
Functional testing
Functional testing is a type of testing that seeks to establish whether each application feature works
as per the software requirements. Each function is compared to the corresponding requirement to
ascertain whether its output is consistent with the end user's expectations.

Or

Functional testing is all about making sure that each part of a software application works as intended
and aligns with the specified requirements. It's like checking off a list to ensure that every function
and feature performs correctly.

By performing functional testing, development teams can gain confidence that each function of the
software is behaving correctly and meeting the expectations outlined in the requirements. It's an
essential step in the software development life cycle to deliver a reliable and user-friendly product.

Types of Functional Testing:

• Boundary Value Analysis: Testing at the limits of input ranges.

• Equivalence Class Testing: Dividing input data into classes for testing.
• Decision Table Testing: Ensuring all possible combinations of conditions are tested.
• Cause-Effect Graphing: Identifying and testing all possible cause-effect relationships.

Structural Testing
Structural Testing is a type of software testing. This testing is used to test the internal design of the
software or the structure of the coding for the particular software. Structural testing uses white box
testing techniques.

Or

Structural testing is a type of software testing that focuses on examining the internal design and
structure of the software, particularly the code. Unlike functional testing, which evaluates the
software based on its external behaviour, structural testing delves into the underlying
implementation details.

Structural testing is about inspecting the internal structure of the software to ensure it is well-
designed, follows best practices, and is robust in terms of code quality and logic. It plays a crucial
role in building reliable and maintainable software systems.
Types of Structural Testing:
Some common types of structural testing include:
• Path Testing: Ensuring that every possible path through the code is executed at least once.
• Data Flow Testing: Analyzing how data is processed and propagated through the code.
• Mutation Testing: Introducing small changes (mutations) to the code to check if the tests
can detect and identify these changes.
Unit Testing

Testing individual components or functions in isolation.

Unit testing is testing the smallest testable unit of an application. It is done during the coding phase
by the developers. To perform unit testing, a developer writes a piece of code (unit tests) to verify
the code to be tested (unit) is correct.
Unit testing is a fundamental aspect of the software testing process that involves testing individual
components or functions in isolation. The primary objective of unit testing is to ensure that each unit
of the software—typically a function or a small piece of code—functions correctly on its own.

Isolation of Components:
• In unit testing, each component or unit of the software is tested independently of
the rest of the system. This means that the focus is solely on the specific
functionality of that unit.
Purpose of Unit Testing:
• The goal is to validate that each unit performs as intended, adhering to the specified
requirements and producing the expected outputs for various inputs.
Benefits of Unit Testing:
• Early Detection of Defects: Unit testing allows for the early identification and
rectification of defects, ensuring that issues are addressed at the component level
before they propagate to the entire system.
• Simplified Debugging: When a unit test fails, it's easier to pinpoint the specific
component responsible for the failure, making the debugging process more
straightforward.
• Support for Refactoring: Unit tests provide a safety net when making changes to the
code. If existing functionality is inadvertently altered, unit tests will catch it.

Debugging

The process of identifying and fixing errors or defects in the software.

It is the process of finding and fixing errors or bugs in the source code of any software.
Debugging is the process of detecting and removing of existing and potential errors (also called as
'bugs') in a software code that can cause it to behave unexpectedly or crash. To prevent incorrect
operation of a software or system, debugging is used to find and resolve bugs or defects.

Debugging Process: The steps involved in debugging are:

• Problem identification and report preparation.
• Assigning the report to the software engineer defect to verify that it is genuine.
• Defect Analysis using modeling, documentation, finding and testing candidate flaws,
etc.
• Defect Resolution by making required changes to the system.
• Validation of corrections.
The debugging process will always have one of two outcomes :
1. The cause will be found and corrected.
2. The cause will not be found.
Integration and System Testing

Integration and System Testing verifies that components work together correctly and the system as a
whole meets requirements. It verifies that components work together correctly and the system as a
whole meets requirements.
Both integration testing and system testing play a critical role in the software development lifecycle.
Integration testing helps to ensure that the individual components are integrated correctly and work
together as intended, while system testing helps to ensure that the software functions correctly as a
whole.
Software Testing

Software Testing tools are the tools that are used for the testing of software. Software testing tools
are often used to assure firmness, thoroughness, and performance in testing software products.
Unit testing and subsequent integration testing can be performed by software testing tools. These
tools are used to fulfill all the requirements of planned testing activities. These tools also work as
commercial software testing tools. The quality of the software is evaluated by software testers
with the help of various testing tools.

Types of Testing Tools: Software testing is of two types, static testing, and dynamic testing.
The tools used during these testing are named accordingly on these testing.
Testing tools can be categorized into two types which are as follows:

1. Static Test Tools:

Static test tools are used to work on the static testing processes. In the testing through these
tools, the typical approach is taken. These tools do not test the real execution of the software.
Certain input and output are not required in these tools. Static test tools consist of the
following:

• Flow analyzers: Flow analyzers provides flexibility in the data flow from input to
output.
• Path Tests: It finds the not used code and code with inconsistency in the software.
• Coverage Analyzers: All rationale paths in the software are assured by the coverage
analyzers.
• Interface Analyzers: They check out the consequences of passing variables and data in
the modules.

2. Dynamic Test Tools:

Dynamic testing process is performed by the dynamic test tools.
These tools test the software with existing or current data.
Dynamic test tools comprise the following:

• Test driver: The test driver provides the input data to a module-under-test (MUT).
• Test Beds: It displays source code along with the program under execution at the same
time.
• Emulators: Emulators provide the response facilities which are used to imitate parts of
the system not yet developed.
• Mutation Analyzers: They are used for testing the fault tolerance of the system by
knowingly providing the errors in the code of the software.
 There is one more categorization of software testing tools. According to this classification,
software testing tools are of 10 types:
1. Test Management Tools: Test management tools are used to store information on
how testing is to be done, help to plan test activities, and report the status of quality
assurance activities. For example, JIRA, Redmine, Selenium, etc.
2. Automated Testing Tools: Automated testing tools helps to conduct testing activities
without human intervention with more accuracy and less time and effort. For
example, Appium, Cucumber, Ranorex, etc.
3. Performance Testing Tools: Performance testing tools helps to perform effectively and
efficiently performance testing which is a type of non-functional testing that checks
the application for parameters like stability, scalability, performance, speed, etc. For
example, WebLOAD, Apache JMeter, Neo Load, etc.
4. Cross-browser Testing Tools: Cross-browser testing tools helps to perform cross-
browser testing that lets the tester check whether the website works as intended
when accessed through different browser-OS combinations. For example, Testsigma,
Testim, Perfecto, etc.
5. Integration Testing Tools: Integration testing tools are used to test the interface
between the modules and detect the bugs. The main purpose here is to check whether
the specific modules are working as per the client’s needs or not. For example, Citrus,
FitNesse, TESSY, etc.
6. Unit Testing Tools: Unit testing tools are used to check the functionality of individual
modules and to make sure that all independent modules works as expected. For
example, Jenkins, PHPUnit, JUnit, etc.
7. Mobile Testing Tools: Mobile testing tools are used to test the application for
compatibility on different mobile devices. For example, Appium, Robotium, Test IO,
etc.
8. GUI Testing Tools: GUI testing tools are used to test the graphical user interface of the
software. For example, EggPlant, Squish, AutoIT, etc.
9. Bug Tracking Tools: Bug tracking tool helps to keep track of various bugs that come up
during the application lifecycle management. It helps to monitor and log all the bugs
that are detected during software testing. For example, Trello, JIRA, GitHub, etc.
10. Security Testing Tools: Security testing is used to detect the vulnerabilities and
safeguard the application against the malicious attacks. For example, NetSparker,
Vega, ImmuniWeb, etc.

Software Maintenance

It refers to the process of modifying and updating a software system after it has been delivered to
the customer. This can include fixing bugs, adding new features, improving performance, or
updating the software to work with new hardware or software systems. The goal of software
maintenance is to keep the software system working correctly, efficiently, and securely, and to
ensure that it continues to meet the needs of the users.

Software maintenance is a continuous process that occurs throughout the entire life cycle of the
software system. It is important to have a well-defined maintenance process in place, which
includes testing and validation, version control, and communication with stakeholders.
Several Types of Software Maintenance:
• Corrective Maintenance: This involves fixing errors and bugs in the software system.
• Patching: It is an emergency fix implemented mainly due to pressure from
management. Patching is done for corrective maintenance but it gives rise to
unforeseen future errors due to lack of proper impact analysis.
• Adaptive Maintenance: This involves modifying the software system to adapt it to
changes in the environment, such as changes in hardware or software, government
policies, and business rules.
• Perfective Maintenance: This involves improving functionality, performance, and
reliability, and restructuring the software system to improve changeability.
• Preventive Maintenance: This involves taking measures to prevent future problems,
such as optimization, updating documentation, reviewing and testing the system, and
implementing preventive measures such as backups.

Need for Maintenance

Software Maintenance must be performed in order to:
• Correct faults.
• Improve the design.
• Implement enhancements.
• Interface with other systems.
• Accommodate programs so that different hardware, software, system features, and
telecommunications facilities can be used.
• Migrate legacy software.
• Retire software.
• Requirement of user changes.
• Run the code fast

Categories of Software Maintenance

• Corrective maintenance: Corrective maintenance of a software product may be
essential either to rectify some bugs observed while the system is in use, or to
enhance the performance of the system.
• Adaptive maintenance: This includes modifications and updations when the customers
need the product to run on new platforms, on new operating systems, or when they
need the product to interface with new hardware and software.
• Perfective maintenance: A software product needs maintenance to support the new
features that the users want or to change different types of functionalities of the
system according to the customer’s demands.
• Preventive maintenance: This type of maintenance includes modifications and
updations to prevent future problems with the software. It goals to attend to
problems, which are not significant at this moment but may cause serious issues in the
future.
Maintenance Models

1. Quick-Fix Model
A quick-fix model in software maintenance is a method for addressing bugs or issues in the software
by prioritizing a fast resolution over a more comprehensive solution.

This approach typically involves making a small, localized change to the software to address the
immediate problem rather than fully understanding and addressing the underlying cause. However,
organizations adopt this approach of maintenance only in the case of emergency situations that call
for quick resolutions.Under the quick-fix model, tech teams carry out the following software
maintenance activities:

• Annotate software changes by including change IDs and code comments

• Enter them into a maintenance history detailing why they made the change and the
techniques used by them.
• Note each location and merge them via the change ID if there are multiple points in the code
change

2. Iterative Enhancement Model

The iterative model is used for small-scale application modernization and scheduled maintenance.
Generally, the business justification for changes is ignored in this approach as it only involves the
software development team, not the business stakeholders. So, the software team will not know if
more significant changes are required in the future, which is quite risky.

The iterative enhancement model treats the application target as a known quantity. It incorporates
changes in the software based on the analysis of the existing system. The iterative model best suits
changes made to confined application targets, with little cross-impact on other apps or
organizations.

3. Reuse-Oriented Model
The reuse-oriented model identifies components of the existing system that are suitable to use again
in multiple places. In recent years, this model also includes creating components that can be reused
in multiple applications of a system.

There are three ways to incorporate the reuse-oriented model — object and function, application
system, and component.

• Object and function reuse: This model reuses the software elements that implement a single
well-defined object.
• Application system reuse: Under this model, developers can integrate new components in an
application without making changes to the system or re-configuring it for a specific user to
reuse.
• Component reuse: Component reuse refers to using a pre-existing component rather than
creating a new one in software development. This can include using pre-built code libraries,
frameworks, or entire software applications.
 4. Barry Bohem

Introduced in 1978, Boehm’s model focuses on measuring characteristics to get non-tech

stakeholders involved with the life cycle of software. The model represents a hierarchical
structure of high-level, intermediate, and primitive characteristics of software that define its
overall quality.

The high-level characteristics of quality software are:

• Maintainability: It should be easy to understand, evaluate, and modify the processes in a

system.
• Portability: Software systems should help in ascertaining the most effective way to make
environmental changes
• As-is utility: It should be easy and effective to use an as-is utility in the system.

The intermediate level of characteristics represented by the model displays different factors that
validate the expected quality of a software system. These characteristics are:

• Reliability: Software performance is as expected, with zero defects.

• Portability: The software can run in various environments and on different platforms.
• Efficiency: The system makes optimum utilization of code, applications, and hardware
resources.
• Testability: The software can be tested easily and the users can trust the results.
• Understandability: The end-user should be able to understand the functionality of the
software easily and thus, use it effectively.
• Usability: Efforts needed to learn, use, and comprehend different software functions should
be minimum.

5. Taute Maintenance Model

Developed by B.J. Taute in 1983, the Taute maintenance model facilitates development teams to
update and perform necessary modifications after executing the software.

The Taute model for software maintenance can be carried out in the following phases:

• Change request phase: In this phase, the client sends the request to make changes to the
software in a prescribed format.

• Estimate phase: Then, developers conduct an impact analysis on the existing system to
estimate the time and effort required to make the requested changes.

• Schedule phase: Here, the team aggregates the change requests for the upcoming scheduled
release and creates the planning documents accordingly.

• Programming phase: In the programming phase, requested changes are implemented in the
source code, and all the relevant documents, like design documents and manuals, are
updated accordingly.

• Test phase: During this phase, the software modifications are carefully analyzed. The code is
tested using existing and new test cases, along with the implementation of regression
testing.
 • Documentation phase: Before the release, system and user documentation are prepared
and updated based on regression testing results. Thus, developers can maintain the
coherence of documents and code.

• Release phase: The customer receives the new software product and updated
documentation. Then the system’s end users perform acceptance testing.

Regression Testing

It is the process of testing the modified parts of the code and the parts that might get affected due
to the modifications to ensure that no new errors have been introduced in the software after the
modifications have been made. Regression means the return of something and in the software
field, it refers to the return of a bug.

When to do regression testing?

• When a new functionality is added to the system and the code has been modified to
absorb and integrate that functionality with the existing code.
• When some defect has been identified in the software and the code is debugged to fix
it.
• When the code is modified to optimize it working.

Reverse Engineering

Reverse engineering in software engineering refers to the process of analyzing a software system to
understand its design, functionality, and inner workings. Unlike traditional software development,
where the focus is on creating new software, reverse engineering involves working backward from an
existing software product to gain insights into its structure and code.
While reverse engineering can provide valuable insights and benefits, it's essential to approach it
with a clear understanding of legal and ethical considerations. Respect for intellectual property rights
and adherence to relevant laws and regulations are critical aspects of responsible reverse
engineering practices.
Or
Software Reverse Engineering is a process of recovering the design, requirement specifications,
and functions of a product from an analysis of its code. It builds a program database and generates
information from this.
The purpose of reverse engineering is to facilitate the maintenance work by improving the
understandability of a system and producing the necessary documents for a legacy system.
Reverse engineering can extract design information from source code, but the abstraction level,
the completeness of the documentation, the degree to which tools and a human analyst work
together, and the directionality of the process are highly variable.

Reverse Engineering Goals:

• Cope with Complexity. Facilitate Reuse.

• Recover lost information.
• Detect side effects.
• Synthesis higher abstraction.
Software Re-engineering
Restructuring and updating existing software to improve its performance or adapt to new
requirements.

Software Re-engineering is a process of software development which is done to improve the

maintainability of a software system. Re-engineering is the examination and alteration of a system
to reconstitute it in a new form. This process encompasses a combination of sub-processes like
reverse engineering, forward engineering, reconstructing etc.
Re-engineering, also known as reverse engineering or software re-engineering, is the process of
analyzing, designing, and modifying existing software systems to improve their quality,
performance, and maintainability. This can include updating the software to work with new
hardware or software platforms, adding new features, or improving the software’s overall design
and architecture.
Software re-engineering, also known as software restructuring or software renovation, refers to the
process of improving or upgrading existing software systems to improve their quality,
maintainability, or functionality. It involves reusing the existing software artifacts, such as code,
design, and documentation, and transforming them to meet new or updated requirements.
The primary goal of software re-engineering is to improve the quality and maintainability of the
software system, while minimizing the risks and costs associated with the redevelopment of the
system from scratch.

Configuration Management:
Managing changes systematically to maintain the integrity of the software.
Software configuration management is a systems engineering process that tracks and monitors
changes to a software systems configuration metadata. In software development, configuration
management is commonly used alongside version control and CI/CD infrastructure.
By implementing SCM practices, software development teams can enhance collaboration, maintain
code quality, and effectively manage the evolution of their software systems throughout the
development life cycle.

Documentation:
Keeping thorough and up-to-date documentation for future reference and understanding.