DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

UNIT-IV
SOFTWARE ENGINEERING

VALIDATION AND VERIFICATION IN SOFTWARE ENGINEERING

Verification
Verification is the process of checking that software achieves its goal without any bugs. It is the
process to ensure whether the product that is developed is right or not. It verifies whether the
developed product fulfills the requirements that we have. Verification is static testing.
Validation
Validation is the process of checking whether the software product is up to the mark or in other
words product has high-level requirements. It is the process of checking the validity of the product
i.e. it checks what we are developing is the right product. it is a validation of the actual and
expected products. It is also known as Dynamic Testing.
Verification and Validation is the process of investigating whether a software system satisfies
specifications and standards and fulfills the required purpose. Verification is the process of
checking that software achieves its goal without any bugs. It is the process to ensure whether the
product that is developed is right or not. It verifies whether the developed product fulfills the
requirements that we have. Verification is simply known as Static .
Roles of Verification and Validation
The various roles of Verification and Validation(V&V) in SDLC in the software testing process
are given below:
Traceability Analysis
Traceability can be defined as a property that describes the degree to which it can be traced to its
point of origin. It also describes the ability to establish a predecessor-successor relationship
between one work product and another. It helps us in tracing every software requirement back to
its original system requirements established in the concept activity. The thing is to ensure that
every requirement correctly satisfies the system requirements and that no extra things of software
requirements are included. In this technique, we also determine whether any derived requirements
are consistent with the original objectives, physical laws, and technologies described in the system
document.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Interface Analysis
It is the detailed analysis of the interface requirements specifications in the software development
lifecycle. It also helps us in identifying the interfaces between the applications to determine the
requirements for ensuring that the components interact with each other effectively. The evaluation
criteria are the same as those for requirements specification as it helps us in determining the
requirements for interoperability. The main target of this analysis is the interfaces between the
software, hardware, and user.
Criticality Analysis
The criticality is given to each and every software requirement and when the requirements are
combined into functions, the combined criticality of requirements forms the criticality for the
aggregate function. Criticality analysis is updated regularly after there have been any new
requirement changes. This is because such changes can cause an increase or decrease in a
function’s criticality which depends on how the revised requirement impacts system criticality.
The Criticality analysis has the following steps:
1. The first step is to construct a control flow diagram (CFD) of the system with its elements
where every block will represent only one software function.
2. Then next, it will trace every critical function or its quality requirement with the help of a
control flow diagram.
3. Classify all traced software functions as critical to the proper execution of critical software
functions & quality requirements.
4. Focus additional analysis on these traced critical software functions.
5. Lastly, it will repeat the criticality analysis for every life cycle process to check whether
the implementation details shifted the emphasis of the criticality.
Hazard and Risk Analysis
Hazard and risk analysis, conducted during the requirements definition phase, plays a crucial role
in the verification and validation (V&V) processes within the Software Development Life Cycle
(SDLC). By identifying potential dangers and assessing their impact early on, this analysis ensures
that risks are addressed through careful planning and mitigation strategies. Verification checks that
these risks are properly managed according to specifications, while validation ensures the final
product is safe, reliable, and meets user needs. This integration of hazard and risk analysis with
V&V helps in delivering a robust and secure software product.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Strategies approach to Software Testing

Software testing is the process of evaluating a software application to identify if it meets specified
requirements and to identify any defects. The following are common testing strategies:
1. Black box testing – Tests the functionality of the software without looking at the internal
code structure.
2. White box testing – Tests the internal code structure and logic of the software.
3. Unit testing – Tests individual units or components of the software to ensure they are
functioning as intended.
4. Integration testing – Tests the integration of different components of the software to
ensure they work together as a system.
5. Functional testing – Tests the functional requirements of the software to ensure they are
met.
6. System testing – Tests the complete software system to ensure it meets the specified
requirements.
7. Acceptance testing – Tests the software to ensure it meets the customer’s or end-user’s
expectations.
8. Regression testing – Tests the software after changes or modifications have been made to
ensure the changes have not introduced new defects.
9. Performance testing – Tests the software to determine its performance characteristics
such as speed, scalability, and stability.
10. Security testing – Tests the software to identify vulnerabilities and ensure it meets security
requirements.
Software Testing is a type of investigation to find out if there are any defects or errors present in
the software, so that the errors can be reduced or removed to increase the quality of the software
and to check whether it fulfills the specified requirements or not.
According to Glen Myers, software testing has the following objectives:
 The process of investigating and checking a program to find whether there is an error or
not and does it fulfill the requirements or not is called testing.
 When the number of errors found during the testing is high, it indicates that the testing was
good and is a sign of good test case.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Finding an unknown error that wasn’t discovered yet is a sign of a successful and a good
test case.
The main objective of software testing is to design the tests in such a way that it systematically
finds different types of errors without taking much time and effort so that less time is required for
the development of the software. The overall strategy for testing software includes:

1. Before testing starts, it’s necessary to identify and specify the requirements of the
product in a quantifiable manner. Different characteristics quality of the software is
there such as maintainability that means the ability to update and modify, the probability
that means to find and estimate any risk, and usability that means how it can easily be used
by the customers or end-users. All these characteristic qualities should be specified in a
particular order to obtain clear test results without any error.
2. Specifying the objectives of testing in a clear and detailed manner. Several objectives
of testing are there such as effectiveness that means how effectively the software can
achieve the target, any failure that means inability to fulfill the requirements and perform
functions, and the cost of defects or errors that mean the cost required to fix the error. All
these objectives should be clearly mentioned in the test plan.
3. For the software, identifying the user’s category and developing a profile for each
user. Use cases describe the interactions and communication among different classes of
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

users and the system to achieve the target. So as to identify the actual requirement of the
users and then testing the actual use of the product.
4. Developing a test plan to give value and focus on rapid-cycle testing. Rapid Cycle
Testing is a type of test that improves quality by identifying and measuring the any changes
that need to be required for improving the process of software. Therefore, a test plan is an
important and effective document that helps the tester to perform rapid cycle testing.
5. Robust software is developed that is designed to test itself. The software should be
capable of detecting or identifying different classes of errors. Moreover, software design
should allow automated and regression testing which tests the software to find out if there
is any adverse or side effect on the features of software due to any change in code or
program.
6. Before testing, using effective formal reviews as a filter. Formal technical reviews is
technique to identify the errors that are not discovered yet. The effective technical reviews
conducted before testing reduces a significant amount of testing efforts and time duration
required for testing software so that the overall development time of software is reduced.
7. Conduct formal technical reviews to evaluate the nature, quality or ability of the test
strategy and test cases. The formal technical review helps in detecting any unfilled gap in
the testing approach. Hence, it is necessary to evaluate the ability and quality of the test
strategy and test cases by technical reviewers to improve the quality of software.
8. For the testing process, developing a approach for the continuous development. As a
part of a statistical process control approach, a test strategy that is already measured should
be used for software testing to measure and control the quality during the development of
software.
Advantages of software testing:
1. Improves software quality and reliability – Testing helps to identify and fix defects early
in the development process, reducing the risk of failure or unexpected behavior in the final
product.
2. Enhances user experience – Testing helps to identify usability issues and improve the
overall user experience.
3. Increases confidence – By testing the software, developers and stakeholders can have
confidence that the software meets the requirements and works as intended.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

