* limitations under the License.
 */

package org.gradle.plugin.use.internal;

import org.gradle.internal.classpath.ClassPath;

public class InjectedPluginClasspath {

    private final ClassPath classPath;

    public InjectedPluginClasspath(ClassPath classPath) {
        this.classPath = classPath;
    }

    public ClassPath getClasspath() {
        return classPath;
    }

        for (GradleModuleServices services : servicesProviders) {
            services.registerBuildSessionServices(registration);
        }
        registration.add(InjectedPluginClasspath.class, new InjectedPluginClasspath(injectedPluginClassPath));
        registration.add(BuildCancellationToken.class, buildCancellationToken);
        registration.add(BuildRequestMetaData.class, buildRequestMetaData);

            + ", useDaemon=" + useDaemon
            + ", injectedPluginClasspath=" + injectedPluginClasspath
            + '}';
    }

    @Override
    public boolean isUseDaemon() {
        return useDaemon;
    }

    @Override
    public ClassPath getInjectedPluginClasspath() {
        return injectedPluginClasspath;
    }

            stdin = operationParameters.stdin;
            colorOutput = operationParameters.colorOutput;
            javaHome = operationParameters.javaHome;
            injectedPluginClasspath = operationParameters.injectedPluginClasspath;
            systemProperties = operationParameters.systemProperties;
        }
    }

    private final String entryPointName;

            PluginInspector pluginInspector,
            InjectedPluginClasspath injectedPluginClasspath,
            ScriptClassPathResolver scriptClassPathResolver,
            FileCollectionFactory fileCollectionFactory,
            InjectedClasspathInstrumentationStrategy instrumentationStrategy
        ) {
            if (injectedPluginClasspath.getClasspath().isEmpty()) {

        when:
        builder.tasks = tasks
        builder.injectedPluginClasspath = classpath
        def params = builder.build()

        then:
        params.tasks == tasks
        params.injectedPluginClasspath == classpath.asFiles
        params.launchables == null
    }

    def "launchables from provider"() {
        when:

                             StartParameterInternal startParameter,
                             BuildRequestMetaData requestMetaData,
                             ClassPath injectedPluginClassPath,
                             BuildCancellationToken buildCancellationToken,
                             BuildClientMetaData buildClientMetaData,
                             BuildEventConsumer buildEventConsumer) {

        def producer = producer(providerVersion)
        producer.produceModel(Void, ConsumerOperationParameters.builder().with {
            entryPoint = "foo"
            if (injectedClasspath) {
                injectedPluginClasspath = DefaultClassPath.of(new File("foo"))
            }
            build()
        })
    }

    ModelProducer producer(String providerVersion) {