for _, t := range types {
		for _, n := range t.testvalues() {
			fmt.Printf("var %s_%s %s = %d\n", t.name, valname(n), t.name, n)
		}
	}

	fmt.Println("func main() {")

	for _, t := range types {
		// test binary ops
		for _, op := range binops {
			for _, x := range t.testvalues() {
				for _, y := range t.testvalues() {
					if (op.name == "/" || op.name == "%") && y.Sign() == 0 {

package clause_test

import (
	"fmt"
	"testing"

	"gorm.io/gorm/clause"
)

func TestValues(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{
				clause.Insert{},
				clause.Values{
					Columns: []clause.Column{{Name: "name"}, {Name: "age"}},
					Values:  [][]interface{}{{"jinzhu", 18}, {"josh", 1}},
				},
			},

	}

	got2 := a.Keys(m2)
	sort.Ints(got2)
	if !a.SliceEqual(got2, want) {
		panic(fmt.Sprintf("a.Keys(%v) = %v, want %v", m2, got2, want))
	}
}

func TestValues() {
	got1 := a.Values(m1)
	want1 := []int{2, 4, 8, 16}
	sort.Ints(got1)
	if !a.SliceEqual(got1, want1) {
		panic(fmt.Sprintf("a.Values(%v) = %v, want %v", m1, got1, want1))
	}

	got2 := a.Values(m2)

		var got []int
		for k := range Keys(m) {
			got = append(got, k)
		}
		slices.Sort(got)
		if !slices.Equal(got, want) {
			t.Errorf("Keys(%v) = %v, want %v", m, got, want)
		}
	}
}

func TestValues(t *testing.T) {
	for size := 0; size < 10; size++ {
		var want []int
		m := make(map[int]int)
		for i := range size {
			m[i] = i
			want = append(want, i)
		}

		var got []int

	}

	got2 := _Keys(m2)
	sort.Ints(got2)
	if !_SliceEqual(got2, want) {
		panic(fmt.Sprintf("_Keys(%v) = %v, want %v", m2, got2, want))
	}
}

func TestValues() {
	got1 := _Values(m1)
	want1 := []int{2, 4, 8, 16}
	sort.Ints(got1)
	if !_SliceEqual(got1, want1) {
		panic(fmt.Sprintf("_Values(%v) = %v, want %v", m1, got1, want1))
	}

	got2 := _Values(m2)

	if len(names) != 0 {
		t.Errorf("some values remain after deletion: %v", names)
	}
}

func TestValues(t *testing.T) {
	softwareK, err := registry.OpenKey(registry.CURRENT_USER, "Software", registry.QUERY_VALUE)
	if err != nil {
		t.Fatal(err)
	}
	defer softwareK.Close()

	testKName := randKeyName("TestValues_")

				t.Errorf("at iteration %d got %d, %d want %d, %d", cnt, i, v, ei, ev)
			}
			ei--
			ev--
			cnt++
		}
		if cnt != size {
			t.Errorf("read %d values expected %d", cnt, size)
		}
	}
}

func TestValues(t *testing.T) {
	for size := 0; size < 10; size++ {
		var s []int
		for i := range size {
			s = append(s, i)
		}
		ev := 0
		cnt := 0
		for v := range Values(s) {
			if v != ev {

	testValues := []string{"100m", "1Gi"}
	zero := MustParse("0")
	for _, testValue := range testValues {
		value := MustParse(testValue)
		v1 := value.DeepCopy()
		// ensure non-zero - zero = non-zero (suffix preserved)
		v1.Sub(zero)
		// ensure we preserved the input value
		if v1.String() != testValue {
			t.Errorf("Expected %v, actual %v", testValue, v1.String())
		}

    public static void main(String[] args) {
        if (!"${testValue}".equals(System.getProperty("testValue"))) {
            throw new RuntimeException("Unexpected value: testValue=" + System.getProperty("testValue"));
        }
        if (!"${testValue2}".equals(System.getProperty("testValue2"))) {
            throw new RuntimeException("Unexpected value: testValue2=" + System.getProperty("testValue2"));
        }

func (k key2) String() string { return fmt.Sprintf("%[1]T(%[1]d)", k) }

var k1 = key1(1)
var k2 = key2(1) // same int as k1, different type
var k3 = key2(3) // same type as k2, different int

func TestValues(t *testing.T) {
	check := func(c Context, nm, v1, v2, v3 string) {
		if v, ok := c.Value(k1).(string); ok == (len(v1) == 0) || v != v1 {
			t.Errorf(`%s.Value(k1).(string) = %q, %t want %q, %t`, nm, v, ok, v1, len(v1) != 0)