*
     * @return this
     */
    ClassLoaderScope local(ClassPath classPath);

    /**
     * Makes the provided classes visible to this scope and its children. The classes are loaded in their own ClassLoader whose parent is the export ClassLoader
     * of the parent scope.
     *
     * <p>Can not be called after being locked.
     *
     * @return this
     */
    ClassLoaderScope export(ClassPath classPath);

    /**

    def gradleInternal = Mock(GradleInternal)
    def settingsLocation = Mock(SettingsLocation)
    def buildOperationScriptPlugin = new BuildOperationSettingsProcessor(settingsProcessor, buildOperationRunner)
    def classLoaderScope = Mock(ClassLoaderScope)
    def startParameter = Mock(StartParameter)
    def state = Mock(SettingsState)
    def settingsInternal = Mock(SettingsInternal)
    def rootDir = new File("root")

    }

    private void createChildProjectsRecursively(BuildState owner, DefaultProjectDescriptor parentProjectDescriptor, ClassLoaderScope parentProjectClassLoaderScope, ClassLoaderScope baseProjectClassLoaderScope) {
        for (DefaultProjectDescriptor childProjectDescriptor : parentProjectDescriptor.children()) {
            ClassLoaderScope childProjectClassLoaderScope = parentProjectClassLoaderScope.createChild("project-" + childProjectDescriptor.getName(), null);

        }

        private
        fun createSettings(): SettingsState {
            val baseClassLoaderScope = gradle.classLoaderScope
            val classLoaderScope = baseClassLoaderScope.createChild("settings", null)
            val settingsSource = TextResourceScriptSource(service<TextFileResourceLoader>().loadFile("settings file", settingsFile))

import org.gradle.groovy.scripts.ScriptSource;

public interface ScriptHandlerFactory {
    ScriptHandlerInternal create(ScriptSource scriptSource, ClassLoaderScope classLoaderScope);

    ScriptHandlerInternal create(ScriptSource scriptSource, ClassLoaderScope classLoaderScope, DomainObjectContext context);

                    "isLocked" to it.isLocked
                )
            }
        )
    )
}


private
fun hierarchyOf(initialScope: ClassLoaderScope): List<ClassLoaderScope> =
    initialScope.foldHierarchy(arrayListOf<ClassLoaderScope>()) { result, scope ->
        result.apply { add(scope) }
    }


private
fun hierarchyOf(classLoader: ClassLoader): ArrayList<ClassLoaderNode> {

     *
     * @throws IllegalStateException if called before {@link #setBaseProjectClassLoaderScope(ClassLoaderScope)}
     */
    ClassLoaderScope baseProjectClassLoaderScope();

    /**
     * @throws IllegalStateException if called more than once
     */
    void setBaseProjectClassLoaderScope(ClassLoaderScope classLoaderScope);

    @Override
    StartParameterInternal getStartParameter();

    }

    /**
     * A string representing the path of this {@link ClassLoaderScope} in the {@link ClassLoaderScope} graph.
     */
    public String getPath() {
        return id.getPath();
    }

    @Override
    public ClassLoaderScope local(ClassPath classPath) {
        return immutable();
    }

    @Override
    public ClassLoaderScope export(ClassPath classPath) {
        return immutable();
    }

    def buildLayoutFactory = Mock(BuildLayoutFactory)
    def settingsScript = Mock(ScriptSource)
    def startParameter = new StartParameterInternal()
    def classLoaderScope = Mock(ClassLoaderScope)
    def settingsProcessor = Mock(SettingsProcessor)
    def buildInCommand = Mock(BuiltInCommand)
    def settingsHandler = new DefaultSettingsLoader(settingsProcessor, buildLayoutFactory, [buildInCommand])

import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.model.ObjectFactory;
import org.gradle.internal.classpath.ClassPath;

import java.util.List;
import java.util.Map;

public interface DependenciesAccessors {
    void generateAccessors(List<VersionCatalogBuilder> builders, ClassLoaderScope classLoaderScope, Settings settings);