}
	return sprintf(fset, qf, false, format, args...)
}

func (check *Checker) trace(pos token.Pos, format string, args ...any) {
	fmt.Printf("%s:\t%s%s\n",
		check.fset.Position(pos),
		strings.Repeat(".  ", check.indent),
		sprintf(check.fset, check.qualifier, true, format, args...),
	)
}

// dump is only needed for debugging
func (check *Checker) dump(format string, args ...any) {

	fmt.Printf("\r\n")

	if params.Get("writestderr") != "" {
		fmt.Fprintf(os.Stderr, "Hello, stderr!\n")
	}

	if params.Get("bigresponse") != "" {
		// 17 MB, for OS X: golang.org/issue/4958
		line := strings.Repeat("A", 1024)
		for i := 0; i < 17*1024; i++ {
			fmt.Printf("%s\r\n", line)
		}
		return
	}

	fmt.Printf("test=Hello CGI\r\n")

	keys := make([]string, 0, len(params))
	for k := range params {

  IntOrString rollingMaxUnavailable = 32 [deprecated = true];

  string externalTrafficPolicy = 34;

  repeated k8s.io.api.core.v1.Toleration tolerations = 35 [deprecated = true];

  repeated google.protobuf.Struct ingressPorts = 36;

  repeated google.protobuf.Struct additionalContainers = 37;

  repeated google.protobuf.Struct configVolumes = 38;

  google.protobuf.BoolValue runAsRoot = 45;

}

// IsType reports whether the corresponding expression specifies a type.
func (tv TypeAndValue) IsType() bool {
	return tv.mode == typexpr
}

// IsBuiltin reports whether the corresponding expression denotes
// a (possibly parenthesized) built-in function.
func (tv TypeAndValue) IsBuiltin() bool {
	return tv.mode == builtin
}

// IsValue reports whether the corresponding expression is a value.

        when:
        run(":help")

        then:
        def schemaFile = file(".gradle/declarative-schema/settings.dcl.schema")
        schemaFile.isFile() && schemaFile.text != ""
    }

    def 'reports #kind errors in settings'() {
        given:
        file("settings.gradle.dcl") << """
            rootProject.name = "test"
            $code
        """

        when:
        def failure = fails(":help")

            rootProject.name = 'root'
            include 'b'
            includeBuild 'included'
        """
        file("included/settings.gradle") << """
            include 'c'
        """
    }

    def "reports successful project configuration progress events"() {
        when:
        runBuild("tasks")

        then:
        events.operations.size() == 6
        events.trees == events.operations

    /**
     * Caches [KaAnalysisPermissionChecker] to avoid repeated [Project.getService] calls in [analyze].
     */
    @KaCachedService
    private val permissionChecker by lazy(LazyThreadSafetyMode.PUBLICATION) {
        KaAnalysisPermissionChecker.getInstance(project)
    }

    /**
     * Caches [KaBaseLifetimeTracker] to avoid repeated [Project.getService] calls in [analyze].
     */
    @KaCachedService

	ipv6Enabled           bool
	ipv4MappedIPv6Enabled bool
}

var ipStackCaps ipStackCapabilities

// supportsIPv4 reports whether the platform supports IPv4 networking
// functionality.
func supportsIPv4() bool {
	ipStackCaps.Once.Do(ipStackCaps.probe)
	return ipStackCaps.ipv4Enabled
}

// supportsIPv6 reports whether the platform supports IPv6 networking
// functionality.
func supportsIPv6() bool {

)

// IsUnspecified reports whether ip is an unspecified address, either
// the IPv4 address "0.0.0.0" or the IPv6 address "::".
func (ip IP) IsUnspecified() bool {
	return ip.Equal(IPv4zero) || ip.Equal(IPv6unspecified)
}

// IsLoopback reports whether ip is a loopback address.
func (ip IP) IsLoopback() bool {
	if ip4 := ip.To4(); ip4 != nil {

        fixture.writeApiTo(processorProjectDir)
        fixture.writeAnnotationProcessorTo(processorProjectDir)
        fixture.writeSupportLibraryTo(processorProjectDir)
    }

    @TargetGradleVersion(">=5.1")
    def "reports annotation processor results for JavaCompile task"() {
        when:
        def events = runBuild("compileJava")

        then:
        def operation = events.operation("Task :compileJava")