I have a testSuite class:
package com.company.tests;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import com.company.tests.facing.CustomerTests;
import com.company.tests.backend.BookTests;
import com.company.tests.backend.ChargeTests;
#RunWith(Suite.class)
#Suite.SuiteClasses({
CustomerTests.class,
BookTests.class,
ChargeTests.class,
})
public class TestSuite {
}
I use a gradle wrapper to run the tests as follows:
./gradlew test -PTestSuite
...but this runs ALL tests under /src/test/java/com/company/tests/
Is there a way I can run JUST the ones in TestSuite class using gradle wrapper from commandline? I looked at other questions on stackoverflow but couldn't work out, Please give an example.
This can be achieved by running the following:
./gradlew test --tests TestSuite
And the documentation provides information about the kind of matching it supports.
Note that this assumes Gradle 4.7+.
I have created multiple Test case java files in eclipse and version of JUnit is JUnit5.
Now, I am trying to create a Junit TestSuite through the eclipse GUI and during the creation, I am not seeing the JUnit5 in the available versions.
This is the sample code that I have written for creation of TestSuite.
import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.suite.api.IncludeClassNamePatterns;
import org.junit.platform.suite.api.IncludeEngines;
import org.junit.runner.RunWith;
#RunWith(JUnitPlatform.class)
#IncludeClassNamePatterns(".*Tests?")
#IncludeEngines("junit-jupiter")
public class AllTests {
}
This is the error I am getting while executing.
Should I do any manual setting to be able to create/run test suites?
When executing tests in a class annotated with #RunWith, that class is technically a JUnit 4 test class.
Thus, you have to execute your test suite using the "JUnit 4 Runner" in the "Run Configurations" of Eclipse.
See the following Eclipse bug for more information: https://bugs.eclipse.org/bugs/show_bug.cgi?id=512772
Regarding the "JUnit Test Suite" dialog, that won't help you if you are using #RunWith(JUnitPlatform.class) to execute a suite in JUnit 5.
you are not using JUnit5, Junit5 FQN is org.junit.jupiter.api.*
see https://www.eclipse.org/community/eclipse_newsletter/2017/october/article5.php
I am trying to run all tests with the annotation #FastTests in a module using IntelliJ . I can run all tests in the module using the JUnit configuration with the test kind All In Package and the relevant package name.
When I try to run a single category by choosing the Category test kind JUnit configuration and choose Search For Tests: Across Module Dependencies or Search for Tests: In Single module I get No Tests were found
Is there a way to run JUnit tests with annotated with a single category in intellij?
Cheers
This works for me using Intellij IDEA 2018.1:
with category marker defined as interface:
public interface FastTests { /* category marker */ }
and test class or method annotated like this:
import cu.nicolau.sircap.nomencladores.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
public class NomencladorServiceImplTest {
#Test
#Category(FastTests.class)
public void categoryTest() {
...
}
}
With JUnit 5, the #Category annotation gets replaced with the more flexible #Tag annotation.
If you consider migrating to JUnit 5, this blog can be a good place to start. Also, this and this answer can show you how to filter the tests execution based on their tags, using Intellij IDEA or Maven.
When I try running JUnit tests, I get the error message
No tests found with test runner 'JUnit 4'
and therefore I have tried solutions from
No tests found with test runner 'JUnit 4'
junit: no tests found
'No JUnit tests found' in Eclipse
However, in my case, the difference seems to be that I specify the tests to run on package level instead of folder level.
Running JUnit tests works if I specify a package that directly contains test classes (e.g. com.example.tests.smoketests) but does not work if a higher level package is specified (e.g. com.example.tests).
If I define a test in com.example.tests, it is found and run.
Is there a way to let Eclipse/JUnit find tests in a package and all subpackages?
Out of the box, there is nothing to do this for you. You can use the Suite annotation to achieve this goal in JUnit4, though this still requires you to manually define a Suite test for each package, and then include all of them in a aggregate Suite test (such they recursively call child Suites).
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import a.sub.package.AnotherSuiteTest.class;
#RunWith(Suite.class)
#Suite.SuiteClasses({
PackageLocalTestClass1.class,
PackageLocalTestClass2.class,
AnotherSuiteTest.class
})
public class JunitTestSuite {
}
I've played around with building my own utility class before which creates the entire series of tests. This article provides an analogous utility.
I want to be able to run all tests in a project programmatically. I know Eclipse has a "Run as JUnit test" configuration which somehow grabs all the tests in a project and run them. Is there any way for me to also grab the list of tests programmatically and run them? Or is there some good way to construct a test suite containing all the test cases without manually listing out every one (all 700+) of them?
I've tried the "New... -> Test Suite" option in Eclipse, but that seems to work only for JUnit 3, identifying tests by their extending from TestCase
The test classes are JUnit 4, so their only distinguishing characteristic is the annotation, no naming convention, no subclassing from TestCase.
Thanks in advance!
Though it does not really solve your immediate problem, I find it a very useful general practice to create suites and suites of suites, e.g. for a package something like PackageFooSuite etc. and assemble these suites in one or more suites again, like ModuleFooSuite and have one top-level suite, like AllTestsSuite. That way it's easy to run both all tests in one step as well as submodule tests for the package I'm currently working on (and have the tests run quicker than if I would always run all of them):
#RunWith(Suite.class)
#Suite.SuiteClasses({ PackageFooSuite.class, PackageBarSuite.class} )
public final class AllTestsSuite {} // or ModuleFooSuite, and that in AllTests
None of the other answers did it for me. I had 40k tests I needed to run, so manually listing every class was not an option.
I did it with ClasspathSuite. A test suite that runs all Junit4 and Junit3 test cases in the class path is as follows:
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.extensions.cpsuite.ClasspathSuite.*;
import org.junit.runner.RunWith;
import org.junit.runner.JUnitCore;
import static org.junit.extensions.cpsuite.SuiteType.*;
#RunWith(ClasspathSuite.class)
#SuiteTypes({ JUNIT38_TEST_CLASSES, TEST_CLASSES })
public class RunAllSuite {
/* main method not needed, but I use it to run the tests */
public static void main(String args[]) {
JUnitCore.runClasses(RunAllSuite.class);
}
}
I needed to run it from command line, so this is what I did:
Downloaded cp-1.2.6.jar
Create the previously mentioned RunAllSuite
Compile the class, javac RunAllSuite.java -cp cpsuite-1.2.6.jar;junit-4.8.1.jar
run it with target tests in the class path, java -cp cpsuite-1.2.6.jar;junit-4.8.1.jar;path/to/runallsuite/folder;target/classes;target/test-classes RunAllSuite
And that's it. With the RunAllSuite above, anywhere in your code you can just do JUnitCore.runClasses(RunAllSuite.class), which runs all tests in class path. There are other config options as well which are explained in the ClasspathSuite home page.
Note also that the class given above does not print anything. If that is needed, you can do
import org.junit.extensions.cpsuite.ClasspathSuite;
import org.junit.extensions.cpsuite.ClasspathSuite.*;
import org.junit.runner.RunWith;
import org.junit.runner.JUnitCore;
import org.junit.internal.TextListener;
import static org.junit.extensions.cpsuite.SuiteType.*;
#RunWith(ClasspathSuite.class)
#SuiteTypes({ JUNIT38_TEST_CLASSES, TEST_CLASSES })
public class RunAllSuite {
public static void main(String args[]) {
JUnitCore junit = new JUnitCore();
junit.addListener(new TextListener(System.out));
junit.run(RunAllSuite.class);
}
}
You can do this fairly easily from within maven using the surefire plugin: I usually clean/compile/install my projects from the command line before comparing them for eclipse usage (mvn eclipse:clean eclipse:eclipse) and you can define a test suite in your pom which lists all the tests you want to run en masse every time you run mvn install. You're not calling them programatically, exactly, but you can certainly call them en masse.
In Eclipse (I'm using 4.6.1) - Right click the project folder, select "Run As", choose "JUnit Test"
It will run all tests in that project. Same for a package.
Of the top of my head using Spring:
Implement a TypeFilter that matches classes with methods annotated with #Test (don't forget to consider the superclasses)
Invoke classpath scanning on your top-most test package
Invoke the JUnitRunner with the scan results
More info on classpath scanning and custom type filters here
With Eclipse Indigo (possibly Helios as well) in the Run Configurations dialog box, you now have the ability to Run all tests in a selected project, package or source folder.
Also a good reference from Eclipse is the article Java Unit testing with JUnit 4.x in Eclipse.
I also recommend using the JUnit Suite annotations. Follow the link for more detail.