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 {

    private final DirectoryProperty archiveDestinationDirectory;
    private final RegularFileProperty archiveFile;
    private final Property<String> archiveName;
    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;

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

                                }
                                def mergeResourcesTask = p.tasks.create("merge${f.capitalize()}${bt.capitalize()}Resources", Zip) { task ->
                                    task.archiveBaseName = "resources-${p.name}-${f}${bt}"
                                    task.from mergedResourcesConf
                                }

            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 { compile; create('default') }
            dependencies { compile project(':') }
            task jar1(type: Jar) { destinationDirectory = buildDir; archiveBaseName = '1' }
            task jar2(type: Jar) { destinationDirectory = buildDir; archiveBaseName = '2' }
            artifacts { compile jar1; 'default' jar2 }
'''
        resolve.prepare("compile")

        when:
        succeeds("checkDeps")