}

            return invokeOpaqueMethod(metaClass, name, arguments);
        }

        @Nullable
        protected MetaMethod lookupMethod(MetaClass metaClass, String name, Class[] arguments) {
            return metaClass.pickMethod(name, arguments);
        }

        protected DynamicInvokeResult invokeOpaqueMethod(MetaClass metaClass, String name, Object[] arguments) {

        return delegate.setProperty(propertyName, newValue)
    }

    override fun getMetaClass(): MetaClass {
        return delegate.metaClass
    }

    override fun setMetaClass(metaClass: MetaClass?) {
        delegate.metaClass = metaClass
    }

    override fun invokeMethod(name: String, args: Any?): Any? =
        delegate.invokeMethod(name, args)
}

        withEntryPoint(INVOKE_METHOD, "test") {
            method1 = instance.metaClass.pickMethod("test", new Class[]{})
            method2 = instance.metaClass.pickMethod("test", new Class[]{InterceptorTestReceiver})
        }
        // not in the scope of an entry point, so should not be an intercepted method
        def method3 = instance.metaClass.pickMethod("test", new Class[]{String})

        then:

    @Issue("gradle/gradle#742")
    @NotYetImplemented
    @Ignore("Apparently sometimes the test passes on CI")
    def "doesn't cache the metaclass from previous execution if build script changes"() {
        buildFile '''
void bar() {
   println 'Original bar'
}

FileCollection.metaClass.environmentMarkers = { String... markerStrings ->
   bar()
   // to make this test pass, a workaround is to uncomment this line

            delegate.withGroovyBuilder { hasProperty(absentPropertyName) }
        )

        inOrder(delegate, metaClass) {
            verify(delegate).metaClass
            verify(metaClass).hasProperty(delegate, existingPropertyName)
            verify(delegate).metaClass
            verify(metaClass).hasProperty(delegate, absentPropertyName)
            verifyNoMoreInteractions()
        }
    }

    @Test

    def originalMetaClass = null

    def setup() {
        interceptorTestReceiverClassLock.lock()
        originalMetaClass = InterceptorTestReceiver.metaClass
    }

    def cleanup() {
        InterceptorTestReceiver.metaClass = originalMetaClass
        interceptorTestReceiverClassLock.unlock()
    }

    @Override
    protected Predicate<String> shouldInstrumentAndReloadClassByName() {

    }

    public static void decorateGroovyBean(bean) {
        Map values = [:]
        bean.metaClass.getDynamicGroovyProperty << {-> values.dynamicGroovyProperty }
        bean.metaClass.setDynamicGroovyProperty << {value -> values.dynamicGroovyProperty = value}
        bean.metaClass.dynamicGroovyMethod << {a, b -> "dynamicGroovy:$a.$b".toString() }
    }
}

 * limitations under the License.
 */

package org.gradle.internal.classpath;

import groovy.lang.Closure;
import groovy.lang.GroovySystem;
import groovy.lang.MetaClass;
import groovy.lang.MetaClassRegistry;
import org.gradle.api.NonNullApi;
import org.gradle.internal.classpath.intercept.CallInterceptorResolver;

class ClassInspectorTest extends Specification {
    def "extracts properties of a Groovy class"() {
        expect:
        def details = ClassInspector.inspect(SomeClass)

        details.propertyNames == ['class', 'metaClass', 'prop', 'readOnly', 'writeOnly'] as Set

        def prop = details.getProperty('prop')
        prop.getters.size() == 1
        prop.setters.size() == 1

        def readOnly = details.getProperty('readOnly')

            "org.codehaus.groovy.runtime\\..*"
                    + "|org.codehaus.groovy.reflection\\..*"
                    + "|org.codehaus.groovy\\..*MetaClass.*"
                    + "|groovy\\..*MetaClass.*"
                    + "|groovy.lang.MetaMethod"
                    + "|groovy.lang.GroovyObject"
                    + "|java.lang.reflect\\..*"
                    + "|sun.reflect\\..*"