Building or modernizing a Java enterprise web app has always been a long process, historically. Not even remotely quick.
That's the main goal of Jmix is to make the process quick without losing flexibility - with the open-source RAD platform enabling fast development of business applications.
Critically, it has very minimal impact on your server's performance, with most of the profiling work done separately - so it needs no server changes, agents or separate services.
Simply put, a single Java or Kotlin developer can now quickly implement an entire modular feature, from DB schema, data model, fine-grained access control, business logic, BPM, all the way to the UI.
Jmix supports both developer experiences – visual tools and coding , and a host of super useful plugins as well:
Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.
The Jet Profiler was built for MySQL only , so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.
Critically, it has very minimal impact on your server's performance, with most of the profiling work done separately - so it needs no server changes, agents or separate services.
Basically, you install the desktop application, connect to your MySQL server , hit the record button, and you'll have results within minutes:
out the Profiler
DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema .
The way it does all of that is by using a design model , a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.
And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.
Take a look at DBSchema
The Kubernetes ecosystem is huge and quite complex, so it’s easy to forget about costs when trying out all of the exciting tools.
To avoid overspending on your Kubernetes cluster, definitely have a look at the free K8s cost monitoring tool from the automation platform CAST AI. You can view your costs in real time, allocate them, calculate burn rates for projects, spot anomalies or spikes, and get insightful reports you can share with your team.
Connect your cluster and start monitoring your K8s costs right away:
Kubernetes cost monitoring
Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
>> CHECK OUT THE COURSE1. Introduction
In this quick tutorial, we'll be looking at how to test if an exception was thrown using the JUnit library.
We will, of course, make sure to cover both the JUnit 4 and JUnit 5 versions.
Further reading:
2. JUnit 5
JUnit 5 Jupiter assertions API introduces the assertThrows method for asserting exceptions.
This takes the type of the expected exception and an Executable functional interface where we can pass the code under test through a lambda expression:
@Test
public void whenExceptionThrown_thenAssertionSucceeds() {
Exception exception = assertThrows(NumberFormatException.class, () -> {
Integer.parseInt("1a");
String expectedMessage = "For input string";
String actualMessage = exception.getMessage();
assertTrue(actualMessage.contains(expectedMessage));
If the expected exception is thrown, assertThrows returns the exception, which enables us to also assert on the message.
Furthermore, it's important to note that this assertion is satisfied when the enclosed code throws an exception of type NumberFormatException or any of its derived types.
This means that if we pass Exception as the expected exception type, any exception thrown will make the assertion succeed since Exception is the super-type for all exceptions.
If we change the test above to expect a RuntimeException, this will also pass:
@Test
public void whenDerivedExceptionThrown_thenAssertionSucceeds() {
Exception exception = assertThrows(RuntimeException.class, () -> {
Integer.parseInt("1a");
String expectedMessage = "For input string";
String actualMessage = exception.getMessage();
assertTrue(actualMessage.contains(expectedMessage));
The assertThrows() method enables more fine-grained control for exception assertion logic because we can use it around specific parts of the code.
3. JUnit 4
When using JUnit 4, we can simply use the expected attribute of the @Test annotation to declare that we expect an exception to be thrown anywhere in the annotated test method.
As a result, when the test is run, it will fail if the specified exception isn't thrown and will pass if it's thrown:
@Test(expected = NullPointerException.class)
public void whenExceptionThrown_thenExpectationSatisfied() {
String test = null;
test.length();
In this example, we've declared that we're expecting our test code to result in a NullPointerException.
This is enough if we're only interested in asserting that an exception is thrown.
When we need to verify some other properties of the exception, we can use the ExpectedException rule.
Let's see an example of verifying the message property of an exception:
@Rule
public ExpectedException exceptionRule = ExpectedException.none();
@Test
public void whenExceptionThrown_thenRuleIsApplied() {
exceptionRule.expect(NumberFormatException.class);
exceptionRule.expectMessage("For input string");
Integer.parseInt("1a");
In the example above, we're first declaring the ExpectedException rule. Then in our test, we're asserting that the code that attempts to parse an Integer value will result in a NumberFormatException with the message “For input string”.
4. Conclusion
In this article, we covered asserting exceptions with both JUnit 4 and JUnit 5.
The full source code for the examples is available over on GitHub.
Course – LS – All
Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:
>> CHECK OUT THE COURSE
