What is the main difference between

 - `@Before` and `@BeforeClass`
  - and in JUnit 5 `@BeforeEach` and `@BeforeAll`
 - `@After` and `@AfterClass`

According to the [JUnit Api][1] `@Before` is used in the following case:

&gt; When writing tests, it is common to find that several tests need similar objects created before they can run. 

Whereas `@BeforeClass` can be used to establish a database connection. But couldn&#39;t `@Before` do the same?


  [1]: http://junit.sourceforge.net/javadoc/

Difference between @Before, @BeforeClass, @BeforeEach and @BeforeAll

Is there a better way to assert that a method throws an exception in JUnit 5?

Currently, I have to use an @Rule in order to verify that my test throws an exception, but this doesn&#39;t work for the cases where I expect multiple methods to throw exceptions in my test.

JUnit 5: How to assert an exception is thrown?

I&#39;ve got a gradle FAILURE:

    ...&quot;Deprecated Gradle features were used in this build, making it incompatible with Gradle 5.0.&quot;

Case description:

- Attached to the project codebase the next libs:

**APP/build.gradle**

        //(Required) Writing and executing Unit Tests on the JUnit Platform 
    testImplementation &quot;org.junit.jupiter:junit-jupiter-api:5.2.0&quot;
    testRuntimeOnly &quot;org.junit.jupiter:junit-jupiter-engine:5.2.0&quot;
        // (Optional) If you need &quot;Parameterized Tests&quot;
    testImplementation &quot;org.junit.jupiter:junit-jupiter-params:5.2.0&quot;
        // (Optional) If you also have JUnit 4-based tests
    testImplementation &quot;junit:junit:4.12&quot;
    testRuntimeOnly &quot;org.junit.vintage:junit-vintage-engine:5.2.0&quot;

    testImplementation &quot;io.mockk:mockk:1.8.5&quot;

- Updated the **gradle-wrapper.properties**

    distributionUrl=https\....gradle-**4.4-all**.zip to **4.7-all**

 
- after all of that gradle was built success

- created the test calss

        @TestInstance(TestInstance.Lifecycle.PER_CLASS)
          class TestClass {
    
          @Test
          internal fun testName() {
            Assert.assertEquals(2, 1 + 1)
          }
        }


- ran the test and got the FAILURE message.
[![enter image description here][1]][1]
 

- ran the Gradle build with a command line argument `./gradlew --warning-mode=all` to see what exactly the deprecated features are.
[![enter image description here][2]][2]

As a result I couldn&#39;t build the app and I&#39;ve got that FAILURE: message.


  [1]: https://i.stack.imgur.com/7nZ04.png
  [2]: https://i.stack.imgur.com/TxV5L.png

Deprecated Gradle features were used in this build, making it incompatible with Gradle 5.0

How can I use injection with Mockito and JUnit 5?

In JUnit4 I can just use the `@RunWith(MockitoJUnitRunner.class) ` Annotation. In JUnit5 is no `@RunWith` Annotation?

How to use Mockito with JUnit5

I wrote a simple test method with JUnit 5:

    public class SimlpeTest {
        @Test
        @DisplayName(&quot;Some description&quot;)
        void methodName() {
            // Testing logic for subject under test
        }
    }
But when I run `mvn test`, I got:

    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    Running SimlpeTest
    Tests run: 0, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec
    
    Results :
    
    Tests run: 0, Failures: 0, Errors: 0, Skipped: 0
