then:
        hasMethod(clazzA.clazz, 'foo').modifiers == Opcodes.ACC_ABSTRACT + Opcodes.ACC_PUBLIC
        hasMethod(clazzA.clazz, 'bar').modifiers == Opcodes.ACC_PUBLIC
        hasMethod(extractedA, 'foo').modifiers == Opcodes.ACC_ABSTRACT + Opcodes.ACC_PUBLIC
        hasMethod(extractedA, 'bar').modifiers == Opcodes.ACC_PUBLIC

        and:
        hasMethod(clazzB.clazz, 'foo').modifiers == Opcodes.ACC_PUBLIC

        extension.properties == adapter.properties
    }

    def "has no methods"() {
        given:
        extension.set("foo") { }

        expect:
        !adapter.hasMethod("foo", "anything")

        and:
        !adapter.hasMethod("other")
    }

    def "getting missing property throws MPE"() {
        when:
        adapter.getProperty("foo")

        then:
        thrown(MissingPropertyException)

        expect:
        dynamicObject.hasMethod("m", [12] as Object[])
        !dynamicObject.hasMethod("m", [] as Object[])
        !dynamicObject.hasMethod("other", [12] as Object[])
        dynamicObject.hasMethod("overlap", [Integer] as Object[])
        dynamicObject.hasMethod("overlap", [0] as Object[])
        !dynamicObject.hasMethod("methodWithClass", [0] as Object[])

    private val problemFactory: ProblemFactory,
    private val dynamicCallProblemReporting: DynamicCallProblemReporting
) : DynamicObject {
    override fun hasMethod(name: String, vararg arguments: Any?): Boolean {
        onAccess(MemberKind.METHOD, name)
        return delegate.hasMethod(name, *arguments)
    }

    override fun tryInvokeMethod(name: String, vararg arguments: Any?): DynamicInvokeResult {
        onAccess(MemberKind.METHOD, name)

        public Map<String, ?> getProperties() {
            return dynamicTarget.getProperties();
        }

        @Override
        public boolean hasMethod(String name, Object... arguments) {
            return scriptObject.hasMethod(name, arguments) || dynamicTarget.hasMethod(name, arguments);
        }

        @Override
        public boolean hasProperty(String name) {

        ExtensibleDynamicObjectTestHelper.decorateGroovyBean(bean);

        assertTrue(bean.hasMethod("groovyMethod", "a", "b"));
        assertThat(bean.getAsDynamicObject().invokeMethod("groovyMethod", "a", "b"), equalTo((Object) "groovy:a.b"));

        assertTrue(bean.hasMethod("dynamicGroovyMethod", "a", "b"));

        }
        properties.put("properties", properties);
        return properties;
    }

    @Override
    public boolean hasMethod(String name, @Nullable Object... arguments) {
        for (DynamicObject object : objects) {
            if (object.hasMethod(name, arguments)) {
                return true;
            }
        }
        return false;
    }

    @Override

        convention.add("foo", ext)

        //then
        assertTrue(convention.extensionsAsDynamicObject.hasProperty("foo"))
        assertTrue(convention.extensionsAsDynamicObject.hasMethod("foo", {}))
        assertTrue(convention.extensionsAsDynamicObject.hasMethod("foo", {} as Action))
        assertEquals(convention.extensionsAsDynamicObject.properties.get("foo"), ext)
    }

    @Test void extensionsTakePrecedenceOverPluginConventions() {

     *
     * <p>Note that not every method is known. Some methods may require an attempt invoke it in order for them to be discovered.</p>
     */
    boolean hasMethod(String name, @Nullable Object... arguments);

    /**
     * Invokes the method with the given name and arguments.
     */
    DynamicInvokeResult tryInvokeMethod(String name, @Nullable Object... arguments);

                return DynamicInvokeResult.found();
            }
            DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(property);
            if (dynamicObject.hasMethod("call", arguments)) {
                return dynamicObject.tryInvokeMethod("call", arguments);
            }
        }
        return DynamicInvokeResult.notFound();
    }