TestMu 2025 - The Largest Virtual Software Testing Conference is Back | 50,000+ Attendees

How to use getAnnotation method of org.junit.runners.model.FrameworkMethod class

Best junit code snippet using org.junit.runners.model.FrameworkMethod.getAnnotation

...59        return afters.isEmpty() ? statement : new RunAfters(method, statement, afters,60                target);61    }62    protected Statement withPotentialTimeout(FrameworkMethod method, Object test, Statement next) {63        long timeout = this.getTimeout(method.getAnnotation(Test.class));64        if (timeout <= 0L && mTimeout > 0L) {65            timeout = mTimeout;66        }67        return timeout <= 0L ? next : new FailOnTimeout(next, timeout);68    }69    private long getTimeout(Test annotation) {70        return annotation == null ? 0L : annotation.timeout();71    }72    protected List<FrameworkMethod> looperWrap(FrameworkMethod method, Object test,73            List<FrameworkMethod> methods) {74        RunWithLooper annotation = method.getAnnotation(RunWithLooper.class);75        if (annotation == null) annotation = mKlass.getAnnotation(RunWithLooper.class);76        if (annotation != null) {77            methods = new ArrayList<>(methods);78            for (int i = 0; i < methods.size(); i++) {79                methods.set(i, LooperFrameworkMethod.get(methods.get(i),80                        annotation.setAsMainLooper(), test));81            }82        }83        return methods;84    }85    protected FrameworkMethod looperWrap(FrameworkMethod method, Object test,86            FrameworkMethod base) {87        RunWithLooper annotation = method.getAnnotation(RunWithLooper.class);88        if (annotation == null) annotation = mKlass.getAnnotation(RunWithLooper.class);89        if (annotation != null) {90            return LooperFrameworkMethod.get(base, annotation.setAsMainLooper(), test);91        }92        return base;93    }94    public boolean shouldRunOnUiThread(FrameworkMethod method) {95        if (mKlass.getAnnotation(UiThreadTest.class) != null) {96            return true;97        } else {98            return UiThreadStatement.shouldRunOnUiThread(method);99        }100    }101}...

Source: ConditionalSpringRunner.java

...22    }23    @Override24    @SneakyThrows25    protected boolean isTestMethodIgnored(final FrameworkMethod frameworkMethod) {26        ConditionalIgnore ignore = frameworkMethod.getDeclaringClass().getAnnotation(ConditionalIgnore.class);27        if (ignore != null) {28            final IgnoreCondition condition = ignore.condition().getDeclaredConstructor().newInstance();29            return !condition.isSatisfied();30        }31        ignore = frameworkMethod.getAnnotation(ConditionalIgnore.class);32        if (ignore != null) {33            final IgnoreCondition condition = ignore.condition().getDeclaredConstructor().newInstance();34            return !condition.isSatisfied();35        }36        return super.isTestMethodIgnored(frameworkMethod);37    }38    @Override39    @SneakyThrows40    protected Statement withBeforeClasses(final Statement statement) {41        final ConditionalIgnore ignore = getTestClass().getJavaClass().getAnnotation(ConditionalIgnore.class);42        if (ignore != null) {43            final IgnoreCondition condition = ignore.condition().getDeclaredConstructor().newInstance();44            if (!condition.isSatisfied()) {45                return new ConditionalIgnoreRule.IgnoreStatement(condition);46            }47        }48        return super.withBeforeClasses(statement);49    }50    @Override51    @SneakyThrows52    protected Statement withAfterClasses(final Statement statement) {53        final ConditionalIgnore ignore = getTestClass().getJavaClass().getAnnotation(ConditionalIgnore.class);54        if (ignore != null) {55            final IgnoreCondition condition = ignore.condition().getDeclaredConstructor().newInstance();56            if (!condition.isSatisfied()) {57                return new ConditionalIgnoreRule.IgnoreStatement(condition);58            }59        }60        return super.withAfterClasses(statement);61    }62}...

Source: RepeatedRunner.java

