// tag::test-report[]
// A resolvable configuration to collect test reports data
plugins {
    id 'reporting-base'
}

configurations {
    testReportData {
        canBeConsumed = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))
            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType, 'test-report-data'))
        }
    }
}

dependencies {

        """

        when:
        fails 'help'

        then:
        failure.hasErrorOutput("Archives can not be added to the `compile` configuration.")
    }

    def "fail if a non-resolvable configuration is resolved"() {
        given:
        buildFile << """
            task resolve {
                dependsOn configurations.compileOnly
                doLast {

     * superconfigurations.
     */
    Set<ExcludeRule> getAllExcludeRules();

    /**
     * @implSpec Usage: This method should only be called on resolvable configurations and should throw an exception if
     * called on a configuration that does not permit this usage.
     */
    @Nullable
    ConfigurationInternal getConsistentResolutionSource();

    /**

package cgotest

import "testing"

// If gcc is used, and linking internally, __mulsc3 and __muldc3
// will be linked in from libgcc which make several R_PPC64_TOC16_DS
// relocations which may not be resolvable with the internal linker.
func test8694(t *testing.T) { t.Skip("not supported on ppc64/ppc64le with internal linking") }

127.0.0.1 test
127.0.0.2 test2.example.com 2.test
127.0.0.3 3.test test3.example.com
127.0.0.4 example.com
127.0.0.5 test4.example.com 4.test 5.test test5.example.com

# must be a non resolvable domain on the internet

                    }
                }
            }

            """
        )

        build("assertions")
    }

    @Test
    fun `all embedded kotlin dependencies are resolvable`() {

        withBuildScript(
            """

            plugins {
                `embedded-kotlin`
            }

            $repositoriesBlock

            dependencies {

                    .because("Configurations should be created with the role-based API in org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationContainerInternal");

    /**
     * Ensures no new usages of resolvable + dependency scope Configurations are added and ensures usages of "maybe" methods are avoided.
     */
    @ArchTest

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

/**
 * A concrete resolvable {@link DefaultConfiguration} that cannot change roles.
 */
public class DefaultResolvableConfiguration extends DefaultConfiguration implements ResolvableConfiguration {

    public DefaultResolvableConfiguration(

    }

    def "attribute combinations and capabilities on legacy resolvable configurations can match without a warning"() {
        given:
        buildFile << """
            plugins {
                id 'java'
            }

            configurations {
                sample1 {
                    // Configurations that are both resolvable and consumable are legacy and should not be used

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