package main

func setpd(a []int) {
	//	print("setpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
	for i := 0; i < len(a); i++ {
		a[i] = i
	}
}

func sumpd(a []int) int {
	//	print("sumpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
	t := 0
	for i := 0; i < len(a); i++ {
		t += a[i]
	}
	//	print("sumpd t=", t, "\n");
	return t
}

func setpf(a *[20]int) {

	"SCASQ",
	"SCASW",
	"SETCC",
	"SETCS",
	"SETEQ",
	"SETGE",
	"SETGT",
	"SETHI",
	"SETLE",
	"SETLS",
	"SETLT",
	"SETMI",
	"SETNE",
	"SETOC",
	"SETOS",
	"SETPC",
	"SETPL",
	"SETPS",
	"SFENCE",
	"SGDT",
	"SHA1MSG1",
	"SHA1MSG2",
	"SHA1NEXTE",
	"SHA1RNDS4",
	"SHA256MSG1",
	"SHA256MSG2",
	"SHA256RNDS2",
	"SHLB",
	"SHLL",
	"SHLQ",
	"SHLW",

        withLibraryDependencies<DependencyRemovalByNameRule>(libs.sshdScp, setOf("slf4j-simple"))
        withLibraryDependencies<DependencyRemovalByNameRule>(libs.sshdSftp, setOf("slf4j-simple"))
        withLibraryDependencies<DependencyRemovalByNameRule>(libs.gradleProfiler, setOf("slf4j-simple"))
        withLibraryDependencies<DependencyRemovalByNameRule>(libs.samplesCheck, setOf("slf4j-simple"))

        when:
        def aggregate = subject.aggregate()

        then:
        aggregate.exportedResourcePrefixes == setOf("META-INF/gradle-plugins")
        aggregate.exportedPackages == setOf("kotlin", "org.gradle", "groovy")
    }

    static class SpecProvider1 implements GradleApiSpecProvider {
        @Override
        GradleApiSpecProvider.Spec get() {

                    "d" to listOf("b", "e2")
                )
            ),
            equalTo(
                mapOf(
                    "a" to setOf("e1", "e2"),
                    "b" to setOf("e1"),
                    "c" to setOf("e1", "e2"),
                    "d" to setOf("e1", "e2")
                )
            )
        )
    }

  )
val expectedCompileClasspathAndroidVersion =
  expectedReducedRuntimeClasspathAndroidVersion + setOf("j2objc-annotations-3.0.0.jar")
val expectedCompileClasspathJreVersion =
  expectedReducedRuntimeClasspathJreVersion + setOf("j2objc-annotations-3.0.0.jar")

val extraLegacyDependencies = setOf("google-collections-1.0.jar")

buildscript {
  val agpVersion = if (gradle.gradleVersion.startsWith("5.")) "3.6.4" else "7.0.4"

func (t *Mask) Merge(other Mask) {
	*t |= other
}

// MergeMaskable will merge other into t.
func (t *Mask) MergeMaskable(other Maskable) {
	*t |= Mask(other.Mask())
}

// SetIf will add other if b is true.
func (t *Mask) SetIf(b bool, other Mask) {
	if b {
		*t |= other
	}
}

// Mask returns the mask as a uint64.
func (t Mask) Mask() uint64 {
	return uint64(t)
}

                )
            )
        )

        assertEquals(
            mapOf(
                "First.class" to setOf("Second.class", "Third.class", "Forth.class"),
                "Second.class" to emptySet(),
                "Third.class" to setOf("First.class"),
                "Forth.class" to emptySet()
            ),
            result
        )
    }

eclipse {
    classpath {
        plusConfigurations += functional
    }
}

// tag::test-sources[]
eclipse {
    classpath {
        testSourceSets = testSourceSets.get() + setOf(integTest)
        testConfigurations = testConfigurations.get() + setOf(functional)
    }
}
// end::test-sources[]

// tag::test-fixtures[]
eclipse {
    classpath {
        containsTestFixtures = true
    }
}

// tag::declare_capability[]
dependencies {
    // Activate the "LoggingCapability" rule
    components.all(LoggingCapability::class.java)
}

class LoggingCapability : ComponentMetadataRule {
    val loggingModules = setOf("log4j", "log4j-over-slf4j")

    override
    fun execute(context: ComponentMetadataContext) = context.details.run {
        if (loggingModules.contains(id.name)) {
            allVariants {