Software Testing Bootcamp | Types of Testing | Verification, Validation | Software Testing Tutorials

Summary

This tutorial delves into the basics of software testing, focusing on the two primary types: static and dynamic testing. It clarifies the differences between these types, emphasizing that static testing involves reviewing documents without code execution, while dynamic testing requires interacting with and running the code. The video also explains the concepts of verification (ensuring the product is built correctly) and validation (ensuring the product meets customer needs). The presenter sets the stage for future lessons on why testing is crucial and addresses common industry questions.

Takeaways

• 💻 Static testing focuses on reviewing work products like documentation, requirements, and designs without executing code.
• 🛠️ Dynamic testing involves executing the code and interacting with the actual product to validate its functionality.
• 📂 Static testing is often referred to as verification, which ensures the product is being built correctly through non-executable methods.
• ⚙️ Dynamic testing, also called validation, ensures the right product is being built, focusing on the actual customer requirements.
• 📊 Static testing methods include reviews, walkthroughs, and inspections, while dynamic testing uses white-box, black-box, functional, and non-functional testing.
• 🧪 Static testing can detect defects early in the development process, such as during requirements or design phases, which is more cost-effective.
• 🚀 Dynamic testing happens after static testing and identifies bugs by interacting with the system during its execution.
• 🛠️ Levels of dynamic testing include unit testing, integration testing, system testing, and acceptance testing.
• ✅ Verification checks if the product conforms to specifications, while validation ensures the product meets the customer’s needs.
• 🛡️ Both static and dynamic testing are crucial, with static testing preventing early defects and dynamic testing ensuring the final product functions as expected.

Q & A

What are the two main types of testing discussed in the video?

The two main types of testing are static testing and dynamic testing.

How is static testing different from dynamic testing?

Static testing is non-executable and focuses on reviewing documents and work products without running code. Dynamic testing, on the other hand, involves executing code and interacting with the software to validate functionalities.

Can you provide examples of work products involved in static testing?

Examples of work products include requirements, design documents, business models, UML diagrams, test cases, and test plans.

What are some methods used in static testing?

Static testing methods include reviews, walkthroughs, technical reviews, and inspections.

What is dynamic testing and when is it performed?

Dynamic testing involves running the code or application and testing its functionality. It is performed after static testing and occurs at different levels, such as unit, integration, system, and acceptance testing.

How are verification and validation related to static and dynamic testing?

Verification is associated with static testing and focuses on ensuring that the work products meet specified requirements without executing code. Validation, linked with dynamic testing, ensures that the final product meets the customer's expectations by executing the software.

What is the difference between verification and validation in simple terms?

Verification checks if the product is built right, meaning it meets the requirements correctly. Validation checks if the right product is built, meaning it fulfills the customer's needs and expectations.

What is an example illustrating the difference between verification and validation?

An example is when a customer asks for an iPhone but is shown a Samsung phone. While the Samsung phone is a working product (verification passed), it is not what the customer requested (validation failed).

What are some benefits of static testing in the early stages of software development?

Static testing helps identify defects early in the development process, such as in design or requirement phases, which makes fixing these defects cheaper and more efficient.

Why is dynamic testing essential even after static testing?

Dynamic testing identifies defects that static testing cannot catch, as it involves actual execution of the software to check for issues that arise when the code is run.

Outlines

00:00

📚 Introduction to Types of Testing: Static vs. Dynamic

In this section, the speaker introduces the concept of software testing types, highlighting that many people mistakenly think of manual vs. automation or white box vs. black box as types of testing. However, the correct classification is between static and dynamic testing. The speaker clarifies that all other testing types, such as functional, non-functional, regression, and white/black box testing, fall under these two categories. Static testing involves reviewing work products like requirements, designs, and test plans, and it is non-executable. Dynamic testing, on the other hand, is executable and involves interacting with the code or product, which is tested across various levels such as unit, integration, and system testing.

05:03

🔍 Verification vs. Validation: Understanding the Difference

The second section elaborates on the differences between verification and validation, which are common questions in software testing. Verification is ensuring that the product is built correctly, focusing on documentation and code reviews without execution. Validation ensures that the right product is being built according to customer requirements. The analogy of building a phone (verifying that it functions) versus ensuring that it is the correct phone for the customer (validation) is used to clarify this distinction. This section emphasizes the importance of verification in early stages, like design and requirements, to catch defects early and reduce costs.

10:04

🚀 Conclusion and Next Steps: Why Testing is Crucial

In the final section, the speaker wraps up the tutorial by summarizing the importance of understanding basic testing terminologies, verification, and validation. The speaker teases the next tutorial, which will explore why testing is important, and encourages viewers to leave comments and questions. The closing message promotes continuous learning and invites the audience to stay engaged with future content.

Keywords

💡Static Testing

Static testing refers to the process of reviewing work products like documents, designs, and models without executing any code. In the video, static testing is described as a non-executable process that helps identify defects early in the development life cycle, such as in requirements or design documents. This form of testing ensures that work products meet standards before proceeding to the next stages.

💡Dynamic Testing

