SOFTWARE TESTING UNIT I

INTRODUCTION TO SOFTWARE TESTING

FUNDAMENTAL OF SOFTWARE TESTING

Software testing can be stated as the process of verifying and validating whether a software or
application is bug-free, meets the technical requirements as guided by its design and
development, and meets the user requirements effectively and efficiently by handling all the
exceptional and boundary cases.

The process of software testing aims not only at finding faults in the existing software but
also at finding measures to improve the software in terms of efficiency, accuracy, and
usability. It mainly aims at measuring the specification, functionality, and performance of a
software program or application.

Software testing can be divided into two steps:

1. Verification: it refers to the set of tasks that ensure that the software correctly
implements a specific function.

2. Validation: it refers to a different set of tasks that ensure that the software that has
been built is traceable to customer requirements.

Verification: “Are we building the product right?”

Validation: “Are we building the right product?”

What are different types of software testing?

Software Testing can be broadly classified into two types:

1. Manual Testing: Manual testing includes testing software manually, i.e., without using any
automation tool or any script. In this type, the tester takes over the role of an end-user and
tests the software to identify any unexpected behavior or bug. There are different stages for
manual testing such as unit testing, integration testing, system testing, and user acceptance
testing. Testers use test plans, test cases, or test scenarios to test software to ensure the
completeness of testing. Manual testing also includes exploratory testing, as testers explore
the software to identify errors in it.

2. Automation Testing: Automation testing, which is also known as Test

Automation, is when the tester writes scripts and uses another software to test the product.
This process involves the automation of a manual process. Automation Testing is used to re-
run the test scenarios quickly and repeatedly, that were performed manually in manual
testing.
Apart from regression testing, automation testing is also used to test the application from a
load, performance, and stress point of view. It increases the test coverage, improves accuracy,
and saves time and money when compared to manual testing.

What are the different types of Software Testing Techniques ?

Software testing techniques can be majorly classified into two categories:

1. Black Box Testing: The technique of testing in which the tester doesn’t have access to
the source code of the software and is conducted at the software interface without any
concern with the internal logical structure of the software is known as black-box
testing.

2. White-Box Testing: The technique of testing in which the tester is aware of the
internal workings of the product, has access to its source code, and is conducted by
making sure that all internal operations are performed according to the specifications
is known as white box testing.

Black Box Testing White Box Testing

Internal workings of an application are Knowledge of the internal workings is a

not required. must.

Also known as closed box/datadriven

Also known as clear box/structural testing.
testing.

End users, testers, and developers. Normally done by testers and developers.

This can only be done by a trial and error Data domains and internal boundaries can be
method. better tested.
What are different levels of software testing?

Software level testing can be majorly classified into 4 levels:

1. Unit Testing: A level of the software testing process where individual

units/components of a software/system are tested. The purpose is to validate that each
unit of the software performs as designed.

2. Integration Testing: A level of the software testing process where individual units are
combined and tested as a group. The purpose of this level of testing is to expose faults
in the interaction between integrated units.
 3. System Testing: A level of the software testing process where a complete, integrated
system/software is tested. The purpose of this test is to evaluate the system’s
compliance with the specified requirements.

4. Acceptance Testing: A level of the software testing process where a

system is tested for acceptability. The purpose of this test is to evaluate the system’s
compliance with the business requirements and assess whether it is acceptable for
delivery.

Note: Software testing is a very broad and vast topic and is considered to be an integral and
very important part of software development and hence should be given its due importance.

NEED FOR SOFTWARE TESTING

Software testing is an activity which aims at evaluating the quality of a software product
and also to improve it by identifying defects. Software testing strives to achieve its
objectives but has certain limitations. However, adherence to the established objectives
ensures effective testing. In this article, we will focus on the following points:

• What are the Objectives of Software Testing?

• Do Objectives vary with the type of Testing Technique and SDLC model?

What are Software Testing Objectives?

Some of the significant objectives of software testing are as follows:

To evaluate the work products such as requirements, design, user stories, and code:

The work products such as Requirement document, Design, and User Stories should be
verified before the developer picks it up for development. Identifying any ambiguity or
contradicting requirements at this stage saves considerable development and test time. The
static analysis of the code (reviews, walk-thru, inspection, etc.) happens before the code
integrates/is ready for testing. This idea of testing is known as Verification. It is the process
of evaluating the product during the development phase of each work product.

