}

		if !fdtest.Exists(fd) {
			continue
		}

		fmt.Printf("leaked parent file. fdtest.Exists(%d) got true want false\n", fd)

		fdfile := fmt.Sprintf("/proc/self/fd/%d", fd)
		link, err := os.Readlink(fdfile)
		fmt.Printf("readlink(%q) = %q, %v\n", fdfile, link, err)

		var args []string
		switch runtime.GOOS {
		case "plan9":
			args = []string{fmt.Sprintf("/proc/%d/fd", os.Getpid())}
		case "aix", "solaris", "illumos":

	b.WriteString("InFilenames:      " + fmt.Sprint(a.InFilenames) + "\n")
	b.WriteString("ReadinessTimeout: " + fmt.Sprint(a.ReadinessTimeout) + "\n")
	b.WriteString("SkipConfirmation: " + fmt.Sprint(a.SkipConfirmation) + "\n")
	b.WriteString("Force:            " + fmt.Sprint(a.Force) + "\n")
	b.WriteString("Verify:           " + fmt.Sprint(a.Verify) + "\n")
	b.WriteString("Set:              " + fmt.Sprint(a.Set) + "\n")

			total += clrLen
		}
		buffer := make([]byte, maxLen)

		text := ""
		if minLen >= (1 << 20) {
			text = fmt.Sprint(minLen>>20, "M ", (maxLen+(1<<20-1))>>20, "M")
		} else if minLen >= (1 << 10) {
			text = fmt.Sprint(minLen>>10, "K ", (maxLen+(1<<10-1))>>10, "K")
		} else {
			text = fmt.Sprint(minLen, " ", maxLen)
		}
		b.Run(text, func(b *testing.B) {
			b.SetBytes(int64(total))
			for i := 0; i < b.N; i++ {

			cl := NewFakeClientWithVersion(fmt.Sprint(tt.clusterVersion))
			if got := IsLessThanVersion(cl, tt.minorVersion); got != tt.want {
				t.Errorf("IsLessThanVersion() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetVersionAsInt(t *testing.T) {
	tests := []struct {
		name       string
		major      string
		minor      string
		want       int
		gitVersion string
	}{
		{
			name:  "1.22",

	items1000 := []string{}
	for i := 0; i < 1000; i++ {
		items1000 = append(items1000, fmt.Sprint(i))
	}
	items100 := []string{}
	for i := 0; i < 100; i++ {
		items100 = append(items100, fmt.Sprint(i))
	}
	items2 := []string{}
	for i := 0; i < 2; i++ {
		items2 = append(items2, fmt.Sprint(i))
	}
	b.Run("Set", func(b *testing.B) {
		set1000 := sets.New(items1000...)
		set100 := sets.New(items100...)

		l, e := listenCfg.Listen(ctx, "tcp", serverAddr)
		if e != nil {
			if opts.Trace != nil {
				opts.Trace(fmt.Sprint("listenCfg.Listen: ", e))
			}

			listenErrs[i] = e
			continue
		}

		if opts.Trace != nil {
			opts.Trace(fmt.Sprint("adding listener to ", l.Addr()))
		}

		listeners = append(listeners, l)
	}

	if len(listeners) == 0 {

		z := make([]Word, n)
		b.Run(fmt.Sprint(n), func(b *testing.B) {
			b.SetBytes(int64(n * _W))
			for i := 0; i < b.N; i++ {
				addVV(z, x, y)
			}
		})
	}
}

func BenchmarkSubVV(b *testing.B) {
	for _, n := range benchSizes {
		if isRaceBuilder && n > 1e3 {
			continue
		}
		x := rndV(n)
		y := rndV(n)
		z := make([]Word, n)
		b.Run(fmt.Sprint(n), func(b *testing.B) {

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

package main

import "fmt"

var x = uint32(0x01020304)
var y = [...]uint32{1,2,3,4,5}

func main() {
	fmt.Sprint(y[byte(x)])

	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
	const n = uint(len(dots))
	i := 2 * indent
	var s string
	for ; i > n; i -= n {
		s += fmt.Sprint(dots)
	}
	s += dots[0:i]
	if s != ". . . . . . . . . . " {
		panic(s)
	}

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

package main

import (
	"fmt"

	"./a"
)

var v = a.S{}

func main() {
	want := "{{ 0}}"
	if got := fmt.Sprint(v.F); got != want {
		panic(got)
	}