!implementation.visible
        !implementation.canBeConsumed
        !implementation.canBeResolved

        when:
        def runtimeOnly = project.configurations.getByName(JvmConstants.RUNTIME_ONLY_CONFIGURATION_NAME)

        then:
        runtimeOnly.transitive
        !runtimeOnly.visible
        !runtimeOnly.canBeConsumed
        !runtimeOnly.canBeResolved
        runtimeOnly.extendsFrom == [] as Set

import org.gradle.api.attributes.java.TargetJvmVersion

plugins {
    id 'java-library'
}

// tag::declare-outgoing-configuration[]
configurations {
    instrumentedJars {
        canBeConsumed = true
        canBeResolved = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.LIBRARY))
            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))

        settingsFile << "include 'lib'"

        file("lib/build.gradle") << """
            configurations {
                testFixtures {
                    canBeResolved = false
                    assert canBeConsumed
                    attributes {
                        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, 'java-api'))

    baselineJars {
        extendsFrom baseline
        attributes.attribute(ARTIFACT_TYPE, 'gradle-baseline-jars')
    }
    currentClasspath {
        canBeConsumed = false
        canBeResolved = false
        visible = false
    }
    currentApiClasspath {
        canBeConsumed = false
        canBeResolved = true
        description = "Classpath to check binary compatibility against"

            }
        '''
        subproject('a') {
            'build.gradle'('''
                configurations {
                    javadoc {
                        assert canBeResolved
                        canBeConsumed = false
                        attributes {
                            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))

            def color = Attribute.of("color", String)
            configurations.configureEach {
                if (canBeConsumed && name.startsWith(alternate.name))  {
                    attributes {
                        attribute(color, 'green')
                    }
                } else if (canBeConsumed && !name.startsWith(alternate.name))  {
                    attributes {
                        attribute(color, 'blue')

            project(':a') {
                configurations {
                    compileFreeDebug {
                        canBeConsumed = false
                        canBeResolved = false
                    }
                    compileFreeRelease {
                        canBeConsumed = false
                        canBeResolved = false
                    }
                    compileFreeDebugPath {

    }

    private Configuration createOutgoingConfiguration(Project project) {
        project.configurations.create("instrumentedJars") { Configuration cnf ->
            cnf.canBeConsumed = true
            cnf.canBeResolved = false
            cnf.attributes {
                it.attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category, Category.LIBRARY))

        buildFile << """
            apply plugin: 'java-base'

            configurations {
                consumer {
                    assert canBeResolved
                    canBeConsumed = false
                    attributes {
                        // intentionally not complete
                        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_RUNTIME))

            subprojects {
                configurations.create("myconfig1") {
                    assert canBeResolved
                    canBeConsumed = false
                }
                configurations.create("myconfig2") {
                    assert canBeResolved
                    canBeConsumed = false
                }

                def problematic = tasks.register("problematicTask", OutputsAsMappedInputs) {