}

  @Test
  @TestMetadata("ScriptArgument.kts")
  public void testScriptArgument() {
    runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/ScriptArgument.kts");
  }

  @Test
  @TestMetadata("ScriptResult.kts")

    private final resolver = TestFiles.pathToFileResolver(tmpDir.testDirectory)
    private final fileCollectionFactory = TestFiles.fileCollectionFactory(tmpDir.testDirectory)
    private DefaultJavaForkOptions options

    def setup() {
        options = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())
    }

    FileResolver resolver = Mock()
    DomainObjectContext context = Mock()
    FileResourceListener listener = Mock()
    RegularFileProperty lockFile = TestFiles.filePropertyFactory().newFileProperty()

    def setup() {
        context.identityPath(_) >> { String value -> Path.path(value) }
        resolver.canResolveRelativePath() >> true

        given:
        def repo1 = addRepo1()
        def repo2 = Mock(ModuleComponentRepository)
        resolver.add(repo2)
        def repo3 = Mock(ModuleComponentRepository)
        resolver.add(repo3)

        when:
        resolver.resolve(moduleComponentId, componentRequestMetaData, result)

        then:

            this.resolver = resolver;
            this.patternSetFactory = patternSetFactory;
            this.taskDependencyFactory = taskDependencyFactory;
            setFrom(owner, resolver, patternSetFactory, taskDependencyFactory, propertyHost, item);
        }

    }

    @Test public void testResolveUriObjectToUri() {
        URI uri = new URI("http://www.gradle.org")
        assertEquals(uri, baseDirConverter.resolveUri(uri))
    }

    @Test public void testResolveUrlObjectToUri() {
        assertEquals(new URI("http://www.gradle.org"), baseDirConverter.resolveUri(new URL("http://www.gradle.org")))
    }

        private final PathToFileResolver resolver;

        ResolvingRegularFileTransform(PathToFileResolver resolver) {
            this.resolver = resolver;
        }

        @Override
        public RegularFile transform(CharSequence path) {
            return new FixedFile(resolver.resolve(path));
        }
    }

====

In general, when applying toolchain resolver plugins, the toolchain download resolvers provided by them also need to be configured.
Let's illustrate with an example.
Consider two toolchain resolver plugins applied by the build:

* One is the Foojay plugin mentioned above, which downloads toolchains via the `FoojayToolchainResolver` it provides.
* The other contains a **FICTITIOUS** resolver named `MadeUpResolver`.

    }

    /**
     * Returns a resolver with no base directory.
     */
    public static FileResolver resolver() {
        return FILE_LOOKUP.getFileResolver();
    }

    /**
     * Returns a resolver with no base directory.
     */
    public static PathToFileResolver pathToFileResolver() {

        project.displayName >> "<project>"
        projects.stateFor(project.identityPath) >> project.owner
    }

    def resolver = new DefaultProjectDependencyPublicationResolver(registry, projectConfigurer, projects)

    def "resolving component configures project"() {
        when:
        resolver.resolveComponent(ModuleVersionIdentifier, project.identityPath)

        then: