import static org.hamcrest.CoreMatchers.startsWith

class ObjectFactoryNamedTypeIntegrationTest extends AbstractIntegrationSpec {
    def "plugin can create named instances of interface using injected factory"() {
        buildFile """
            interface Thing extends Named { }

            class CustomPlugin implements Plugin<Project> {
                ObjectFactory objects

                @javax.inject.Inject

        given:
        buildFile << """
            task disabledTask {
                enabled = false
            }
        """

        when:
        runBuild('disabledTask')

        then:
        taskSkippedResult(':disabledTask')
    }

    def "reports execution reason for executed task without declared outputs"() {
        given:
        buildFile << """
            task helloWorld {

        given:
        settingsFile << """
            include('a')
            include('b')
        """
        withSomeToolingModelBuilderPluginInBuildSrc()
        buildFile << """
            allprojects {
                plugins.apply('java-library')
            }
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI)

        when:
        buildFile.text = """
            buildscript {
                repositories { maven { url "${mavenRemote.uri}" } }
                dependencies { classpath "$artifactCoordinates" }
            }
        """

        then:
        run("help")

        when:
        buildFile.text = """
            buildscript {

                    out.write("\\n");
                }
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        """)


        buildFile.text = """
            apply plugin: "java"

            task run(type: JavaExec) {
                classpath = project.layout.files(compileJava)
                mainClass = "driver.Driver"
                args "1"

            connection.getModel(ProjectPublications)
        }

        then:
        publications.publications.empty
    }

    def "project without any configured publications"() {
        buildFile << "apply plugin: 'java'"

        when:
        ProjectPublications publications = withConnection { connection ->
            connection.getModel(ProjectPublications)
        }

        then:

    public final Kind kind
    public final TestFile buildFile

    BuildLogicChangeFixture(TestFile projectDir, Language language = Language.JAVA, Kind kind = Kind.CHANGE_SOURCE) {
        this.projectDir = projectDir
        this.language = language
        this.kind = kind
        this.buildFile = file("build.gradle.kts")
    }

    void setup() {
        buildFile << kotlinDslScriptForLanguage
        buildFile << """

        Assume.assumeNotNull(target)
        withJavaProjectUsingToolchainsForJavaVersion(target)
    }

    def withJavaProjectUsingToolchainsForJavaVersion(Jvm jvm) {
        buildFile << """
            apply plugin: 'java'
            ${mavenCentralRepository()}
            java {
                toolchain {
                    languageVersion = JavaLanguageVersion.of(${jvm.javaVersion.majorVersion})

    def "input files properties are sensitive to line endings by default (#api, #pathsensitivity)"() {
        createTaskWithNormalization(InputFiles, LineEndingSensitivity.DEFAULT, pathsensitivity, api)

        buildFile << """
            taskWithInputs {
                sources.from(project.files("foo"))
                outputFile = project.file("\${buildDir}/output.txt")
            }
        """

class ConfigurationCacheJavaSerializationIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "restores task fields whose value is Serializable and has writeReplace method"() {
        buildFile << """
            class Placeholder implements Serializable {
                String value

                private Object readResolve() {
                    return new OtherBean(prop: "[\$value]")
                }