}

    def "archiveFileName with empty extension"() {
        when:
        archiveTask.archiveExtension.set(null)

        then:
        archiveTask.archiveFileName.get() == 'testbasename-testappendix-1.0-src'
    }

    def "archiveFileName with empty extension in provider"() {
        when:
        archiveTask.archiveExtension.set(project.provider { null })

        then:

                <td><literal><replaceable>${archiveBaseName}</replaceable>-<replaceable>${archiveAppendix}</replaceable>-<replaceable>${archiveVersion}</replaceable>-<replaceable>${archiveClassifier}</replaceable>.<replaceable>${archiveExtension}</replaceable></literal></td>
            </tr>
            <tr>
                <td>archiveFile</td>

        tar.compression == Compression.NONE
        tar.archiveExtension.get() == 'tar'
    }

    def "compression determines default extension"() {
        when:
        tar.compression = Compression.GZIP

        then:
        tar.archiveExtension.get() == 'tgz'

        when:
        tar.compression = Compression.BZIP2

        then:
        tar.archiveExtension.get() == 'tbz2'

        when:

        def archive = rootProject.task('foo', type: Zip, {})
        archive.archiveBaseName.set("baseName")
        archive.destinationDirectory.set(temporaryFolder.testDirectory)
        archive.archiveExtension.set(archiveExtension)
        archive.archiveClassifier.set(archiveClassifier)

        MavenArtifact mavenArtifact = parser.parseNotation(archive)

        then:
        mavenArtifact.extension == artifactExtension

    private final Property<String> archiveBaseName;
    private final Property<String> archiveAppendix;
    private final Property<String> archiveVersion;
    private final Property<String> archiveExtension;
    private final Property<String> archiveClassifier;
    private final Property<Boolean> archivePreserveFileTimestamps;
    private final Property<Boolean> archiveReproducibleFileOrder;

    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        zip
    }

    def "test Zip"() {
        given:
        zip = createTask(Zip)

        expect:
        zip.archiveExtension.get() == Zip.ZIP_EXTENSION
        checkConstructor()
    }

        new ArchivePublishArtifact(taskDependencyFactory, withAppendixOnly).name == "javadoc"
    }

    static class DummyJar extends AbstractArchiveTask {
        DummyJar() {
            archiveExtension.set("jar")
        }

        protected CopyAction createCopyAction() {
            return null
        }
    }

        given:
        createBuildScripts "foo"
        buildFile << """
            configurations {
                jar.archiveExtension.set('foo')
            }
        """

        when:
        succeeds "publish"

        then:
        javaLibrary.assertPublished('foo', 'foo')

        war = createTask(War)
        configure(war)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        war
    }

    def "test War"() {
        expect:
        war.archiveExtension.get() == War.WAR_EXTENSION
    }

    def "can configure WEB-INF CopySpec using an Action"() {
        given:
        war.webInf({ CopySpec spec ->
            spec.from temporaryFolder.createFile('file.txt')

        jar = createTask(Jar)
        configure(jar)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        jar
    }

    def "test Jar"() {
        expect:
        jar.archiveExtension.get() == Jar.DEFAULT_EXTENSION
        jar.manifest != null
        jar.metaInf != null
    }

    def "correct jar manifest"() {
        when:
        jar.manifest = new DefaultManifest(null)