Software Testing Tutorial #27 - Verification and Validation in Software Testing

Summary

This tutorial explains the key differences between verification and validation in software testing, a crucial concept often addressed in interviews. It highlights how verification (static testing) involves reviewing documents and code without execution, while validation (dynamic testing) involves executing the software to test its functionality. The tutorial emphasizes the importance of early defect detection in verification to reduce costs and effort. It also covers various testing techniques such as code reviews for verification and unit, integration, and system testing for validation, providing examples and tips for explaining these concepts confidently in interviews.

Takeaways

• 🔍 Verification is static testing, while validation is dynamic testing.
• 📄 Verification involves reviewing documents and code without execution (e.g., code review), focusing on identifying defects early in the development phase.
• 🚀 Validation includes executing the actual software or application to check for defects in the functional behavior (e.g., launching an e-commerce website).
• 📊 Verification checks if the software aligns with requirements and design documents, while validation ensures the final product meets user needs.
• ⚙️ Verification helps in identifying issues early in the development process, reducing the cost and effort of fixing defects.
• 🛠️ Code reviews, walkthroughs, and inspections are examples of verification techniques used to find issues before code execution.
• 🔧 Validation is performed during testing phases like unit testing, integration testing, system testing, and acceptance testing.
• 💡 In verification, defects are found by analyzing documents and code, whereas in validation, bugs are found during software execution.
• ⏳ Dynamic testing (validation) is conducted once the code is complete, while static testing (verification) happens throughout development.
• 💰 Identifying defects early through verification reduces the cost and complexity of fixing issues later in the software development lifecycle.

Q & A

What is the main difference between verification and validation in software testing?

Verification is static testing, where the code is not executed but documents and code are reviewed manually. Validation is dynamic testing, which involves executing the code to check if the software meets the required specifications.

What is static testing in the context of software verification?

Static testing refers to the process of manually checking documents, code, or designs without executing the software. It includes activities like code reviews, inspections, and walkthroughs.

What is dynamic testing in the context of software validation?

Dynamic testing involves executing the software to validate its functionality. It ensures that the software behaves as expected when running, such as testing an e-commerce website by launching and interacting with the application.

How is the V-model related to verification and validation?

In the V-model, verification activities are performed on the left side, where documents and designs are reviewed. Validation takes place on the right side after the code is ready and executed in various testing phases such as unit, integration, and system testing.

Why is it important to find defects early during verification?

Finding defects early in the verification phase saves time and cost. If issues are identified before coding, they can be corrected before they propagate to the design or code, reducing the complexity and cost of fixing them later in the development cycle.

What is an example of verification in software testing?

An example of verification is a code review, where developers manually inspect the code for adherence to coding standards without executing the program.

What is an example of validation in software testing?

An example of validation is launching an e-commerce website, navigating through it, and performing functional tests like adding items to the cart to ensure the site works as expected.

What types of defects are typically found during verification?

Verification helps identify defects in documentation, design flaws, or missing requirements. These issues can be caught early without executing the software.

What are some testing techniques used in verification?

Common testing techniques in verification include code reviews, walkthroughs, inspections, and technical reviews, which do not involve running the code but focus on reviewing the structure and design.

What testing techniques are used in validation?

Validation techniques include dynamic tests such as unit testing, integration testing, system testing, acceptance testing, and regression testing, all of which involve executing the software.

Outlines

00:00

🧑‍💻 Introduction to Verification and Validation in Software Testing

This paragraph introduces the key topic of verification and validation in software testing, emphasizing their importance in interviews for both freshers and experienced testers. It explains that verification (static testing) and validation (dynamic testing) are often discussed together, with verification being a non-execution activity and validation involving code execution. It also sets the stage for further explanation by referencing the V-model, which is central to understanding the difference between these two concepts.

05:02

📄 Verification: Checking Documentation without Code Execution

Here, the focus is on verification, described as a manual process where code is not executed. The purpose of verification is to review documentation like requirement and design documents, as well as the code itself through activities like peer code reviews. By examining these documents, teams can ensure that best practices and standards are followed without executing any software. The paragraph provides examples such as requirement verification and code review to explain static testing in greater detail.

10:05

🖥️ Validation: Testing Software through Code Execution

This paragraph contrasts validation with verification by explaining that validation involves dynamic testing, where the actual code is executed. After the code is written, it is installed in the test environment, and testers validate its functionality by running it. For example, in an e-commerce website, validation happens when the site is deployed and testers interact with it by launching it in a browser. This process verifies whether the software functions as expected, making it a dynamic activity.

🔍 Early Bug Detection through Verification

