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

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(

                    }
                }
            }

            """
        )

        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

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

    val mainClassName: Property<String>
}

val app = extensions.create<LaunchableJar>("app")

val manifestClasspath = configurations.dependencyScope("manifestClasspath")
val resolveManifestClasspath = configurations.resolvable("resolveManifestClasspath") {
    isTransitive = false
    extendsFrom(manifestClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

tasks.jar.configure {

            testReportDirectory.convention(javaPluginExtension.getTestReportDir());
        });

        // A resolvable configuration to collect test results
        Configuration testResultsConf = configurations.resolvable("aggregateTestReportResults").get();
        testResultsConf.extendsFrom(testAggregation);

val distribution = configurations.dependencyScope("distribution") {
    description = "Dependencies to extract the public Gradle API from"
}
val distributionClasspath = configurations.resolvable("distributionClasspath") {
    extendsFrom(distribution.get())
    configureAsRuntimeJarClasspath(objects)
}

// Defines configurations used to resolve external dependencies
// that the public API depends on.

plugins {
    // because this snippet is used in TestReportIntegrationTest which rewrites build files for different JUnit flavors
    id 'java'
}

// tag::test-report[]
// A resolvable configuration to collect test reports data
configurations {
    testReportData {
        canBeConsumed = false
        attributes {
            attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, Category.DOCUMENTATION))