// and returns it.
func Sorted[E cmp.Ordered](seq iter.Seq[E]) []E {
	s := Collect(seq)
	Sort(s)
	return s
}

// SortedFunc collects values from seq into a new slice, sorts the slice
// using the comparison function, and returns it.
func SortedFunc[E any](seq iter.Seq[E], cmp func(E, E) int) []E {
	s := Collect(seq)
	SortFunc(s, cmp)
	return s
}

See the License for the specific language governing permissions and
limitations under the License.
*/

package openapi

import (
	"encoding/json"
	"reflect"
	"testing"

	"github.com/google/go-cmp/cmp"
	"k8s.io/kube-openapi/pkg/common"
	"k8s.io/kube-openapi/pkg/handler"
	"k8s.io/kube-openapi/pkg/validation/spec"
)

func TestOpenAPIRoundtrip(t *testing.T) {

// For example:
// (CMPBconstload c (ADDQ x y)) -> (CMPBconstloadidx1 c x y) -> (CMPB c (MOVBloadidx1 x y))

(CMP(Q|L|W|B)load {sym} [off] ptr x mem) => (CMP(Q|L|W|B) (MOV(Q|L|W|B)load {sym} [off] ptr mem) x)

(CMP(Q|L|W|B)constload {sym} [vo] ptr mem) && vo.Val() == 0 => (TEST(Q|L|W|B) x:(MOV(Q|L|W|B)load {sym} [vo.Off()] ptr mem) x)

[exec:patch] exec patch -p1 -i diff.patch
[exec:patch] go mod tidy -diff
[exec:patch] ! stdout .
[exec:patch] cmp go.mod go.mod.tidyResult
[exec:patch] cmp go.sum go.sum.tidyResult

go list -deps -test -f $MODFMT all
cp stdout out-117.txt

go mod edit -go=1.16
go list -deps -test -f $MODFMT all
cmp stdout out-117.txt


# If we explicitly drop compatibility with 1.16, we retain fewer checksums,

			t.Errorf("encoding of %s failed: %s", &tx, err)
			continue
		}
		var rx Rat
		if err := dec.Decode(&rx); err != nil {
			t.Errorf("decoding of %s failed: %s", &tx, err)
			continue
		}
		if rx.Cmp(&tx) != 0 {
			t.Errorf("transmission of %s failed: got %s want %s", &tx, &rx, &tx)
		}
	}
}

// Sending a nil Rat pointer (inside a slice) on a round trip through gob should yield a zero.
// TODO: top-level nils.

See the License for the specific language governing permissions and
limitations under the License.
*/

package runtime

import (
	"testing"

	"reflect"

	"github.com/google/go-cmp/cmp"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

func TestPreferredVersionsAllGroups(t *testing.T) {
	tests := []struct {
		name                string
		versionPriority     map[string][]string

go work use -r foo
cmp go.work go.want_work_r

! go work use other
stderr '^go: error reading other'${/}'go.mod: missing module declaration'

go mod edit -C other -module=other
go work use other
cmp go.work go.want_work_other
-- go.work --
go 1.18

use (
	foo
	foo/bar // doesn't exist
)
-- go.want_work_r --
go 1.18

use (
	./foo
	./foo/bar/baz
)
-- go.want_work_other --
go 1.18

use (
	./foo

See the License for the specific language governing permissions and
limitations under the License.
*/

package debugger

import (
	"testing"

	"github.com/google/go-cmp/cmp"

	"k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/kubernetes/pkg/scheduler/framework"
)

func TestCompareNodes(t *testing.T) {
	tests := []struct {
		name      string
		actual    []string

See the License for the specific language governing permissions and
limitations under the License.
*/

package internalbootstrap

import (
	"fmt"
	"testing"

	"github.com/google/go-cmp/cmp"

	flowcontrol "k8s.io/api/flowcontrol/v1"
	apiequality "k8s.io/apimachinery/pkg/api/equality"
	"k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap"
)

func TestBootstrapConfigurationWithDefaulted(t *testing.T) {

! stderr '\(\)' # If we don't have a reason for -mod=readonly, don't log an empty one.
cmp go.mod go.mod.empty

# -mod=readonly should be set by default.
env GOFLAGS=
! go list all
stderr '^x.go:2:8: no required module provides package rsc\.io/quote; to add it:\n\tgo get rsc\.io/quote$'
cmp go.mod go.mod.empty

env GOFLAGS=-mod=readonly

# update go.mod - go get allowed
go get rsc.io/quote