*          that this closure is now in the scope of an instrumented call, so changing its delegate must be reflected in updating the new delegate's
 *          metaclass for call interception.
 *     <li> Overrides {@link Closure#setDelegate}, adding a call to {@link InstrumentedGroovyMetaClassHelper#addInvocationHooksInClosureDispatchObject} with

                    }
                }
                implementation 'com.google.inject:guice:4.2.2:no_aop'
            }

            java {
                if (JavaPluginExtension.metaClass.respondsTo(delegate, 'registerFeature')) {
                    sourceSets {
                        hibernateSupport
                    }
                    registerFeature("hibernateSupport") {

        dynamicObject.getProperty("readOnly") == "read-only"
    }

    def "can get metaClass of groovy object"() {
        def bean = new Bean(prop: "value")
        def dynamicObject = new BeanDynamicObject(bean)

        expect:
        dynamicObject.hasProperty("metaClass")
        dynamicObject.getProperty("metaClass") == bean.metaClass
    }

    def "can get property of dynamic groovy object"() {

            }

            // GENERATE private MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(getClass())
            addField(ACC_PRIVATE | ACC_TRANSIENT, META_CLASS_FIELD, META_CLASS_TYPE_DESCRIPTOR);

            // GENERATE public MetaClass getMetaClass() {
            //     if (metaClass == null) {
            //         metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(getClass());

 * limitations under the License.
 */

package org.gradle.util.internal;

import com.google.common.base.Objects;
import groovy.lang.Closure;
import org.codehaus.groovy.runtime.metaclass.MissingMethodExecutionFailed;
import org.gradle.api.Action;
import org.gradle.api.InvalidActionClosureException;
import org.gradle.util.Configurable;

/**

        mavenHttpRepo.module("test", "lang", "2.6").publish()

        and:
        server.allowGetOrHead("/repo", mavenRepo.rootDir)

        and:
        buildFile << """
repositories {
    if (repositories.metaClass.respondsTo(repositories, 'maven')) {
        maven { url "${mavenHttpRepo.uri}" }
    } else {
        mavenRepo urls: "${mavenHttpRepo.uri}"
    }
}

configurations {
    compile
}

dependencies {

            class SomeTask extends DefaultTask {
            }
            class SomeExtension {
            }

            SomeTask.metaClass.p1 = 12
            SomeTask.metaClass.m1 = { -> "m1" }
            SomeExtension.metaClass.p2 = 10
            SomeExtension.metaClass.m2 = { String p -> p }

            task t(type: SomeTask)
            extensions.add("e", SomeExtension)

            assert t.p1 == 12

        ConnectCompletion connect(Address address) throws ConnectException {
            def connection = [:] as RemoteConnection
            // unsure why I can't add this as property in the map-mock above
            connection.metaClass.num = address.num
            return { connection } as ConnectCompletion
        }
    }

    def createAddress(int i) {
        new Address() {
            int getNum() { i }

        }

        then:
        thrown InvalidUserDataException
    }

    private void enhanceCredentials(Credentials credentials, String... props) {
        props.each { prop ->
            credentials.metaClass."$prop" = { String val ->
                delegate."set${prop.capitalize()}"(val)
            }
        }
    }

    class AuthSupportedRepository extends AbstractAuthenticationSupportedRepository {

        cl.package.name == "org.gradle.api.plugins"

        def obj = JavaReflectionUtil.newInstance(cl)
        obj instanceof GroovyObject
        obj.getMetaClass()
        obj.metaClass
        obj.setProperty("prop", "value")
        obj.getProperty("prop") == "value"
        obj.invokeMethod("doSomething", "arg") == "arg"

        def newMetaClass = new MetaClassImpl(cl)