4. Facilitates maintenance – By identifying and fixing defects early, testing makes it easier to
maintain and update the software.
5. Reduces costs – Finding and fixing defects early in the development process is less
expensive than fixing them later in the life cycle.
Disadvantages of software testing:
1. Time-consuming – Testing can take a significant amount of time, particularly if thorough
testing is performed.
2. Resource-intensive – Testing requires specialized skills and resources, which can be
expensive.
3. Limited coverage – Testing can only reveal defects that are present in the test cases, and it
is possible for defects to be missed.
4. Unpredictable results – The outcome of testing is not always predictable, and defects can
be hard to replicate and fix.
5. Delays in delivery – Testing can delay the delivery of the software if testing takes longer
than expected or if significant defects are identified.
Strategic planning, which outlines the goals, objectives, and methodology, serves as the foundation
for effective software testing. It entails determining the scope of testing, establishing appropriate
testing procedures, and outlining the resources and timescales required. A solid plan ensures that
testing efforts are aligned with the project's objectives and that any risks and problems are
mitigated. When embarking on a software testing project, it is vital to prioritize strategy and
investment. A well-defined strategy is required to determine the methodologies and tools required
for testing a website or application. Assessing the whole project investment is easier with a clear
approach. As a result, in this blog, we will look at software testing methodologies and approaches.
Testing Strategies and its types
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Software testing strategies are comprehensive approaches that guide the testing process and ensure
effective and efficient testing of software applications. There are four types of Testing strategies.
Here are some commonly used software testing strategies:
 Static Testing Strategy
 Structural Testing Strategy
 Behavioral Testing Strategy
 Front-End Testing Strategy
Static Testing Strategy
A static test assesses the quality of a system without executing the system, which may initially
appear challenging. However, there are several strategic approach to software testing available to
achieve this evaluation.
 Static testing involves analyzing specific portions or elements of a system to identify
potential issues at an early stage. One example is desk-checking, where developers review
their code before pushing it, serving as a form of static testing. Another example is
conducting review meetings to assess requirements, design, and code.
 Static tests provide significant advantages by detecting problems in requirements before
they manifest as system bugs, resulting in time and cost savings. Additionally, conducting
a preliminary code review helps identify bugs without the need to build, install, and run
the entire system.
 Timing is a vital aspect of static tests. Reviewing requirements after developers have
completed coding the software can assist testers in designing effective test cases. However,
it is important to note that testers can only identify bugs in existing code by executing the
system, thus undermining the purpose of static tests. In such cases, individual developers
should review the code promptly after creation and before integration.
 Organizations can enhance software quality, mitigate risks, and optimize the overall
development process by implementing comprehensive static testing practices at
appropriate stages.
Structural Testing Strategy
Although static tests provide valuable insights, they need to be more comprehensive. Executing
the software on real devices and running the entire system to ensure comprehensive bug detection
is essential. Unit testing, including structural tests, is employed to achieve this objective.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 White-box testing, also known as clear-box testing or structural testing in software testing,
is conducted by testers with extensive knowledge of the devices and systems under
evaluation.
 This testing approach is frequently employed to scrutinize specific components and
interfaces, aiming to pinpoint and rectify localized errors within data flows. To gain
practical expertise in Software Testing, consider enrolling in a Software Testing Online
Course. These courses offer comprehensive training, and enable learners to master in
Software Testing.
Behavioral Testing Strategy
Behavioral Testing, or black-box testing, centers around the system's behavior rather than its
underlying mechanisms. It emphasizes workflows, configurations, performance, and all aspects of
the user journey. The main objective of these tests is to assess a website or app from an end-user
perspective.
 Behavioral Testing should encompass multiple user profiles and diverse usage scenarios.
 It primarily focuses on evaluating fully integrated systems rather than individual
components. This approach allows for a comprehensive assessment of system behavior
from the user's perspective, which becomes evident only when the system is sufficiently
assembled and integrated.
 While behavioral tests are predominantly executed manually, certain aspects can be
automated.
 Manual testing requires meticulous planning, thoughtful design, and thorough result
verification to identify potential issues.
 Automation testing streamlines repetitive actions, such as regression tests, ensuring that
new code implementations do not disrupt existing functioning features. For instance, when
testing a website, automating the process of filling in multiple form fields with various
values can significantly save time, effort and mitigate human error.
Front-End Testing Strategy
The front end of an application pertains to its user-facing component, serving as the primary
interface for content consumption and business transactions. Front-end is one of the software
testing strategies that plays a vital role in the software development life cycle (SDLC) by ensuring
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

the proper functioning of GUI elements. We can break them into the following categories of
software testing types and approaches:
 Unit Testing: Unit Testing is the initial layer integrated into the codebase, focusing on
running test functions before the application is built to assess individual processes and
modules.
 Functional Testing: Functional testing involves manually evaluating features and
components through a user interface, typically using mock data.
 Integration Testing: Integration testing involves connecting front-end components with
back-end services to ensure seamless integration from client inputs, through APIs, to
database management within a dedicated test environment.
 System/UI Testing: System/UI testing occurs once a test version of the user interface has
been successfully integrated with the back-end service, enabling automated testing and
analysis conducted by developers in collaboration with the QA team.
 Performance/Load Testing: Performance/load testing verifies the application's ability to
handle the expected load and scale, considering optimal usage scenarios.
 Stress/Security Testing: Stress/Security Testing validates the application's response under
unexpected loads and threats beyond the expected limit.
 Accessibility Testing: Accessibility testing ensures that individuals with disabilities can
effectively utilize the application.
These software testing strategies can be adapted and combined based on project requirements,
development methodologies, and the specific characteristics of the software application. The
selection of an appropriate testing strategy depends on factors such as the software's complexity,
time constraints, available resources, and the desired level of quality assurance. By enrolling in the
Best Software Testing Institute in Bangalore, learners can gain knowledge and a comprehensive
understanding of the concepts of Software Testing. The training program offers extensive
guidance, enabling participants to effectively grasp the core principles of Software Testing.
Test strategies for Conventional Software
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Test strategies for conventional software are systematic approaches employed to ensure effective
testing of traditional software applications. These strategies outline the overall approach, goals,
and techniques to be utilized during the testing process. Some commonly used test strategies for
conventional software include:
 Requirement-based Testing: Requirement-based Testing is a strategy that focuses on
verifying whether the software meets the specified requirements. Test cases are designed
based on the documented requirements, and the software is evaluated against these
requirements to ensure compliance.
 Functional Testing: Functional Testing strategy aims to validate the functional aspects of
the software by testing individual functions or features. It involves designing test cases to
exercise different functionalities and verifying that the software performs as intended.
 Integration Testing: Integration testing involves testing the interaction and integration
between various software components or modules. It ensures that different components
work together seamlessly and accurately to exchange data.
 System Testing: System testing is conducted to validate the entire software system. It
includes testing all integrated components and subsystems to ensure they function correctly
and meet the overall system requirements.
 Performance Testing: This strategy evaluates the software's performance under specific
conditions, such as load, stress, or scalability. It aims to identify performance bottlenecks,
measure response times, and ensure the software can handle expected workloads.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Regression Testing: This testing is one of the software testing strategies that focuses on
retesting previously tested functionalities to ensure that recent changes or fixes have not
introduced new defects or caused any unintended side effects.
 User Acceptance Testing (UAT): UAT is performed by end-users or representatives to
verify whether the software meets their expectations and requirements. It ensures the
software is ready for deployment and use in a real-world environment.
 Security Testing: The security Testing strategy aims to identify vulnerabilities and ensure
the software's resistance against potential security threats. It includes testing for
authentication, authorization, data encryption, and protection against common security
attacks.
 Usability Testing: Usability testing assesses the software's user-friendliness, ease of use,
and overall user experience. It evaluates interface design, navigation, and user interaction
to ensure optimal usability.
 Maintenance Testing: Maintenance testing is performed after software updates or