To verify the fulfillment of all specified requirements:

This objective reveals the fact that the essential elements of testing should be to fulfill the
customer’s needs. Testers test the product and ensure the implementation of all the specified
requirements have. Developing all the test cases, regardless of the testing technique ensures
verification of the functionality for every executed test case. The Tester should also create a
requirement traceability matrix (RTM), which will ensure the mapping of all the test cases to
requirements. RTM is an effective way to ensure that test cases have got the right
requirement coverage.

To validate if the test object is complete and works as per the expectation of the users and the
stakeholders:

Testing ensures the implementation of requirements along with the assurance that they work
as per the expectation of users. This idea of testing is called Validation. It is the process of
checking the product after development. Validation can be a manual or automation. It
usually employs various types of testing techniques, i.e., Black Box, White Box, etc.
Generally, testers perform validation, whereas customers can also validate the product as
part of User acceptance testing. Every business considers the customer as the king. Thus the
customer's satisfaction is a predominant need for any business. For example, customer
satisfaction and loyalty in online shopping and ecommerce environments is a useful
indicator for long-term business success.
To build confidence in the quality level of the test object:

One of the critical objectives of software testing is to improve software quality. High-Quality
software means a lesser number of defects. In other words, the more efficient the testing
process is, the fewer errors you will get in the end product. Which, in turn, will increase the
overall quality of the test object. Excellent quality contributes to a significant increase in
customer satisfaction as well as lower maintenance costs.

To prevent defects in the software product:

One of the objectives of software testing is to avoid the mistakes in the early stage of the
development. Early detection of errors significantly reduces the cost and effort. The
prevention of defects involves doing a root cause analysis of the defects found previously and
after that, taking specific measures to prevent the occurrence of those types of errors in the
future. Efficient testing helps in providing an error-free application. If you prevent defects, it
will result in reducing the overall defect count in the product, which further ensures a high-
quality product to the customer.

To find defects in the software product:

Another essential objective of software testing is to identify all defects in a product. The main
motto of testing is to find maximum defects in a software product while validating whether
the program is working as per the user requirements or not. Defects should be identified as
early in the test cycle as possible.
E.g., a defect found in the UAT phase will be much costlier to fix than the same defect found
in the Sprint testing phase.

To provide sufficient information to stakeholders to allow them to make informed decisions,

especially regarding the level of quality of the test object:

The purpose of testing is to provide complete information to the stakeholders about technical
or other restrictions, risk factors, ambiguous requirements, etc. It can be in the form of test
coverage, testing reports covering details like what is missing, what went wrong. The aim is
to be transparent and make stakeholders fully understand the issues affecting quality.

To reduce the level of risk of insufficient software quality:

The possibility of loss is also known as risk. The objective of software testing is to reduce the
occurrence of the risk. Each software project is unique and contains a significant number of
uncertainties from different perspectives, such as market launch time, budget, the technology
chosen, implementation, or product maintenance. If we do not control these uncertainties, it
will impose potential risks not only during the development phases but also during the whole
life cycle of the product. So, the primary objective of software testing is to integrate the Risk
management process to identify any risk as soon as possible in the development process.
To comply with contractual, legal, or regulatory requirements or standards, and to verify the
test object’s compliance with such requirements or standards:

This objective ensures that software developed for a specific region must follow the legal
rules and regulations of that region. Moreover, the software product must be compatible with
the national and international standards of testing. We have ISO/IEC/IEEE 29119 standards
that deal with the software testing concept.

E.g., each country has laws specific to accessibility requirements which must be fulfilled to
avoid legal implications. The European Union has strict rules on how the Personal
Identifiable Information (PII) like Social security number etc. should be handled. Failure to
adhere to such requirements will lead to failure of the product, no matter how defect-free it
has been working!

Do the Software Testing Objectives vary with the type of Testing Technique and SDLC
model?

Yes, sometimes, the objectives can vary based on the type of testing techniques. Let's
understand it by using some basic testing types.

• Unit testing: In Unit/Component testing, the objective is to find as many defects as

