*/

package org.gradle.api.internal.tasks.testing;

public class DefaultTestMethodDescriptor extends DefaultTestDescriptor {
    public DefaultTestMethodDescriptor(Object id, String className, String methodName) {
        super(id, className, methodName);
    }

    @Override
    public String toString() {
        return "Test method " + getName() + "(" + getClassName() + ")";
    }

        return testSourceConfiguration.getRunOrExtendWithAnnotation(runOrExtendWithClasses)
    }

    String maybeParentheses(String methodName) {
        return testSourceConfiguration.maybeParentheses(methodName)
    }

    String getIgnoreOrDisabledAnnotation() {
        return testSourceConfiguration.getIgnoreOrDisabledAnnotation()
    }

    def setup() {

            return true;
        }

        @Override
        public void assertMutationAllowed(String methodName, Object target) {
            // do nothing
        }

        @Override
        public <T> void assertMutationAllowed(String methodName, T target, Class<T> targetType) {
            // do nothing
        }
    };

    /**

                        Type type = TypeUtils.extractType(typeMirror);
                        String methodName = extractMethodName(originalRequest, annotation);
                        originalRequest.getRequestExtras().add(new WithExtensionReferencesExtra(type, methodName));
                    }));
            });
        }
        return Collections.singletonList(originalRequest);
    }

        then:
        assertTaskNotExecuted(":test")
        assertTaskExecuted(":included-build:test")
        assertTestExecuted(className: "example.IncludedTest", methodName: "foo2", task: ":included-build:test")
        assertTestNotExecuted(className: "example.IncludedTest", methodName: "foo")
    }

        }
    }

    protected void init(String methodName) {
        if (methodName == null) {
            // must be a @ClassRule; use the rule's class name instead
            methodName = getClass().getSimpleName();
        }
        if (prefix == null) {
            String safeMethodName = shortenPath(methodName.replaceAll("[^\\w]", "_"), 16);

                if (methodCall == null) {
                    continue;
                }

                String methodName = AstUtils.extractConstantMethodName(methodCall);
                if (methodName == null) {
                    continue;
                }

                if (methodName.equals(MODEL)) {
                    source.getErrorCollector().addError(

            @Override
            public InternalJvmTestRequest transform(String methodName) {
                return new DefaultInternalJvmTestRequest(testClass, methodName, null);
            }
        });
        this.internalJvmTestRequests.addAll(newRequests);
        this.testClassNames.add(testClass);
        return this;
    }

    private final String className;
    private final String displayName;

    public DefaultParameterizedTestDescriptor(Object id, String methodName, @Nullable String className, String displayName, CompositeIdGenerator.CompositeId parentId) {
        super(id, methodName);
        this.className = className;
        this.displayName = displayName;
        this.parentId = parentId;
    }

     */
    @Nullable
    protected static <T> T invokeMethod(@Nullable Object obj, String methodName, Class<T> targetClass) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        if (obj == null) {
            return null;
        }

        Method method = obj.getClass().getMethod(methodName);
        Object result = method.invoke(obj);
        if (result == null) {
            return null;