modifications to ensure that the changes have not introduced new defects or adversely
affected existing functionalities. To see how Software Testing might be used, join the
Software Testing Course in Coimbatore and learn the various applications and their
functionalities.
Different Software Testing Strategies
A strategic approach to software testing involves a well-planned and structured methodology to
ensure effective testing and quality assurance throughout the software development lifecycle. Here
are the key elements of a strategic approach to software testing:
 Risk Assessment: It is important to evaluate the risks associated with testing carefully.
Consider the possibility of tests disrupting the functioning of the software. For instance,
when testing new features or updates of an established app in the digital market, there is a
risk of crashes or unintended scrambling of existing features. In such cases, testers may
need to adopt regression-averse strategies to mitigate potential risks.
 Objective Alignment: The testing strategy should align with the requirements and
expectations of the stakeholders. It is crucial to ensure that the tests assess the functionality
of all software features, meet the business requirements, and deliver genuine benefits to the
users.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Compliance with Regulations: Verifying that the software being tested complies with all
relevant regulations applicable to its industry and the digital domain is vital. Different
geographical regions may have varying regulations that the same app or website must
adhere to. Testers should know local regulations to ensure the software remains compliant
and does not unintentionally violate laws.

The Fundamentals of Software Testing

It's easy to get caught up in the details of software testing – focusing on individual test cases, bugs,
and technicalities – while losing sight of the bigger picture. Just like missing the forest for the
trees, we sometimes forget the fundamental principles that guide a reliable testing process.
Software testing fundamentals are essential for building a strong foundation, streamlining
workflows, improving quality, and ensuring we're not just fixing isolated issues but delivering a
robust product overall.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Levels of testing:
 Unit Testing: Testing individual components or units of code. For example, testing the
function that adds a new task to make sure it works independently.
 Integration Testing: Ensures that different components work together. For instance,
checking if syncing tasks between devices works smoothly in your to-do app.
 System Testing: Verifies the entire system as a whole. Does the app meet its overall
requirements and handle various real-world scenarios?
 Acceptance Testing: Confirms that the software meets business and user needs before
release.

Automated vs Manual testing

A major decision in testing is whether to use manual or automated testing – or a combination of
both.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Manual testing:
Manual testing involves human testers interacting with the app to identify issues. It's useful for:
 Exploratory Testing: Where testers explore the software freely to find bugs.
 Usability Testing: Where the focus is on user experience and feedback.
For example, a manual tester might explore your to-do app to check if the user interface is intuitive
and if the features work as expected.
Automated testing:
Automated testing uses scripts and tools to run test cases automatically. It's ideal for:
 Regression Testing: Ensuring that old features work after adding new code.
 Load Testing: Simulating high volumes of users or data to see how the system performs
under pressure.
For your to-do app, you might use automated tests to repeatedly check that tasks can be added,
saved, and synced without errors.

Test plan in Validation and Verifications in Software Testing

Test Plan
A test plan is a document that consists of all future testing-related activities. It is prepared at the
project level and in general, it defines work products to be tested, how they will be tested, and test
type distribution among the testers. Before starting testing there will be a test manager who will
be preparing a test plan. In any company whenever a new project is taken up before the tester is
involved in the testing the test manager of the team would prepare a test Plan.
 The test plan serves as the blueprint that changes according to the progressions in the
project and stays current at all times.
 It serves as a base for conducting testing activities and coordinating activities among a QA
team.
 It is shared with Business Analysts, Project Managers, and anyone associated with the
project.
A test plan is a comprehensive document outlining all testing-related activities for a project. It
details what will be tested, how, and by whom, serving as a blueprint for testing and coordinating
among the QA team. To understand how to create and use a test plan effectively, explore the
factors:
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Factors Roles

Who writes Test Plans? Test lead, Test Manager, Test Engineer

Test Lead, Test Manager, Test Engineer,

Who reviews the Test Plan?
Customer, Development Team

Who approves the Test Plan? Customer, Test Manager

Who writes Test Cases? Test Lead, Test Engineer

Test Engineer, Test Lead, Customer,

Who reviews Test Cases?
Development Team

Who approves Test Cases? Test Manager, Test Lead, Customer

Test Plan creation important

The following are some of the key benefits of making a test plan:
 Defines Objectives: A test plan clearly outlines the testing objectives and the scope of
testing activities, ensuring that all team members understand what needs to be achieved.
 Structured Approach : It provides a systematic approach to testing, detailing the steps
and processes involved, which helps in organizing the testing effort.
 Avoids Scope Creep : By defining what will and will not be tested, the test plan helps
manage the scope of testing activities, preventing unnecessary work and focusing on
irrelevant areas.
 Resource Allocation : Helps in identifying the necessary resources, including personnel,
tools, and environments, ensuring they are available when needed.
 Identifies Risks : A test plan identifies potential risks and outlines mitigation strategies,
helping to address issues proactively rather than reactively.
 Contingency Plans : These include contingency plans for dealing with unexpected events
or issues that may arise during testing.
 Stakeholder Alignment : Facilitates communication among stakeholders, including
developers, testers, project managers, and clients, ensuring everyone is aligned on the
testing objectives, approach, and schedule.
 Documentation : Serves as a comprehensive document that can be referred to by all team
members, aiding in knowledge sharing and transparency.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Resource Optimization : Helps in efficiently utilizing available resources, including time

and personnel, by providing a clear plan of action.
 Focus on Priorities : Ensures that testing efforts are focused on high-priority areas that are
critical to the success of the project.
Objectives of the Test Plan
1. Overview of testing activities: The test plan provides an overview of the testing activities
and where to start and stop the work.
2. Provides timeline: The test plan helps to create the timeline for the testing activities based
on the number of hours and the workers needed.
3. Helps to estimate resources: The test plan helps to create an estimate of the number of
resources needed to finish the work.
4. Serves as a blueprint: The test plan serves as a blueprint for all the testing activities, it
has every detail from beginning to end.
5. Helps to identify solutions: A test plan helps the team members They consider the
project’s challenges and identify the solutions.
6. Serves as a rulebook: The test plan serves as a rulebook for following rules when the
project is completed phase by phase.
Difference between Test Strategy and Test Plan:

Aspect Test Strategy Test Plan

A detailed document that describes the

A high-level document outlining the specific testing activities, resources,
Definition
overall testing approach and goals. schedule, and scope for a particular
project.

Provides a framework and general Specifies the exact process, tasks, and
Purpose guidelines for testing across multiple timelines for testing a specific project or
projects or the entire organization. release.

Broad and generic, applicable to all Narrow and project-specific, tailored to

Scope
projects within the organization. the needs of a particular project.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Aspect Test Strategy Test Plan

High-level, focusing on overall

Detailed, including specific test cases,
Level of Detail methodologies, standards, and tools to
environments, schedules, and resources.
be used.

Typically created by senior Typically created by test managers or test

Responsibility
management or test architects. leads for a specific project.

More dynamic, updated regularly to

More static and less frequently
Components reflect changes in project scope,
updated, serving as a long-term guide.
requirements, and timelines.

Intended for the project team, including

Intended for stakeholders, project
Audience testers, developers, and project
managers, and senior management.
managers.

Describes the use of automated testing Outlines specific test cases, test
Examples tools, defect tracking processes, and environments, and test data requirements
overall testing standards. for a particular application.

Emphasizes the “how,” “when,” and

Emphasizes the “what” and “why” of
Focus “who” of the testing activities for a
testing processes and standards.
specific project.

Long-term, spanning multiple projects Short-term, aligned with the project

Timeframe
and releases. lifecycle and specific release schedules.

Less frequent, typically reviewed More frequent, updated as the project

Updates
annually or semi-annually. evolves and new requirements emerge.