...11		super(klass);12	}13	@Override14	protected Description describeChild(FrameworkMethod method) {15		if (method.getAnnotation(Repeat.class) != null && method.getAnnotation(Ignore.class) == null) {16			return describeRepeatTest(method);17		}18		return super.describeChild(method);19	}20	private Description describeRepeatTest(FrameworkMethod method) {21		int times = method.getAnnotation(Repeat.class).value();22		Description description = Description23				.createSuiteDescription(testName(method) + "(" + times + " times)", method.getAnnotations());24		for (int i = 1; i <= times; i++) {25			description.addChild(Description26					.createTestDescription(getTestClass().getJavaClass(), "[" + i + "] " + testName(method)));27		}28		return description;29	}30	@Override31	protected void runChild(final FrameworkMethod method, RunNotifier notifier) {32		Description description = describeChild(method);33		if (method.getAnnotation(Repeat.class) != null && method.getAnnotation(Ignore.class) == null) {34			runRepeatedly(methodBlock(method), description, notifier);35		}36		super.runChild(method, notifier);37	}38	private void runRepeatedly(Statement statement, Description description, RunNotifier notifier) {39		for (Description desc : description.getChildren()) {40			runLeaf(statement, desc, notifier);41		}42	}43}...

Source: JUnitOrderedRunner.java

...14        List<FrameworkMethod> list = super.computeTestMethods();15        Collections.sort(list, new Comparator<FrameworkMethod>() {16            @Override17            public int compare(FrameworkMethod f1, FrameworkMethod f2) {18                TestOrder o1 = f1.getAnnotation(TestOrder.class);19                TestOrder o2 = f2.getAnnotation(TestOrder.class);20                if (o1 == null || o2 == null)21                    return -1;22                return o1.order() - o2.order();23            }24        });25        return list;26    }27}...

getAnnotation

Using AI Code Generation

1public class MyRunner extends BlockJUnit4ClassRunner {2    public MyRunner(Class<?> klass) throws InitializationError {3        super(klass);4    }5    protected Statement methodInvoker(FrameworkMethod method, Object test) {6        Statement statement = super.methodInvoker(method, test);7        Annotation annotation = method.getAnnotation(MyAnnotation.class);8        if (annotation != null) {9            return new MyStatement(statement);10        }11        return statement;12    }13}14public class MyStatement extends Statement {15    private final Statement next;16    public MyStatement(Statement next) {17        this.next = next;18    }19    public void evaluate() throws Throwable {20        System.out.println("before");21        next.evaluate();22        System.out.println("after");23    }24}25public class MyTest {26    public void test() {27        System.out.println("test");28    }29}30@RunWith(MyRunner.class)31public class MyRunnerTest {32    public void test() {33        System.out.println("test");34    }35}36@RunWith(MyRunner.class)37public class MySuite {38    public void test() {39        System.out.println("test");40    }41}

getAnnotation

Using AI Code Generation

1public class JunitTestRunner extends BlockJUnit4ClassRunner {2    public JunitTestRunner(Class<?> klass) throws InitializationError {3        super(klass);4    }5    protected Statement methodInvoker(FrameworkMethod method, Object test) {6        Statement statement = super.methodInvoker(method, test);7        return new AnnotationStatement(method, statement);8    }9    private static class AnnotationStatement extends Statement {10        private final FrameworkMethod method;11        private final Statement statement;12        public AnnotationStatement(FrameworkMethod method, Statement statement) {13            this.method = method;14            this.statement = statement;15        }16        public void evaluate() throws Throwable {17            System.out.println("Before test method: " + method.getName());18            statement.evaluate();19            System.out.println("After test method: " + method.getName());20        }21    }22}23public class JunitTest {24    public void test1() {25        System.out.println("test1");26    }27}28@RunWith(JunitTestRunner.class)29public class JunitTestRunnerTest {30    public void test() {31        System.out.println("test");32    }33}

getAnnotation

Using AI Code Generation

1public static void main(String[] args) {2    try {3        Class<?> cls = Class.forName("org.junit.runners.model.FrameworkMethod");4        Method method = cls.getMethod("getAnnotation", Class.class);5        Object obj = cls.newInstance();6        method.setAccessible(true);7        Object result = method.invoke(obj, org.junit.Test.class);8        System.out.println(result);9    } catch (Exception e) {10        e.printStackTrace();11    }12}13@org.junit.Test(timeout=0)

StackOverFlow community discussions

Questions

Discussion

How do I pass the HttpServletRequest object to the test case?

ant junit build error inside eclipse

