What is the main difference between assertTimeout and assertTimeoutPreemptively?
Tags: java, unittest, testing
Published: 2024-07-08 12:48:32

In this blog post, I’m gonna explain what is the main difference between in these methods. First of all why do we use this methods. This method will be useful when we test our methods performance or we want to know how much time takes our method to complete.

## How these methods works?

First we have to give time our test method , after that these tests execute operations in the test. If this operations takes longer time than specified and then this test will be fail.

## Difference between `assertTimeout` and `assertTimeoutPreemptively`

Okay now we know what these methods are, why we use them in our testing methods. Then we must know the difference.

Let me explain briefly. `assertTimeout` method counts the time we give, if our test method takes longer than specified, this test will fail after all operations are completed. However, if the `assertTimeoutPreemptively` method takes longer than specified, this method will fail immediately. And it won’t wait for all the processes to be completed, we will test this in the project in the next step.

## Test

First open your favorite IDE. I open Intellij Idea because this IDE is very popular among Java developers. Of course you can use favorite IDE such as Eclipse, Netbeans which one you prefer.

Now create a new Maven project and add these 2 dependencies to your `pom.xml` file.

```xml
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>
```

After add these open the `src/test/java` folder and

Create new class and give the name whatever you want I’ll give `TimeoutTest`.

Create 2 test method, one of them tests `assertTimeout` and the other one tests `assertTimeoutPreemptively`.

![assertTimeout and assertTimeoutPreemptively](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/e3zbkif3d2xsbbzq6jwj.png)

After that I give the duration and add simple print message.

![Informational messages](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pkltzraqbi2m3dvsgj28.png)

I add the `Thread.sleep()` method and Thread sleeps **8000 ms** ( 8 seconds). But these 2 methods will be fail because these methods takes longer than 3 seconds. Let me test these methods to understand better.

![result of methods](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zy3nih34whxlie5rz8jm.png)

And you see `testAssertTimeout` method takes **8s 3ms** because this method wait to complete all operations , but the other one takes **3s 45ms**, and it doesn’t wait to complete other process, it fails immediately.

You can see the message `testAssertTimeout` method prints the message but `assertTimeoutPreemptively` method doesn’t print the message, it ignored other operations.

## Conclusion

In this post we talked about the main difference between `assertTimeout` and `assertTimeoutPreemptively`.

At last, code is available on the [Github](https://github.com/mammadyahyayev/blog-posts/tree/master/junit-tutorial).

Take care of yourself, see you soon.