useJavadocAndSourceJars()
        publishing {
            publications {
                maven(MavenPublication) {
                    from components.java
                    artifact sourcesJar
                    artifact javadocJar
                }
            }
        }
    }

    def "publication added to container after signing is specified"() {
        given:
        def signTasks = []

    id("gradlebuild.publish-public-libraries")
    id("gradlebuild.shaded-jar")
}

description = "Gradle Tooling API - the programmatic API to invoke Gradle"

gradlebuildJava.usedInToolingApi()

tasks.named<Jar>("sourcesJar") {
    // duplicate package-info.java because of split packages
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

shadedJar {
    shadedConfiguration.exclude(mapOf("group" to "org.slf4j", "module" to "slf4j-api"))

        useJavadocAndSourceJars()
        configurations {
            meta
            produced.extendsFrom meta, archives
        }
        
        artifacts {
            meta javadocJar, sourcesJar
        }
    }
        
    def "sign configuration with defaults"() {
        when:
        signing {
            sign configurations.archives, configurations.meta
        }

        then:

                compileOnly project(":annotation")
                annotationProcessor project(":processor")
            }
            task sourcesJar(type: Jar) {
                from sourceSets.main.output.generatedSourcesDirs
            }
        """

        expect:
        succeeds "sourcesJar"
        executed(":compileJava")
    }

    def "can model annotation processor arguments"() {
        buildFile << """

        } else {
            javaPluginConfig + """
                configurations {
                    $configurationName
                }

                artifacts {
                    $configurationName sourcesJar, javadocJar
                }
            """
        }
    }

    TestFile m2RepoFile(String name) {
        file("build", "m2Repo", "sign", artifactId, version, name)
    }

        buildFile << """
            ${keyInfo.addAsPropertiesScript()}
            ${javadocAndSourceJarsScript}

            signing {
                ${signingConfiguration()}
                sign jar, javadocJar, sourcesJar
            }
        """

        when:
        run "signJar", "signJavadocJar", "signSourcesJar"

        then:
        executedAndNotSkipped(":signJar", ":signJavadocJar", ":signSourcesJar")

            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.DOCUMENTATION))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("gradle-source-folders"))
        }
    }
    tasks.named<Jar>("sourcesJar") {
        from(sourcesPath.incoming.artifactView { lenient(true) }.files)
    }
    val sourcesElements by configurations
    sourcesElements.attributes {

        failure.assertHasCause("There were failing tests.")
    }

    def 'sourcesJar'() {
        def rootBuildFile = dslFixtureFor(scriptDsl).getBuildFile()

        when: 'build is initialized'
        run 'init', '--dsl', scriptDsl.id as String

        then: 'sourcesJar task configuration is generated'
        rootBuildFile.text.contains(TextUtil.toPlatformLineSeparators('''

    @Override
    public String getJavadocJarTaskName() {
        return getTaskName(null, "javadocJar");
    }

    @Override
    public String getSourcesJarTaskName() {
        return getTaskName(null, "sourcesJar");
    }

    @Override
    public String getTaskName(@Nullable String verb, @Nullable String target) {
        return namingScheme.getTaskName(verb, target);
    }

This JAR is also automatically built by the `assemble` task.
Furthermore, the plugin can be configured to provide the `javadocJar` and `sourcesJar` tasks to package Javadoc and source code if so desired.
If a publishing plugin is used, these tasks will automatically run during publishing or can be called directly.

.Configure a project to publish Javadoc and sources