for (Object object : plugins.values()) {
                BeanDynamicObject dynamicObject = asDynamicObject(object);
                if (dynamicObject.hasMethod(name, args)) {
                    return true;
                }
            }
            return false;
        }

        private BeanDynamicObject asDynamicObject(Object object) {
            if (dynamicObjects == null) {

        }

        then:
        container.size() == 2
        container.findByName("Fred") == realFred
        container.findByName("Barney") == realBarney
        container.asDynamicObject.getProperty("Fred") == realFred
        container.asDynamicObject.getProperty("Barney") == realBarney
    }

    def "create elements with specified type"() {

 * limitations under the License.
 */

package org.gradle.internal.metaobject;

import org.gradle.api.internal.DynamicObjectAware;

public abstract class DynamicObjectUtil {
    public static DynamicObject asDynamicObject(Object object) {
        if (object instanceof DynamicObject) {
            return (DynamicObject)object;
        } else if (object instanceof DynamicObjectAware) {

            }
            DynamicDelegatedPropertiesMock.SettingsMock(
                mock<DynamicAwareSettingsMockType>(name = "settings") {
                    on { asDynamicObject } doReturn dynamicObject
                    on { gradle } doReturn gradleMock
                },
                dynamicObject
            )
        }

    private

    private final ClassLoader antlibClassLoader;

    public AntBuilderDelegate(Object builder, ClassLoader antlibClassLoader) {
        this.originalBuilder = builder;
        this.builder = DynamicObjectUtil.asDynamicObject(builder);
        this.antlibClassLoader = antlibClassLoader;
    }

    public AntBuilderDelegate getAnt() {
        return this;
    }

    public void taskdef(Map<String, String> args) {

    public ConfigureDelegate(Closure<?> configureClosure, Object delegate) {
        _original_owner = configureClosure.getOwner();
        _owner = DynamicObjectUtil.asDynamicObject(_original_owner);
        _delegate = DynamicObjectUtil.asDynamicObject(delegate);
    }

    @Override
    public String toString() {
        return _delegate.toString();
    }

    @Nullable
    public Object _original_owner() {

    
    def "fails lazily for non dsl object"() {
        when:
        def dsl = new DslObject(new Object())

        then:
        notThrown(Exception)

        when:
        dsl.asDynamicObject

        then:
        thrown(IllegalStateException)
    }

    static class Thing {}

    def "works for dsl object"() {
        when:

ant: org.gradle.api.internal.project.DefaultAntBuilder@12345
antBuilderFactory: org.gradle.api.internal.project.DefaultAntBuilderFactory@12345
artifacts: org.gradle.api.internal.artifacts.dsl.DefaultArtifactHandler_Decorated@12345
asDynamicObject: DynamicObject for project ':api'

            } else if (thing instanceof GroovyObject) {
                name = ((GroovyObject) thing).getProperty("name");
            } else {
                name = DynamicObjectUtil.asDynamicObject(thing).getProperty("name");
            }
        } catch (MissingPropertyException e) {
            throw new NoNamingPropertyException(thing);
        }

        if (name == null) {

                ((NamedDomainObjectContainer) property).configure((Closure) arguments[0]);
                return DynamicInvokeResult.found();
            }
            DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(property);
            if (dynamicObject.hasMethod("call", arguments)) {
                return dynamicObject.tryInvokeMethod("call", arguments);
            }
        }
        return DynamicInvokeResult.notFound();