Somehow, surefire didn&#39;t recognize that test class. My `pom.xml` looks like:

    &lt;properties&gt;
        &lt;java.version&gt;1.8&lt;/java.version&gt;
        &lt;junit.version&gt;5.0.0-SNAPSHOT&lt;/junit.version&gt;
    &lt;/properties&gt;

    &lt;dependencies&gt;
        &lt;dependency&gt;
            &lt;groupId&gt;org.junit&lt;/groupId&gt;
            &lt;artifactId&gt;junit5-api&lt;/artifactId&gt;
            &lt;version&gt;${junit.version}&lt;/version&gt;
            &lt;scope&gt;test&lt;/scope&gt;
        &lt;/dependency&gt;
    &lt;/dependencies&gt;

    &lt;repositories&gt;
        &lt;repository&gt;
            &lt;id&gt;snapshots-repo&lt;/id&gt;
            &lt;url&gt;https://oss.sonatype.org/content/repositories/snapshots&lt;/url&gt;
            &lt;releases&gt;
                &lt;enabled&gt;false&lt;/enabled&gt;
            &lt;/releases&gt;
            &lt;snapshots&gt;
                &lt;updatePolicy&gt;always&lt;/updatePolicy&gt;
                &lt;enabled&gt;true&lt;/enabled&gt;
            &lt;/snapshots&gt;
        &lt;/repository&gt;
    &lt;/repositories&gt;
           
    &lt;build&gt;
        &lt;plugins&gt;
            &lt;plugin&gt;
                &lt;artifactId&gt;maven-compiler-plugin&lt;/artifactId&gt;
                &lt;configuration&gt;
                    &lt;source&gt;${java.version}&lt;/source&gt;
                    &lt;target&gt;${java.version}&lt;/target&gt;
                &lt;/configuration&gt;
            &lt;/plugin&gt;
        &lt;/plugins&gt;
    &lt;/build&gt;
Any idea how to make this work?
       

Surefire is not picking up Junit 5 tests

##The problem
Whenever I run my projects JUnit test (using JUnit 5 with Java 9 and Eclipse Oxygen 1.a) I encounter the problem that eclipse can&#39;t find any tests.

##The description
Under the run configuration, eclipse can&#39;t even find the method which is annotated with @Test, but instead only shows me &quot;*(all methods)*&quot;.
The following picture hopefully gives a better glimps of my setup:

