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)
}

    @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

    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;

            "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\\..*"

        interceptorTestReceiverOriginalMetaClass = InterceptorTestReceiver.metaClass
        compositeInterceptorTestReceiverClassLock.lock()
        compositeInterceptorTestReceiverOriginalMetaClass = CompositeInterceptorTestReceiver.metaClass
    }

    def cleanup() {
        InterceptorTestReceiver.metaClass = interceptorTestReceiverOriginalMetaClass
        interceptorTestReceiverClassLock.unlock()

        }
    }
}


internal
object GroovyMetaClassCodec : Codec<MetaClass> {
    override suspend fun WriteContext.encode(value: MetaClass) {
        writeClass(value.theClass)
    }

    override suspend fun ReadContext.decode(): MetaClass? {
        return InvokerHelper.getMetaClass(readClass())
    }

    }

    def originalMetaClass = null

    def setup() {
        originalMetaClass = CallInterceptionFilteringTestReceiver.metaClass
    }

    def cleanup() {
        CallInterceptionFilteringTestReceiver.metaClass = originalMetaClass
    }

    String interceptedWhen(
        boolean shouldDelegate,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.metaobject;

/**
 * An implementation of a Groovy MetaClass that is instrumented and might need to cancel some optimizations
 * in order to get the instrumentation to work properly.
 */
public interface InstrumentedMetaClass {
    /**