possible. Fixing defects at the unit level saves cost, effort, and time.
• Integration testing: The objective is to find defects in the integration touchpoints of 2
or more systems. Individual system testing is not a focus here.
• User acceptance testing: The objective of this type of testing is to confirm the system
works as expected by the end-user. It is the final stage of the testing before its
deployment.
• Regression testing: The objective of Regression testing is to ensure no new defects
have been introduced mainly in case of enhancements or defect fix.
• Operational testing: This testing checks the reliability and performance of the
software. The software should be tested to find out if it works as expected, even under
the maximum workload.

In addition to the type of testing, the objectives also vary with the SDLC model. For instance,
in a waterfall model, the aim is to be as detailed as possible in the artifact creation (e.g., test
cases). Whereas in the agile model, the artifacts are created just in time and with the
minimum required details.
created just in time and with the minimum required details.

PSYCHOLOGY OF TESTING

Psychological Testing in Software Testing

Software development, including software testing, involves human beings.

Therefore, human psychology has important effect on software testing.
In software testing, psychology plays an extremely important role. It is one of those factors
that stay behind the scene, but has a great impact on the end result. Categorized into three
sections, the psychology of testing enables smooth testing as well as makes the process
hassle-free. It is mainly dependent on the mindset of the developers and testers, as well as the
quality of communication between them. Moreover, the psychology of testing improves

mutual understanding among team members and helps them work towards a common goal.

The three sections of the psychology of testing are:

• The mindset of Developers and Testers.

• Communication in a Constructive Manner.
• Test Independence.

The mindset of Developers and Testers

The software development life cycle is a combination of various activities, which are
performed by different individuals using their expertise and knowledge. It is not an unknown
fact that to accomplish the success, development of software, people with different skills and
mindset are required. Developers synthesize code. They build up things, putting pieces
together and figuring out fun and unique ways of combining those distinct little bits to do
wonderful and amazing things.

But Testers are all about analysis. Once it has all been put together, the tester likes to take it
apart again, piece by piece, this time looking for those little corners, edges, and absurdities
that hide in those weird and strange interactions that come from those new and amazing ways

of putting pieces together.

Testing and Reviewing the applications are different from analyzing and developing it. While

testing or reviewing a product, testers mainly look for defects or failures in the product. If we
are building or developing applications, we have to work positively to solve the problems
during the development process and to make the product according to the user specification.

As an example,
Identifying defects during static testing such as requirements review or user story
refinement session or identifying failures during dynamic test execution, may be perceived
as Criticism of the product and of its author. So the developer or the analyst may have
problems with you as a tester because he thinks that you are criticizing them.

There’s an element of human psychology called Confirmation bias, which means that most of
people find it difficult to accept information that disagrees with currently held believes.

For example, since developers expect their code to be correct, they have a confirmation bias
that makes it difficult to accept that the code is incorrect. In addition to confirmation bias,
other cognitive biases may make it difficult for people to understand or accept information

produced by testing.
Further, it is a common human trait to blame the bearer of bad news and information
produced by testing often contains bad news.

So as a result of these psychological factors, some people may perceive testing as a

destructive activity, even though it contributes greatly to project progress and product quality.

To try to reduce these perceptions, information about defects and failures should be

communicated in a Constructive Way.

This way, tensions between the testers and the analysts, product owners, designers, and

developers can be reduced. This applies during both static and dynamic testing in which
Static Testing is a software testing technique where the software is tested without executing
the code and Dynamic Testing will use the dynamic behaviour of the code by opening the
application and run it.

Communication in a Constructive Manner

Testers and test managers need to have good interpersonal skills to be able to communicate
effectively about the defects, failures, test results, test progress and risks and to build positive
relationships among colleagues.
Communication, if done in a polite and respectful manner can help build a strong and reliable
relationship between the team members and help them avoid any misunderstanding.

Similarly during the process of testing also, the requirement of communication in a

constructive manner is extremely high. As testers are responsible for finding bugs and
reporting them, it becomes vitally important for them to communicate it in a respectful,

polite, and suitable way to avoid hurting and disappointing someone.

Finding and reporting defects can be an achievement for the tester but is merely an
inconvenience for programmers, designers, developers, and other stakeholders of the project.
As testing can be a destructive activity, it is important for software testers to report defects
and failures as objectively and politely as possible to avoid hurting and upsetting other
members related to the project.

So as testers, there are many ways to communicate collaboratively with developers.

• Start with collaboration rather than battels.

• Remind everyone about their common goal of having better quality systems.

• Emphasize the benefits of testing.