[![https://imgur.com/a/FTe9c][1]][1]

##Console output:

    java.lang.NoClassDefFoundError: org/junit/platform/launcher/core/LauncherFactory
    	at org.eclipse.jdt.internal.junit5.runner.JUnit5TestLoader.&lt;init&gt;(JUnit5TestLoader.java:31)
    	at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    	at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
    	at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
    	at java.base/java.lang.reflect.Constructor.newInstance(Unknown Source)
    	at java.base/java.lang.Class.newInstance(Unknown Source)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.createRawTestLoader(RemoteTestRunner.java:368)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.createLoader(RemoteTestRunner.java:363)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.defaultInit(RemoteTestRunner.java:307)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.init(RemoteTestRunner.java:222)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:206)
    Caused by: java.lang.ClassNotFoundException: org.junit.platform.launcher.core.LauncherFactory
    	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(Unknown Source)
    	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(Unknown Source)
    	at java.base/java.lang.ClassLoader.loadClass(Unknown Source)
    	... 11 more


##What I tried so far
I&#39;ve already tried

 - to remove the test folder from build path and add it again.
 - to start the test with hovering over the method annotated with @Test and then click &quot;Run as JUnit Test&quot;. 
 - remove JUnit from Buildpath and add it again
 - restart eclipse
 - I&#39;ve also moved the project whole project from one machine to another machine and tried it with the provided eclipse installation there
 - to rename the test method.
 - to retype the @Test annotation

Some of these steps [can be found here][2], but in the end the problem remained.

  [1]: https://i.stack.imgur.com/wVTPt.png
  [2]: https://stackoverflow.com/questions/20057771/no-junit-tests-found-in-eclipse


Eclipse No tests found using JUnit 5 caused by NoClassDefFoundError for LauncherFactory

The `@BeforeAll` annotation marks a method to run before all tests in a *class*.

http://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations

But is there a way to run some code before *all* tests, in all classes? 

I want to ensure that tests use a certain set of database connections, and the global one-time setup of these connections must occur **before** running **any** tests.


In JUnit 5, how to run code before all tests

I have a simple app using Spring Boot and Junit 5:

 - When using Spring Boot 2.1 (e.g, 2.1.8 or 2.1.12), my unit tests run
   smoothly

 - When using Spring Boot 2.2 (e.g., 2.2.2.RELEASE or 2.3.2.RELEASE) my unit tests fail with error message 
```
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.22.2:test (default-test) on project XXX: There are test failures.
[ERROR]
[ERROR] Please refer to D:\Projets\workspace\XXX\target\surefire-reports for the individual test results.
[ERROR] Please refer to dump files (if any exist) [date].dump, [date]-jvmRun[N].dump and [date].dumpstream.
[ERROR] There was an error in the forked process
[ERROR] TestEngine with ID &#39;junit-vintage&#39; failed to discover tests
[ERROR] org.apache.maven.surefire.booter.SurefireBooterForkException: There was an error in the forked process
[ERROR] TestEngine with ID &#39;junit-vintage&#39; failed to discover tests
[ERROR]         at org.apache.maven.plugin.surefire.booterclient.ForkStarter.fork(ForkStarter.java:656)
```
I am using Maven 3.6.1, JDK 1.8, JUnit 5.6.0 and JUnit platform 1.6.0. I exclude the dependency on ```junit:junit``` from ```spring-boot-starter-test```, so that I have no JUnit 4 artifacts left in the dependency tree. Note that both Spring Boot 2.2 and 2.3 use ```maven-surefire-plugin``` 2.22.2, so my problem does not originate from any regression of the ```maven-surefire-plugin```.

Should I stick to Spring Boot **2.1** in order to have my unit test working?

Thanks in advance for your help.

Error &quot;TestEngine with ID &#39;junit-vintage&#39; failed to discover tests&quot; with Spring Boot 2.2

Is there any reason to group multiple assertions:

    public void shouldTellIfPrime(){
        Assertions.assertAll(
                () -&gt; assertTrue(isPrime(2)),
                () -&gt; assertFalse(isPrime(4))
        );
    }

instead of doing this:

    public void shouldTellIfPrime(){
        Assertions.assertTrue(isPrime(2));
        Assertions.assertFalse(isPrime(4));
    }

assertAll vs multiple assertions in JUnit5

I&#39;m using WireMock in my tests and have such a line of code:

    @Rule
    public WireMockRule wireMockRule = new WireMockRule(8080);

I want to switch to JUnit 5. So I added the next dependency (using Gradle):

    testCompile(&#39;org.junit.jupiter:junit-jupiter-engine:5.1.1&#39;)

But there are no suggestions when I&#39;m trying to import `@Rule` annotation.

Do I need to add another module of JUnit dependency? Or are rules not supported in JUnit 5? If not, how can I replace `@Rule` annotation to make tests work again?

How to replace WireMock @Rule annotation in JUnit 5?

I can write up and execute Selenium script without any special test framework but I wanted to use Junit 5 (because we have dependency with other tools) and I have never seen such error `org.junit.jupiter.api.extension.ParameterResolutionException` while working with Junit 4.

Currently it&#39;s Junit 5 and 
I googled it to get some sort of idea but can not resolve the issue. 

Test script using `JUnit 5`, `Eclipse 4.8` and `Selenium`:

    import static org.junit.jupiter.api.Assertions.assertEquals;
    import org.junit.jupiter.api.AfterEach;
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    import org.openqa.selenium.By;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    
    public  class loginTest  {
    	public  WebDriver driver = null;

    	public loginTest(WebDriver driver) {
    	    this.driver=driver;
    	}

    	@BeforeEach
    	public void setUp() throws Exception {
    		driver.get(&quot;google.com&quot;);
    		System.out.println(&quot;Page title is: &quot; + driver.getTitle());
    	}

    	@Test
    	public void test() {
    		// some action here I have in original script
    		System.out.println(&quot;Page title is: &quot; + driver.getTitle());
    	}

    	@AfterEach
    	public void tearDown() throws Exception {
    		driver.quit();
    	}
    }

Stack trace:

&gt;    org.junit.jupiter.api.extension.ParameterResolutionException: No ParameterResolver registered for parameter [org.openqa.selenium.WebDriver arg0] in executable [public login.loginTest(org.openqa.selenium.WebDriver)].
    	at org.junit.jupiter.engine.execution.ExecutableInvoker.resolveParameter(ExecutableInvoker.java:191)

Junit 5 - No ParameterResolver registered for parameter

My team and I have been working on a bunch of microservices using Spring boot. 
Since the services went through JUnit and Spring Boot upgrades (We&#39;re using now Spring Boot 2 and JUnit 5), different JUnit implemented by different devs, are now using different patterns with:

 - @ExtendWith
 - @RunWith

Today what&#39;s the difference between the two of them and do we really need them for our Unit Tests or are embedded in some new Spring Boot annotation?

When to use @RunWith and when @ExtendWith

Mockito appears to be throwing an `UnfinishedVerificationException` when I think I&#39;ve done everything correctly. Here&#39;s my partial test case:

    HttpServletRequest req = mock(HttpServletRequest.class);
    when(req.getHeader(&quot;Authorization&quot;)).thenReturn(&quot;foo&quot;);

    HttpServletResponse res = mock(HttpServletResponse.class);
 
    classUnderTest.doMethod(req, res); // Use the mock

    verify(res, never());
    verify(req).setAttribute(anyString(), anyObject());

And here&#39;s the partial class and method:

    class ClassUnderTest extends AnotherClass {
        @Override
        public String doMethod(ServletRequest req, ServletRequest res) {
            // etc.
            return &quot;someString&quot;;
        }
    }

Ignoring the fact that you should never mock interfaces you don&#39;t own, why is Mockito giving me the following message?

    org.mockito.exceptions.misusing.UnfinishedVerificationException: 
    Missing method call for verify(mock) here:
    -&gt; at (redacted)

    Example of correct verification:
        verify(mock).doSomething()

    Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods.
    Those methods *cannot* be stubbed/verified.

	at [test method name and class redacted]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:47)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:44)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:271)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:70)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:309)
	at org.mockito.internal.runners.JUnit45AndHigherRunnerImpl.run(JUnit45AndHigherRunnerImpl.java:37)
	at org.mockito.runners.MockitoJUnitRunner.run(MockitoJUnitRunner.java:62)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:160)
	... etc

