*/
    void withApi();

    /**
     * Gets the consumable configuration created by {@link #withJavadocJar()}.
     *
     * @return null if {@link #withJavadocJar()} has not been called.
     */
    @Nullable
    Configuration getJavadocElementsConfiguration();

    /**
     * Gets the consumable configuration created by {@link #withSourcesJar()}.
     *

            include("producer", "consumer")
            dependencyResolutionManagement {
                ${mavenCentralRepository()}
            }
        """
    }

    def "plugin runtime configuration is not consumable"() {
        given:
        file("producer/build.gradle") << """
            plugins {
                id("$plugin")
            }
        """

        when:
        file("consumer/build.gradle") << """

        return variants;
    }

    public List<ReportConfiguration> getExtendedConfigurations() {
        return extendedConfigurations;
    }

    public boolean isPurelyConsumable() {
        return Type.CONSUMABLE == type;
    }

    public boolean isPurelyResolvable() {
        return Type.RESOLVABLE == type;
    }

    public boolean isLegacy() {
        return Type.LEGACY == type;
    }

import org.gradle.internal.reflect.Instantiator;
import org.gradle.internal.typeconversion.NotationParser;
import org.gradle.internal.work.WorkerThreadRegistry;

/**
 * A concrete consumable {@link DefaultConfiguration} that cannot change roles.
 */
public class DefaultConsumableConfiguration extends DefaultConfiguration implements ConsumableConfiguration {

    public DefaultConsumableConfiguration(

            configurations {
                consumable("debugApiElements") {
                    attributes {
                        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_API))
                        attribute(Attribute.of("build-type", String), "debug")
                    }
                }
                consumable("releaseApiElements") {
                    attributes {

 * limitations under the License.
 */

package org.gradle.performance.results;

import javax.annotation.Nullable;
import java.util.List;

public interface ScenarioDefinition {
    /**
     * A human consumable display name for this definition.
     */
    String getDisplayName();

    /**
     * The test project name.
     */
    String getTestProject();

    /**
     * The tasks executed.
     */

                return null;
            }

            // If the configuration exists, it must not be consumable, since variantsByConfigurationName contains
            // all consumable configurations.
            assert !conf.getMetadata().isCanBeConsumed() : "Expected configuration to be non-consumable";

            throw failureHandler.nonConsumableConfigurationFailure(name, component.getId());
        }

        @Override

     * Returns a short name for the operation. This is a short human consumable description of the operation that makes sense in the context of the parent operation.
     * See TAPI {@code OperationDescriptor}.
     */
    public String getName() {
        return name;
    }

    /**
     * Returns the display name for the operation. This should be a standalone human consumable description of the

            </tr>
            <tr>
                <td>getAt</td>
            </tr>
            <tr>
                <td>detachedConfiguration</td>
            </tr>
            <tr>
                <td>consumable</td>
            </tr>
            <tr>
                <td>resolvable</td>
            </tr>
            <tr>
                <td>dependencyScope</td>
            </tr>
        </table>
    </section>

    // This is needed because of the duplicate package-info.class files
    duplicatesStrategy = DuplicatesStrategy.WARN
}

// The consumable configuration containing the public Gradle API artifact
// and its external dependencies.
val gradleApiElements = configurations.consumable("gradleApiElements") {
    extendsFrom(externalApi.get())
    outgoing.artifact(task)
    configureAsRuntimeElements(objects)
}