import org.gradle.test.fixtures.file.TestFile
import org.gradle.tooling.model.eclipse.EclipseProject
import org.gradle.tooling.model.idea.IdeaModuleDependency
import org.gradle.tooling.model.idea.IdeaProject

/**
 * Dependency substitution is performed for models in a composite build
 */
@TargetGradleVersion(">=3.1")

}
"""
        file('settings.gradle').text = """
        rootProject.name = "root"
        include 'api', 'impl', 'contrib:api', 'contrib:impl'"""

        when:

        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }

        then:
        def allNames = project.modules*.name
        allNames.unique().size() == 6

        IdeaModule impl = project.modules.find { it.name == 'root-impl' }

 * Models the generation/parsing/merging capabilities.
 * Adds XML-related hooks.
 * <p>
 * For examples see docs for {@link org.gradle.plugins.ide.eclipse.model.EclipseProject}
 * or {@link org.gradle.plugins.ide.idea.model.IdeaProject} and others.
 */
public class XmlFileContentMerger extends FileContentMerger {

    private XmlTransformer xmlTransformer;

    public XmlFileContentMerger(XmlTransformer xmlTransformer) {

import org.gradle.tooling.model.idea.IdeaProject;
import org.gradle.tooling.model.kotlin.dsl.KotlinDslScriptsModel;

public class KotlinIdeaModelBuildAction implements BuildAction<Object> {

    @Override
    public Object execute(BuildController controller) {
        controller.getModel(KotlinDslScriptsModel.class);
        controller.getModel(IdeaProject.class);
        return null;
    }

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

import gradlebuild.basics.repoRoot
import org.gradle.plugins.ide.idea.model.IdeaProject
import org.jetbrains.gradle.ext.CopyrightConfiguration
import org.jetbrains.gradle.ext.ProjectSettings
import org.jetbrains.gradle.ext.Remote
import org.jetbrains.gradle.ext.RunConfiguration

plugins {

                    ${implementationConfiguration} project(':b')
                }
            }
        """

        when:
        def ideaProject = withConnection {
            action(new FetchIdeaProject()).run()
        }

        then:
        def moduleA = ideaProject.modules.find { it.name == 'a'}
        moduleA.dependencies[0].targetModuleName == 'b'
    }

    def "Applies gradle project identifier mapping"() {

import org.gradle.tooling.model.eclipse.HierarchicalEclipseProject
import org.gradle.tooling.model.gradle.GradleBuild
import org.gradle.tooling.model.idea.BasicIdeaProject
import org.gradle.tooling.model.idea.IdeaProject
import spock.lang.Specification

class ModelMappingTest extends Specification {
    final mapping = new ModelMapping()

    def "maps model type to version it was added in"() {
        expect:

import org.gradle.plugins.ide.api.XmlFileContentMerger;
import org.gradle.plugins.ide.idea.model.IdeaLanguageLevel;
import org.gradle.plugins.ide.idea.model.IdeaProject;

import javax.annotation.Nullable;
import javax.inject.Inject;

@NonNullApi
public abstract class IdeaProjectInternal extends IdeaProject {

    @Inject
    public IdeaProjectInternal(Project project, XmlFileContentMerger ipr) {
        super(project, ipr);
    }

                    <td>Default with <literal>idea</literal> and <literal>java</literal> plugin</td>
                </tr>
            </thead>
            <tr>
                <td>ideaProject</td>
                <td><literal>project.idea.project</literal></td>
                <td/>
            </tr>
            <tr>
                <td>outputFile</td>

import org.gradle.tooling.model.gradle.BasicGradleProject;
import org.gradle.tooling.model.gradle.GradleBuild;
import org.gradle.tooling.model.idea.IdeaDependency;
import org.gradle.tooling.model.idea.IdeaProject;

public class HasCompatibilityMapping {

    public <T> ViewBuilder<T> applyCompatibilityMapping(ViewBuilder<T> viewBuilder, ConsumerOperationParameters parameters) {