Components and Attributes of Test Plan :

 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Components and Attributes of Test Plan

1. Objective: It describes the aim of the test plan, whatever the good process and procedure they
are going to follow to give quality software to customers. The overall objective of the test is to
find as many defects as possible and to make software bug-free. The test objective must be broken
into components and sub-components. In every component following activities should be
performed.
 List all the functionality and performance to be tested.
 Make goals and targets based on the application feature.
2. Scope: It consists of information that needs to be tested concerning an application. The scope
can be divided into two parts:
 In-Scope: The modules that are to be tested rigorously.
 Out Scope: The modules that are not to be tested rigorously.
Example: In an application A, B, C, and D features have to be developed, but the B feature has
already been designed by other companies. So the development team will purchase B from that
company and perform only integrated testing with A, B, and C.
3. Testing Methodology: The methods that are going to be used for testing depend on application
to application. The testing methodology is decided based on the feature and application
requirements. Since the testing terms are not standard, one should define what kind of testing will
be used in the testing methodology. So that everyone can understand it.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

4. Approach: The approach of testing different software is different. It deals with the flow of
applications for future reference. It has two aspects:
 High-Level Scenarios: For testing critical features high-level scenarios are written. For
Example, login to a website, and book from a website.
 The Flow Graph: It is used when one wants to make benefits such as converging and
merging easy.
5. Assumption: In this phase, certain assumptions will be made.
Example:
 The testing team will get proper support from the development team.
 The tester will get proper knowledge transfer from the development team.
 Proper resource allocation will be given by the company to the testing department.
6. Risk: All the risks that can happen if the assumption is broken. For Example, in the case of
wrong budget estimation, the cost may overrun. Some reason that may lead to risk is:
 Test Manager has poor management skills.
 Hard to complete the project on time.
 Lack of cooperation.
7. Mitigation Plan: If any risk is involved then the company must have a backup plan, the purpose
is to avoid errors. Some points to resolve/avoid risk:
 Test priority is to be set for each test activity.
 Managers should have leadership skills.
 Training course for the testers.
8. Roles and Responsibilities: All the responsibilities and role of every member of a particular
testing team has to be recorded.
Example:
 Test Manager: Manages the project, takes appropriate resources, and gives project
direction.
 Tester: Identify the testing technique, verify the test approach, and save project costs.
9. Schedule: Under this, it will record the start and end date of every testing-related activity. For
Example, writing the test case date and ending the test case date.
10. Defect Tracking: It is an important process in software engineering as lots of issue arises
when you develop a critical system for business. If there is any defect found while testing that
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

defect must be given to the developer team. There are the following methods for the process of
defect tracking:
 Information Capture: In this, we take basic information to begin the process.
 Prioritize: The task is prioritized based on severity and importance.
 Communication: Communication between the identifier of the bug and the fixer of the
bug.
 Environment: Test the application based on hardware and software.
Example: The bug can be identified using bug-tracking tools such as Jira, Mantis, and Trac.
11. Test Environments: It is the environment that the testing team will use i.e. the list of hardware
and software, while testing the application, the things that are said to be tested will be written under
this section. The installation of software is also checked under this.
Example:
 Software configuration on different operating systems, such as Windows, Linux, Mac, etc.
 Hardware Configuration depends on RAM, ROM, etc.
12. Entry and Exit Criteria: The set of conditions that should be met to start any new type of
testing or to end any kind of testing.
 Entry Condition:
o Necessary resources must be ready.
o The application must be prepared.
o Test data should be ready.
 Exit Condition:
o There should not be any major bugs.
o Most test cases should be passed.
o When all test cases are executed.
 Example: If the team member reports that 45% of the test cases failed, then testing will be
suspended until the developer team fixes all defects.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Example of Test Plan

13. Test Automation: It consists of the features that are to be automated and which features are
not to be automated.
 If the feature has lots of bugs then it is categorized as Manual Testing.
 If the feature is frequently tested then it can be automated.
14. Effort Estimation: This involves planning the effort that needs to be applied by every team
member.
15. Test Deliverables: It is the outcome from the testing team that is to be given to the customers
at the end of the project.
 Before the testing phase :
o Test plan document.
o Test case document.
o Test design specification.
 During the testing phase :
o Test scripts.
o Test data.
o Error logs.
 After the testing phase :
o Test Reports.
o Defect Report.
o Installation Report.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

It contains a test plan, defect report, automation report, assumption report, tools, and other
components that have been used for developing and maintaining the testing effort.
16. Template: This is followed by every kind of report that is going to be prepared by the testing
team. All the test engineers will only use these templates in the project to maintain the consistency
of the product.
Types of Test Plans:
The following are the three types of test plans:
 Master Test Plan: In this type of test plan, includes multiple test strategies and has multiple
levels of testing. It goes into great depth on the planning and management of testing at the
various test levels and thus provides a bird’s eye view of the important decisions made,
tactics used, etc. It includes a list of tests that must be executed, test coverage, the
connection between various test levels, etc.
 Phase Test Plan: In this type of test plan, emphasis is on any one phase of testing. It includes
further information on the levels listed in the master testing plan. Information like testing
schedules, benchmarks, activities, templates, and other information that is not included in
the master test plan is included in the phase test plan.
 Specific Test Plan: This type of test plan, is designed for specific types of testing especially
non-functional testing for example plans for conducting performance tests or security tests.
How to create a Test Plan :
Below are the eight steps that can be followed to write a test plan:

Create Test Plan

 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

1. Analyze the product: This phase focuses on analyzing the product, Interviewing clients,
designers, and developers, and performing a product walkthrough. This stage focuses on answering
the following questions:
 What is the primary objective of the product?
 Who will use the product?
 What are the hardware and software specifications of the product?
 How does the product work?
2. Design the test strategy: The test strategy document is prepared by the manager and details the
following information:
 Scope of testing which means the components that will be tested and the ones that will be
skipped.
 Type of testing which means different types of tests that will be used in the project.
 Risks and issues that will list all the possible risks that may occur during testing.
 Test logistics mentions the names of the testers and the tests that will be run by them.
3. Define test objectives: This phase defines the objectives and expected results of the test
execution. Objectives include:
 A list of software features like functionality, GUI, performance standards, etc.
 The ideal expected outcome for every aspect of the software that needs testing.
4. Define test criteria: Two main testing criteria determine all the activities in the testing project:
 Suspension criteria: Suspension criteria define the benchmarks for suspending all the
tests.
 Exit criteria: Exit criteria define the benchmarks that signify the successful completion of
the test phase or project. These are expected results and must match before moving to the
next stage of development.
5. Resource planning: This phase aims to create a detailed list of all the resources required for
project completion. For example, human effort, hardware and software requirements, all
infrastructure needed, etc.
6. Plan test environment: This phase is very important as the test environment is where the QAs
run their tests. The test environments must be real devices, installed with real browsers and
operating systems so that testers can monitor software behavior in real user conditions.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

7. Schedule and Estimation: Break down the project into smaller tasks and allocate time and
effort for each task. This helps in efficient time estimation. Create a schedule to complete these
tasks in the designated time with a specific amount of effort.
8. Determine test deliverables: Test deliverables refer to the list of documents, tools, and other
equipment that must be created, provided, and maintained to support testing activities in the
project.
Best Practices for Creating an effective Test Plan:
Creating an effective test plan is essential for ensuring a comprehensive and systematic approach
to software testing. Here are some best practices to consider when developing a test plan:
1. Understand the Project Requirements:
 Gather Information: Ensure a thorough understanding of both functional and non-
functional requirements.
 Stakeholder Input: Involve stakeholders to gather expectations and address specific