For example, for the authors, defect information can help them to improve the work products
and their skills.

• For the organization, defects found and fixed during testing will save money,

time and reduce overall risk to product quality.

• Communicate test results and other findings in a neutral, fact focused way
without criticizing the person who created the defected item.
• Write objectives, defect reports and review findings.

• Try to understand how the other person feels and the reasons they may react

negatively to the information.

• Confirm that the other person has understood what has been said.

• Clearly define the right set of test objectives has important psychological
implications.

• Most people tend to align their plans and behaviors with the objectives set by the
team, management, and stakeholders. So it’s also important that testers adhere to
these objectives with minimum personnel bias.

Self-testing and Independent testing

Comparison of the mindsets of a tester and a programmer does not mean that a tester cannot
be a programmer, or that a programmer cannot be the tester, although they often are separate
roles. In fact, programmers are the testers. They always test the component which they built.

While testing their own code they find many problems so the programmers, architect, and
developers always test their own code before giving it to anyone. However, we all know that
it is difficult to find our own mistakes. It might be due to some reasons such as,

• “Parental feelings” towards their code

• Focus on the “Positive Paths”

• Work-based on the principle of simplifying of complex scenarios

• Inability to catch small things in big pictures

• Lack of end-to-end & real-user perspective

• bLess experience with common bugs & application pitfalls

So, programmers, architects, business analysts depend on others to help test their work. This
other person might be some other developer from the same team or the Testing specialists or
professional testers.

Giving applications to the testing specialists or professional testers allows an independent

test of the system.
As this type of testing is mainly performed by individuals, who are not related to the project
directly or are from a different organization, they are hired mainly to test the quality as well
as the effectiveness of the developed product. Test independence, therefore, helps developers

and other stakeholders get more accurate test results, which helps them build a better software
product, with innovative and unique features and functionality.

There are several levels of independence in software testing which is listed here from the
lowest level of independence to the highest:

i. Tests by the person who wrote the item.

ii. Tests by another person within the same team, like another programmer.
iii.Tests by the person from some different groups such as an independent test team.

iv. Tests by a person from a different organization or company, such as outsourced testing or
certification by an external body.

To achieve successful testing it’s important for the software engineers to consider the
psychological aspects of testing, as they can interrupt the result of testing and can impact the
performance of the end product. The importance of these technological aspects is similar to
any other tool or technique adopted for the process of testing.

The mindset of the team members, the communication between them, and most importantly
the test independence while performing the testing is crucial and needs great consideration.

Therefore, if you want your software testing to be free of any hurdles, do consider the
psychological aspects stated above.

VARIOUS APPROACHES OF SOFTWARE TESTING

Testing is the process of executing a program to find errors. To make our software perform
well it should be error-free. If testing is done successfully it will remove all the errors from
the software.

Principles of Testing:-

(i) All the tests should meet the customer requirements.

(ii) To make our software testing should be performed by a third party. (iii) Exhaustive
testing is not possible. As we need the optimal amount of testing based on the risk
assessment of the application.
(iv) All the tests to be conducted should be planned before implementing it (v) It follows the
Pareto rule(80/20 rule) which states that 80% of errors come from 20% of program
components.
(vi) Start testing with small parts and extend it to large parts.
Types of Testing:-

1. Unit Testing

It focuses on the smallest unit of software design. In this, we test an individual unit or group
of interrelated units. It is often done by the programmer by using sample input and observing
its corresponding outputs.

Example:

a) In a program we are checking if the loop, method, or function is working fine

b) Misunderstood or incorrect, arithmetic precedence.
c) Incorrect initialization

2. Integration Testing

The objective is to take unit-tested components and build a program structure that has been
dictated by design. Integration testing is testing in which a group of components is combined
to produce output.

Integration testing is of four types: (i) Top-down (ii) Bottom-up (iii) Sandwich (iv) Big-Bang

Example:

(a) Black Box testing:- It is used for validation. In this, we ignore internal
working mechanisms and focus on what is the output?.

(b) White box testing:- It is used for verification.

In this, we focus on internal mechanisms i.e.
how the output is achieved?

3. Regression Testing

Every time a new module is added leads to changes in the program. This type of testing
makes sure that the whole component works properly even after adding components to the
complete program.

