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}},
				},
			},

            for (String key : present) {
                if (!testValue(expectedPayload[key], actualPayload[key])) {
                    return false
                }
            }
            true
        } as Predicate
    }

    private static boolean testValue(expectedValue, actualValue) {
        if (expectedValue instanceof Closure) {
            expectedValue.call(actualValue)

	}

	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)

	r := NewTestREST(testResponse{result: probe.Success, data: "ok"})
	opts := metainternalversion.ListOptions{
		LabelSelector: labels.SelectorFromSet(map[string]string{
			"testLabel": "testValue",
		}),
	}
	got, err := r.List(genericapirequest.NewContext(), &opts)
	if err != nil {
		t.Fatalf("Unexpected error: %v", err)
	}
	expect := &api.ComponentStatusList{
		Items: []api.ComponentStatus{},

 */
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
public class MultimapValuesTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testValues() {
    List<V> expected = Lists.newArrayList();
    for (Entry<K, V> entry : getSampleElements()) {
      expected.add(entry.getValue());
    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

		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

 */
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
public class MultimapValuesTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testValues() {
    List<V> expected = Lists.newArrayList();
    for (Entry<K, V> entry : getSampleElements()) {
      expected.add(entry.getValue());
    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

	}

	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)

	}
	expT, err := mp.ExprType()
	if err != nil {
		t.Errorf("fail to get cel type: %s", err)
	}
	if expT.GetMapType() == nil {
		t.Errorf("got %v, wanted CEL map type", expT)
	}
}

func testValue(t *testing.T, id int64, val interface{}) *DynValue {
	t.Helper()
	dv, err := NewDynValue(id, val)
	if err != nil {
		t.Fatalf("NewDynValue(%d, %v) failed: %v", id, val, err)
	}
	return dv

    @BeforeEach
    void onSetup() {
        // MockitoAnnotations.openMocks(this);

        Map<String, String> envVarMap = new HashMap<>();
        envVarMap.put("testKey", "testValue");
        envVarMap.put("testSpecialCharactersKey", "<test&Value>");
        OperatingSystemUtils.setEnvVarSource(new TestEnvVarSource(envVarMap));

        toolchainBuilder = new DefaultToolchainsBuilder(