* limitations under the License.
 */

package org.gradle.api.internal.file.collections;

import com.google.common.collect.ImmutableSet;
import org.gradle.api.Buildable;
import org.gradle.api.Task;
import org.gradle.api.file.DirectoryTree;
import org.gradle.api.internal.file.AbstractOpaqueFileCollection;
import org.gradle.api.internal.file.CompositeFileCollection;

                    return modelName == '${CustomModel2.name}'
                }
                Object buildAll(String modelName, Project project) {
                    return new DefaultCustomModel2();
                }
            }
        """

        if (getTargetVersion() < GradleVersion.version("4.4")) {
            buildFile << """
                class CustomBuilder implements ToolingModelBuilder {

        addBuilderRegisteringPluginImplementation("plugins", "MyModelBuilder")

        settingsFile << """
            includeBuild("plugins")
            rootProject.name = 'root'
        """
        buildFile << """
            plugins {
                id("my.plugin")
            }
        """

        when:
        def model = toolingApi.withConnection() { connection -> connection.getModel(BaseModel) }

import org.junit.Rule

class ParallelActionExecutionCrossVersionSpec extends ToolingApiSpecification {
    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        buildFile << """
            import javax.inject.Inject
            import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
            import org.gradle.tooling.provider.model.ToolingModelBuilder

@ToolingApiVersion(">=8.1")
@Requires(IntegTestPreconditions.NotEmbeddedExecutor)
class ToolchainsParallelActionExecutionCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        buildFile << """
            import javax.inject.Inject
            import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
            import org.gradle.tooling.provider.model.ToolingModelBuilder

            }
        """
    }

    @TargetGradleVersion("=8.6")
    def "Can use problems service in model builder and get problem"() {
        given:
        Assume.assumeTrue(jdk != null)
        buildFile getBuildScriptSampleContent(false, false, targetVersion)
        def listener = new ProblemProgressListener()

        when:
        withConnection {
            it.model(CustomModel)

        failure.assertHasDescription("Could not compile build file '${buildFile}'.")
                .assertThatCause(containsString("build file '$buildFile': 3: unable to resolve class org.gradle.unknown.Unknown"))
                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(3)
    }

    def "produces reasonable error message when buildFile evaluation fails with exception"() {
        when:

        fixture.assertStateLoaded()
    }

    TestFile customType(TestFile dir) {
        def buildFile = dir.file("build.gradle")
        taskTypeWithInputFileCollection(buildFile)
        buildFile << """
            println "configuring project \$project.path"
            configurations {
                implementation {

        validateCompilationProblem(problems, buildFile)
        problems[0].failure.failure.message == "Could not compile build file '$buildFile.absolutePath'."
    }

    static void validateCompilationProblem(List<ProblemEvent> problems, TestFile buildFile) {
        problems.size() == 1
        problems[0].label.label == "Could not compile build file '$buildFile.absolutePath'."

        failure.assertHasCause("Task with name 'task1' not found")
    }

    def "fails to create custom task if constructor arguments are missing"() {
        given:
        buildFile << CUSTOM_TASK_WITH_CONSTRUCTOR_ARGS
        buildFile << "tasks.register('myTask', CustomTask, 'hello')"

        when:
        fails 'myTask'

        then:
        failure.assertHasCause("Could not create task ':myTask'.")