How to use getTitleAnnotation method of net.thucydides.core.adapters.junit4.JUnit4Adapter class

1package net.thucydides.core.adapters.junit4;
2
3import net.thucydides.core.adapters.TestStrategyAdapter;
4import net.thucydides.core.model.TestTag;
5
6import java.lang.reflect.Method;
7import java.util.List;
8import java.util.Optional;
9
10/**
11 * This is an INTERNAL helper class of serenity, it should not be used directly and may be subject to refactoring.
12 * <p>
13 * It serves to decouple serenity-model (and serenity-core) from JUnit. If JUnit is on the classpath, JUnit
14 * classes will be handled specifically. But serenity will continue to function without JUnit being on the classpath.
15 * Furthermore, users can choose between JUnit 4 and JUnit 5 or even use both together.
16 * <p>
17 * Ideally this approach could be generalized to avoid any special treatment of JUnit as a test framework.
18 * Test-framework specific strategies could be registered from the framework-specific modules. That would allow
19 * to place the implementation of (and the tests for) the test-framework specific strategies into the modules that know
20 * about those frameworks and also have the necessary dependencies.
21 * <p>
22 * But this would be a more extensive change, potentially breaking backwards compatibility. So for now this class does
23 * exactly only this: It provides an adapter for JUnit 4 and JUnit 5, and makes explicit the parts of the code where
24 * there has previously been a hard dependency on JUnit 4.
25 * <p>
26 * As such it is self-contained and should be possible to be grasped rather easily. And it marks the starting point for
27 * a potential refactoring towards a more general approach.
28 */
29public class JUnit4Adapter implements TestStrategyAdapter {
30
31
32    private final JUnit4Strategy jUnit4Strategy;
33
34    public JUnit4Adapter() {
35        jUnit4Strategy = new JUnit4Strategy();
36    }
37
38    public boolean isTestClass(final Class<?> testClass) {
39        if (testClass == null) {
40            return false;
41        }
42        return jUnit4Strategy.isTestClass(testClass);
43    }
44
45    public boolean isTestMethod(final Method method) {
46        if (method == null) {
47            return false;
48        }
49        return jUnit4Strategy.isTestMethod(method);
50    }
51
52    public boolean isTestSetupMethod(final Method method) {
53        if (method == null) {
54            return false;
55        }
56        return jUnit4Strategy.isTestSetupMethod(method);
57    }
58
59    public boolean isSerenityTestCase(final Class<?> testClass) {
60        if (testClass == null) {
61            return false;
62        }
63        return jUnit4Strategy.isSerenityTestCase(testClass);
64    }
65
66    public boolean isAssumptionViolatedException(final Throwable throwable) {
67        return jUnit4Strategy.isAssumptionViolatedException(throwable);
68    }
69
70    public boolean isATaggableClass(final Class<?> testClass) {
71        if (testClass == null) {
72            return false;
73        }
74        return jUnit4Strategy.isATaggableClass(testClass);
75    }
76
77    public boolean isIgnored(final Method method) {
78        if (method == null) {
79            return false;
80        }
81        return jUnit4Strategy.isIgnored(method);
82    }
83
84    public Optional<String> getTitleAnnotation(Method testMethod) {
85        return jUnit4Strategy.getTitleAnnotation(testMethod);
86    }
87
88    public List<TestTag> getTagsFor(Method testMethod) {
89        return jUnit4Strategy.getTagsFor(testMethod);
90    }
91
92    @Override
93    public Double priority() {
94        return 4.13;
95    }
96}
97

Source: JUnit4Adapter.java

package net.thucydides.core.adapters.junit4;

import net.thucydides.core.adapters.TestStrategyAdapter;
import net.thucydides.core.model.TestTag;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;

/**
 * This is an INTERNAL helper class of serenity, it should not be used directly and may be subject to refactoring.
 * <p>
 * It serves to decouple serenity-model (and serenity-core) from JUnit. If JUnit is on the classpath, JUnit
 * classes will be handled specifically. But serenity will continue to function without JUnit being on the classpath.
 * Furthermore, users can choose between JUnit 4 and JUnit 5 or even use both together.
 * <p>
 * Ideally this approach could be generalized to avoid any special treatment of JUnit as a test framework.
 * Test-framework specific strategies could be registered from the framework-specific modules. That would allow
 * to place the implementation of (and the tests for) the test-framework specific strategies into the modules that know
 * about those frameworks and also have the necessary dependencies.
 * <p>
 * But this would be a more extensive change, potentially breaking backwards compatibility. So for now this class does
 * exactly only this: It provides an adapter for JUnit 4 and JUnit 5, and makes explicit the parts of the code where
 * there has previously been a hard dependency on JUnit 4.
 * <p>
 * As such it is self-contained and should be possible to be grasped rather easily. And it marks the starting point for
 * a potential refactoring towards a more general approach.
 */
public class JUnit4Adapter implements TestStrategyAdapter {


    private final JUnit4Strategy jUnit4Strategy;

    public JUnit4Adapter() {
        jUnit4Strategy = new JUnit4Strategy();
    }

    public boolean isTestClass(final Class<?> testClass) {
        if (testClass == null) {
            return false;
        }
        return jUnit4Strategy.isTestClass(testClass);
    }

    public boolean isTestMethod(final Method method) {
        if (method == null) {
            return false;
        }
        return jUnit4Strategy.isTestMethod(method);
    }

    public boolean isTestSetupMethod(final Method method) {
        if (method == null) {
            return false;
        }
        return jUnit4Strategy.isTestSetupMethod(method);
    }

    public boolean isSerenityTestCase(final Class<?> testClass) {
        if (testClass == null) {
            return false;
        }
        return jUnit4Strategy.isSerenityTestCase(testClass);
    }

    public boolean isAssumptionViolatedException(final Throwable throwable) {
        return jUnit4Strategy.isAssumptionViolatedException(throwable);
    }

    public boolean isATaggableClass(final Class<?> testClass) {
        if (testClass == null) {
            return false;
        }
        return jUnit4Strategy.isATaggableClass(testClass);
    }

    public boolean isIgnored(final Method method) {
        if (method == null) {
            return false;
        }
        return jUnit4Strategy.isIgnored(method);
    }

    public Optional<String> getTitleAnnotation(Method testMethod) {
        return jUnit4Strategy.getTitleAnnotation(testMethod);
    }

    public List<TestTag> getTagsFor(Method testMethod) {
        return jUnit4Strategy.getTagsFor(testMethod);
    }

    @Override
    public Double priority() {
        return 4.13;
    }
}