if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgallTierStats(b *testing.B) {
	v := allTierStats{}
	b.ReportAllocs()
	b.ResetTimer()

from typing import Union

from fastapi import Depends, FastAPI
from typing_extensions import Annotated

app = FastAPI()


async def common_parameters(
    q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/items/")
async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
    return commons


@app.get("/users/")

! stderr downloading
stderr 'panic: use of network' # test catches network access
env GOSUMDB=$oldsumdb

# Test a real GOTOOLCHAIN
[short] skip
[!net:golang.org] skip
[!net:sum.golang.org] skip
[!GOOS:darwin] [!GOOS:windows] [!GOOS:linux] skip
[!GOARCH:amd64] [!GOARCH:arm64] skip

env GOPROXY=
[go-builder] env GOSUMDB=
[!go-builder] env GOSUMDB=sum.golang.org  # Set explicitly in case GOROOT/go.env is modified.

# embedded in a package, that is referenced by a Go assembly function.
# See issue 33139.

[!compiler:gc] skip
[!cgo] skip
[short] skip 'invokes system C compiler'

# External linking is not supported on linux/ppc64.
# See: https://github.com/golang/go/issues/8912
[GOOS:linux] [GOARCH:ppc64] skip

cc -c -o syso/objTestImpl.syso syso/src/objTestImpl.c
go build -ldflags='-linkmode=external' ./cmd/main.go

-- go.mod --

[short] skip
[!cgo] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test cgo coverage with an external test.

go test -short -cover cgocover2
stdout  'coverage:.*[1-9][0-9.]+%'
! stderr '[^0-9]0\.0%'

-- go.mod --
module cgocover2

go 1.16
-- p.go --
package p

/*
void
f(void)
{
}
*/
import "C"

var b bool

func F() {
	if b {
		for {
		}
	}
	C.f()
}

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# Cleanup should run after F.Skip.
go test -run=FuzzTargetSkip
stdout cleanup

# Cleanup should run after F.Fatal.
! go test -run=FuzzTargetFatal
stdout cleanup

# Cleanup should run after an unexpected runtime.Goexit.
! go test -run=FuzzTargetGoexit
stdout cleanup

# Cleanup should run after panic.
! go test -run=FuzzTargetPanic
stdout cleanup

from typing import Union

from fastapi import Depends, FastAPI

app = FastAPI()


async def common_parameters(
    q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/items/")
async def read_items(commons: dict = Depends(common_parameters)):
    return commons


@app.get("/users/")
async def read_users(commons: dict = Depends(common_parameters)):

from typing import Annotated, Union

from fastapi import Depends, FastAPI

app = FastAPI()


async def common_parameters(
    q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/items/")
async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
    return commons


@app.get("/users/")

from typing import Union

from fastapi import Depends, FastAPI
from typing_extensions import Annotated

app = FastAPI()


async def common_parameters(
    q: Union[str, None] = None, skip: int = 0, limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}


CommonsDep = Annotated[dict, Depends(common_parameters)]


@app.get("/items/")
async def read_items(commons: CommonsDep):
    return commons

        if (enabledBottomSpec && enabledIteration) {
            ToBeFixedForConfigurationCache.Skip skip = annotation.skip()
            if (skip == ToBeFixedForConfigurationCache.Skip.DO_NOT_SKIP) {
                return new ExpectingFailureRuleStatement(base, "Configuration Cache")
            } else {