"apiElements" -> "api"
   "apiElements" -> "compileOnlyApi"

   "api" [shape="box", label=<<B>api</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]
   "compileOnlyApi" [shape="box", label=<<B>compileOnlyApi</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]

        'java'         | 'runtimeClasspath'             | FORBIDDEN
        'java'         | 'annotationProcessor'          | VALID
        'java'         | 'api'                          | DOES_NOT_EXIST
        'java'         | 'compileOnlyApi'               | DOES_NOT_EXIST

        'java-library' | 'compileOnly'                  | VALID
        'java-library' | 'runtimeOnly'                  | VALID
        'java-library' | 'implementation'               | VALID

        when:
        def compileOnlyApi = project.configurations.getByName(JvmConstants.COMPILE_ONLY_API_CONFIGURATION_NAME)

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

        when:

   node [fontname = "Sans"];
   edge [fontname = "Sans"];

   "api" [shape="box", label=<<B>api</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]

   "compileOnlyApi" [shape="box", label=<<B>compileOnlyApi</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]

   "implementation" [shape="box", label=<<B>implementation</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]

                compileOnly "org.apache.commons:commons-lang3:3.12.0"

                api "org.springframework:spring-core:5.3.22"
                compileOnlyApi "com.google.guava:guava:32.1.2-jre"
            }
        """
        writeBaseBuildFile()
        writeNonApiAccessibilityTest()
        writeApiAccessibilityTest()

        when:

        this.compileOnlyApi = dependencyScope("Compile-only API", JvmConstants.COMPILE_ONLY_API_CONFIGURATION_NAME, true, true);

        this.apiElements.extendsFrom(api, compileOnlyApi);
        this.implementation.extendsFrom(api);
        this.compileOnly.extendsFrom(compileOnlyApi);

        // TODO: Why do we not always do this? Why only when we have an API?

        project.getPluginManager().apply(JavaPlugin.class);

        JvmSoftwareComponentInternal component = JavaPluginHelper.getJavaComponent(project);
        component.getMainFeature().withApi();

        // Make compileOnlyApi visible to tests.
        JvmTestSuite defaultTestSuite = JavaPluginHelper.getDefaultTestSuite(project);
        project.getConfigurations()
            .getByName(defaultTestSuite.getSources().getCompileOnlyConfigurationName())

 *
 * <p>TODO: Before publicizing this component, we also need to consider how component extensibility works.
 * For example, for the java-library plugin we have the additional {@code api} and {@code compileOnlyApi}
 * dependency configurations. Do we expect that plugin to write a new feature interface and extend a base
 * interface in order to add the proper getter methods? What about the concrete feature class which implements

                    it.canBeResolved = true
                    it.canBeDeclared = true
                }

                [implementation, runtimeOnly, compileOnly, api, compileOnlyApi].each {
                    it.canBeConsumed = true
                    it.canBeResolved = true
                }

                [runtimeClasspath, compileClasspath].each {

     * but not at runtime.
     *
     * @since 6.7
     */
    public static final String COMPILE_ONLY_API_CONFIGURATION_NAME = "compileOnlyApi";

    /**
     * The name of the runtime only dependencies configuration, used to declare dependencies
     * that should only be found at runtime.
     *
     * @since 3.4
     */