if (host instanceof final StandardHost standardHost) {
                standardHost.setErrorReportValveClass(SuppressErrorReportValve.class.getName());
            }
        }).useTldDetect(jarName -> (jarName.contains("jstl") || jarName.contains("lasta-taglib"))).asDevelopment(isNoneEnv()).bootAwait();
    }

    public static void shutdown(final String[] args) {
        System.exit(0);
    }

        this.resolver = resolver;
        addGradleLibsRepository();
    }

    @Override
    public File resolveLocalGroovySources(String jarName) {
        Matcher matcher = FILE_NAME_PATTERN.matcher(jarName);
        if (!matcher.matches()) {
            return null;
        }
        VersionNumber version = VersionNumber.parse(matcher.group(3));

        return component."wb-module".property.collectEntries { [(it.@name) : it.@value] }
    }

    WbModule lib(String jarName) {
        def module = modules.find {
            def handle = it.node.@handle
            return handle.startsWith('module:/classpath/') && handle.endsWith(jarName)
        }
        assert module != null
        assert module.node."dependency-type"*.text() == ['uses']
        return module
    }

            substitute module("org.gradle:module2:1.0") using project(":project1")
        }
    }
}
""")

        def classpath = classpath("project2")
        assert classpath.libs*.jarName == ["module1-1.0.jar"]
        assert classpath.projects.collect { it.name } == ["project1"]
    }


    @Test
    @ToBeFixedForConfigurationCache
    void "project dependency substituted with external dependency"() {

    public static final GradleApiSourcesResolver INSTANCE = new NullGradleApiSourcesResolver();

    private NullGradleApiSourcesResolver() {
    }

    @Override
    public File resolveLocalGroovySources(String jarName) {
        return null;
    }

 * limitations under the License.
 */

package org.gradle.plugins.ide.internal.resolver;

import java.io.File;

public interface GradleApiSourcesResolver {
    File resolveLocalGroovySources(String jarName);

    <nature>org.eclipse.jdt.core.javanature</nature>
  </natures>
</projectDescription>
"""
    }

    private String getDotClasspathText(String jarName) {
        """<?xml version="1.0" encoding="UTF-8"?>
<classpath>
  <classpathentry exported="true" kind="lib" path="${jarName}"/>
  <classpathentry kind="output" path="bin"/>
</classpath>
"""
    }

    }

    private Set<String> output(String docsType) {
        file("a/build/$docsType").listFiles().collect { it.name } as Set
    }

    private ZipTestFixture jar(String jarName) {
        new ZipTestFixture(file("a/build/$jarName"))
    }

    private void subproject(String name, @DelegatesTo(value=FileTreeBuilder, strategy = Closure.DELEGATE_FIRST) Closure<Void> config) {

        def classpath = EclipseClasspathFixture.create(testDirectory, executer.gradleUserHomeDir)
        def libs = classpath.libs
        def apiLibs = libs.findAll { l ->
            l.jarName.startsWith(apiJarPrefix)
        }
        assert apiLibs.size() == 1 : "gradle API jar not found"
        return apiLibs.get(0)
    }

    void ideFileContainsNoSourcesAndJavadocEntry() {

        assertEquals("java.lang.String", pc.getAttribute("implementation"));

        Parameter mp = md.getParameters().get(0);

        assertEquals("finalName", mp.getName());
        assertEquals("jarName", mp.getAlias());
        assertEquals("java.lang.String", mp.getType());
        assertEquals("java.lang.String", mp.getImplementation());
        assertTrue(mp.isEditable());
        assertFalse(mp.isRequired());