private final String containingType;
        private final String methodName;
        private final String descriptor;

        private AccessorKey(String containingType, String methodName, String descriptor) {
            this.containingType = containingType;
            this.methodName = methodName;
            this.descriptor = descriptor;
        }

            return false;
        }
        return !(methodName != null ? !methodName.equals(that.methodName) : that.methodName != null);
    }

    @Override
    public int hashCode() {
        int result = className != null ? className.hashCode() : 0;
        result = 31 * result + (methodName != null ? methodName.hashCode() : 0);
        return result;
    }

     */
    public NoSuchMethodRuntimeException(final Class<?> targetClass, final String methodName, final Class<?>[] argTypes,
            final Throwable cause) {
        super("ECL0057", asArray(targetClass.getName(), MethodUtil.getSignature(methodName, argTypes)), cause);
        this.targetClass = targetClass;
        this.methodName = methodName;
        this.argTypes = argTypes;
    }

    /**
     * ターゲットクラスを返します。
     *

class PerformanceTestIdProvider implements TestRule {

    private testSpec
    private String methodName
    private String className

    PerformanceTestIdProvider() {}

    @Override
    Statement apply(Statement base, Description description) {
        methodName = description.methodName
        className = description.className
        updateId()
        return base
    }

public class WithExtensionReferencesExtra implements RequestExtra {
    public final Type ownerType;
    public final String methodName;

    public WithExtensionReferencesExtra(Type ownerType, String methodName) {
        this.ownerType = ownerType;
        this.methodName = methodName;
    }

    public static class ProducedSynthetically implements RequestExtra {
    }

    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;

        then:
        // 2 test class + 2 test method events
        events.testClassesAndMethods.size() == 4
        assertTestExecuted(className: 'example2.MyOtherTest', methodName: 'bar', task: ':secondTest')
        assertTestExecuted(className: 'example2.MyOtherTest2', methodName: 'baz', task: ':secondTest')

        when:
        events.clear()
        stdout.reset() // we are interested in the output of the second build only

    }

    private static boolean isPrefixable(String methodName, String prefix) {
        return methodName.startsWith(prefix) && methodName.length() > prefix.length() && Character.isUpperCase(methodName.charAt(prefix.length()));
    }

    private static String getPropertyName(String methodName) {
        if (methodName.startsWith("get")) {
            return getPropertyName(methodName, "get");
        } else if (methodName.startsWith("is")) {

        []
    }

    protected def getAsmSource(String methodName) {
        if (toolChain.isVisualCpp()) {
            return """
.386
.model    flat

PUBLIC    _${methodName}
_TEXT     SEGMENT
_${methodName}    PROC
mov    eax, DWORD PTR 4[esp]
add    eax, DWORD PTR 8[esp]
ret    0
_${methodName}    ENDP
_TEXT   ENDS
END
"""
        }else{
            return """
.text

    @Override
    public void assertMutationAllowed(String methodName, Object target) {
        if (!isMutationAllowed()) {
            throw createIllegalStateException(new DslObject(target).getPublicType().getConcreteClass(), methodName, target);
        }
    }

    @Override
    public <T> void assertMutationAllowed(String methodName, T target, Class<T> targetType) {
        if (!isMutationAllowed()) {