concerns.
2. Define Clear Objectives and Scope:
 Purpose of Testing : Clearly state the objectives and what you aim to achieve.
 In-Scope and Out-of-Scope: Define what will be tested and what will not, to manage
expectations and focus resources.
3. Develop a Comprehensive Test Strategy:
 Approach : Outline the types of testing to be performed (e.g., functional, regression,
performance).
 Techniques and Tools: Specify testing techniques (e.g., black-box, white-box) and tools
(e.g., Selenium, JIRA) to be used.
4. Create Detailed Test Cases:
 Test Case Design : Develop detailed test cases covering all scenarios, including positive,
negative, edge, and boundary cases.
 Traceability : Ensure each test case is traceable to specific requirements to verify
comprehensive coverage.
5. Establish a Test Environment:
 Setup Requirements : Define hardware, software, network configurations, and tools
required for testing.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Environment Management: Ensure the test environment closely mirrors the production
environment to identify environment-specific issues.
6. Plan for Test Data and Reporting Mechanisms:
 Data Requirements : Identify and manage realistic, consistent test data securely,
especially if it includes sensitive information.
 Status Reporting: Establish processes for regular status updates on testing progress,
issues, and results, and use defect tracking systems effectively.


Test Design in Validation and Verifications in Software Testing

Test Design in Software Testing
Introduction to test design
Building a foundation for reliable and maintainable products transcends just writing code. It
involves investing in the long-term health and success of your software project. Ensuring a flawless
user experience, building confidence, anticipating challenges, and ultimately bringing a vision to
life are crucial. The American professor of software engineering, Cem Kaner, succinctly captures
it: “The best tester isn’t the one who finds the most bugs or who embarrasses the most
programmers. The best tester is the one who gets the most bugs fixed.” Hence, there’s a need
to have a system in place to test your software project. This system is called “test design,” which
allows for creating tests that verify software applications.
In this post, you’ll learn about a test design, what it is, and why it’s important to have a good test
design. Furthermore, we’ll examine the details of types of design techniques or concepts, as well
as steps and processes to design effective tests. Additionally, we’ll look into the challenges of test
design and some best practices for addressing those challenges.
Let’s get started!
Test Design
Test design is the process of creating a strategic plan for test cases, scenarios, and conditions to
ensure it meets the performance and reliability of software or systems. It aims to ensure test cases
effectively uncover software defects and behave as expected under various conditions. An
American computer scientist, entrepreneur, and author, Glenford Myers, has this to say about test
design: ”Good test design anticipates potential failure modes and explores system
boundaries.”
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Elements of test design

Some key elements of test design are:
Test Objectives: Define what you intend to achieve with the testing. Aim to verify system
functionality, usability, security, and other aspects of the software.
Test Cases: Describe instructions for executing a test. The test can include the ID, summary, steps,
and test environment.
Test Scenarios: Describe what to test to ensure you test the software from an end-to-end
perspective and cover user paths.
Test Data: Ensure the data used for executing test cases covers various scenarios and test
conditions. The data can be valid, invalid, or boundary value data.
Test Design Techniques: Identify the methods used to create test cases to achieve maximum
coverage.
Test Plan: Create a comprehensive document showing the testing approach, objectives, scope,
and criteria for success.
Importance of test design
Test design is a key concept in the software testing process and quality assurance. It’s key to
achieving high quality by systematically evaluating and validating if the software meets its
intended requirements and functions correctly.
Some of the importance of test design to software testing processes are:
1. Efficiency: Well-designed tests focus on critical areas, which saves time and resources.
2. Prompt Issue Identification: Effective test design reduces the cost of fixing issues by
uncovering defects early in the development process.
3. Quality: Extensive testing improves user satisfaction and software quality.
4. Improve Communication: Sharing detailed test cases with team members provides a clear
framework and documentation, improving communication and understanding.
5. Risk Mitigation: Test designs prevent costly failures by uncovering potential issues.
Software testing is a crucial aspect of any software development process, and test design plays a
major role in ensuring the effectiveness of the testing process. It refers to the process of creating
test cases that can effectively validate the functionality of the software being developed. It involves
identifying test scenarios, defining test conditions, and creating test cases that can detect bugs in
the software. Test design is a challenging process that requires careful planning, attention to detail,
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

and a great understanding of the product. In this article, we will discuss test design and everything
you need to know about it.
What is Test Design
Test design is a process that defines how testing has to be done. It involves the process of
identifying the testing techniques, test scenarios, test cases, test data, and expected test results.
Also, testers need to be specific about the test cases they create, such as providing specific inputs,
steps, and test data for each test case.
What is the Purpose of Test Design
Software testing, like all processes, is an investment and is considered successful when it provides
an ROI. To ensure, we are getting the ROI; it has to be tracked too. One factor that will create an
impact on the ROI, is the effectiveness of the test strategy. An effective test design will largely
dictate the effectiveness of the testing strategy, thus the ROI from the software testing process.
When to Create a Test Design
Test design should be created once the test conditions are defined, and adequate information is
available to create the test cases of both high and low levels.
Why is Test Design Important for Test Automation
Just as Test Design is important for an effective test strategy, a well-defined test design plays an
important role in the success of test automation too.
It is a crucial activity that helps determine the effectiveness of automated test cases in identifying
bugs and is highly essential for quality control and testing.“More than the act of testing, the act of
designing tests is one of the best bug preventers known. “ – says Boris Beizer.
For the effectiveness of test automation, you also need to have a test automation tool that supports
your goals. Thus, choosing the right test automation tool is vital, as also stated by a report that
said: 26% of companies consider finding the right tools for automation testing as their biggest
challenge.
How Is Test Design Done?
Test design is done using several test design techniques. The following is a list of some of the top
design techniques,
 Equivalence Class Testing
 State Transition
 Exploratory Testing
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Boundary value analysis

 Pairwise test design
 Error guessing test design
Let’s talk about some of the top techniques in the below section.
Top Test Design Techniques
1. Equivalence Class Testing
Equivalence class testing, also known as Equivalence Class Partitioning, is a test design technique
that lets you partition your test data into equivalent classes or sections.
It aims to reduce the number of test cases required to test a product by dividing the input domain
into a set of equivalence classes. You can use this whenever an input field has a range like age.
Example:
Consider a gaming website has a form that requires users to enter their age. And the form specifies
that the age has to be between 18 and 60. Now, using the Equivalence Class Partitioning technique,
you can divide the input range into three partitions, as follows,
 1 to 17 (invalid)
 18 to 60 (valid)
 >60 (invalid)
By partitioning the input range into equal partitions, you can create test cases that cover all possible
scenarios. This way, you can easily make sure that your form is working correctly without testing
every possible number between 18 and 60.
2. State Transitioning
It is a type of black box testing that is performed to check the change in the application’s state
under various inputs. This testing is used where different system transitions have to be tested.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

State Transition DiagramAbove is a state transition diagram that needs to be tested, it depicts
how a system’s state changes on specific inputs. The four main components for a state transition
diagram are as follows:
1. States
2. Transition
3. Events
4. Actions
State transition testing helps understand the system’s behavior and covers all the conditions. Let’s
try to understand this with an example.
Example:
Consider a bank application that allows users to log in with valid credentials. But, if the user
doesn’t remember the credentials, the application allows them to retry with up to three attempts.
If they provide valid credentials within those three attempts, it will lead to a successful login. In
case of three unsuccessful attempts, the application will have to block the account.
The below image will explain this scenario in a clear way.

