name   string
		input  map[string]interface{}
		expect clause.Values
	}{
		{
			name: "Test convert string value",
			input: map[string]interface{}{
				"name": "my name",
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "name"}},
				Values:  [][]interface{}{{"my name"}},
			},
		},
		{
			name: "Test convert int value",
			input: map[string]interface{}{
				"age": 18,
			},

    private static final long serialVersionUID = 1L;

    /**
     * The internal LRU hash map used to store elements.
     */
    private final LruHashMap<E, Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    /**
     * Creates a new {@link LruHashSet} with the specified limit size.
     *

    // Hack around K not being a subtype of Comparable.
    // Unsafe, see ImmutableSortedSetFauxverideShim.
    @SuppressWarnings("unchecked")
    Ordering<K> naturalOrder = (Ordering<K>) NATURAL_ORDER;
    return copyOfInternal(map, naturalOrder);
  }

  /**
   * Returns an immutable map containing the same entries as {@code map}, with keys sorted by the

   * {@code EnumHashBiMap} or an {@link EnumBiMap}, the new bimap has the same key type as the input
   * bimap. Otherwise, the specified map must contain at least one mapping, in order to determine
   * the key type.
   *
   * @param map the map whose mappings are to be placed in this map

        assertTrue(result instanceof List);
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> resultList = (List<Map<String, Object>>) result;
        assertEquals(2, resultList.size());

        Map<String, Object> map1 = resultList.get(0);
        assertEquals("name1", map1.get("name"));

        Map<String, Object> map2 = resultList.get(1);
        assertEquals("name2", map2.get("name"));
    }

	testCases := []struct {
		queryParams map[string]string
		headers     map[string]string
		region      string
		expected    APIErrorCode
	}{
		// (0) Should error without a set URL query.
		{
			region:   globalMinioDefaultRegion,
			expected: ErrInvalidQueryParams,
		},
		// (1) Should error on an invalid access key.
		{
			queryParams: map[string]string{
				"X-Amz-Algorithm":     signV4Algorithm,

        final Set<String> keySet = createTestParam(0).keySet();
        final Map<String, Object> updateMap = getUpdateMap();
        final Map<String, Object> searchBody = createSearchBody(SEARCH_ALL_NUM);
        List<Map<String, Object>> settings = getItemList(searchBody);

        for (Map<String, Object> setting : settings) {
            final Map<String, Object> requestBody = new HashMap<>(updateMap);

        val performanceTestsCiJsonObj: Map<String, List<Map<String, Any>>> = objectMapper.readValue(performanceTestsCiJson)

        return performanceTestsCiJsonObj["performanceTests"]!!.map { scenarioObj ->
            val testId = scenarioObj["testId"] as String
            val groups =
                (scenarioObj["groups"] as List<Map<String, Any>>).map { groupObj ->

                final Map<String, Object> map = new HashMap<>();
                map.put("id", item.getEncodedId());
                map.put("path", item.getPath());
                map.put("name", item.getName());
                map.put("hashCode", item.hashCode());
                map.put("size", item.getSize());
                map.put("directory", item.isDirectory());

import java.util.Map;
import java.util.Map.Entry;

/**
 * GWT emulation of {@link ImmutableEnumMap}. The type parameter is not bounded by {@code Enum<E>}
 * to avoid code-size bloat.
 *
 * @author Hayward Chan
 */
final class ImmutableEnumMap<K, V> extends ForwardingImmutableMap<K, V> {
  static <K, V> ImmutableMap<K, V> asImmutable(Map<K, V> map) {