Example
In school, record suppose we have module staff, students and finance
combining these modules and checking if on integration of these modules
works fine in regression testing
4. Smoke Testing

This test is done to make sure that the software under testing is ready or stable for further
testing
It is called a smoke test as the testing of an initial pass is done to check if it did not catch the
fire or smoke in the initial switch on.

Example:

If the project has 2 modules so before going to the module make sure that
module 1 works properly

5. Alpha Testing

This is a type of validation testing. It is a type of acceptance testing which is done before the
product is released to customers. It is typically done by QA people.

Example:

When software testing is performed internally within the

organization

6. Beta Testing

The beta test is conducted at one or more customer sites by the end-user of the software. This
version is released for a limited number of users for testing in a real-time environment

Example:

When software testing is performed for the limited

number of people

7. System Testing

This software is tested such that it works fine for the different operating systems. It is covered
under the black box testing technique. In this, we just focus on the required input and output
without focusing on internal working. In this, we have security testing, recovery testing,
stress testing, and performance testing

Example:

This includes functional as well as nonfunctional testing

 8. Stress Testing

In this, we give unfavorable conditions to the system and check how they perform in those
conditions.

Example:

(a) Test cases that require maximum memory or other resources are
executed
(b) Test cases that may cause thrashing in a virtual operating system
(c) Test cases that may cause excessive disk requirement

9. Performance Testing

It is designed to test the run-time performance of software within the context of an integrated
system. It is used to test the speed and effectiveness of the program. It is also called load
testing. In it we check, what is the performance of the system in the given load.

Example:

Checking several processor cycles.

10. Object-Oriented Testing

This testing is a combination of various testing techniques that help to verify and validate
object-oriented software. This testing is done in the following manner:
• Testing of Requirements,
• Design and Analysis of Testing,
• Testing of Code,
• Integration testing, System testing, User Testing.

11. Acceptance Testing

Acceptance testing is done by the customers to check whether the delivered products perform
the desired tasks or not, as stated in requirements.

CHARACTERISTIC AND STRATEGIES OF SOFTWARE TESTING

Software Testing Strategies

Software testing strategy is an approach which incorporates planning of the steps to test the
software along with the planning of time, effort & resources that will be required to test the
software. Software testing strategies plans to test any software starting from the smallest
component of the software and then integrating test towards the complete system.
The testing strategy should be developed carefully as a non-effective testing strategy would
waste the time, cost, effort & resources of the organization. In this section, we will discuss
the strategies of software testing, along with the characteristics of testing strategies and the
level of testing strategy. We will further study the factors that should be considered while
developing the strategy of software testing.

Software Testing Strategies

Software testing strategy is the planning done before testing commences and exercised
systematically to test the software. The testing strategy could be developed by the project
manager, or by the software engineers or it could even be a testing specialist.

Developing a testing strategy for software is important because if testing is not conducted
properly it would lead to wastage of time and effort and it would even be the case that some
error or bugs remain undetected. Some general characteristics that should be considered while
developing the testing strategy are as follow:

1. For successful testing, you should conduct the technical evaluation, it would
reveal many of the error before the testing starts. It would help in correcting
the technical error before the testing commences & would save time while
testing the software.

2. Testing must start from the core of the software design and it must progress
outward to incorporate testing of the entire software.

3. You should not follow the same strategy to test all the software. Appropriate
testing strategies must be developed for different software engineering
approach.

4. Generally, the developer of the software conduct the software testing, and in
case the project is large a separate team must be allotted to test the software.

5. Though debugging and testing are two distinct jobs; debugging must be
incorporated in every testing strategy.

The software testing strategy is implemented at two levels, low-level testing and high-
level testing. Low-level testing is conducted at the core of software design like verifying
the code segments of the software. Whereas, high-level testing is conducted to validate
software functions against the specified requirements of the customers.

Verification and Validation

Verifying and validating a software incorporates a wide range of software quality

assurance activities. By verifying a software, we ensure that every function in the
software is implemented and functioning accurately. By validating software, we ensure
that the developed software meets the requirements specified by the customer.

In a simple language, verification answers the question of whether ‘we are implementing the
software correctly?’ & validating answers, the question of whether ‘we are implementing the
correct software?’.

Levels of Software Testing Strategies

While developing the software the software engineers first review the customer requirements,
then models it and finally go for coding. That means while developing the software
developers move inwards the spiral in an anticlockwise direction.