Class Not Found: Empty Test Suite in IntelliJ

How do I unit test jdbc code in java?

Executing JUnit 4 and JUnit 5 tests in a same build

Hibernate 5.2.2: No Persistence provider for EntityManager

junit: no tests found

Naming convention JUnit suffix or prefix Test

No tests found with test runner 'JUnit 4'

Will an assertion error be caught by in a catch block for java exception?

Spring provides a class called MockHttpServletRequest, which can be used to test code that needs a HttpServletRequest.

public void testCheckBatchExecutionSchedule() throws Exception
{
   MockHttpServletRequest request = new MockHttpServletRequest();
   request.addParameter("parameterName", "someValue");
   assertTrue("Batch is Completed :", returnPointsRatingDisputeFrom.checkBatchExecutionSchedule(request));
}

https://stackoverflow.com/questions/11721622/how-do-i-pass-the-httpservletrequest-object-to-the-test-case

I experienced the same stylesheet problem within Eclipse using the following environment:

Windows 7 x64
Eclipse 3.7.2 (SR2) 32-bit
JDK 1.6.0_32 32-bit
Ant 1.7.2 (from Eclipse) or 1.7.4 (from Apache, current)
Junit 4.8.1 (project dependency)

My build succeeds while using JDK 1.6.0_31, so it appears the stylesheet problem is an Ant or Java bug introduced with the release of Java 6 build 32. I could not find any reports in Apache's Bugzilla system. If it helps someone, these are the bug fixes included in build 32: http://www.oracle.com/technetwork/java/javase/2col/6u32bugfixes-1579554.html

My current workaround is to use Java 6 JDK build 31.

Update: Workaround to use a newer JDK

The Ant failures from within Eclipse started with a defect introduced in Java 6u32 and Java7u4. The saga is reported in Eclipse Bug #384757, including a workaround allowing you to use newer JDKs.

Download the org.apache.xalan and org.apache.xml.serializer plug-ins from the Eclipse Orbit project
Copy them to a directory listed in the Java java.ext.dirs property

I use the following directories because they are defined by default and independent of JDK version:

On Windows: C:\Windows\Sun\Java\lib\ext
On Mac: /Users/$USER/Library/Java/Extensions

The root problem was reported to Oracle, but the bug is no longer in their bug database. I am not optimistic it will ever be fixed.

Update: Apache fixed the problem in Ant

Apache has fixed the root problem; it may be available in the Ant 1.9.0 release (Apache Bug #54641).

Update: Ant 1.9.1 scheduled for Eclipse 4.4

As @OliBlogger mentioned, Apache fixed the root problem in Ant 1.9.1. Eclipse plans to update to Ant 1.9.1 in Eclipse 4.4 (perhaps sooner, the Eclipse bug system does not yet have 4.3.x milestones).

Update: Fixed in Eclipse 4.4

I confirmed that my build now succeeds using Java 7 JDK build 67 and Ant 1.9.2 distributed with Eclipse 4.4.1 (Windows 7) without using the Orbit plug-in workaround.

https://stackoverflow.com/questions/10536095/ant-junit-build-error-inside-eclipse

JUnit 5 provides a way out of the box.

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

Each one is a distinct project and using all of them allows to compile and execute JUnit 4 and JUnit 5 tests in a same project.

JUnit Jupiter is the combination of the new programming model and extension model for writing tests and extensions in JUnit 5.

JUnit Vintage provides a TestEngine for running JUnit 3 and JUnit 4 based tests on the platform.

The JUnit Platform serves as a foundation for launching testing frameworks on the JVM

Update : from Maven Surefire 2.22.0

From the JUnit 5 documentation :

Starting with version 2.22.0, Maven Surefire provides native support for executing tests on the JUnit Platform.

So the configuration is much simpler.
Note that the junit-4 api dependency is optional as the engine dependencies that are now required already pull a default api version (it is the case for both junit 4 and 5).

Here is a sample pom.xml.

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>david</groupId>
    <artifactId>jupiter-4-and-5-same-build</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit-jupiter.version>5.1.0</junit-jupiter.version>
        <!-- optional : if we want to use a junit4 specific version -->
        <junit.version>4.12</junit.version>
    </properties>
    <dependencies>
        <!--JUnit Jupiter Engine to depend on the JUnit5 engine and JUnit 5 API -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit-jupiter.version}</version>
            <scope>test</scope>
        </dependency>
        <!--JUnit Jupiter Engine to depend on the JUnit4 engine and JUnit 4 API  -->
        <dependency>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
            <version>${junit-jupiter.version}</version>
        </dependency>
        <!-- Optional : override the JUnit 4 API version provided by junit-vintage-engine -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.0</version>
            </plugin>
        </plugins>
    </build>

