private static String getPropertyName(String methodName) {
        if (methodName.startsWith("is") && methodName.length() > 2 && Character.isUpperCase(methodName.charAt(2))) {
            return Character.toLowerCase(methodName.charAt(2)) + methodName.substring(3);
        } else if ((methodName.startsWith("get") || methodName.startsWith("set")) && methodName.length() > 3 && Character.isUpperCase(methodName.charAt(3))) {

    private final String methodName;

    /**
     * {@link MethodNotStaticRuntimeException}を作成します。
     *
     * @param targetClass
     *            ターゲットクラス
     * @param methodName
     *            メソッド名
     */
    public MethodNotStaticRuntimeException(final Class<?> targetClass, final String methodName) {
        super("ECL0100", asArray(targetClass.getName(), methodName));
        this.targetClass = targetClass;

        private final String methodName;
        private final Action<Object> action;

        ActionInvocationHandler(String methodName, Action<Object> action) {
            this.methodName = methodName;
            this.action = action;
        }

        @Override
        public void dispatch(MethodInvocation message) {
            if (message.getMethodName().equals(methodName)) {

    def "knows if test matches class"() {
        expect:
        matcher(input, [], []).matchesTest(className, methodName) == match
        matcher([], [], input).matchesTest(className, methodName) == match

        where:
        input                    | className                 | methodName            | match
        ["FooTest"]              | "FooTest"                 | "whatever"            | true

    private final String className;
    private final String methodName;

    public DefaultJvmTestOperationDescriptor(
        InternalJvmTestDescriptor internalJvmTestDescriptor,
        OperationDescriptor parent,
        JvmTestKind jvmTestKind,
        String suiteName,
        String className,
        String methodName
    ) {
        super(internalJvmTestDescriptor, parent);

        DeprecationSpec deprecationSpec,
        BinaryCompatibility binaryCompatibility
    ) {
        this.propertyName = propertyName;
        this.methodName = methodName;
        this.methodDescriptor = methodDescriptor;
        this.propertyType = propertyType;
        this.isFluentSetter = isFluentSetter;
        this.implementationClassName = implementationClassName;
        this.interceptedPropertyName = interceptedPropertyName;

    }

    @Override
    public MethodDesc[] getMethodDescs(final String methodName) {
        assertArgumentNotEmpty("methodName", methodName);

        final MethodDesc[] methodDescs = methodDescsCache.get(methodName);
        if (methodDescs == null) {
            throw new MethodNotFoundRuntimeException(beanClass, methodName, null);
        }

     *
     * @param methodName
     *            メソッド名。{@literal null}や空文字列であってはいけません
     * @param paramTypes
     *            メソッドの引数型の並び
     * @return 引数の型に応じた{@link MethodDesc}
     */
    MethodDesc getMethodDescNoException(String methodName, Class<?>... paramTypes);

    /**
     * 引数に適合する{@link MethodDesc}を返します。
     *
     * @param methodName
     *            メソッド名。{@literal null}や空文字列であってはいけません

        return invokeIntercepted(object, INVOKE_METHOD, methodName, argsForInterceptor, () -> adaptee.invokeMethod(object, methodName, arguments));
    }

    @Override
    public Object invokeMethod(Object object, String methodName, Object[] arguments) {
        return invokeIntercepted(object, INVOKE_METHOD, methodName, arguments, () -> adaptee.invokeMethod(object, methodName, arguments));
    }

    @Override

        }
        return includePatterns;
    }

    public boolean matchesTest(String className, String methodName) {
        return matchesPattern(buildScriptIncludePatterns, className, methodName)
            && matchesPattern(commandLineIncludePatterns, className, methodName)
            && !matchesExcludePattern(className, methodName);
    }

    public boolean mayIncludeClass(String fullQualifiedClassName) {