pluginClasspath.setFrom(sourceSets.main.runtimeClasspath)
                outputDirectory = file('build/some/other')
            }
        """

        when:
        succeeds TASK_NAME

        then:
        file("build/some/other/$METADATA_FILE_NAME").exists()
    }

    def "not up-to-date if pluginClasspath change"() {
        given:
        buildFile << """

                File buildFile
                List<File> pluginClasspath

                def setup() {
                    new File(testProjectDir, 'settings.gradle') << "rootProject.name = 'test'"
                    buildFile = new File(testProjectDir, 'build.gradle')
                    pluginClasspath = getClass().classLoader.getResource("plugin-classpath.txt")
                      .readLines()

        testKitDir = file("test-kit")
        def executer = new TestKitBackedGradleExecuter(distribution, temporaryFolder, getBuildContext(), testKitDir)
        jar = file("plugins/sneaky.jar")
        executer.pluginClasspath.add(jar)
        return executer
    }

    def cleanup() {
        DaemonLogsAnalyzer.newAnalyzer(testKitDir.file(ToolingApiGradleExecutor.TEST_KIT_DAEMON_DIR_NAME)).killAll()
    }

    @Override

        runner.pluginClasspath == originalClasspath

        when:
        originalArguments << 'arg5'
        originalJvmArguments << 'arg6'
        originalClasspath << new File('file:///Users/foo/bar/other.jar')

        then:
        runner.arguments == ['arg1', 'arg2']
        runner.jvmArguments == ['arg3', 'arg4']
        runner.pluginClasspath == [new File('/Users/foo/bar/test.jar').absoluteFile]

    private final ConfigurableFileCollection pluginClasspath = getProject().files();
    private final DirectoryProperty outputDirectory = getProject().getObjects().directoryProperty();

    /**
     * The code under test. Defaults to {@code sourceSets.main.runtimeClasspath}.
     */
    @Classpath
    public ConfigurableFileCollection getPluginClasspath() {
        return pluginClasspath;
    }

    /**

            project.getTasks().withType(Test.class).configureEach(test -> {
                test.getInputs()
                    .files(pluginClasspathTask.get().getPluginClasspath())
                    .withPropertyName("pluginClasspath")
                    .withNormalizer(ClasspathNormalizer.class);

                test.getJvmArgumentProviders().add(new AddOpensCommandLineArgumentProvider(test));
            });

    abstract val coreClasspath: ConfigurableFileCollection

    @Input
    val core = coreClasspath.toGradleModuleNameProvider()

    @get:Internal
    abstract val pluginsClasspath: ConfigurableFileCollection

    @Input
    val plugins = pluginsClasspath.toGradleModuleNameProvider()

    @get:OutputFile
    abstract val manifestFile: RegularFileProperty

    @TaskAction
    fun generate() {

fun pluginsManifestTask(runtimeClasspath: Configuration, coreRuntimeClasspath: Configuration, api: GradleModuleApiAttribute) =
    tasks.registering(PluginsManifest::class) {
        pluginsClasspath.from(
            runtimeClasspath.incoming.artifactView {
                lenient(true)
                attributes.attribute(GradleModuleApiAttribute.attribute, api)
            }.files
        )