</project>

On my GitHub space I added a working sample maven project that you can browse/clone. URL: https://github.com/ebundy/junit4-and-5-minimal-maven-project

Old way : for Maven Surefire below 2.22.0

Here is the minimal configuration to use with Maven to configure the project to compile and run both JUnit4 and JUnit5 tests :

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>mygroup</groupId>
    <artifactId>minimal-conf-junit4-5</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <!-- JUnit 5 depends on JDK 1.8 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!--  JUnit dependency versions -->
        <junit.version>4.12</junit.version>
        <junit-vintage-engine>4.12.1</junit-vintage-engine>
        <junit-jupiter.version>5.0.1</junit-jupiter.version>
        <junit-platform.version>1.0.1</junit-platform.version>
    </properties>

    <dependencies>
        <!--JUnit Jupiter API to write and compile tests with JUnit5 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit-jupiter.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- JUnit 4 to make legacy JUnit 4 tests compile -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version> <!-- matters until now-->
                <dependencies>
                    <!-- to let surefire to run JUnit 4 but also JUnit 5 tests -->
                    <dependency>
                        <groupId>org.junit.platform</groupId>
                        <artifactId>junit-platform-surefire-provider</artifactId>
                        <version>${junit-platform.version}</version>
                    </dependency>
                    <!-- JUnit vintage engine to run JUnit 3 or JUnit 4 tests -->
                    <dependency>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                        <version>${junit-vintage-engine}</version>
                    </dependency>
                    <!-- JUnit 5 engine to run JUnit 5 tests -->
                    <dependency>
                        <groupId>org.junit.jupiter</groupId>
                        <artifactId>junit-jupiter-engine</artifactId>
                        <version>${junit-jupiter.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

Now mvn test compiles and runs both JUnit 4 and JUnit 5 tests.

Note 1 : the junit-vintage-engine (4.12.1) and the junit (4.12) dependencies don't specify the same exact version.
This is not an issue at all as :

their release are not related between them
junit-vintage-engine is designed to run any JUnit 3 or 4 tests.

Note 2 : maven-surefire-plugin with the 2.19.1 version matters whatever you want to compile JUnit 5 test classes or both JUnit 4 and JUnit 5 test classes.
Next version of the plugin causes indeed some exceptions during JUnit 5 tests execution but the 2.22.0 that at last solves the issue (see the first part of the answer : "Update : from Maven Surefire 2.22.0").

https://stackoverflow.com/questions/47158583/executing-junit-4-and-junit-5-tests-in-a-same-build

I was getting this error, too:

junit.framework.AssertionFailedError: No tests found in ...

The reason was that I forgot to specify

defaultConfig {
    ...
    testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}

After syncing the project, it found the tests. So maybe it helps someone else.

https://stackoverflow.com/questions/22469480/junit-no-tests-found

Another argument for suffix - at least in english language:

A class usually represents a noun, it is a model of a concept. An instance of one of your tests would be a 'MyClass test'. In contrast, a method would model some kind of action, like 'test [the] calculate [method]'.

Because of this, I'd always use the 'suffix' for test classes and the prefix for test methods:

the MyClass test          --> MyClassTest
test the calculate method --> testCalculate()

https://stackoverflow.com/questions/3146821/naming-convention-junit-suffix-or-prefix-test

You have almost answered your own question. Your catch block will not catch the AssertionError that the Assert throws if it fails, because it is an Error (or, more specifically, it extends java.lang.Error). See the docs for more information on this. Your catch block only catches Throwable objects that extend java.lang.Exception

If you really want to catch it - you need to use

catch (AssertionError e) {
...

However, as others have mentioned, this is a very unusual way to use assertions - they should usually pass and if they fail it is very unusual for you to want to carry on the program execution. That's why the failure throws an Error rather than an Exception. You can read more about (not) catching Error in this question.

If you just want a test the variable value, it is preferred to use if ( variableName == "1")

NB if you are testing unit-test helper code, like a matcher, it might make sense to catch the AssertionError.

https://stackoverflow.com/questions/29671796/will-an-assertion-error-be-caught-by-in-a-catch-block-for-java-exception

Blogs

Check out the latest blogs from LambdaTest on this topic:

How to Integrate LambdaTest with Calliope.pro?

Collaboration is pivotal for any successful release. Can you imagine going through a sprint without consulting or informing any other team involved in the project about what you did? You can’t right because it is not a pretty picture. Modern SDLCs demand various teams to coordinate as they try to deliver a product as quickly as possible in the market, with assured quality.

How to use Assert and Verify in Selenium WebDriver

During the process of test automation, you would come across a number of scenarios where a decision needs to be taken regarding “What if the test(s) result in a failure?” If the error (or issue) being encountered is a minor one, you might want the test execution to continue. In case of serious errors, it is better to abort the execution of the test case (or test suite). This can be achieved using ‘Assert and Verify in Selenium WebDriver Tutorial.

How To Integrate Jenkins & Maven With Selenium?

This article is a part of our Content Hub. For more in-depth resources, check out our content hub on Jenkins Tutorial.

Parallel Testing With JUnit 5 And Selenium [Tutorial]

Parallel test execution with Selenium is one of the major factors that can affect the test execution speed. Serial execution in Selenium can be effective only if the tests have to be run on a small number of browser and OS combinations. Therefore, parallel execution should be leveraged at the early stages of QA testing to expedite test execution rapidly.

How To Modify HTTP Request Headers In JAVA Using Selenium WebDriver?

One of the most common test automation challenges is how do we modify the request headers in Selenium WebDriver. As an automation tester, you would come across this challenge for any programming language, including Java. Before coming to the solution, we need to understand the problem statement better and arrive at different possibilities to modify the header request in Java while working with Selenium WebDriver Tutorial.

JUnit Tutorial:

LambdaTest also has a detailed JUnit tutorial explaining its features, importance, advanced use cases, best practices, and more to help you get started with running your automation testing scripts.

JUnit Tutorial Chapters:

Here are the detailed JUnit testing chapters to help you get started:

Importance of Unit testing - Learn why Unit testing is essential during the development phase to identify bugs and errors.
Top Java Unit testing frameworks - Here are the upcoming JUnit automation testing frameworks that you can use in 2023 to boost your unit testing.
What is the JUnit framework
Why is JUnit testing important - Learn the importance and numerous benefits of using the JUnit testing framework.
Features of JUnit - Learn about the numerous features of JUnit and why developers prefer it.
JUnit 5 vs. JUnit 4: Differences - Here is a complete comparison between JUnit 5 and JUnit 4 testing frameworks.
Setting up the JUnit environment - Learn how to set up your JUnit testing environment.
Getting started with JUnit testing - After successfully setting up your JUnit environment, this chapter will help you get started with JUnit testing in no time.
Parallel testing with JUnit - Parallel Testing can be used to reduce test execution time and improve test efficiency. Learn how to perform parallel testing with JUnit.
Annotations in JUnit - When writing automation scripts with JUnit, we can use JUnit annotations to specify the type of methods in our test code. This helps us identify those methods when we run JUnit tests using Selenium WebDriver. Learn in detail what annotations are in JUnit.
Assertions in JUnit - Assertions are used to validate or test that the result of an action/functionality is the same as expected. Learn in detail what assertions are and how to use them while performing JUnit testing.
Parameterization in JUnit - Parameterized Test enables you to run the same automated test scripts with different variables. By collecting data on each method's test parameters, you can minimize time spent on writing tests. Learn how to use parameterization in JUnit.
Nested Tests In JUnit 5 - A nested class is a non-static class contained within another class in a hierarchical structure. It can share the state and setup of the outer class. Learn about nested annotations in JUnit 5 with examples.
Best practices for JUnit testing - Learn about the best practices, such as always testing key methods and classes, integrating JUnit tests with your build, and more to get the best possible results.
Advanced Use Cases for JUnit testing - Take a deep dive into the advanced use cases, such as how to run JUnit tests in Jupiter, how to use JUnit 5 Mockito for Unit testing, and more for JUnit testing.