[!cgo] skip 'test verifies cgo pkg-config errors'
[!exec:pkg-config] skip 'test requires pkg-config tool'

! go list -export .
stderr '^# example\n# \[pkg-config .*\]\n(.*\n)*Package .* not found'

-- go.mod --
module example
go 1.20
-- example.go --
package example

// #cgo pkg-config: libnot-a-valid-cgo-library
import "C"

	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 BenchmarkMarshalMsgLockArgs(b *testing.B) {
	v := LockArgs{}
	b.ReportAllocs()
	b.ResetTimer()

            }
            r  : 'hello' ID ;
            ID : [a-z]+ ;
            WS : [ \\t\\r\\n]+ -> skip ;
        """

        file("grammar-builder/src/main/antlr/Another.g4") << """grammar Another;
            r  : 'hello' ID ;
            ID : [a-z]+ ;
            WS : [ \\t\\r\\n]+ -> skip ;
        """
    }

    private badGrammar() {

# golang.org/issue/13037: 'go get' was not parsing <meta> tags in 404 served over HTTPS.

[!net:bazil.org] skip
[!git] skip

env GONOSUMDB=bazil.org,github.com,golang.org
env GO111MODULE=on
env GOPROXY=direct
go get bazil.org/fuse/fs/fstestutil


-- go.mod --
module m

                version = '1.2'
            }
        """
        repo.commit('initial')
        repo.createLightWeightTag('1.2')
    }

    @ToBeFixedForConfigurationCache(skip = ToBeFixedForConfigurationCache.Skip.FAILS_TO_CLEANUP)
    def "can populate into same dir in parallel"() {
        given:
        createDirs("A", "B", "C", "D")
        settingsFile << """
            include 'A', 'B', 'C', 'D'
        """

[short] skip
[!cgo] skip '-buildmode=c-shared requires external linking'
[!buildmode:c-shared] stop

env GO111MODULE=on

go get rsc.io/fortune
go build -buildmode=c-shared -o external.so rsc.io/fortune
go version external.so
stdout '^external.so: .+'
go version -m external.so
stdout '^\tpath\trsc.io/fortune'
stdout '^\tmod\trsc.io/fortune\tv1.0.0'

-- go.mod --
module m

-- empty.go --
package main

	case "windows", "plan9", "android", "ios", "openbsd": // no getcontext
		t.Skipf("skipping test on %s", runtime.GOOS)
	}
	got := runTestProg(t, "testprogcgo", "StackSwitchCallback")
	skip := "SKIP\n"
	if got == skip {
		t.Skip("skipping on musl/bionic libc")
	}
	want := "OK\n"
	if got != want {
		t.Errorf("expected %q, got %v", want, got)
	}

In the example above they have default values of `skip=0` and `limit=10`.

So, going to the URL:

```
http://127.0.0.1:8000/items/
```

would be the same as going to:

```
http://127.0.0.1:8000/items/?skip=0&limit=10
```

But if you go to, for example:

```
http://127.0.0.1:8000/items/?skip=20
```

The parameter values in your function will be:

* `skip=20`: because you set it in the URL

	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 BenchmarkMarshalMsgCondCheck(b *testing.B) {
	v := CondCheck{}
	b.ReportAllocs()
	b.ResetTimer()

func (rst *rustState) writeByte(c byte) {
	if rst.skip {
		return
	}
	if rst.max > 0 && rst.buf.Len() > rst.max {
		rst.skip = true
		return
	}
	rst.last = c
	rst.buf.WriteByte(c)
}

// writeString writes a string to the buffer.
func (rst *rustState) writeString(s string) {
	if rst.skip {
		return
	}
	if rst.max > 0 && rst.buf.Len() > rst.max {
		rst.skip = true
		return
	}
	if len(s) > 0 {