Mockito gives UnfinishedVerificationException when it seems OK

To use Hamcrest with JUnit 4 we use an `assertThat()` function. However, JUnit 5 is no longer going to have an `assertThat()` function. How do I use Hamcrest without an `assertThat()`?

How do I use Hamcrest with JUnit 5 when JUnit 5 doesn&#39;t have an assertThat() function?

What&#39;s the difference between maven modules `junit-jupiter-api` and `junit-jupiter-engine`? Is it necessary to include both dependencies in `build.gradle`?

Do I need to provide both dependencies?

    testCompile(&quot;org.junit.jupiter:junit-jupiter-engine:${junitVersion}&quot;)
    testCompile(&quot;org.junit.jupiter:junit-jupiter-api:${junitVersion}&quot;)

Or only one dependency is enough?

    testCompile(&quot;org.junit.jupiter:junit-jupiter-engine:${junitVersion}&quot;)

And do I need to add a dependency on `junit-vintage-engine`?

Difference between junit-jupiter-api and junit-jupiter-engine

JUnit 5 does not invoke my method in a test class that is annotated with the `@BeforeEach` annotation, where I initialize some fields of the test object that are needed in the tests. When trying to access these fields inside a test method (method annotated with `@Test`) I obviously get a NullpointerException. So I added some output messages to the methods.

    import static org.junit.jupiter.api.Assertions.assertEquals;
    
    import org.junit.jupiter.api.BeforeEach;
    import org.junit.jupiter.api.Test;
    
    public class TestClass {
       private String s;
    
       public TestClass() {
    
       }
    
       @BeforeEach
       public void init() {
          System.out.println(&quot;before&quot;);
          s = &quot;not null&quot;;
       }
    
       @Test
       public void test0() {
          System.out.println(&quot;testing&quot;);
          assertEquals(&quot;not null&quot;, s.toString());
       }
    
    }

In the output of the tests when running `mvn clean test` I get the &quot;testing&quot; message from the `test0()` method annotated with `@Test` annotation, but the &quot;before&quot; message is not printed.

    Running de.dk.spielwiese.TestClass
    !!!testing!!!
    Tests run: 1, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0 sec &lt;&lt;&lt; FAILURE!
    de.dk.spielwiese.TestClass.test0()  Time elapsed: 0 sec  &lt;&lt;&lt; FAILURE!
    java.lang.NullPointerException
            at de.dk.spielwiese.TestClass.test0(TestClass.java:24)

The very obvious and only reason that I can think of is that the `init()` method is not invoked. The documentation of `@BeforeEach` says

&gt; @BeforeEach is used to signal that the annotated method should be
&gt; executed before each @Test, @RepeatedTest, @ParameterizedTest,
&gt; @TestFactory, and @TestTemplate method in the current test class.

I also tried running the tests in eclipse and there they always pass without any errors.

