stderr '(compile|gccgo)( |\.exe).*test_cache.go'  # not cached
env CACHE=$OLD_GOCACHE

# Run same tests but with gccgo.
env GO111MODULE=off
[!exec:gccgo] stop
[cross] stop  # gccgo can't necessarily cross-compile

! go build -compiler=gccgo .
go build -compiler=gccgo -overlay overlay.json -o main_gccgo$GOEXE .
exec ./main_gccgo$goexe
stdout '^hello$'

// license that can be found in the LICENSE file.

package poll

import (
	"internal/syscall/unix"
	"runtime"
	"sync"
	"syscall"
	"unsafe"
)

const (
	// spliceNonblock doesn't make the splice itself necessarily nonblocking
	// (because the actual file descriptors that are spliced from/to may block
	// unless they have the O_NONBLOCK flag set), but it makes the splice pipe
	// operations nonblocking.
	spliceNonblock = 0x2

	keepDirs := make(map[string]string)

	var sw toolchain.Switcher

	// lookDir updates the entry in keepDirs for the directory dir,
	// which is either absolute or relative to the current working directory
	// (not necessarily the directory containing the workfile).
	lookDir := func(dir string) {
		absDir, dir := pathRel(workDir, dir)

		file := base.ShortPath(filepath.Join(absDir, "go.mod"))
		fi, err := fsys.Stat(file)

        val semanticsFromSignature = inferFunctionSemanticsFromSignature(function, function.returnType, inType, preIndex, configureLambdas)
        val maybeConfigureTypeRef = when (semanticsFromSignature) { // there is not necessarily a lambda parameter of this type: it might be an adding function with no lambda
            is FunctionSemantics.ConfigureSemantics -> semanticsFromSignature.configuredType
            else -> null
        }

                    artifact(fileName: 'a_main.jar', version: '')
                    // Version is extracted from the file name byt classifier is extracted from the URL. This is checking current behaviour not necessarily desired behaviour
                    artifact(fileName: 'a_extra.jar', version: '', classifier: 'extra')
                    artifact(type: 'zip', version: '')
                }
            }
        }
    }

    public void artifactsAccessed(String displayName) {
        verifyConcurrently();
        synchronized (failuresLock) {
            if (hasFatalFailure) {
                // There are fatal failures, but not necessarily on all artifacts so we first filter out
                // the artifacts which only have not fatal errors
                Map<ModuleComponentArtifactIdentifier, Collection<RepositoryAwareVerificationFailure>> filtered =

A **request** body is data sent by the client to your API. A **response** body is the data your API sends to the client.

Your API almost always has to send a **response** body. But clients don't necessarily need to send **request** bodies all the time.

To declare a **request** body, you use <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> models with all their power and benefits.

!!! info

func volumeNameLen(path string) int {
	switch {
	case len(path) >= 2 && path[1] == ':':
		// Path starts with a drive letter.
		//
		// Not all Windows functions necessarily enforce the requirement that
		// drive letters be in the set A-Z, and we don't try to here.
		//
		// We don't handle the case of a path starting with a non-ASCII character,

   * The order of the elements in the element set is unspecified.
   *
   * <p>If the element set supports any removal operations, these necessarily cause <b>all</b>
   * occurrences of the removed element(s) to be removed from the multiset. Implementations are not
   * expected to support the add operations, although this is possible.
   *

	})
	for _, e := range b.events {
		tw.WriteEvent(e)
	}
}

// Seq represents a sequence counter.
type Seq uint64

// Time represents a low-level trace timestamp (which does not necessarily
// correspond to nanoseconds, like trace.Time does).