Hello all welcome back to the next one. Since we have now already learned, what is the test suite and how we can club classes to make a test Wait, let's take a mod together. Since we have a test suite now similar to before class and after class, there could be requirements that we want to execute before all of the test cases start. And there could be requirements that we want to clean up the whole system after all the test cases are run. exactly similar to before class and after class right before class has things which we want to set up for that particular class and after classes has those stuff, which you want to clean up from that particular class. We can have similar requirements for the complete test suite for the combination of test classes.

Now is the time to learn what is a before suite and after suite annotation. So what I've done here is to simplify some stuff. I have copied the These tests class one and class two to a new package called regression suite. It's these are the same classes, I just modified the print statements to be a little cleaner instead of big lines, just small lines, create a new test with the XML suite and named it as regression dash suite dot XML. So we know that we can actually name it anything and updated the package name here to refer to the correct classes. And then I created a base package and there's nothing inside it.

We'll just talk about it why we created since we have some common stuff right now that we are talking about, we want to execute something common before all the suite is gonna get run. And we want to clean up our system after the complete test suite is done executing. We want a place where we want to put all the common stuff. We don't want to put that common stuff in every class. We don't want to unnecessarily bulk up those classes. That's why we will create a base test class and inherited that base class in every test class.

So all the common stuff is written at a single place. That's why I created a package called base. Inside it, I'll say new, and other test engine class. Click Next. And here we will call it as base test suite. I'm going to import this thing before sweet after suede.

And let's say we have a few common things before in that we want to put in before class and after class for the basis we're also so understand these things as something specific to all the test classes there is something common that you want to execute in before class. Those common things Also, you don't want to put in every single class, it's better to put in a common place. Maybe for a test class one, there is a common thing and which is common to test class two, and there are some separate stuff also. So those common things can be put into the base test suite. And then the separate specific stuff to test class one can be put in the before class of test class one. So we can actually select these also and click Finish.

It will create a base test wait for us, I can format it. I can delete that. Add the rate test annotation because there will be no test case inside this class. We only want to put the common stuff here. I can do command shift or Ctrl Shift o to clean up the import statements. And that's about it.

Now I'm gonna just copy some print statement here. So we can type it here. So it's just easy to understand from where our print statements are coming. Obviously, for an application, you will have the test code the common stuff here right now we are just printing it out because we are more interested in learning the concept, then we are testing any application. So this thing is from base test suite. It's a before class.

And we'll put the similar thing in after class as well. And we'll put the similar thing in before sweet and after sweet. So, these annotations these methods, they will only execute once before both the test classes execute not once after every before every test class only once and then it will execute as class one then it will execute as class two and then after a suite will get executed. So this guy is after and sweet, not the class. So that's about it. Now what we want to do here is we want to extend our test classes to use the base test suite.

So type extends, this is from inheritance base test suite. And as soon as I did that, you should notice that it imported based test suite here. And this is very important important. If we don't import this, it will not know about the base test suite. Right. Let me do it manually here in test class to so you guys can see it.

So this is import from base dot base test suite. This is how we import it. And here we will say extends base test suite. So controlspace is our shortcut for the IntelliSense and all done. Now both the test classes are set up I'm just going to right click the regression suite dot XML and run this and then we're going to take a look at the output. So run as test in G Suite.

And we can see here that regression test suite from regression package both the test class one and class two are executed successfully. Let's go to console and let's take a look at the output. So from based as to it before, so it is executed, then from based test suite before class is executed. Then starts their first test class. From first class before class is executed and before method and test method burned and after method, then again before method and test method to the after method and test class one and share and it executes after class. Then notice that the base test suite after classes executed and then based test suite before classes.

Execute. Again, but there is no after suite executed from base test suite. So it's all going before class and after class executed. And then test class two started before class before method, test method one after method before method test method two after method and then test class two ends after class is executed, then from base test suite after class is executed. And finally, from base test suite after a suite is executed. So, before suite and after suite execute only once and in between all the test classes will get executed.

So this is the purpose of before suite and after suite annotation. This was the right time to talk about them because we already saw how we run the test suites in combination, how we run all the test classes in combination using a test suite. So that's about it. Please practice it and let me know if you have any questions and I'll see you in the next lecture. Thanks We're ending this one