I am using maven 3.5.3.
I declared JUnit Jupiter 5.1.0 as dependency in my pom.xml

    &lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot;
	xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
	xsi:schemaLocation=&quot;http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd&quot;&gt;
	&lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt;

	&lt;groupId&gt;de.dk&lt;/groupId&gt;
	&lt;artifactId&gt;spielwiese&lt;/artifactId&gt;
	&lt;version&gt;0-SNAPSHOT&lt;/version&gt;
	&lt;packaging&gt;jar&lt;/packaging&gt;

	&lt;name&gt;Spielwiese&lt;/name&gt;

	&lt;properties&gt;
		&lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt;
	&lt;/properties&gt;
	&lt;build&gt;
		&lt;plugins&gt;
			&lt;plugin&gt;
				&lt;artifactId&gt;maven-assembly-plugin&lt;/artifactId&gt;
				&lt;version&gt;3.0.0&lt;/version&gt;
				&lt;configuration&gt;
					&lt;archive&gt;
						&lt;manifest&gt;
							&lt;mainClass&gt;de.dk.spielwiese.Spielwiese&lt;/mainClass&gt;
						&lt;/manifest&gt;
					&lt;/archive&gt;
					&lt;descriptorRefs&gt;
						&lt;descriptorRef&gt;jar-with-dependencies&lt;/descriptorRef&gt;
					&lt;/descriptorRefs&gt;
					&lt;appendAssemblyId&gt;false&lt;/appendAssemblyId&gt;
					&lt;finalName&gt;Spielwiese&lt;/finalName&gt;
				&lt;/configuration&gt;
				&lt;executions&gt;
					&lt;execution&gt;
						&lt;id&gt;assemble-all&lt;/id&gt;
						&lt;phase&gt;package&lt;/phase&gt;
						&lt;goals&gt;
							&lt;goal&gt;single&lt;/goal&gt;
						&lt;/goals&gt;
					&lt;/execution&gt;
				&lt;/executions&gt;
			&lt;/plugin&gt;
			&lt;plugin&gt;
				&lt;artifactId&gt;maven-compiler-plugin&lt;/artifactId&gt;
				&lt;version&gt;3.6.2&lt;/version&gt;
				&lt;configuration&gt;
					&lt;source&gt;1.8&lt;/source&gt;
					&lt;target&gt;1.8&lt;/target&gt;
				&lt;/configuration&gt;
			&lt;/plugin&gt;
			&lt;plugin&gt;
				&lt;artifactId&gt;maven-jar-plugin&lt;/artifactId&gt;
				&lt;version&gt;3.0.2&lt;/version&gt;
			&lt;/plugin&gt;
		&lt;/plugins&gt;
	&lt;/build&gt;

	&lt;dependencies&gt;
		&lt;dependency&gt;
			&lt;groupId&gt;de.dk&lt;/groupId&gt;
			&lt;artifactId&gt;util&lt;/artifactId&gt;
			&lt;version&gt;0.0.1&lt;/version&gt;
		&lt;/dependency&gt;
		&lt;dependency&gt;
			&lt;groupId&gt;org.junit.jupiter&lt;/groupId&gt;
			&lt;artifactId&gt;junit-jupiter-engine&lt;/artifactId&gt;
			&lt;version&gt;5.1.0&lt;/version&gt;
			&lt;scope&gt;test&lt;/scope&gt;
		&lt;/dependency&gt;
	&lt;/dependencies&gt;
&lt;/project&gt;

Why is my `init()` method not invoked?

JUnit 5 does not execute method annotated with BeforeEach

I am trying to use JUnit 5 with Gradle after I succeeded in running a JUnit 4 test.

**Expected result:** Tthe JUnit 4 test gave a nice &#39;passed&#39; in the output and an html report in `build/reports/tests`.

**Actual result:** The JUnit 5 test as below does not output anything besides `(...) build succesful`, while I know the test is not actually run since there is no test log output passed/skipped/failed, and putting a `fail` in the test keeps the build successful.

Running `gradle test --info` yields `Skipping task &#39;:testClasses&#39; as it has no actions.` among a lot of I think mostly unrelevant output.
Surprisingly, it also says `Executing task &#39;:test&#39; ` and `Generating HTML test report... Finished generating test html results ` and similar for the xml in `build/test-results/test`, while the xml is not generated, the html shows no tests run and no errors, and the test is indeed not run.

