So when we consider the scenario where we want to verify the Operation Fire design that is designed
and destroyed, so we could have three possible methods to do that right.
First method is where we manually apply a stimulus.
OK, so this we've been doing from the beginning.
So we use the force constant air force to apply the manual stimulus to a duty and then we are analyzing
a response rate.
So this is time consuming.
If you have a complex design, right?
And in that case, we prefer to write the dispatch, right?
So when we consider it has been showcased, we have a set of construct which are specifically there
for performing a verification of our design, right?
So they need not have to be synthesized, but they could be non synthesized.
Right now we have two alternatives, so we could write it test painting.
We used to write or we could write it and very now remember.
It doesn't matter which language you have utilized to develop your duty.
This bench could also be available, so we've been utilizing we still as a for looking our decide.
So if you considered it, do you?
So it is returning.
We we you know, this is completely a different model.
And then we will be writing one more source code, right?
And that will basically behave as a desperate trade.
So this will be generating a random stimulus that will be applying to a duty.
And then we will be analyzing the response rate.
So we will be applying a stimulus and then we'll be analyzing the response of our design, right?
And then we'll be comparing it with the gold and we don't see whether our design is correctly behaving
right now.
Test bench could be of reagent type or it could also be on very long.
Great note here our agenda will be first.
We will be considering how we work around with manual stimulus.
This is the easiest step to start understanding the test bench.
Then we probably consider a few simple example we can you right?
And then we will be focusing more on our very low as the language for her test page now.
A primary reason for choosing a very long war still is it provides us the technical function that could
be used to analyze the value of variable easily as compared to we actually could also be used to generate
the random stimulus for the different set of an input as compared to it, and it could also be utilized
to generate the complex signals which could be applied to what you do.
And that is the reason.
What we're going to do is we will be choosing test language to be very low.
No, you do not need to worry because you are not anyway utilizing very lot for creating a design,
right?
So the way by which we will be creating a design is by utilizing vision, right?
So you are now good at handling how you design your right.
The only thing that we want to do is we will be taking the help of a non synthesize able construct that
we have in a very low rate, so they are anyway not synthesized.
So if you utilize them in an instant, they will be simply ignored, right?
So we will be taking the help of the non synthesize.
It will construct that we have in a very low.
And then we will be building the complex stimulus.
And again, simulator is capable of handling the mixed language, right?
So we could have this bench written in a very low, OK, and we're going to have our duty.
That is our design and innovation.
OK, so the primary reason for choosing very local where version for writing the test benches, it provides
a set of a function which could be used to build up the complex expression, right?
So that is the first advantage that we get where we could easily build up the complex expression.
OK, now this doesn't mean we could not be the complex expression in a version, but the effort and
time that we spend for building a complex expression and vision is far more as compared to very low
rate, and our agenda will be to develop as we are just writing the test cases.
OK.
So the language provides us the easier methods.
OK?
We could actually choose it, right?
So we could write the complex expression OK for a signal.
The second advantages that display functions that we get, OK, that could be used to easily analyze
the values of a variable.
OK.
So these are very, very easy to handle as compared to the display functions that we get with them.
And remember, we usually just strongly type language and that basically restrict us to perform the
strict confusion between the time before we actually use the display function right there as very long
as a weekly type language.
So display function works without a conclusion, and that is the second advantage that we get now.
As we progress further, we'll be understanding that one page is OK as we demonstrate the usage of available
writing letters, right?
And the third one is.
You get in capability where you could use the pseudo.
Random.
No.
Generators.
Right.
So this helps to generate the random stimulus for our duty rate, and this is far more easier to compare
to if you're going to rate the generation offering them no return rate.
So this gives us motivation that we could learn the very lot looking for specifically for writing the
test.
And we will be focusing primarily on understanding of very low to write the test drive.
So we won't be considering how you design the system with a very low that is not at all our agenda in
this specific course.
Our agenda will be simply how you easily read the stimulus.