id("base")
            }

            task jar1(type: Jar) {}
            task jar2(type: Jar) {}
            task jar3(type: Jar) {}

            configurations {
                consumable("con") {
                    outgoing.artifact(tasks.jar1)
                }
                resolvable("res") {
                    outgoing.artifact(tasks.jar2)
                }

By default, `resolvableConfigurations` prints information about all purely resolvable configurations.
These are configurations that are marked resolvable but *not* marked consumable.
Though some resolvable configurations are also marked consumable, these are legacy configurations that should *not* have dependencies added in build scripts.

        return cachedToString;
    }

    public Units<Q> getUnits() {
        return units;
    }

    public BigDecimal getValue() {
        return value;
    }

    /**
     * Returns a human consumable string representation of this amount.
     */
    public String format() {
        if (cachedFormattedString == null) {
            cachedFormattedString = doFormat();
        }
        return cachedFormattedString;

        then:
        1 * context.add(conf)
        1 * context.add({ it.is(conf.allArtifacts) })
        0 * _
    }

    void "doesn't allow selection of configuration is not consumable"() {
        def context = Mock(TaskDependencyResolveContext)

        project.configurations.create('conf') {
            canBeConsumed = false
        }

            });
        });
    }

    private void addTestResultsVariant(ProjectInternal project, JvmTestSuite suite, JvmTestSuiteTarget target) {
        final Configuration variant = project.getConfigurations().consumable(TEST_RESULTS_ELEMENTS_VARIANT_PREFIX + StringUtils.capitalize(target.getName())).get();

            taskDependencyFactory
        );
        instance.addMutationValidator(rootComponentMetadataBuilder.getValidator());
        return instance;
    }

    /**
     * Creates a new locked consumable configuration instance.
     */
    DefaultConsumableConfiguration createConsumable(
        String name,
        ConfigurationsProvider configurationsProvider,

            if (conf == null) {
                return null;
            }
            assert conf.getMetadata().isCanBeConsumed() : "External components' configurations are always consumable";
            return conf.asVariant();
        }
    }

        given:
        publishes(multiCoordinateComponent {
            compilation("first")
        })
        file("other/build.gradle") << """
            configurations {
                consumable("extraRuntimeElements") {
                    attributes {
                        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, "extra"))
                    }
                }
            }

    private void configureConfigurations(final ProjectInternal project) {
        RoleBasedConfigurationContainerInternal configurations = project.getConfigurations();

        // Once these configurations become non-consumable, we can use
        // 'jvmPluginServices.configureAsRuntimeClasspath()' to configure the configurations.

        return new FlatMapProvider<>(this, transformer);
    }

    /**
     * Returns the human consumable display name for this provider, or null if this is not known.
     */
    @Nullable
    protected DisplayName getDeclaredDisplayName() {
        return null;
    }

    /**