What I also think very interesting, is that `gradle test --debug` yields
    
    [TestEventLogger] Gradle Test Run :test STARTED
    [org.gradle.api.internal.tasks.testing.junit.JUnitDetector] test-class-
    scan : failed to scan parent class java/lang/Object, could not find the class file
    [TestEventLogger]
    [TestEventLogger] Gradle Test Run :test PASSED


while my only test contains

    fail(&quot;test fails&quot;);

which I think is very strange!

My build file is

&lt;!-- language: lang-groovy --&gt;

    apply plugin: &#39;java&#39;
    
    test {
        dependsOn &#39;cleanTest&#39; // run tests every time
    
    }
    
    sourceSets {
        main {
            java {
                srcDirs &#39;src&#39;
            }
        }
        test {
            java {
                srcDirs &#39;test&#39;
            }
        }
    }
    
    repositories {
        mavenCentral()
    }
    
    dependencies {
        // when using this, it worked with a junit 4 test
    //    testCompile &#39;junit:junit:4.10&#39;
        // this should be needed for junit 5 (using M4 is required since IJ 2017.1.2
        testCompile(&quot;org.junit.jupiter:junit-jupiter-api:5.0.0-M4&quot;)
    }
    
    test {
        testLogging {
            events &quot;passed&quot;, &quot;skipped&quot;, &quot;failed&quot;
        }
    }

My test is

&lt;!-- language: lang-java--&gt;

    package mypackage;
    
    import org.junit.jupiter.api.Test;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    
    public class HelloWorldTest {
        @Test
        public void testHelloWorld(){
            assertEquals(2, 1+1, &quot;message&quot;);
        }
    }

My folder structure is, using package `mypackage`,

    java-template-project
    --- src
        --- mypackage
            --- HelloWorld.java
    --- test
        --- mypackage
            --- HelloWorldTest.java

and in IntelliJ 2017.1.3, which I am using, the module structure looks like this

    java-template-project
    --- java-template-project_main
        --- src/mypackage
            --- HelloWorld(.java)
    --- java-template-project_test
        --- test/mypackage
            --- HelloWorldTest(.java)
because Gradle nowadays wants the source and tests in their own package.

**What I tried**

Obviously this is not the first question about this topic, all the relevant questions I found are

 - https://stackoverflow.com/questions/38293901/gradle-project-running-junit-5-tests-in-intellij

    But as you can see this is for older versions of IntelliJ, and I am already using the syntax for IJ 2016.3.3 and higher according to one of the answers, in  in the one JUnit dependency line, so that should be okay.

 - https://stackoverflow.com/questions/38576011/upgrade-from-junit-4-to-junit-5-in-intellij-with-gradle

    Links back to above question, and links to this [Jetbrains blog][1] which uses the same line as above question. Also links to:

 - https://stackoverflow.com/questions/38576108/integrate-junit-5-tests-results-with-intellij-test-report
    This one shows, in the question, as dependency also

        testRuntime(&quot;org.junit.vintage:junit-vintage-engine:5.0.0-M1&quot;)

    which is explained in https://stackoverflow.com/questions/38822189/why-were-junit-jupiter-and-junit-vintage-separated-when-i-running-testcase-in-in
    Well, when I ran it, the output showed it couldn&#39;t find this version but according to the [Maven Repository][2] this one is for JUnit 5:

        testRuntime(&quot;org.junit.vintage:junit-vintage-engine:4.12.0-M4&quot;)
    
    The answers there note that you can just run the tests within IntelliJ since the later versions have JUnit 5 support. I know, and the test runs fine when I run from within IntelliJ. But I want to use Gradle (and Travis, which needs dependency management).

 - https://stackoverflow.com/questions/43151448/how-to-capture-stdout-stderr-in-junit-5-gradle-test-report

    I tried using 

        testCompile(&quot;org.junit.platform:junit-platform-gradle-plugin:1.0.0-M3&quot;)
        testCompile(&quot;org.junit.jupiter:junit-jupiter-engine:5.0.0-M3&quot;)

    but results didn&#39;t change.

   My template project is located on https://github.com/PHPirates/java-template-project but this question should contain all information necessary.


  [1]: https://blog.jetbrains.com/idea/2016/08/using-junit-5-in-intellij-idea/
  [2]: https://mvnrepository.com/artifact/org.junit.vintage/junit-vintage-engine/4.12.0-M4

All Junit5 Solutions on Gang of Coders

Total of 17 Junit5 Solutions