attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
                consumable("cons") {
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
            }

     * Returns the role used to create this configuration and set its initial allowed usage.
     */
    ConfigurationRole getRoleAtCreation();

    /**
     * Indicates if the allowed usages of this configuration (consumable, resolvable, declarable) can be changed.
     *
     * @return {@code true} if so; {@code false} otherwise
     */
    boolean usageCanBeMutated();

    /**

     */
    PublicationContainer getPublications();

    /**
     * Configures the publications of this project.
     * <p>
     * The publications container defines the outgoing publications of the project. That is, the consumable representations of things produced
     * by building the project. An example of a publication would be an Ivy Module (i.e. {@code ivy.xml} and artifacts), or
     * Maven Project (i.e. {@code pom.xml} and artifacts).
     * <p>

}

// shouldPProf returns true if we should be doing pprof runs.
func (m *Metrics) shouldPProf() bool {
	return m != nil && len(m.filebase) > 0
}

// makeBenchString makes a benchmark string consumable by Go's benchmarking tools.
func makeBenchString(name string) string {
	needCap := true
	ret := []rune("Benchmark")
	for _, r := range name {
		if unicode.IsSpace(r) {
			needCap = true
			continue
		}

                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)
                }

        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();

    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;
    }

    /**