Dynamic testing involves executing the actual code or product to validate its functionality by interacting with it. In the script, dynamic testing is contrasted with static testing and involves running the software to validate that it works as expected. It is executable and is typically done after static testing, verifying if the product functions correctly according to the requirements.

💡Verification

Verification is the process of checking whether the product has been built correctly according to the specifications, without executing the product. In the video, verification is explained as a type of static testing, focusing on reviewing documents and designs. It ensures that the product development process adheres to the predefined specifications.

💡Validation

Validation checks whether the right product has been built, ensuring it meets the customer's needs and expectations. This is a type of dynamic testing that involves interacting with the actual product. In the video, the example given illustrates the difference between a functioning product (verification) and the correct product for the customer (validation).

💡Functional Testing

Functional testing is a type of dynamic testing where the tester validates that the software behaves according to the functional requirements. It checks specific functionalities by inputting data and evaluating the output. The video mentions functional testing as part of dynamic testing, ensuring the software performs tasks as expected by the end-user.

💡Non-Functional Testing

Non-functional testing evaluates aspects of the software not related to specific behaviors, such as performance, security, and usability. The script explains that non-functional testing is part of dynamic testing and checks elements like performance and security, ensuring the system performs well under stress and meets broader system requirements.

💡White Box Testing

White box testing involves testing the internal structures or workings of an application, often performed by developers. In the script, white box testing is mentioned as a method under dynamic testing, where the tester has knowledge of the internal code and design of the application, allowing them to test specific functionalities deeply.

💡Black Box Testing

Black box testing is a method where the tester evaluates the software's functionality without knowing its internal structure or code. The script refers to black box testing as part of dynamic testing, where testers interact with the software from an end-user perspective, focusing on inputs and outputs rather than the underlying code.

💡Software Development Life Cycle (SDLC)

The SDLC is a process that includes planning, designing, developing, testing, and deploying software. The video highlights that static testing is performed on various work products produced throughout the SDLC, such as requirements, design documents, and test cases, to ensure quality before moving forward in the development process.

💡Levels of Testing

Levels of testing refer to the stages in software testing, such as unit testing, integration testing, system testing, and acceptance testing. The script discusses dynamic testing happening across these levels to ensure that each part of the system functions properly on its own and when integrated with other components. These levels validate both functional and non-functional aspects of the software.

Highlights

Introduction to software testing basics and career building through software testing tutorials.

Clarification on the types of testing: The two main types are static and dynamic testing.

Static testing involves reviewing work products like documentation, diagrams, and test plans without execution.

Dynamic testing includes code execution and product interaction to validate functionalities.

Static testing is non-executable and focuses on identifying anomalies, contradictions, and inconsistencies.

Dynamic testing happens after static testing and includes levels like unit, integration, system, and acceptance testing.

Verification and validation concepts are discussed, with verification checking if the product is built correctly, and validation ensuring it's the right product for the customer.

Static testing is referred to as verification, and dynamic testing is validation, marking the distinction between the two.

Verification is conducted during the early stages of the software development life cycle to find bugs early and cost-effectively.

Dynamic testing is executable, involving practical interaction with the product to find defects that static testing may miss.

Functional and non-functional testing falls under dynamic testing, with levels like performance, security, and usability.

Differences between verification and validation: verification includes document and code reviews, while validation involves real product testing.

Example given to explain verification vs. validation: a program to add two numbers is verified, but validation ensures it's the program the client requested.

Dynamic testing focuses on running code and interacting with the system to validate product requirements and performance.

The tutorial ends with a teaser for the next topic on why testing is important, encouraging viewers to continue learning.

Transcripts

here one

two one

[Music]

hello friends and greetings for the day

welcome back to another tutorial on our

software testing boot camp where we are

exploring a lot about what is testing

all about in details and helping you

build a better career on qi we are

currently in the chapter one talking

about the basics of software testing and

as a part of it we are still getting

continued with 1.1 what is testing and

this is the part three of this

particular segment

to talk about this today we are jumping

into the other part of it where a lot of

people have a great confusion to

understand that when it comes to types

of testing what should i say all right

now of course a lot of people will come

up and say oh types of testing looks

like manual and automation people will

say white box or black box people would

sometimes also say functional and

non-functional but

very rarely people respond to my

question on this that

it is static and dynamic

right this is to clarify you today that

the types of testing when you say what

are the types of testing the answer is

static and dynamic whereas all other

items are differently arranged under

these two items itself no matter you

talk about white box testing you talk

about black box functional

non-functional retesting regression

testing and many more things we'll be

talking about them in detail in our

chapter too but right now let's

elaborate more on what is static testing

and dynamic testing when it comes to

static testing on your left is all about

reviewing various work products which

are prepared as a part of the entire

software development life cycle now what

are these work products work products

are basically important to understand

that it is any kind of documentation any

kind of reference any kind of diagrams

which is created as a part of the

project and

needs to be reviewed of course for any

kind of anomalies contradictions

omissions inconsistency inconsistencies

contradictions etc right so any

particular such

uh

work product which is any document on

reference for example it could be

requirement it could be a design it

could be a business model or it could be

any kind of uml diagram right use cases

any such thing beta test case test plan

as well

