cmdsanity "k8s.io/kubectl/pkg/cmd/util/sanity"
)

func main() {
	var errorCount int

	kubectl := cmd.NewKubectlCommand(cmd.KubectlOptions{IOStreams: genericiooptions.IOStreams{In: os.Stdin, Out: io.Discard, ErrOut: io.Discard}})
	errors := cmdsanity.RunCmdChecks(kubectl, cmdsanity.AllCmdChecks, []string{})
	for _, err := range errors {
		errorCount++
		fmt.Fprintf(os.Stderr, "     %d. %s\n", errorCount, err)
	}

		Delay: make([]int, 1),
	}
	if err := EncodeAll(io.Discard, g0); err == nil {
		t.Error("expected error from mismatched delay and image slice lengths")
	}

	g1 := &GIF{
		Image:    images,
		Delay:    make([]int, len(images)),
		Disposal: make([]byte, 1),
	}
	for i := range g1.Disposal {
		g1.Disposal[i] = DisposalNone
	}
	if err := EncodeAll(io.Discard, g1); err == nil {

	Error(context.Context, string, ...interface{})
	Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)
}

var (
	// Discard logger will print any log to io.Discard
	Discard = New(log.New(io.Discard, "", log.LstdFlags), Config{})
	// Default Default logger
	Default = New(log.New(os.Stdout, "\r\n", log.LstdFlags), Config{
		SlowThreshold:             200 * time.Millisecond,

	wantErr := uncloned.Execute(io.Discard, nil)

	// toClone must be the same as uncloned. It has to be recreated from scratch,
	// since cloning cannot occur after execution.
	toClone := Must(New("").Funcs(funcs).Parse("{{customFunc}}"))
	cloned := Must(toClone.Clone())
	gotErr := cloned.Execute(io.Discard, nil)

	if wantErr.Error() != gotErr.Error() {

		initialize()
	}
	b.ReportAllocs()
	b.SetBytes(fileSize)
	for i := 0; i < b.N; i++ {
		testprint(io.Discard, fileNode)
	}
}

func BenchmarkPrintDecl(b *testing.B) {
	if declNode == nil {
		initialize()
	}
	b.ReportAllocs()
	b.SetBytes(declSize)
	for i := 0; i < b.N; i++ {
		testprint(io.Discard, declNode)
	}

	br.ReadRune()
	br.Discard(1)
	if err := br.UnreadRune(); err == nil {
		t.Error("UnreadRune didn't fail after Discard")
	}
}

func TestNoUnreadByteAfterDiscard(t *testing.T) {
	br := NewReader(strings.NewReader("example"))
	br.ReadByte()
	br.Discard(1)
	if err := br.UnreadByte(); err == nil {
		t.Error("UnreadByte didn't fail after Discard")
	}
}

		"a\tb\t\td\n" + // hard tabs - do not discard column
			"a\tb\t\td\te\n" +
			"a\n" +
			"a\tb\tc\td\n" +
			"a\tb\tc\td\te\n",

		"a\tb\t\td\n" +
			"a\tb\t\td\te\n" +
			"a\n" +
			"a\tb\tc\td\n" +
			"a\tb\tc\td\te\n",
	},

	{
		"16c debug",
		100, 100, 0, '\t', DiscardEmptyColumns | Debug,
		"a\tb\t\td\n" + // hard tabs - do not discard column
			"a\tb\t\td\te\n" +
			"a\n" +

import (
	"io"
	"os"
)

func g[T any](...T) {}

// Interface and non-interface types do not match.
func _() {
	var file *os.File
	g(file, io /* ERROR "type io.Writer of io.Discard does not match inferred type *os.File for T" */ .Discard)
	g(file, os.Stdout)
}

func _() {
	var a *os.File
	var b any
	g(a, a)
	g(a, b /* ERROR "type any of b does not match inferred type *os.File for T" */)
}

		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}

	b.SetBytes(1)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := msgp.Encode(io.Discard, &v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkEncodeDiskInfoGOB(b *testing.B) {
	v := DiskInfo{
		Total:     1000,
		Free:      1000,
		Used:      1000,

	for _, tc := range benchTestCases() {
		b.Run(tc.name, func(b *testing.B) {
			b.ReportAllocs()
			for n := 0; n < b.N; n++ {
				err := target.Encode(tc.obj, ioutil.Discard)
				if err != nil {
					b.Fatal(err)
				}
			}
		})
	}
}

func benchmarkEncodeWithAllocatorFor(b *testing.B, target runtime.EncoderWithAllocator) {
	for _, tc := range benchTestCases() {