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:

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

                    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
     */

    /**
     * Configures this feature to publish a variant containing a list of this feature's source directories.
     */
    void withSourceElements();

    /**
     * Adds the {@code api} and {@code compileOnlyApi} dependency configurations to this feature.
     *
     * TODO: Should this live on the "base" JVM feature? Should all JVM features know how to add

| no
| no
| This is where you declare dependencies which are required at compile time, but not at runtime. This typically includes dependencies which are shaded when found at runtime.

| `compileOnlyApi`
| Declaring compile only API dependencies
| no
| no

    dependencies {
        api 'test:api:1.0'
        implementation project(':other-java')
        implementation files('file-dep.jar')
        compileOnly 'test:compile-only:1.0'
        compileOnlyApi 'test:compile-only-api:1.0'
        implementation 'test:implementation:1.0'
        runtimeOnly 'test:runtime-only:1.0'
    }
}

project(':consumer') {
    configurations { consume }

                DependencyCollector getImplementation();

                DependencyCollector getRuntimeOnly();

                DependencyCollector getCompileOnly();

                // CompileOnlyApi is not included here, since both Android and KMP do not support it.
                // Does that mean we should also reconsider if we should support it? Or, should we
                // talk to Android and KMP about adding support