3. Exploratory Testing
Exploratory testing is primarily used in Agile methods and involves outside-the-box thinking.This
process does not follow pre-defined test cases but instead involves testers using their knowledge,
skills, and creativity to identify issues that may not have been anticipated by developers.During
exploratory testing, the tester will explore the software application in an unstructured way, creating
and executing tests on the fly. The goal of this testing is to uncover bugs that may have been missed
by other traditional testing methods.
Test Design Concepts You Must Be Familiar With
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

As a software tester, there are several test design concepts that you must be familiar with to create
effective test cases. Here are some of the most important test design concepts,
Test Automation Pyramid
Test Automation Pyramid is a testing framework that helps developers and testers to build high-
quality products. It emphasizes the importance of automation at each level. The pyramid consists
of three levels, each representing a different type of testing as follows,
 Unit Tests
 Integration Tests
 End-to-End Tests

Unit testing: Here, testing is done on individual units or software modules. Each unit is tested
separately to ensure that it behaves as intended and meets its requirements.Integration testing: It
helps verify that different modules of a software application are working as intended when they
are integrated together.End-to-End testing: It involves evaluating the entire software application,
from start to finish, to ensure that all components work together as expected and meet the
requirements and business objectives. Also, it enables quick feedback cycles and helps developers
fix bugs in a short time. It helps save time, reduce costs, and improve the overall quality of an
application.
Test Execution For Software Testing
The term Test Execution tells that the testing for the product or application needs to be executed
in order to obtain the expected result. After the development phase, the testing phase will take
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

place where the various levels of testing techniques will be carried out and the creation and
execution of test cases will be taken place. The article focuses on discussing test execution.
Test execution is useful in these cases:
 Validating the software requirements to ensure that the system functions as intended.
 Identifying and reporting defects or issues in the software by comparing actual results with
expected results.
 Verifying that each component, module, or feature of the software performs as per the
design and functional specifications.
 Confirming that new changes or enhancements to the software do not negatively impact
existing functionality.
 Validating the software documentation.
Test Execution
Test Execution is the process of executing the tests written by the tester to check whether the
developed code or functions or modules are providing the expected result as per the client
requirement or business requirement. Test Execution comes under one of the phases of the
Software Testing Life Cycle (STLC).
In the test execution process, the tester will usually write or execute a certain number of test cases,
and test scripts or do automated testing. If it creates any errors then it will be informed to the
respective development team to correct the issues in the code. If the text execution process shows
successful results then it will be ready for the deployment phase after the proper setup for the
deployment environment.
Importance of Test Execution:
 The project runs efficiently: Test execution ensures that the project runs smoothly and
efficiently.
 Application competency: It also helps to make sure the application’s competency in the
global market.
 Requirements are correctly collected: Test executions make sure that the requirements
are collected correctly and incorporated correctly in design and architecture.
 Application built in accordance with requirements: It also checks whether the software
application is built in accordance with the requirements or not.
Activities for Test Execution
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

The following are the 5 main activities that should be carried out during the test execution.
1. Defect Finding and Reporting: Defect finding is the process of identifying the bugs or
errors raised while executing the test cases on the developed code or modules. If any error
appears or any of the test cases failed then it will be recorded and the same will be reported
to the respective development team. Sometimes, during the user acceptance testing also
end users may find the error and report it to the team. All the recorded details will be
reported to the respective team and they will work on the recorded errors or bugs.
2. Defect Mapping: After the error has been detected and reported to the development team,
the development team will work on those errors and fix them as per the requirement. Once
the development team has done its job, the tester team will again map the test cases or test
scripts to that developed module or code to run the entire tests to ensure the correct output.
3. Re-Testing: From the name itself, we can easily understand that Re-Testing is the process
of testing the modules or entire product again to ensure the smooth release of the module
or product. In some cases, the new module or functionality will be developed after the
product release. In this case, all the modules will be re-tested for a smooth release. So that
it cannot cause any other defects after the release of the product or application.
4. Regression Testing: Regression Testing is software testing that ensures that the newly
made changes to the code or newly developed modules or functions should not affect the
normal processing of the application or product.
5. System Integration Testing: System Integration Testing is a type of testing technique that
will be used to check the entire component or modules of the system in a single run. It
ensures that the whole system will be checked in a single test environment instead of
checking each module or function separately.
Test Execution Process
The test Execution technique consists of three different phases which will be carried out to process
the test result and ensure the correctness of the required results. In each phase, various activities
or work will be carried out by various team members. The three main phases of test execution are
the creation of test cases, test case execution, and validation of test results. Let us discuss each
phase.
1. Creation of Test Cases: The first phase is to create suitable test cases for each module or
function. Here, the tester with good domain knowledge must be required to create suitable test
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

cases. It is always preferable to create simple test cases and the creation of test cases should not be
delayed else it will cause excess time to release the product. The created test cases should not be
repeated again. It should cover all the possible scenarios raised in the application.
2. Test Cases Execution: After test cases have been created, execution of test cases will take
place. Here, the Quality Analyst team will either do automated or manual testing depending upon
the test case scenario. It is always preferable to do both automated as well as manual testing to
have 100% assurance of correctness. The selection of testing tools is also important to execute the
test cases.
3. Validating Test Results: After executing the test cases, note down the results of each test case
in a separate file or report. Check whether the executed test cases achieved the expected result and
record the time required to complete each test case i.e., measure the performance of each test case.
If any of the test cases is failed or not satisfied the condition then report it to the development team
for validating the code.
Ways to Perform Test Execution
Testers can choose from the below list of preferred methods to carry out test execution:
1. Run test cases: It is a simple and easiest approach to run test cases on the local machine
and it can be coupled with other artifacts like test plans, test suites, test environments, etc.
2. Run test suites: A test suite is a collection of manual and automated test cases and the test
cases can be executed sequentially or in parallel. Sequential execution is useful in cases
where the result of the last test case depends on the success of the current test case.
3. Run test case execution and test suite execution records: Recording test case execution
and test suite execution is a key activity in the test process and helps to reduce errors,
making the testing process more efficient.
4. Generate test results without execution: Generating test results from non-executed test
cases can be helpful in achieving comprehensive test coverage.
5. Modify execution variables: Execution variables can be modified in the test scripts for
particular test runs.
6. Run automated and manual tests: Test execution can be done manually or can be
automated.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

7. Schedule test artifacts: Test artifacts include video, screenshots, data reports, etc. These
are very helpful as they document the results of the past test execution and provide
information about what needs to be done in future test execution.
8. Defect tracking: Without defect tracking test execution is not possible, as during testing
one should be able to track the defects and identify what when wrong and where.
Test Execution Priorities
Test Execution Priorities are nothing but prioritizing the test cases depending upon several factors.
It means that it executes the test cases with high efficient first than the other test cases. It depends
upon various factors. Let us discuss some of the factors to be considered while prioritizing the test
cases.
 Complexity: The complexity of the test cases can be determined by including several
factors such as boundary values of test cases, features or components of test cases, data
entry of test cases, and how much the test cases cover the given business problem.
 Risk Covered: How much risk that a certain test case may undergo to achieve the result.
Risk in the form of time required to complete the test case process, space complexity
whether it is executed in the given memory space, etc.,
 Platforms Covered: It simply tells that in which platform or operating system the test
cases have been executed i.e., test cases executed in the Windows OS, Mac OS, Mobile
OS, etc.,
 Depth: It covers how depth the given test cases cover each functionality or module in the
application i.e., how much a given test procedure covers all the possible conditions in a
single functionality or module.
 Breadth: It covers how the breadth of the given test cases covers the entire functionality
or modules in the application i.e., how much a given test procedure covers all the possible
conditions in the entire functionality or modules in the product or application.
Test Execution States
The tester or the Quality Analyst team reports or notices the result of each test case and records it
in their documentation or file. There are various results raised when executing the test cases. They
are
 Pass: It tells that the test cases executed for the module or function are successful.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Fail: It tells that the test cases executed for the module or function are not successful and