is a candidate of static testing now

static testing is performed as reviews

the approach of conducting static

testing and the reason we call it as

static testing is because it is

non-executable

okay it's just a process where we don't

run any code or do not have an

application as such which we actually

execute and test it so we don't have any

kind of practical executions involved

when we talk about static testing it is

limited to

hardcore documentations to certain

extent we do code review as well but not

about executing the code but doing a dry

run

doing a scenario or dry run execution

which is more of like reviewing what is

that we have written is up to the mark

or not now there are several types of

reviews which we'll be covering in our

upcoming chapters talking about the uh

types of review like informal review

walkthrough technical review inspection

etc and on the other hand the right side

we have the second type of testing which

is dynamic testing and the major

difference between static and dynamic is

static is non-executable

and dynamic is executable here we have a

code we have a product and which we run

interact with it and test

we validate the functionalities by

interacting with the product while

passing on some values running the

application executing the code and then

testing it so that's completely

different than the static testing and of

course dynamic testing takes place after

static testing right and this dynamic

testing is performed as levels of

testing we don't call it as types we

call it as levels of testing and the

several levels which you might be aware

of is unit integration system acceptance

or any other non-functional levels like

performance security

usability accessibility and lot many

other things like that and we know them

as levels of testing now further to add

a level of testing can be classified

into two categories which is functional

or non-functional that's where your

performance and other non-functional

items falls under dynamic testing so

this is again on the high level we'll be

doing a deep dive into the chapter two

about what are these levels and how they

are differentiated on terms of

functional and non-functionality

also to add this particular thing is

basically referred to as a verification

and validation also which is a very

common question for the newcomers to the

industry they a lot of company look

forward to ask you this question that

how do you differentiate between

verification and validation right so the

left side is what you call it as

verification where we don't have any

kind of executions involved and on the

right side dynamic testing is also

referred to as validation but is that

enough to answer no let's talk about in

detail that what is verification and

validation

well in simple terms to define the

verification and validation uh we can

use some great statements which you

always find in any tutorial any

blogspots or if any tutor is teaching

you about testing they will use this

statement that have we built the product

right

or have we built the right product right

the only difference in these two

statements is at the end that is product

right right product when you swap these

two words the meaning changes

it's just simple that

have you

built the product right that means

whatever you have built is it working

fine or not like if i'm writing a

program to add two numbers i'll pass two

values or i'll review it and check that

is it an addition program

if i have to write a program the

expectation is to write a program to

multiply two numbers then i'll do a

drawdown and check if it is exactly what

you need

right and validation is more of like

right product

where we want to make sure that this is

what the customer wanted no matter your

edition program is working fine but

did the client really ask you for

addition or subtraction or

multiplication so validating with

respect to those of the requirements

given to you is the validation part so

verification is just making sure that

what you are doing what you have done so

far is that correct or not

and validation is more about making sure

that this is what the customer wanted

because not always

the right product can be sorry the

product right can be the right product

for example if you go to a shop and you

say hey i'm looking for an apple iphone

and that shopkeeper starts showing you

samsung models

so samsung model is also working phone

it's a phone right but you're not

looking for android you're looking for

ios so verification passed validation

failed

right so being precise to the

requirement is what we validate as a

part of the validation verification is

more of making sure that whatever we are

building up like the left side of the v

model right we say

uh business requirements uh hld lld code

all these things what we prepare

internally is up to the mark or not

correct so also adding more to it we

have got some quick differences for you

to build your confidence on

differentiating between verification and

validation so verification it includes

checking documentations design codes and

program statically

we don't talk about running them

executing them etc on the other hand

validation includes testing and

validating the actual product which is

not just limited to work products but

this is the real product which you might

be releasing into the market

verification is also known as static

testing or the approach is static

testing whereas dynamic testing is all

about the validation

the methods used in verifications or

review walk-through inspections etc and

methods used in validations are white

box black box functional non-functional

and more

it can on the verification side it can

find the bugs early in the stages of the

software development life cycle like

development design requirement phases

because fixing or finding of the effect

early is cheaper to resolve right

because you're not built a system on

that

basis so it's it always helps you to

find defects earlier in the life cycle

whereas on the validation it can only

find the bugs that could not be found by

the verification that means by

interacting

with the system you would be validating

and getting the defects there and here

you will find more early defects on the

work products so the defects will be

there in both the places it's just that

related to work products and

verification and related to real product

on the validation

it checks whether the software confirms

to the specification or not

and validation is checks whether the

software meets the requirement and

expectation of a customer or not so

pretty much making

the same statements which we just

discussed and finally it does not

include the execution of code which is

verification whereas validation deals

with execution of the code practically

interacting with it

now i hope that certainly gives us a

great understanding of some of the basic

terminologies uh

good understanding of what are the

fundamentals of testing

what are the objectives of testing and

so on we'll be now jumping into

something more interesting in our next

tutorial which is to talk about

why testing is important so stay tuned

for that so

that's all from this particular tutorial

team should you have anything else feel

free to comment below i'm always there

to address your queries and answer them

well till then keep learning keep

exploring keep understanding the context

thanks for watching the video team and

happy learning