For testing, initially, the core part of the software is tested, each unit of the software is tested
separately to ensure that as a unit this component functions properly. Then the testing
proceeds outward the spiral along the streamlines. Moving outwards the spiral in the
clockwise direction gradually widens the scope of testing and in each turn, testing integrates
the components and ensure that all the elements of the software are functioning properly and
the desired performance is achieved.
In the image below you can see the levels of testing strategies that are developed to test the
entire software.

Unit Testing

Unit testing focuses on testing the lowest component of the software individually which is
also called unit. Unit testing involves the testing of each code segment to ensure that it
functions properly.
Integration Testing
The unit components are integrated to implement the complete software. Integration testing
involves testing the design structure of the software which include modelling and software
architecture. It focuses on verifying whether functions of the software are working properly
or not.

Validation Testing
Validation testing focuses on the testing of software against the requirements specified by the
customer.

System Testing

System testing focuses on testing the entire system as a whole and its other system elements.
It tests the performance of the system.

Factors Considered to Develop Testing Strategies

1. The first and foremost thing before developing and software are gathering customer
requirements. The requirements specified by the customer should be measurable so
that the testing result is not ambiguous.
2. The objective of testing should be in measurable terms. Like cost required to detect
and debug the error, time spends by the team to test the software.
3. While developing the testing strategy one must understand the need of the user who is
going to use the software.
4. The testing strategy should implement rapid testing cycles and the generated feedback
can be used in software quality control.
5. The software should be designed in a way that it is capable of diagnosing its own
errors.
6. Before testing the software do the technical analysis to discover the error before
testing commences.
7. The testing strategies should be improved for the better testing result of the software.

Key Takeaways

• The testing strategy is a plan of action developed for effective testing of the software.
• If the testing strategy is not planned properly it can waste the time, cost, effort and
resources of the organization.
• Testing strategies should include the steps involved in the testing, the time at which
these steps would be conducted to test the software. The testing strategy also
incorporates cost, time, effort and resources that would be required for testing.
• Software testing strategy incorporates verification and validation of the software.
• Verification of the software ensures that all the elements of the software are
functioning properly.
• Validation of the software ensures that the developed software satisfies the
requirement specified by the customer.
• The testing strategy moves outward in the clockwise direction the spiral from low-
level testing to high-level testing.
• The testing strategy includes unit testing, integration testing, validation testing &
system testing.
• The unit testing verifies the smallest component of the software like code segments.
• Integration testing verifies design and architecture of the software.
• Validation testing ensures that the software functions according to the requirements of
the customers.
• System testing ensures that the overall system is functioning effectively.
 • The software testing strategies are developed by the project manager, developer or an
independent team is allotted for developing testing strategies.
• The testing strategy should incorporate technical review as it would discover error
prior testing starts.

PRINCIPLE OF SOFTWARE TESTING

Software testing is an important element of the software development lifecycle. While most
companies have dedicated testing and QA teams, there are companies that prefer hiring
developers that already have some knowledge of software testing. Here are the top principles
of software testing that every software developer should know.

1. Testing should show the presence of defects

Every application or product release should be tested by different teams and passed through
different phases of testing. In software testing, no-one will say that there is no defect in the
software. The objective of testing is to find hidden defects using various methods and
techniques.
2. Early testing
Software testers should get involved in the early stage of the software development lifecycle.
This helps in identifying defects early during in the requirement analysis phase itself. Starting
early with testing helps in saving the cost required in fixing such defects.

3. Exhaustive testing
It is challenging to test all functions of the software with all valid and invalid combinations.
However exhaustive testing takes account of unlimited efforts. Project timelines do not allow
testing of different combinations.

4. Testing is context-dependent
Software testing is a broad concept which is applicable for software in every industry.
However, testing is always context-specific. Software testing in medical, advertising, travel is
different. Each domain needs to be tested differently. Testing a bank application is different
than testing e-commerce or advertising application.

5. Defect clustering
During testing, it often happens that the most errors are related to small modules. There can be
multiple reasons behind this. The basic principle of software testing states that 80% of
problems are usually found in 20% modules. Defect clustering is an important concept that
developers must learn.

VERIFICATION OF SOFTWARE TESTING