resulted in different outputs.
 Not Run: It tells that the test cases are yet to be executed.
 Partially Executed: It tells that only a certain number of test cases are passed and others
aren’t met the given requirement.
 Inconclusive: It tells that the test cases are executed but it requires further analysis before
the final submission.
 In Progress: It tells that the test cases are currently executed.
 Unexpected Result: It tells that all the test cases are executed successfully but provide
different unexpected results.
Test Execution Cycle
A test execution cycle is an iterative approach that will be helpful in detecting errors. The test
execution cycle includes various processes. These are:
1. Requirement Analysis: In which, the QA team will gather all the necessary requirements
needed for test execution. For example, how many testers are needed, what automation test
tools are needed, what testing covers under the given budget, etc., the QA team will also
plan depending upon the client or business requirement.
2. Test Planning: In this phase, the QA team will plan when to start and complete the testing.
Choosing of correct automation test tool, and testers needed for executing the test plan.
They further plan who should develop the test cases for which module/function, who
should execute the test cases, how many test cases needed to be executed, etc.,
3. Test Cases Development: This is the phase in which the QA team assigned a group of
testers to write or generate the test cases for each module. A tester with good domain
knowledge will easily write the best test cases or test scripts. Prioritizing the developed test
cases is also the main factor.
4. Test Environment Setup: Test Environment Setup usually differs from project to project.
In some cases, it is created by the team itself and it is also created by clients or customers.
Test Environment Setup is nothing but testing the entire developed product with suitable
software or hardware components or with both by executing all the tests on it. It is essential
and it is sometimes carried out along with the test case development process.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

5. Test Execution: This stage involves test execution by the team and all the detected bugs
are recorded and reported for remediation and rectification.
6. Test Closure: This is the final stage and here it records the entire details of the test
execution process. It also contains the end-users testing details. It again modifies the testing
process if any defects are found during the testing. Hence, it is a repetitive process.
Test Execution Report
The Test Execution Report is nothing but a document that contains all the information about the
test execution process. It is documentation that will be recorded and updated by the QA team. In
that, they just record all the processes happening in the day-to-day test execution activities. The
test execution activities are nothing but executing the task related to testing. The documentation
or the report contains various information. They are:
 Who all are going to execute the test cases?
 Who is doing the unit testing, integration testing, system testing, etc.,
 Who is going to write test cases?
 The number of test cases executed successfully.
 The number of test cases failed during the testing.
 The number of test cases executed today.
 The number of test cases yet to be executed.
 What are the automation test tools used for today’s test execution?
 What are the modules/functions testing today?
 Recording the issues while executing the test cases.
 What is today’s testing plan?
 What is tomorrow’s testing plan?
 Recording the pending plans.
 Overall success rate.
 Overall failure rate.
These are the headings in the Test Execution Report:
 Test Summary Report Identifier.
 Summary.
 Variances.
 Comprehensive Assessment.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Summary of Results.
 Evaluation.
 Summary of Activities.
 Approval.
Guidelines for Test Execution
 Write the suitable test cases for each module of the function.
 Assign suitable test cases to respective modules or functions.
 Execute both manual testing as well as automated testing for successful results.
 Choose a suitable automated tool for testing the application.
 Choose the correct test environment setup.
 Note down the execution status of each test case and note down the time taken by the
system to complete the test cases.
 Report all the success status and the failure status to the development team or to the
respective team regularly.
 Track the test status again for the already failed test cases and report it to the team.
 Highly Skilled Testers are required to perform the testing with less or zero failures/defects.
 Continuous testing is required until success test report is achieved.

Software Review in Software Engineering :

Software Review is a systematic inspection of software by one or more individuals who work
together to find and resolve errors and defects in the software during the early stages of the
Software Development Life Cycle (SDLC). A software review is an essential part of the Software
Development Life Cycle (SDLC) that helps software engineers in validating the quality,
functionality, and other vital features and components of the software. It is a whole process that
includes testing the software product and it makes sure that it meets the requirements stated by the
client.
Usually performed manually, software review is used to verify various documents like
requirements, system designs, codes, test plans, and test cases.
Objectives of Software Review
The objective of the software review is:
1. To improve the productivity of the development team.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

2. To make the testing process time and cost-effective.

3. To make the final software with fewer defects.
4. To eliminate the inadequacies.
Process of Software Review

Software Review process

1. Entry Evaluation: By confirming documentation, fulfilling entry requirements and
assessing stakeholder and team preparation, you can determine the software’s availability.
2. Management Preparation: To get ready for the review process, assign roles, gather
resources and provide brief management.
3. Review Planning: Establish the review’s goals and scope, invite relevant parties and set a
time for the meeting.
4. Preparation: Distribute appropriate resources, give reviewers time to get familiar and
promote issue identification to help them prepare.
5. Examination and Exit Evaluation: Reviewers should collaborate to examine the results,
record concerns, and encourage candid communication in meetings. It assess the results,
make remedial plans based on flaws that have been reported and assess the process’s
overall efficacy.
Types of Software Reviews
There are mainly 3 types of software reviews:
1. Software Peer Review
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Peer review is the process of assessing the technical content and quality of the product and it is
usually conducted by the author of the work product along with some other developers.
Peer review is performed in order to examine or resolve the defects in the software, whose quality
is also checked by other members of the team.
Peer Review has following types:
1. Code Review: Computer source code is examined in a systematic way.
2. Pair Programming: It is a code review where two developers develop code together at
the same platform.
3. Walkthrough: Members of the development team is guided by author and other interested
parties and the participants ask questions and make comments about defects.
4. Technical Review: A team of highly qualified individuals examines the software product
for its client’s use and identifies technical defects from specifications and standards.
5. Inspection: In inspection the reviewers follow a well-defined process to find defects.
2. Software Management Review
Software Management Review evaluates the work status. In this section decisions regarding
downstream activities are taken.
3. Software Audit Review
Software Audit Review is a type of external review in which one or more critics, who are not a
part of the development team, organize an independent inspection of the software product and its
processes to assess their compliance with stated specifications and standards. This is done by
managerial level people.
Advantages of Software Review
1. Defects can be identified earlier stage of development (especially in formal review).
2. Earlier inspection also reduces the maintenance cost of software.
3. It can be used to train technical authors.
4. It can be used to remove process inadequacies that encourage defects.

INSPECTION AND AUDIT IN SOFTWARE ENGINEERING :

Introduction :
Software development is a complex process. It involves several tests and development activities,
which aims at creating a product of superior quality that provides exceptional services. Software
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

engineers use innovative and effective techniques to ensure that the product is created according
to the clients demand and fulfils their needs accurately. Audit and Inspection are two parts of
software development, which help testers and developers in monitoring the quality of the software.
Moreover, both of these are immensely important and help the Quality Assurance (QA) team
frequently.
Audit is an independent review and examination of records and activities to assess the adequacy
of the system controls, to ensure compliance with established policies and operational procedures,
and to recommend necessary changes in controls, policies and procedures. Whereas, Inspection
indicates that the regularity authorities are checking documents, records, facilities, and any other
authorities to verify a certain set of standards. To provide a better understanding of these two,
following is a detailed comparison of Audit and Inspection.
Defining Audit in Software Testing:
To ensure clearness and consistency of the software product, it is essential to audit the Software
Development Procedures together with the main significant features. It is a vital action in
companies and helps them check for bugs in the system, which further validates the product quality
and effectiveness. Audits are performed in software testing to ascertain the validity and reliability
of information as well as to provide an assessment of a system’s internal control.
Its goal is to express an opinion of the person, organisation, system, etc., in question or under
evaluation, based on work done on a test basis. Moreover, audit is conducted by owners of the
product only, which allows them to “self-check” and make sure everything is fine and as per the
needs of the organisation.
Audit Required in Software Testing
Auditing in software testing is essential as it aids organisations and comprehends if the progress is
being followed and monitored perfectly. It allows testers to find any defects and errors in the
system and ensures that product performance is of standard quality. Other benefits of auditing in
software testing are mentioned below:
 It ensures that the consistency is sustained and the procedures are truthful.
 To resolve development associated troubles.
 Audit assists testers in locating the exact origin and the reason of a crisis.
 To notice or avoid deception.
 It is used to confirm acquiescence of principles (i.e. ISO, CMM, etc.)
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 With Audit one can advance testing methods.

 Helps in avoiding errors and bugs in the product.
