* Model name to find the underlying builder is derived from the binary name of the {@code modelType}.
     */
    default <T> List<T> getModels(Project requester, List<Project> targets, Class<T> modelType, @Nullable Object parameter) {
        return getModels(requester, targets, modelType.getName(), modelType, parameter);
    }

    /**
     * Applies a plugin of a given type to the given projects.
     */

        ToolingModelParameterCarrier carrier = parameter == null ? null : parameterCarrierFactory.createCarrier(parameter);
        return buildState.withToolingModels(controller -> getModels(controller, targets, modelName, carrier));
    }

    private List<Object> getModels(BuildToolingModelController controller, List<Project> targets, String modelName, @Nullable ToolingModelParameterCarrier parameter) {

    }

    private List<IsolatedGradleProjectInternal> getIsolatedModels(Project root, Collection<Project> projects, IsolatedGradleProjectParameter parameter) {
        return intermediateToolingModelProvider
            .getModels(root, new ArrayList<>(projects), IsolatedGradleProjectInternal.class, parameter);
    }

    private static DefaultGradleProject buildWithoutChildren(ProjectInternal project, IsolatedGradleProjectInternal isolatedModel) {

    }

    private List<IsolatedIdeaModuleInternal> getIsolatedIdeaModules(Project rootProject, List<Project> allProjects, IdeaModelParameter parameter) {
        return intermediateToolingModelProvider
            .getModels(rootProject, allProjects, IsolatedIdeaModuleInternal.class, parameter);
    }

    private static List<DefaultIdeaModule> createIdeaModules(
        DefaultIdeaProject parent,

    visit(rootProject)

    return outputModels
}


private
fun IntermediateToolingModelProvider.getIsolatedModels(requester: Project, targets: List<Project>): List<IsolatedScriptsModel> =
    getModels(requester, targets, IsolatedScriptsModel::class.java, null)


private
fun buildOutputModel(base: ScriptModelBase, model: IntermediateScriptModel): StandardKotlinDslScriptModel {

        _ * modelController.locateBuilderForTarget(projectState, "some.model", false) >> modelScope
        _ * modelScope.getModel("some.model", null) >> model

        when:
        def result = controller.getModel(target, modelId)

        then:
        result.getModel() == model
    }

    def "uses builder for specified build"() {
        def rootDir = new File("dummy")

    }

    @Override
    public <T> T getModel(Class<T> modelType) throws UnknownModelException {
        return getModel(null, modelType);
    }

    @Override
    public <T> T findModel(Class<T> modelType) {
        return findModel(null, modelType);
    }

    @Override
    public GradleBuild getBuildModel() {
        return getModel(null, GradleBuild.class);
    }

    @Override

        if ((groupId == null) && (getModel().getParent() != null)) {
            groupId = getModel().getParent().getGroupId();
        }

        return groupId;
    }

    public void setArtifactId(String artifactId) {
        getModel().setArtifactId(artifactId);
    }

    public String getArtifactId() {
        return getModel().getArtifactId();
    }

        IdeaProject ideaProject = controller.getModel(IdeaProject.class);
        for (IdeaModule ideaModule : ideaProject.getModules()) {
            visit(ideaModule, controller, new HashMap<String, CustomModel>());
        }

        // Use an EclipseProject to reference a project
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);

        def model = new Object()
        def modelType = Object
        def buildResult = Stub(BuildResult) {
            getModel() >> model
        }

        when:
        def result = controller.getModel(null, modelType, null, null)

        then:
        1 * delegate.getModel(null, {it.name == Object.name}) >> buildResult
        0 * delegate._

        and:
        result == model
    }