This paragraph explains the importance of finding defects early in the software development lifecycle through verification. In the V-model, verification is done during the early stages, such as requirement and design phases, allowing teams to identify and fix defects before they are implemented into the code. Early detection reduces the cost and effort needed to resolve issues later. If defects are found only during validation, after the code is written, it may require significant rework and resource expenditure.

📊 Cost-Effectiveness of Early Defect Detection

This paragraph emphasizes how early defect detection during verification is more cost-effective than finding bugs during validation. When defects are identified early in the development process, they can be resolved with minimal resources. However, if issues are found later in the validation phase, the defect must be traced back to earlier stages, such as requirements or design, leading to higher costs and more extensive rework.

🔁 Verification Techniques: Code Review, Walkthroughs, and Inspections

In this paragraph, common verification techniques like code reviews, technical reviews, walkthroughs, and inspections are discussed. These techniques ensure that the code and documentation are up to standard without executing the software. This process is essential in static testing to catch issues early, especially during the design and coding phases.

🧪 Validation Testing Types: Unit, Integration, System, and More

This paragraph outlines the different types of testing performed during validation, including unit, integration, system, acceptance, and regression testing. All of these require the actual software to be available and running to ensure that it meets the specified requirements. This dynamic testing phase is where code execution is necessary to validate the functionality and performance of the application.

💡 Key Points for Interviews: Verification vs. Validation

The final paragraph summarizes the key points about verification and validation, preparing readers for interviews. It reiterates the main differences between static testing (verification) and dynamic testing (validation), providing confidence that these concepts, when explained with examples, will be sufficient to answer related interview questions. Additionally, it encourages further exploration of other points and examples to deepen understanding.

Keywords

💡Verification

Verification in the context of software testing refers to the process of manually checking documents or code without executing it. It is akin to static testing, where one reviews requirements, design documents, or code for adherence to standards and completeness. The video emphasizes that verification is crucial for catching errors early in the development process, which is cost-effective and minimizes the risk of缺陷s propagating to later stages. An example from the script is when developers conduct a code review to ensure best practices and coding standards are followed.

💡Validation

Validation is the process of checking that the software meets the customer's requirements and is fit for its intended use. It is dynamic testing, where the software is executed to verify its functionality. The video explains that validation is akin to dynamic testing, where the software is launched in a test environment, and actual usage scenarios are tested. An example given is launching an e-commerce website and testing user registration or other functionalities.

💡Static Testing

Static testing is a method of software testing where the software is examined without executing its code. It involves reviewing documents and code for syntax errors, adherence to coding standards, and logical consistency. The video script mentions that static testing is synonymous with verification and is performed early in the development cycle to identify potential issues before the code is executed.

💡Dynamic Testing

Dynamic testing involves executing the software to validate its functionality and behavior. It is a form of testing where the software is run in a test environment to ensure it works as intended. The video script explains dynamic testing as being synonymous with validation, where the software is tested for functionality after it has been implemented and deployed.

💡V Model

The V Model is a software development model that illustrates the relationship between software development phases and testing phases. The video script uses the V Model to explain the difference between verification (which occurs on the left side of the V, dealing with requirements and design) and validation (which occurs on the right side of the V, dealing with the execution of the code).

💡Code Review

A code review is a process where a developer's code is examined by peers to ensure it meets coding standards and best practices. It is a key part of verification or static testing, as discussed in the video. The script mentions that code review is a common practice in software development where developers send their code to team leads or peers for review.

💡Defects

Defects in software testing refer to errors or faults in the software that cause it to behave incorrectly or fail to meet requirements. The video emphasizes the importance of finding and fixing defects early in the development cycle through verification to reduce costs and avoid complications in later stages.

💡Testing Techniques

Testing techniques are methods used to conduct software testing. The video script differentiates between techniques used for verification (like code review, technical review, walk-through, and inspection) and those used for validation (like unit testing, integration testing, system testing, acceptance testing, and regression testing).

💡Cost of Defect

The cost of a defect refers to the financial and resource implications of fixing a defect in software. The video script explains that finding defects early through verification is less costly than fixing them during validation or dynamic testing, where they may require significant redesign and retesting.

💡E-Commerce Website

The e-commerce website is used as an example throughout the video script to illustrate the concepts of validation and dynamic testing. It is used to demonstrate how software is tested for functionality once it is deployed and available for use, such as testing the registration process or product purchasing.

Highlights

Difference between verification and validation is a common question in software testing interviews.

Verification is static testing, while validation is dynamic testing.

Static testing (verification) does not involve code execution, but focuses on reviewing documentation, design, or code manually.

Dynamic testing (validation) involves executing the software to test its functionality after it has been developed.

Code review is an example of static testing, where developers manually check the code for best practices and coding standards.

Validation includes testing the functionality of an application, such as launching an e-commerce website and interacting with it to verify user processes.

