assertThat(manyValuesAccumulatorByAddAllStatsAccumulator.mean())
        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_MEAN);
    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();

        collectProblems(childMetadata).empty

        where:
        [parentAnnotation, childAnnotation] << [PROCESSED_PROPERTY_TYPE_ANNOTATIONS, PROCESSED_PROPERTY_TYPE_ANNOTATIONS].combinations()*.flatten()
    }

    def "can override @#processedAnnotation.simpleName property type with @#unprocessedAnnotation.simpleName"() {
        def parentTask = groovyClassLoader.parseClass """

// To change the information in this file, edit the cgoEnabled and/or firstClass
// maps in cmd/dist/build.go, then run 'go generate internal/platform'.

package platform

// List is the list of all valid GOOS/GOARCH combinations,
// including known-broken ports.
var List = []OSArch{
{{range .}}	{ {{ printf "%q" .GOOS }}, {{ printf "%q" .GOARCH }} },
{{end}}
}

var distInfo = map[OSArch]osArchInfo {

    def indyModes() {
        return [true, false]
    }

    final def testCasesWithIndyModes() {
        // Combine each test case with enableIndy=true and/or enableIndy=false
        return [testCases(), indyModes()].combinations().collect { it.flatten() }
    }

    def "#title is intercepted in groovy build script #indyStatus"(VarInitializer varInitializer) {
        given:
        def cwd = testDirectory.file(expectedPwdSuffix)

class ScriptChangeFixture {

    static List<Spec> specs() {
        [
            ScriptDiscovery.values(),
            ScriptLanguage.values(),
            ScriptType.values()
        ].combinations().collect { ScriptDiscovery d, ScriptLanguage l, ScriptType t ->
            new Spec(d, l, t)
        }
    }

    @Immutable
    static class Spec {
        ScriptDiscovery scriptDiscovery

	t.Helper()
	t.Error(msg)
}

var genericIntHelper = genericHelper[int]

func testTestHelper(t *testing.T) {
	testHelper(t)
}

func testHelper(t *testing.T) {
	// Check combinations of directly and indirectly
	// calling helper functions.
	notHelper(t, "0")
	helper(t, "1")
	notHelperCallingHelper(t, "2")
	helperCallingHelper(t, "3")

// To change the information in this file, edit the cgoEnabled and/or firstClass
// maps in cmd/dist/build.go, then run 'go generate internal/platform'.

package platform

// List is the list of all valid GOOS/GOARCH combinations,
// including known-broken ports.
var List = []OSArch{
	{"aix", "ppc64"},
	{"android", "386"},
	{"android", "amd64"},
	{"android", "arm"},
	{"android", "arm64"},
	{"darwin", "amd64"},
	{"darwin", "arm64"},

	// If we wanted to allow the flag to be set multiple times,
	// accumulating values, we would delete this if statement.
	// That would permit usages such as
	//	-deltaT 10s -deltaT 15s
	// and other combinations.
	if len(*i) > 0 {
		return errors.New("interval flag already set")
	}
	for _, dt := range strings.Split(value, ",") {
		duration, err := time.ParseDuration(dt)
		if err != nil {
			return err
		}

[GOOS:windows] ! go env -w CXX=.\cpp
[GOOS:windows] ! go env -w CXX=bin\cpp
[GOOS:windows] stderr 'go: CXX entry is relative; must be absolute path'

# go env -w/-u checks validity of GOOS/ARCH combinations
env GOOS=
env GOARCH=
# check -w doesn't allow invalid GOOS
! go env -w GOOS=linuxx
stderr 'unsupported GOOS/GOARCH pair linuxx'
# check -w doesn't allow invalid GOARCH
! go env -w GOARCH=amd644

    }

    @Unroll("#one ∪ #two ∪ #three = #expected")
    def "union of three elements"() {
        expect:
        [one, two, three].combinations().each { list ->
            assert factory.anyOf(list as Set) == expected
        }

        where:
        one          | two          | three        | expected