archiveBaseName = 'b-foo'
                }
                task foo2Jar(type: Jar) {
                   archiveBaseName = 'b-foo2'
                }
                task foo3Jar(type: Jar) {
                   archiveBaseName = 'b-foo3'
                }
                task barJar(type: Jar) {
                   archiveBaseName = 'b-bar'
                }

configurations.compile.attributes.attribute(flavor, 'preview')

project(':a') {
    dependencies.attributesSchema.attribute(flavor).compatibilityRules.add(OneRule)
    task oneJar(type: Jar) { archiveBaseName = 'a1' }
    task twoJar(type: Jar) { archiveBaseName = 'a2' }
    tasks.withType(Jar) { destinationDirectory = buildDir }
    configurations {
        compile {
            attributes.attribute(buildType, 'debug')
            outgoing {

project(':a') {
    apply plugin: 'base'
    configurations {
        configA1
        configA2
    }
    task A1jar(type: Jar) {
        archiveBaseName = 'A1'
    }
    task A2jar(type: Jar) {
        archiveBaseName = 'A2'
    }
    artifacts {
        configA1 A1jar
        configA2 A2jar
    }
}

project(':b') {
    configurations {
        configB1

            Attributes.Name.IMPLEMENTATION_TITLE.toString() to "Gradle",
            Attributes.Name.IMPLEMENTATION_VERSION.toString() to moduleIdentity.version.map { it.baseVersion.version }
        )
    )
    archiveBaseName = runtimeApiJarName
    into("org/gradle/api/internal/runtimeshaded") {
        from(generateRelocatedPackageList)
    }
    from(apiMapping)
    from(defaultImports)
    from(pluginsManifest)

                artifactId = tasks.jar.get().archiveBaseName.get()
            }
        }
    }
}
----
=====
[.multi-language-sample]
=====
.build.gradle
[source,groovy]
----
subprojects {
    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
                artifactId = jar.archiveBaseName
            }
        }
    }

            task filteredConsumer(type: Zip) {
                from(project.projectDir) {
                    include 'src/**'
                }
                destinationDirectory = file("build")
                archiveBaseName = "output3"
            }
        """

        when:
        run("producer", "filteredConsumer")
        then:
        executedAndNotSkipped(":producer", ":filteredConsumer")
        when:

            .run()
    }

    private String fooAndBarJars() {
        '''
            task fooJar(type: Jar) {
                archiveBaseName = 'c-foo'
                destinationDirectory = projectDir
            }
            task barJar(type: Jar) {
                archiveBaseName = 'c-bar'
                destinationDirectory = projectDir
            }
            artifacts {
                foo fooJar

                configurations.create('default')
                group = 'test'
                version = '1.0'
                def jar = tasks.create("jar_$version", Jar) {
                    archiveBaseName = "test"
                    destinationDirectory = buildDir
                    archiveVersion = project.version
                }
                configurations['default'].outgoing.artifact(jar)
            }

                    assert resource != null && resource.getPath().endsWith('foo.jar!/foo.txt')
                }
            }

            task jarFoo(type: Jar) {
                archiveBaseName = 'foo'
                from 'foo.txt'
            }

            task runInWorker(type: WorkerTask) {
                isolationMode = '${isolationMode}'
                workActionClass = ResourceWorkAction

            @TaskAction
            void doNothing() {
                // does nothing
            }
        }

        task tar(type: Tar) {
            from 'dir1'
            archiveBaseName = "test"
            destinationDirectory.set(layout.buildDirectory)
        }
        task shouldRun(type: TaskWithAutomaticDependency) {
            // "Look Ma, no dependsOn!"