Verification helps in finding defects early in the software development lifecycle, which reduces the cost of fixing them.

In the V-Model of software development, verification happens in the earlier stages (requirements and design), while validation occurs after the code is written.

Finding defects early in the verification phase prevents issues from flowing into the design and code, saving time and resources.

Validation tests can include unit testing, integration testing, system testing, acceptance testing, and regression testing.

The cost of fixing defects found during validation is higher, as it involves more phases and resources to correct the issues.

In static testing, techniques like code review, walkthroughs, inspections, and peer reviews are used.

During dynamic testing, the actual software is executed, and bugs are found by running test cases on the built application.

The V-Model diagram is helpful in interviews to explain the phases of verification and validation.

Combining static and dynamic testing methods ensures that software is thoroughly verified and validated before release.

Transcripts

hello everyone welcome again in the

software testing tutorial

we are going to learn the difference

between verification

and validation now this is very

important question

and concept in terms of interviews

so most of the software testing

interviews if you are fresher or even

you know experience in software testing

and you are going for the interview

you will be asked most of the time this

particular question what is the

difference between verification

validation or static testing and dynamic

testing

now verification and validation or

verification versus validation

uh is similar to what is static testing

and dynamic testing so verification

is static testing so you can say static

for the verification and validation is

dynamic testing right so this is

also asked what is the difference

between static testing

and dynamic testing right so i'll write

it here

so if somebody asks what is the

difference between verification

and validation or static testing and

dynamic testing

these are the points that you can

explain

for both of these questions because

verification

is static testing or static testing is

verification and validation is dynamic

testing

or dynamic testing is validation right

and this verification

versus validation came from the v model

okay and i'll explain what exactly

verification versus validation means and

what are the difference between

verification and validation okay so

let's start with the point one basically

so here if you see the first point says

process of checking document documents

manually right so

when we say verification verification is

the process

of manual verification or the static

verification

so static testing as the name suggests

you do not

execute the code in verification so you

basically

go through browse through the

documentation or any uh

documentation that is present or even

the code that is present

for your software right so for example

software requirement documentation

your plans your design documentation the

code

that is being written by the developers

so the code review happens so when we

say code review

developers have a look at the code and

basically provide the review so they do

not execute but they

just have a look or have a peer review

so

if i'm i'm a developer and i'm writing

the code i'll send the code for review

to another person maybe my team lead

to have a review right and in the review

the other person will just have a look

at

the code and he'll see whether i have

followed the best practices

or uh whether all the coding standards

have been followed or not

right so if somebody is verifying

those sort of things without executing

the code

or just going through the plans and

design and

team is basically analyzing whether the

requirement document that is there

it has all the required details in it or

whether there are any gaps

so all those sort of analysis wherein

the execution part is not involved

and manual verification is done is the

verification or

static testing right when we come to

validation validation is basically the

dynamic testing right so when we say

validation

in the validation when you have the code

written and the code available

to you as a tester as a package that can

be installed and executed

so in the validation what happens is you

once you get the build

the build is installed in the test

environment and

the actual you actually launch the

application or you

you you know invoke the application

uh by executing the software say for

example if you talk about the e-commerce

website so e-commerce

website if you're building an e-commerce

website so verification will be

going through the requirement document

that is given by the customer

okay but validation will be once those

requirements are

implemented and deployed into the

server and you are actually launching

the web page

or ecommerce portal on the browser so

you are opening the browser

on your computer and you are providing

the url so www whatever name

and hitting enter and then you are

launching that particular web page

that uh you know verify that is

validation right so that is

what dynamic testing is you are actually

launching the url and then you are

actually trying to register or trying to

do the test cases

after launching the application so that

is what validation

is so this is very you know um key

difference that you need to

understand and you can take examples of

e-commerce website or any other examples

that you can think of

right to explain in the interview

so that is the first point now coming to

the second point so verification does

not involve executing the code

so which i've already covered in the

first point so in the verification you

just verify

the documentation say for example you

are going through the requirement or

the design that has been made by the

tech lead tech lead is

walking through the whole team with that

design and taking the feedback

right so that does not involve any code

execution however

in the case of validation as we have

seen that once that design is

implemented into the application

an application is being launched into

the browser

in case of e-commerce website then that

is the

validation because you are doing the

code execution and validating the

functionality right

so when i launch the browser when i hit

the server then there is some

execution that happens behind the scene

and that's when

i'm getting the results on my web page

so

if there is a code execution involved

then that is validation

right now the third point is basically

in the verification you find bugs or

defects very early

the reason for that is say for example

in the v model as we have seen so

usually b model it will look like this

right let me remove this line here okay

so v model will usually look like a v

okay so here we have the coding okay

if you haven't watched the v model

of software development please go back

