return Stub(c)
        }
    }

    def "no dependencies test"() {
        applyPluginToProjects()
        project.apply(plugin: 'java')

        def module = project.ideaModule.module // Mock(IdeaModule)
        module.offline = true

        when:
        def result = dependenciesProvider.provide(module)

        then:
        result.isEmpty()
    }

 * <p>
 * See the examples in docs for {@link IdeaModule} or {@link IdeaProject}.
 */
public abstract class IdeaModel {

    private IdeaModule module;
    private IdeaProject project;
    private IdeaWorkspace workspace;
    private String targetVersion;

    /**
     * Configures IDEA module information. <p> For examples see docs for {@link IdeaModule}.
     */
    public IdeaModule getModule() {
        return module;
    }

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import org.gradle.tooling.model.idea.IdeaContentRoot
import org.gradle.tooling.model.idea.IdeaModule
import org.gradle.tooling.model.idea.IdeaProject

/**
 * NOTE: Starting with Gradle 5.0 the contract of IdeaModule#sourceDirs and IdeaModule#testSourceDirs changes in
 * a way that the resource directories are excluded.
 */
@TargetGradleVersion(">=5.0")

        def module = TestUtil.newInstance(IdeaModule, moduleProject, iml)
        expect:
        module.languageLevel == null
    }

    def "target bytecode version is null for non java projects"() {
        given:
        project.getPlugins().apply(JavaPlugin)
        project.getPlugins().apply(IdeaPlugin)
        def iml = Mock(IdeaModuleIml)
        def module = TestUtil.newInstance(IdeaModule, moduleProject, iml)
        expect:

 */
@DisableCachingByDefault(because = "Not made cacheable, yet")
public abstract class GenerateIdeaModule extends XmlGeneratorTask<Module> {

    private IdeaModule module;

    public GenerateIdeaModule() {}

    @Inject
    public GenerateIdeaModule(IdeaModule module) {
        this.module = module;
    }

    @Override
    protected Module create() {

        assert childProject.idea.module.name == "child"
        def existingOutputFolder = childProject.ideaModule.outputFile.parentFile

        when:
        childProject.idea.module.name = "foo"

        then:
        childProject.idea.module.name == "foo"
        childProject.ideaModule.outputFile.name == "foo.iml"
        childProject.ideaModule.outputFile.parentFile == existingOutputFolder
    }

    private applyPluginToProjects() {

        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);
        visit(eclipseProject, controller, new HashMap<String, CustomModel>());

        // Use a GradleProject to reference a project

            final IdeaModule ideaModule = scalaProject.getExtensions().getByType(IdeaModel.class).getModule();
            final Iterable<File> files = getIdeaModuleLibraryDependenciesAsFiles(ideaModule);
            ProjectLibrary library = ((ProjectInternal) scalaProject).getOwner().fromMutableState(p -> createScalaSdkLibrary(scalaProject, files, useScalaSdk, ideaModule));
            if (library != null) {

                }
            }
"""

        def ideaModule = loadToolingModel(IdeaProject).modules[0]

        then:
        ideaModule.dependencies.size() == 2
        ideaModule.dependencies.any { it instanceof IdeaModuleDependency && it.targetModuleName == "b1-renamed" }
        ideaModule.dependencies.any { it instanceof IdeaModuleDependency && it.targetModuleName == "b2-renamed" }

    }

 */

package org.gradle.tooling.internal.consumer.converters;

import org.gradle.tooling.model.idea.IdeaModule;
import org.gradle.tooling.model.idea.IdeaModuleDependency;

/**
 * This is used for compatibility with clients <2.14
 */
public interface BackwardsCompatibleIdeaModuleDependency extends IdeaModuleDependency {
    IdeaModule getDependencyModule();