• Verification is done at the starting of the development process. It includes reviews and
meetings, walk-throughs, inspection, etc. to evaluate documents, plans, code,
requirements and specifications.
• Suppose you are building a table. Here the verification is about checking all the parts of
the table, whether all the four legs are of correct size or not. If one leg of table is not of
the right size it will imbalance the end product. Similar behavior is also noticed in case
of the software product or application. If any feature of software product or application
is not up to the mark or if any defect is found then it will result into the failure of the
end product. Hence, verification is very important. It takes place at the starting of the
development process.

Software verification and validation

• It answers the questions like: Am I building the product right?
• Am I accessing the data right (in the right place; in the right way).
• It is a Low level activity
• Performed during development on key artifacts, like walkthroughs, reviews and
inspections, mentor feedback, training, checklists and standards.
• Demonstration of consistency, completeness, and correctness of the software at each
stage and between each stage of the development life cycle.

Advantages of Software Verification :

1. Verification helps in lowering down the count of the defect in the later stages of
development.
2. Verifying the product at the starting phase of the development will help in
understanding the product in a better way.
3. It reduces the chances of failures in the software application or product.
 4. It helps in building the product as per the customer specifications and needs.
VALIDATION OF SOFTWARE TESTING

Software Testing - Validation Testing

The process of evaluating software during the development process or at the end of the
development process to determine whether it satisfies specified business requirements.
Validation Testing ensures that the product actually meets the client's needs. It can also be
defined as to demonstrate that the product fulfills its intended use when deployed on appropriate
environment.
It answers to the question, Are we building the right product?

Validation Testing - Workflow:

Validation testing can be best demonstrated using V-Model. The
Software/product under test is evaluated during this type of testing.

Activities:
• Unit Testing
• Integration Testing
• System Testing
• User Acceptance Testing

What is Verification Testing ?

Verification is the process of evaluating work-products of a development phase to determine
whether they meet the specified requirements.
verification ensures that the product is built according to the requirements and design
specifications. It also answers to the question, Are we building the product right?

Verification Testing - Workflow:

verification testing can be best demonstrated using V-Model. The artefacts such as test Plans,
requirement specification, design, code and test cases are evaluated.
Activities:
• Reviews
• Walkthroughs
• Inspection

Virtual Users:
Virtual user is a common terminology used from a performance testing point of view. A
Virtual user generator enables testers to create virtual users in order to increase the user load
on the application under test.
Virtual user generator captures the requests to create a virtual user and it can read user
operations.

What is Volume Testing?

Volume testing is a Non-functional testing that is performed as part of performance testing
where the software is subjected to a huge volume of data. It is also referred as flood testing.
Volume Testing Characteristics:
• During development phase, only small amount of data is tested.
• The performance of the software deteriorates over time as there is enormous
amount of data overtime.
• Test cases are derived from design documents.
• Test data is usually generated using a test data generator.
• Test data need not be logically correct but the data is to assess the system
performance.
• Upon completion of testing, results are logged and tracked to bring it to closure.
Volume Testing - Checklist:
• Verify if there is any data loss.
• Check the system's response time.
• Verify if the data is stored incorrectly.
• Check if the data is overwritten without any notification.

DEFECTS AND PREVENTION STRATEGIES OF SOFTWARE TESTING

Defect Prevention is basically defined as a measure to ensure that defects being detected so
far, should not appear or occur again. For facilitating communication simply among members
of team, planning and devising defect prevention guidelines, etc., Coordinator is mainly
responsible. Coordinator is mainly responsible to lead defect prevention efforts, to facilitate
meetings, to facilitate communication between team members and management, etc. DP
board generally has quarterly plan in which sets some goals at organization level. To achieve
these goals, various methods or activities are generally used and carried out to achieve and
complete these goals.

Methods of Defect Prevention :

For defect prevention, there are different methods that are generally used over a long period
of time. These methods or activities are given below :

1. Software Requirement Analysis :

The main cause of defects in software products is due to error in software

requirements and designs. Software requirements and design both are important,
and should be analyzed in an efficient way with more focus. Software requirement
is basically considered an integral part of Software Development Life Cycle
(SDLC). These are the requirements that basically describes features and
functionalities of target product and also conveys expectations or requirement of
users from software product.
Therefore, it is very much needed to understand about software requirements more
carefully, If requirements are not understood well by tester and developers, then
there might be chance of occurring of issue or defect in further process. Therefore,
it is essential to analyze and evaluate requirements in more appropriate and proper
manner.