and watch the v model

in my previous tutorial in the previous

tutorials of the same series

so you'll understand what exactly view

model is so usually

in the model you have the requirement

right and then you have you know design

different levels of design

phases and you know other design so low

level design

high level design and similarly here you

have the

different phases of testing so unit you

know integration

system and acceptance right

so these these will be the phases so

when we say verification so

anything at this side of this v model

is verification or the testing team's

involvement or

the team that is doing the verification

at this side

of the software development model is

verification okay so this is

verification

because here you just have physical you

just have the requirement document and

then that those requirement documents

are being converted into the design

documents

then design documents is basically you

know being

converted into the actual code and then

code is reviewed so

all the verification activities happen

in this

you know section here because

team do not actually execute the code

because the code is not ready so code

gets ready here

and in this side of the

v model once the code is ready and the

code is bundled

as the build and available to the test

team

that's when the actual execution or

dynamic testing starts right so here

it's verification or static testing

so this is static testing in this side

and here

it's dynamic okay so dynamic testing

because

the code is available as build it will

be deployed and

then you launch the application and

you'll test the application in different

phases

that are available here right so this is

validation

or dynamic testing okay

so when we talk about the third point

it says bugs and defects are found early

so what it means is because the code

gets ready

very late in the cycle so when you do a

good verification

techniques you are basically going

through the requirement documents

very early in the phase and figuring out

if there are any gaps

and if you are able to find any gaps in

the requirement phase itself

then those gaps will be rectified in the

requirement phase

and they will not flow to the design to

other design and to the code

right so that is why when we say find

defects early in the cycle

this verification helps a lot in finding

defects early

rather than if you do not do the

verification techniques in these phases

what will happen is if there is

something wrong with the requirement

that will go into the design

same design will get implemented into

the code and

the actual defect will be found very

late when the very

when the validation will start somewhere

here with the testing team

so in that particular case if a defect

is found here

then it has to go back and basically

all the way through it has to come back

from the requirement so basically

the requirement has to be updated

because of this defect then design needs

to be changed

right and then accordingly depending on

how severe the defect is

all the phases or the actual fix

that is required to implement that

particular defect

will be a long and it will require a lot

of resources

and money to basically implement that

right but if that same gap is found here

it can be rectified directly

here okay so that is why finding bugs

and defects early in cycle when we say

we do verification because you found the

defects here

or if say for example there is a defined

design defect it can be found

here or low level design defect can be

found here if you are doing

verification right now finding bugs and

defect during dynamic testing phase so

in

the validation you can only find defects

when you are actually executing the

software

right so that is why you find bugs

during the dynamic testing phase

uh then the fourth point is again i have

explained cost of defect is less because

you found the defect early in the cycle

and

if you found the defect early in the

cycle to fix those defect

is really very easy and very

less cost if the same defect flows

through to the later phases of the

software

development life cycle then that takes

quite a bit of

cost and effort to fix it right so

that's what we have understood as part

of

point number three right so let me

rub this okay so this diagram is very

important in the interview if you are

trying to explain to the interviewer go

through

and explain this with confidence with

the examples

okay so understand this what is static

testing dynamic testing validation

verification and then explain with

example and you will be you know like

very

um you know confident in explaining the

concept okay

so now coming back to the fifth point so

few types of you know testing in the

verification

are so basically reviews if you know

about right so code review would have

definitely heard

code review is very widely used right so

if you have worked

even in any software development

approach

uh code review is always done so when

the developer writes the code he sends

the code to the peer

or the other team members to basically

review

for the standards for you know other

aspects of the code

so any sort of reviews technical review

walk through inspection or code review

these are some of the techniques testing

techniques

for verification or static testing okay

now if we talk about the validation um

it is unit testing integration system

acceptance regression and there are many

more

testing types that you perform

as part of software validation because

all of these

testing here they will require the

actual software built to be available to

be deployed and

you actually execute the code or you run

the software

or launch the software in order to do

any

sort of any of these testing right so

these are some of the

testing types that you do into the

validation right and these are the

testing type for the verification or the

static testing

okay so these are some of the key points

basically there are many more points and

you can come up with many more

points from the same setup point or

there will be you know if you

give a little bit of thought around

verification validation there will be

many more points that you can

google out over the internet and you

will find

but these are some of the key points

which will be good enough for you to

understand

and explain it with example to the

interviewer and this should be

you know more than enough to explain

what is verification validation or

static testing

and dynamic testing and what are the

differences between static testing and

dynamic testing because these are the

key points

that you should know and rest all points

will be you know just an

addition to these points all right so

that's all for this tutorial on

verification and validation or

static testing versus dynamic testing

hope it was helpful and clear please do

share and subscribe and thank you very

much for watching