WEBVTT

00:00.060 --> 00:06.660
So when we consider the scenario where we want to verify the Operation Fire design that is designed

00:06.660 --> 00:10.890
and destroyed, so we could have three possible methods to do that right.

00:11.100 --> 00:14.080
First method is where we manually apply a stimulus.

00:14.100 --> 00:16.890
OK, so this we've been doing from the beginning.

00:16.890 --> 00:24.930
So we use the force constant air force to apply the manual stimulus to a duty and then we are analyzing

00:24.930 --> 00:25.650
a response rate.

00:25.660 --> 00:27.060
So this is time consuming.

00:27.270 --> 00:29.010
If you have a complex design, right?

00:29.010 --> 00:32.850
And in that case, we prefer to write the dispatch, right?

00:33.120 --> 00:39.240
So when we consider it has been showcased, we have a set of construct which are specifically there

00:39.240 --> 00:42.180
for performing a verification of our design, right?

00:42.360 --> 00:47.130
So they need not have to be synthesized, but they could be non synthesized.

00:47.280 --> 00:51.270
Right now we have two alternatives, so we could write it test painting.

00:51.300 --> 00:56.070
We used to write or we could write it and very now remember.

00:57.330 --> 01:02.490
It doesn't matter which language you have utilized to develop your duty.

01:03.300 --> 01:10.920
This bench could also be available, so we've been utilizing we still as a for looking our decide.

01:11.460 --> 01:13.710
So if you considered it, do you?

01:14.430 --> 01:15.430
So it is returning.

01:15.780 --> 01:18.450
We we you know, this is completely a different model.

01:18.720 --> 01:22.050
And then we will be writing one more source code, right?

01:22.320 --> 01:24.990
And that will basically behave as a desperate trade.

01:24.990 --> 01:28.830
So this will be generating a random stimulus that will be applying to a duty.

01:29.070 --> 01:31.680
And then we will be analyzing the response rate.

01:31.680 --> 01:37.860
So we will be applying a stimulus and then we'll be analyzing the response of our design, right?

01:37.870 --> 01:43.110
And then we'll be comparing it with the gold and we don't see whether our design is correctly behaving

01:43.110 --> 01:43.590
right now.

01:43.620 --> 01:49.140
Test bench could be of reagent type or it could also be on very long.

01:49.320 --> 01:52.260
Great note here our agenda will be first.

01:52.260 --> 01:57.300
We will be considering how we work around with manual stimulus.

01:57.960 --> 02:01.890
This is the easiest step to start understanding the test bench.

02:02.100 --> 02:06.290
Then we probably consider a few simple example we can you right?

02:06.480 --> 02:12.600
And then we will be focusing more on our very low as the language for her test page now.

02:12.810 --> 02:20.040
A primary reason for choosing a very long war still is it provides us the technical function that could

02:20.040 --> 02:28.230
be used to analyze the value of variable easily as compared to we actually could also be used to generate

02:28.230 --> 02:36.390
the random stimulus for the different set of an input as compared to it, and it could also be utilized

02:36.390 --> 02:40.470
to generate the complex signals which could be applied to what you do.

02:40.500 --> 02:41.580
And that is the reason.

02:41.910 --> 02:46.600
What we're going to do is we will be choosing test language to be very low.

02:46.600 --> 02:53.010
No, you do not need to worry because you are not anyway utilizing very lot for creating a design,

02:53.010 --> 02:53.240
right?

02:53.250 --> 02:58.940
So the way by which we will be creating a design is by utilizing vision, right?

02:58.980 --> 03:04.110
So you are now good at handling how you design your right.

03:04.350 --> 03:10.950
The only thing that we want to do is we will be taking the help of a non synthesize able construct that

03:10.950 --> 03:14.370
we have in a very low rate, so they are anyway not synthesized.

03:14.910 --> 03:20.190
So if you utilize them in an instant, they will be simply ignored, right?

03:20.580 --> 03:23.970
So we will be taking the help of the non synthesize.

03:23.970 --> 03:26.550
It will construct that we have in a very low.

03:26.580 --> 03:29.030
And then we will be building the complex stimulus.

03:29.490 --> 03:34.290
And again, simulator is capable of handling the mixed language, right?

03:34.290 --> 03:40.050
So we could have this bench written in a very low, OK, and we're going to have our duty.

03:40.050 --> 03:41.940
That is our design and innovation.

03:42.060 --> 03:48.840
OK, so the primary reason for choosing very local where version for writing the test benches, it provides

03:48.870 --> 03:53.640
a set of a function which could be used to build up the complex expression, right?

03:53.640 --> 03:59.340
So that is the first advantage that we get where we could easily build up the complex expression.

03:59.400 --> 04:05.040
OK, now this doesn't mean we could not be the complex expression in a version, but the effort and

04:05.040 --> 04:10.320
time that we spend for building a complex expression and vision is far more as compared to very low

04:10.320 --> 04:16.350
rate, and our agenda will be to develop as we are just writing the test cases.

04:16.380 --> 04:16.680
OK.

04:16.890 --> 04:20.280
So the language provides us the easier methods.

04:20.310 --> 04:20.640
OK?

04:20.970 --> 04:22.530
We could actually choose it, right?

04:22.710 --> 04:27.630
So we could write the complex expression OK for a signal.

04:27.840 --> 04:34.290
The second advantages that display functions that we get, OK, that could be used to easily analyze

04:34.890 --> 04:36.810
the values of a variable.

04:36.840 --> 04:37.170
OK.

04:37.350 --> 04:42.090
So these are very, very easy to handle as compared to the display functions that we get with them.

04:42.390 --> 04:48.630
And remember, we usually just strongly type language and that basically restrict us to perform the

04:48.630 --> 04:53.730
strict confusion between the time before we actually use the display function right there as very long

04:53.730 --> 04:55.000
as a weekly type language.

04:55.010 --> 05:01.370
So display function works without a conclusion, and that is the second advantage that we get now.

05:01.380 --> 05:09.420
As we progress further, we'll be understanding that one page is OK as we demonstrate the usage of available

05:09.440 --> 05:10.600
writing letters, right?

05:11.280 --> 05:12.600
And the third one is.

05:13.610 --> 05:18.170
You get in capability where you could use the pseudo.

05:20.170 --> 05:20.800
Random.

05:22.990 --> 05:23.530
No.

05:25.670 --> 05:26.590
Generators.

05:26.750 --> 05:27.050
Right.

05:27.710 --> 05:34.300
So this helps to generate the random stimulus for our duty rate, and this is far more easier to compare

05:34.350 --> 05:38.060
to if you're going to rate the generation offering them no return rate.

05:38.240 --> 05:46.490
So this gives us motivation that we could learn the very lot looking for specifically for writing the

05:46.500 --> 05:46.730
test.

05:46.970 --> 05:53.310
And we will be focusing primarily on understanding of very low to write the test drive.

05:53.330 --> 05:59.870
So we won't be considering how you design the system with a very low that is not at all our agenda in

05:59.870 --> 06:00.980
this specific course.

06:00.980 --> 06:05.630
Our agenda will be simply how you easily read the stimulus.
