}
            this.root = projectNode(projectPath, moduleVersion)
            cl.resolveStrategy = Closure.DELEGATE_ONLY
            cl.delegate = this.root
            cl.call()
            return this.root
        }

        private NodeBuilder projectNode(String projectIdentityPath, String moduleVersion) {

        readLinkedResources();
        readResourceFilters();
    }

    private void readReferencedProjects() {
        for (Node projectNode : getChildren(findFirstChildNamed(getXml(), "projects"), "project")) {
            referencedProjects.add(projectNode.text());
        }
    }

    private void readNatures() {
        for (Node natureNode : getChildren(findFirstChildNamed(getXml(), "natures"), "nature")) {

 * limitations under the License.
 */

package org.gradle.tooling.model;

/**
 * Represents a model that is associated with some Gradle project.
 *
 * @since 3.0
 */
public interface ProjectModel {
    /**
     * Returns the identifier for the project that this model is associated with.
     */
    ProjectIdentifier getProjectIdentifier();

        and:
        projectLocator.resolveProjectModel("other") >> projectModel
        projectModel.find("components", modelMap(NativeLibrarySpec)) >> null

        then:
        locator.getBinaries(requirement) == null
    }

    private void findLibraryInProject() {
        def libraries = findLibraryContainer(projectModel)
        libraries.containsKey("libName") >> true

    @Override
    public Collection<VariantComponent> resolveCandidates(ModelRegistry projectModel, String libraryName) {
        List<VariantComponent> librarySpecs = new ArrayList<>();
        collectLocalComponents(projectModel, "components", librarySpecs);
        collectLocalComponents(projectModel, "testSuites", librarySpecs);
        if (librarySpecs.isEmpty()) {
            return Collections.emptyList();
        }

    private EclipseProject projectModel;

    public GenerateEclipseProject() {
        getXmlTransformer().setIndentation("\t");
        projectModel = getInstantiator().newInstance(EclipseProject.class, new XmlFileContentMerger(getXmlTransformer()));
    }

    @Inject
    public GenerateEclipseProject(EclipseProject projectModel) {
        this.projectModel = projectModel;
    }

    @Override

        executer.withArguments(ENABLE_CLI)
        def projectModel = fetchModel(GradleProject)

        then:
        fixture.assertStateStored {
            modelsCreated(":", GradleProject, IsolatedGradleProjectInternal)
            modelsCreated(IsolatedGradleProjectInternal, ":lib1", ":lib1:lib11")
        }

        checkGradleProject(projectModel, expectedProjectModel)

        IdeaProject projectModel = ideaModel.getProject();
        JavaVersion projectSourceLanguageLevel = IdeaModuleBuilderSupport.convertToJavaVersion(projectModel.getLanguageLevel());
        JavaVersion projectTargetBytecodeLevel = projectModel.getTargetBytecodeVersion();

        DefaultIdeaProject out = new DefaultIdeaProject()
            .setName(projectModel.getName())

    private void configureEclipseProject(final ProjectInternal project, final EclipseModel model) {
        final EclipseProject projectModel = model.getProject();

        projectModel.setName(uniqueProjectNameProvider.getUniqueName(project));

        final ConventionMapping convention = ((IConventionAware) projectModel).getConventionMapping();
        convention.map("comment", new Callable<String>() {
            @Override

class KotlinStandaloneModificationTrackerFactory : KotlinModificationTrackerFactory() {
    private val projectWide = SimpleModificationTracker()
    private val librariesWide = SimpleModificationTracker()

    override fun createProjectWideOutOfBlockModificationTracker(): ModificationTracker {
        return projectWide
    }

    override fun createLibrariesWideModificationTracker(): ModificationTracker {