Procedure of Audit:
Auditing and test management ensure that software is being developed and deployed in accordance
with company requirements. Organizations benefit from this pairing by gaining basic insight into
day-to-day practices, including potential areas for improvement. The combination of technology
and procedure puts applications in a context in which they can be accurately evaluated. Similarly,
the procedure of Audit in software testing is extremely important and consists of various stages,
which are described below:
1. Analysing the Testing Method as Recognized in the Superiority Description: This aids
the assessor in recognizing the progression as it is described.
2. Analysing the Achievable Credentials at Every Stage: The documents are reviewed
which comprises, test strategy, test plan, test cases, test logs, defects tracked, test treatment
medium, and some additional applicable documents.
3. Questioning the Development Group at Different Stages: The Project Manager, lead,
testers and developers are questioned at different stages to get information about the
considered methods and techniques used during the testing procedure. It provides precious
intuition of what was in fact predictable.
Defining Inspection in Software Testing
In general the term Inspection means the process of evaluating or examining things. The output of
inspection is compared with the set standard or specified requirement to check whether an item
that is being developed is as per the requirement or not. It is the non-destructive type of testing and
it doesn’t harm the product under evaluation. Inspection is a formal review type that is led by
trained and expert moderators.
During the inspection the documents are prepare and checked thoroughly by the reviewers before
the meeting. It involves peers to examine the product. Moreover, a separate preparation is carried
out in Inspection, during which the product is examined and the defects are found. These defects
found are documented in a logging list or issue log, after which a formal follow-up is carried out
by the moderator applying exit criteria.
Goals of Inspection in Software Testing:
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Inspection is a type of appraisal execution that is frequently used in software applications. The
objective of inspection is to enable the observer to achieve agreement on an exertion system and
endorse it for employing it in the development of the software application. Usually inspected job
systems consist of software necessities definition and test designs. Other goals of Inspection are:
1. It helps the author to improve the quality of the document under inspection.
2. Removes defects efficiently, as soon as possible.
3. Helps in improving product quality.
4. Enables common understanding by exchanging information.
5. One can learn from defects found and prevent the occurrence of similar defects.
Characteristics of Inspection
Developed by Michael Fagan in the mid-1970s, the process of Inspection is comprehensive and
customized since its commencement. It includes accessing feature that conclude if the inspection
method is prepared to be initiated. With the assistance of Inspection one can review the system
which is going to be checked.
The phases in the inspections method include Scheduling, outline conference, Research,
examination convention, revise and report-on. The Scheduling, outline conference and Research
stages might be iterated. The characteristics that differentiate inspection from Audit are:
1. The process of inspection is usually led by a trained moderator, who is not the author.
Moderator's role is to do a peer examination of a document.
2. It is extremely formal and is driven by checklists and rules.
3. This review process makes use of entry and exit criteria.
4. It is essential to have a pre-meeting preparation.
5. Inspection report is prepared and shared with the author for appropriate actions.
6. Post Inspection, a formal follow-up process is used to ensure a timely and a prompt
corrective action.
7. Aim of Inspection is not only to identify defects, but also to bring process improvement.

Audit in Software Testing: Benefits, Types, and Metrics

Software development process involves a lot of elements and is a lengthy process. It involves
thorough test planning, continuous feedback among many people. In all this, it becomes important
to make sure the quality of the product is not compromised. That is why it is important to have
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

software audits regularly to check the health of any software product. In this article we’ll
understand what a software audit accomplishes and why it is important.
Software Audit
A software audit is a thorough review of a software product to check its quality, progress, standards
and regulations. It basically checks the health of a product and ensures that everything is going as
planned. It can be done by an internal team or any external independent auditors.
If the audit is performed by an external auditor, it can add some financial strain to the company
and disrupt development to accommodate such audits. It is recommended to perform regular
internal audits on the software to ensure that proper regulations are followed and all licenses are
up-to-date as it can also save the company from unnecessary legal issues.
Benefits of Audit in Software Testing
 Helps in validating the testing process and identifies ways to optimize the existing process
 It checks for any mismatches between the requirements and the delivered features. There
can be miscommunication between business and technical teams which can cause such
mismatches. Audits helps in capturing such issues
 Ensures the development progress is as expected with compliance to regulations and best
practices. It can also catch any potential risks to the product and help mitigate it
 Incase any issues are noticed, proper suggestions are gives to improve upon the process or
the product
Types of Audit in Software Testing
There are different types of audits based on what goals are needed to be achieved for the product
 Internal audit: These audits are done within the organization
 External audit: These are done by independent contractors or external agencies
 Compliance audit: This audit checks if the process is within the given standards. If the
testing process has certain standards to adhere to, this audit ensures that it’s followed
 Process improvement: If there are any changes needed for the existing process, this audit
helps in identifying them. This is done by evaluating the various steps in the process and
identifying any problems, and eliminating them.
 Root cause analysis: This audit helps to find the root cause for a problem using different
testing processes. It is done for specific problems that require some attention and needs to
be resolved.
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

Metrics to watch during an Audit in Software Testing

There are various metrics that are monitored during an audit to ensure that the expected outcome
is being achieved. Some of them are:
1. Project Metrics
 Percentage of test case execution: It analyses how many of the test cases are executed in
the testing process
Percent of Test Case Execution =
(Number of Passed Tests + Number of Failed Tests + Number of Blocked Tests) / Number of Test
Cases
2. Product Metrics
 Critical defects: This helps in understanding the current quality of a product
Total Percentage of Critical Defects = (Critical Defects / Total Defects Reported) x 100
 Defect distribution across components: There may be some components in a product that
may have significantly higher defects than others, and it is important to identify them. This
metric helps in analyzing the problematic areas and focuses on these issues.
Defect Distribution Across Components = Total Number of Defects / Functional area(s)
 Defect priority distribution: This helps in gauging the effectiveness of the testing process.
Based on the priority of the defects within a component, it helps to decide which component
requires more attention over the others.
3. People Metrics
 Issues per reporter: This keeps track of how many issues were reported by each reporter.
It gives an idea of which defects the tester is working on, i.e., regression testing or
identifying bugs
 Tests reported by each team member: This metric helps the management gauge each
team member’s performance
Audit in Software Testing
There are some simple steps to follow while performing an audit:
 Identify the purpose of the audit and what it hopes to find. By being specific, helps in
getting optimum results and eliminates the problems efficiently
 DR S K HIREMATH CMR UNIVERSITY BANGALORE-49

 Examine the testing processes being done and verify the current processes against the
planned and defined procedures and guidelines which were documented as a part of the
testing manual prior to the testing phase
 Once the testing process is verified, each of the test cases, test suites, test logs, defect
reports, test coverage and traceability matrix are thoroughly reviewed
 Interviewing the individuals involved at different stages in the testing process to get a better
idea of the current progress.

*******