then:
        GradleException e = thrown()
        e.message == TextUtil.toPlatformLineSeparators("""The requested build script DSL 'unknown' is not supported. Supported DSLs:
  - 'kotlin'
  - 'groovy'""")
    }

    def "should list all supported build script DSLs"() {
        when:
        def result = BuildInitDsl.listSupported()

        then:
        result.size() == 2
        result[0] == "kotlin"

# tag::gradle-properties[]
gradlePropertiesProp=gradlePropertiesValue
gradleProperties.with.dots=gradlePropertiesDottedValue

        if ( Character.isDigit(hostname.charAt(0)) ) {
            int i, len, dots;
            char[] data;

            i = dots = 0; /* quick IP address validation */
            len = hostname.length();
            data = hostname.toCharArray();
            while ( i < len && Character.isDigit(data[ i++ ]) ) {
                if ( i == len && dots == 3 ) {
                    // probably an IP address
                    return true;

// trailing dot to match pure Go reverse resolver and all other lookup
// routines.
// See golang.org/issue/12189.
// But we don't want to add dots for local names from /etc/hosts.
// It's hard to tell so we settle on the heuristic that names without dots
// (like "localhost" or "myhost") do not get trailing dots, but any other
// names do.
func absDomainName(s string) string {
	if bytealg.IndexByteString(s, '.') != -1 && s[len(s)-1] != '.' {

executable: gradle
args: printProperty
flags: "--quiet --stacktrace -I init.gradle -PgradlePropertiesProp=commandLineValue -PgradleProperties.with.dots=commandLineValueForDottedProperty"

func SilentlyUnmarshalAny[T any](a *anypb.Any) *T {
	dst := any(new(T)).(proto.Message)
	if err := a.UnmarshalTo(dst); err != nil {
		var z *T
		return z
	}
	return any(dst).(*T)
}

func UnmarshalAny[T any](t test.Failer, a *anypb.Any) *T {
	dst := any(new(T)).(proto.Message)
	if err := a.UnmarshalTo(dst); err != nil {
		t.Fatalf("failed to unmarshal to %T: %v", dst, err)
	}
	return any(dst).(*T)
}

        // Remove old distributions used by wrapper that we're unlikely to ever require again
        fileSystemOperations.removeOldVersionsFromDir(workerDir.dir("wrapper/dists"), expireDistributionCache, "gradle-", "-bin")
        fileSystemOperations.delete {
            delete(workerDir.dir("wrapper/dists/dist"))
        }

        // Remove caches that weren't multi-process safe and may be corrupt

				TrustDomain:    "td",
				Namespace:      "ns",
				ServiceAccount: "sa",
			},
		},
		{
			"spiffe://td.with.dots/ns/ns.with.dots/sa/sa.with.dots",
			&Identity{
				TrustDomain:    "td.with.dots",
				Namespace:      "ns.with.dots",
				ServiceAccount: "sa.with.dots",
			},
		},
		{
			// Empty ns and sa
			"spiffe://td/ns//sa/",

		lt = time.Now()
	}
	if len(b.Dests) == 0 {
		return fmt.Errorf("dest required")
	}

	// Over localhost, compression CPU can be the bottleneck. With remotes, compressing usually saves a lot of time.
	compression := gzip.NoCompression
	for _, d := range b.Dests {
		if !strings.HasPrefix(d, "localhost") {
			compression = gzip.BestSpeed
			break
		}
	}

	if start < v.cut {
		return 0, false
	}
	i := start
	dots := 0
	for ; i < len(v.s); i++ {
		c := v.s[i]
		if c == '_' {
			dots = -2
			continue
		}
		if c == '.' {
			dots++
			continue
		}
		if !isLDH(c) {
			break
		}
	}
	if dots >= 0 && i > start {
		return i - start, true
	}
	v.cut = i
	return 0, false
}