Hello all welcome back to the next one. In this one, we'll see how we can run test parallely using test engine. So what I have here is one class, which is test Angie underscore test parallel one. And then another class called test nj underscore test Palo Alto. That's about it. What I have here is two methods inside this one, test method one and test method two.

I'm printing one statement here. This is coming from test and G test parallel one test method one, then I'm sleeping for six seconds, about six seconds. And then I'm just printing more steps in this method. So basically, obviously, let's say the method takes about six seconds to run you might have a lot of steps and it might take about six seconds or maybe even less or more. But we are just taking six seconds for right now. Same thing for this method two and we have the same thing in the test parallel two class as well.

So we have two classes, and all done inside. Now let's take a look at the XML file. So I created one test and G dash parallel dot XML file here. And I named it as parallel test suite. And I actually created two different tests inside it. So this one is test one, and this runs parallel one class.

And this test is test two. And it runs test engine underscore parallel to class. So we have both the classes running in different test inside the same suite. Right. That's about it. So now, let me just try to run this one.

And let's see what happens. So run as test and G Suite. Bring it up so it runs and it's gonna take about six seconds, then it's gonna run tests to And then about six seconds, then it's gonna run test one from parallel to class right from here. And then again, it's waiting for six seconds always right because test engine execution is sequential. If we have multiple classes, multiple methods, everything is running sequentially. First method will complete then second method will start and then so on and so forth.

Right? So it ran for test, everything is fine, we can see here and everything is all good. Now let's see what if I want to run these methods parallely. I don't want to wait till first method is complete for the second method. And this is effective when you have methods not dependent on each other because if you have dependent methods and things really want the first method to complete before second method, children, then you should not do these kinds of things. But if you have like everything independent and you want to run these kind of things, or maybe there could be different configurations where you want to run test parallel one and test parallel to.

So let's assume that you are running this class. Here also, and you're running this class. Here all also. But both these tests are different configurations. Then also, you might want to run these test cases in parallel. But you will know based on your application these things.

So let's take a look how we can run them in parallel. So further suite, we have an attribute called parallel. So I'm going to type pa ra control space parallel. It gives me these options. So by default, it's none. And then I am going to delete this one and then hit Ctrl Space gives me all the options.

So we can run classes in bash. Last fall says none instances methods, or none. Or we can run test in parallel. So tests are these these tags, we can run test in parallel and true. So basically mostly use ones are either we can run classes in parallel, or methods and test. So these three are mostly used.

So right now I'm going to take an example of test. So parallel test. This one will help us running these tests in parallel. Another attribute that we can add here is thread count. So thread count is something it's by five by default, but we can do anything. So I'm going to take two right now.

So thread count is something which is by default, handled by test entity so we don't need to create any thread so don't even worry about creating threads and going into concurrency of Java. It is not at all related right now because testan g takes care of spanning multiple threats and it just does everything for us. So right now what we are concerned about is we can just based on our computer memory available CPU, we can provide number of threads, I'm just providing two right now, but we can actually give more also. So I saved it. And let me again, right click and run this file. And let's see the output.

So right now, both tests parallel to enter, spell one test method one started. So both started at the same time, and C, they finished at the same time, and you can see test parallel been already finished. And right now everything is finished. So basically, multiple methods started in parallel, right? And they finished at different times. So I'm just gonna run it again, because I want you to again, pay a little bit attention.

And let's run it as here and these two ones started together parallel one in Palo Alto test method one started together and then again, method two also started together and everything. So basically everything finished right now. But you guys could see that instead of waiting for six seconds it actually started test parallel to test method one. And then it started this parallel one test method one. Now you must be wondering why it did not start the test method to have the same class, right? Because it started test method one from different classes.

The reason is, we ran tests in parallel. So the test one it has back test and G underscore test parallel one class. So this started and in parallel, this class started. So it started both classes in parallel and whichever method could run it, ran it. That's how we Now what we can do here is, we can, if I provide this thing as classes, it's almost gonna be the same thing because we have both the classes and different tests right now let's take a look at methods What if I do run methods in parallel, so we can see a different output here. So just take a look at the current output right now.

Test method one started from both the classes. And this one ended and then test method two started from both the classes in parallel right. Now, let's right click, run as test in G Suite. And take a look. test method one and two started from the same class test, parallel one executed the steps and then from the same class test method one and two started. So basically, now the methods are running in parallel.

Instead of classes here we can see also will show the result execution. Once this is done, so parallel one testing just underscore test spell one classes done. And then this class started because this time these two methods started in parallel. So basically we can handle what we want to run in parallel. Either we can run tests in parallel or classes in parallel to run classes in parallel makes sense when we have more than one class here, then it makes sense. So the basic idea is still the same.

Whichever thing we want to run in parallel, it will run it run for us. So it depends on how we want to handle our test cases, whether we want to run different configurations in parallel, or we want to run different classes in parallel, or even different methods in parallel, but you have to be very careful that if you're running in parallel, things can get tricky. You might lose track of the logs, you might not figure out if a method is failed because of some other dependent method. So just be careful. This does not apply to every test suite. But it is still a feature if you have everything independent.

And if you want to run test configurations in parallel, this is really a very good feature. So that's about it. I'll see you in the next lectures and thanks for attending this one.