return;
            }

            String methodName = invocation.getName();
            boolean isSupportMethod = methodName.length() > 11 && methodName.startsWith("is") && methodName.endsWith("Supported");
            if (!isSupportMethod) {
                return;
            }

            String getterName = "get" + methodName.substring(2, methodName.length() - 9);

 */

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() + ")";
    }

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

            @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;
    }

    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()
        val methodName = readString()
        val parameterTypes = readClassArray()
        return declaringClass.getDeclaredMethod(methodName, *parameterTypes)
    }

            @Nullable String instance,
            String methodName,
            Function<ExternalProcessFixture, String> groovySpecFactory,
            Function<ExternalProcessFixture, String> kotlinSpecFactory,
            Function<ExternalProcessFixture, String> javaSpecFactory
        ) {
            this.method = instance != null ? "${instance}.$methodName" : methodName
            this.groovySpecFactory = groovySpecFactory

            String methodName = methodSource.getMethodName();
            return matcher.matchesTest(methodSource.getClassName(), methodName)
                || matchesParentMethod(descriptor, methodName);
        }

        private boolean matchesParentMethod(TestDescriptor descriptor, String methodName) {
            return descriptor.getParent()

    }

    @Nullable
    private static Method findAgentMethod(String agentClassName, String methodName, Class<?>... args) {
        Class<?> agentClass = tryLoadAgentClass(agentClassName);
        if (agentClass == null) {
            return null;
        }
        try {
            Method method = agentClass.getMethod(methodName, args);
            method.setAccessible(true);
            return method;

    for (String methodName : STATIC_ONE_ARG_METHODS_SHOULD_PASS) {
      Method method = OneArg.class.getMethod(methodName, String.class);
      try {
        new NullPointerTester().testMethodParameter(new OneArg(), method, 0);
      } catch (AssertionError unexpected) {
        fail("Should not have flagged method " + methodName);
      }
    }
  }