@Test
    @Requires(
        IntegTestPreconditions.NotEmbeddedExecutor::class,
        reason = "ktlint plugin issue in embedded mode"
    )
    fun `generated code follows kotlin-dsl coding conventions`() {

        withBuildScript(
            """
            plugins {
                `kotlin-dsl`
                id("org.gradle.kotlin-dsl.ktlint-convention") version "0.9.0"
            }

        project.tasks.getByName(feature.sourceSet.sourcesJarTaskName)
    }

    def "can create multiple features in a project without adding them to a component"() {
        given:
        project.plugins.apply(JavaBasePlugin)
        def ext = project.getExtensions().getByType(JavaPluginExtension)

        SourceSet one = ext.getSourceSets().create("one")

        "png content"             | content.PNG_CONTENT
        "jpg content"             | content.JPG_CONTENT
        "java class file content" | content.CLASS_FILE_CONTENT
    }

    def "always calls delegate when line ending sensitivity is set to DEFAULT"() {
        def file = file('foo') << content.textWithLineEndings('\r\n')
        def delegate = Mock(ResourceHasher)

            assert spec.sourceFiles == files("Person1.java", "Person2.java")
            assert spec.sourceFiles instanceof ImmutableSet
        }
    }

    def "silently excludes source files not ending in .java"() {
        spec.sourceFiles = files("House.scala", "Person1.java", "package.html", "Person2.java")

        when:
        compiler.execute(spec)

        then:
        1 * target.execute(spec) >> {

- **Windows**: C:\Users\[username]\.m2

A publication destined for a Maven repository normally includes:

- One or more artifacts
- The Gradle Module Metadata
- The Maven POM file

Apply the plugin by adding `maven-publish` to the plugins block in `build.gradle(.kts)`:

[.multi-language-sample]
=====
[source, kotlin]
----
plugins {
    // Apply the application plugin to add support for building a CLI application in Java.

====

=== Archives as inputs

It is common for the integration tests to depend on your packaged application.
If this happens to be a zip or tar archive, then adding it as an input to the integration test task may lead to cache misses.

        packDir."$packType"(sourceFile, readonly)

        then:
        succeeds("unpack")
        executedAndNotSkipped(":unpack")
        outputDir.file("A").text == "original"

        when:
        // adding a new file to the archive instead of modifying 'A' because
        // zipTo won't update the zip file if Ant's zip task thinks the files
        // have not changed.
        packDir.file("B").text = "new-file"

        // Windows line endings are made up of two characters,
        // we should see an equal number of lines unless
        // the generator is using the wrong line ending entirely
        // or has generated some lines with one or the other character
        carriageLineEndings == newlineEndings
        windowsLineEndings == newlineEndings
    }

    }

    private static IvyArtifactName ivyArtifact(String name, String type, String ext, String classifier = null) {
        return new DefaultIvyArtifactName(name, type, ext, classifier)
    }

    def "prevents adding artifact without configurations"() {
        def unattached = ivyArtifact("foo", "jar", "ext")
        md.addConfiguration(new Configuration("runtime"))

        when:

        when:
        def allArgs = executer.getAllArgs()

        then:
        !allArgs.contains("--daemon")
        allArgs.contains("--no-daemon")
    }

    def "when --foreground argument is added, it skips adding --daemon/--no-daemon"() {
        when:
        executer.withArgument("--foreground")
        def allArgs = executer.getAllArgs()

        then:
        !allArgs.contains("--daemon")