baseScope.getExportClassLoader() >> baseChildClassLoader
        classpathHasher.hash(_ as ClassPath) >> TestHashCodes.hashCodeFrom(123)
    }

    void "configures a target object using script"() {
        given:
        final Object target = new Object()

        when:
        def configurer = factory.create(scriptSource, scriptHandler, targetScope, baseScope, false)
        configurer.apply(target)

 * condition.
 */
internal abstract class FirCallableFilteringScope(private val baseScope: FirContainingNamesAwareScope) : FirContainingNamesAwareScope() {
    protected abstract fun isTargetCallable(callable: FirCallableSymbol<*>): Boolean

    private val cachedCallableNames by lazy(LazyThreadSafetyMode.NONE) {
        buildSet {
            baseScope.processAllCallables { callable ->
                if (isTargetCallable(callable)) {

    }

    @Override
    public ScriptPlugin create(ScriptSource scriptSource, ScriptHandler scriptHandler, ClassLoaderScope targetScope, ClassLoaderScope baseScope, boolean topLevelScript) {
        return new ScriptPluginImpl(scriptSource, (ScriptHandlerInternal) scriptHandler, targetScope, baseScope, topLevelScript);
    }

    private class ScriptPluginImpl implements ScriptPlugin {
        private final ScriptSource scriptSource;

        then:
        result == project
        1 * instantiator.newInstance(DefaultProject, "name", null, projectDir, buildFile, { it instanceof TextResourceScriptSource }, gradle, projectState, serviceRegistryFactory, rootProjectScope, baseScope) >> project
        1 * projectRegistry.addProject(project)

        val baseScope = super.getSearchScope(analysisSession, owner) as? FirTypeScope ?: return null
        return if (isSynthetic) {
            FirSyntheticPropertiesScope.createIfSyntheticNamesProviderIsDefined(
                session = analysisSession.useSiteSession,
                dispatchReceiverType = owner.defaultType(),
                baseScope = baseScope,
            )
        } else {

        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope
    ) =
        KotlinScriptHost(
            target,
            scriptSource,
            scriptHandler,
            targetScope,
            baseScope,
            host.serviceRegistryFor(programTarget, target)
        )

    private

    public void process(final ScriptSource initScript, GradleInternal gradle) {
        ClassLoaderScope baseScope = gradle.getClassLoaderScope();
        URI uri = initScript.getResource().getLocation().getURI();
        String id = uri == null ? idGenerator.generateId().toString() : uri.toString();
        ClassLoaderScope scriptScope = baseScope.createChild("init-" + id, null);

    def scriptHandler = Mock(ScriptHandler)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)

    def defaultScriptPlugin = Mock(ScriptPlugin)

    def setup() {
        _ * defaultScriptPluginFactory.create(*_) >> defaultScriptPlugin
    }

    def scriptSource = Mock(ScriptSource)
    def configurerFactory = Mock(ScriptPluginFactory)
    def scriptPlugin = Mock(ScriptPlugin)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)
    def projectState = Mock(ProjectState)
    def buildScriptProcessor = new BuildScriptProcessor(configurerFactory)
    def scriptHandler = Mock(ScriptHandlerInternal)

    def "setup"() {

    target: Any,
    scriptFile: File,
    baseScope: ClassLoaderScope,
    scriptHandlerFactory: ScriptHandlerFactory,
    project: ProjectInternal,
    resourceDescription: String
): Pair<ScriptHandlerInternal, ClassPath> {

    val scriptSource = textResourceScriptSource(resourceDescription, scriptFile, project.serviceOf())
    val scriptScope = baseScope.createChild("model-${scriptFile.toURI()}", null)