2. Review and Inspection :

Review and inspection, both are essential and integral part of software
development. They are considered as powerful tools that can be used to identify
 and remove defects if present before there occurrence and impact on production.
Review and inspection come in different levels or stages of defect prevention to
meet different needs. They are used in all software development and maintenance
methods. There are two types of review i.e. self-review and peerreview.

3. Defect Logging and Documentation :

After successful analysis and review, there should be records maintained about
defects to simply complete description of defect. This record can be further used
to have better understanding of defects. After getting knowledge and
understanding of defect, then only one can take some effective and required
measures and actions to resolve particular defects so that defect cannot be carried
further to next phase.

4. Root Cause Analysis :

Root cause analysis is basically analysis of main cause of defect. It simply
analysis what triggered defect to occur. After analyzing main cause of defect, one
can find best way to simply avoid occurrence of such types of defects next time.

Defect Prevention with its Importance in Fortifying Software Quality

As software development proceeds, the structure turns out to be more complicated. It is very
evident that any fault is difficult to find when the system becomes greater. So, the defect
prevention strategies in software testing turn out to be imperative.
The job of testers with the correct dimension of experience is exceptionally critical now; they
should be involved in defect prevention activities to guarantee the smooth working of
different tasks. It is extremely dangerous to trust that defects will occur at a later stage.
In Medical Science there is a principle, “Prevention is better than Cure”; the equivalent
applies to the Software Development Life Cycle. Consequently, it is extremely important to
control Defect Detection by removing them before they show up in the system. Such defect
prevention techniques assist testers with building a high-quality product and furthermore
reduce the project cost.
Defect prevention strategies in software testing are a standout amongst the most vital software
quality assurance activities of an SDLC, which directly affects controlling the cost of the
project and the quality of deliverables. The cost of rectifying the defect in the product is high
when contrasted with anticipating. Henceforth it is constantly advisable to take measures,
which will keep the defect being presented in the product, as early as possible.
The amount of rework is a noteworthy cost factor in software maintenance and development.
The number of defects and problems related to the product are an immediate contribution to
this cost. Estimation of issues and defects can assist us with understanding where and how the
defects and issues happen and give knowledge to strategies for detection, prevention, and
prediction and monitor costs.
In brief, following are the defect prevention roles for testers in each of the below stages:

• Requirement Specification Review:

After understanding the client’s prerequisites set up your necessity’s essence. A review is
critical at this step-the First dimension of review should be inside the team, followed by
another dimension of external review to ensure that all the viewpoints are in sync.

• Design Review:
Design stage can be viewed as a system phase of sorts and experiencing it will guarantee that
the QA team understands the upsides and downsides of every procedure.
This sort of basic walkthrough will help uncover any issues with the said systems and fix
them before going further. This can be viewed as a feasibility study for the system.

• Code Review:
There isn’t a lot for testers to directly get engaged with this stage, yet the review goes on here
as well. Developers do code assessments, walkthroughs, and reviews before they unit and
integration test the application.
Software Defect Prevention Methods and Techniques:
Some traditional and common defect prevention strategies in software testing that have been
in use since a long time for defect prevention are listed below:
1. Review and Inspection: This technique incorporates the survey by an individual
colleague, peer reviews and assessment of all work products.
2. Walkthrough: This is pretty much like a review yet it’s mostly identified with
contrasting the system to the prototype which will give a superior thought in regards
to the accuracy as well as the look-and-feel of the system.
 3. Defect Logging and Documentation: This strategy gives some key data,
arguments/parameters that can be utilized to help in analyzing
4. Root Cause Analysis: Root cause analysis incorporates two noteworthy
methodologies:
• Pareto Analysis:
The Pareto analysis is a formal and easy method which organizes the request of issue goals
for maximum impact. It expresses that 80% of the issue emerges because of 20% reasons.
• Fishbone Analysis:
It is also called Ishikawa Analysis this strategy is a more visual root cause analysis method.
There are no insights required as this technique depends on team-wide brainstorming.
Some of the advantages of defect prevention in software testing:
• Quicker Delivery – Accelerate the release cycles – Ensure smooth conveyances.
Software Development free of Hassles
• Increase Customer satisfaction
• Reduction of costs
• Reduction of Rework