assertThat(map.isEmpty(), is(false));
        assertThat(map.get(Foo.class.getTypeParameters()[0]), is(sameClass(Object.class)));
    }

    /**
     * @throws Exception
     */
    public void testGenericMethod() throws Exception {
        final Map<TypeVariable<?>, Type> map = GenericsUtil.getTypeVariableMap(Fuga.class);
        assertThat(map, is(notNullValue()));
        assertThat(map.isEmpty(), is(true));

        Map<String, Object> emptyProperties = Map.of();
        assertTrue(Features.deployBuildPom(emptyProperties));

        // Test with null properties
        assertTrue(Features.deployBuildPom(null));
    }

    @Test
    void testDeployBuildPomWithStringTrue() {
        // Test with string "true"
        Map<String, Object> properties = Map.of(Constants.MAVEN_DEPLOY_BUILD_POM, "true");

    map.put(Long.class, null);
    assertThat(map.get(Long.class)).isNull();
    assertThat(map.getInstance(Long.class)).isNull();
  }

  public void testPrimitiveAndWrapper() {
    assertThat(map.getInstance(int.class)).isNull();
    assertThat(map.getInstance(Integer.class)).isNull();

    assertThat(map.putInstance(int.class, 0)).isNull();
    assertThat(map.putInstance(Integer.class, 1)).isNull();
    assertEquals(2, map.size());

     */
    public static ParameterizedClassDesc createParameterizedClassDesc(final Field field, final Map<TypeVariable<?>, Type> map) {
        assertArgumentNotNull("field", field);
        assertArgumentNotNull("map", map);

        return createParameterizedClassDesc(field.getGenericType(), map);
    }

    /**

	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,

    @Override
    protected final Map<String, String> create(Entry<String, String>[] entries) {
      HashMap<String, String> map = new HashMap<>();
      for (Entry<String, String> entry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return wrap(map);
    }

    abstract Map<String, String> wrap(HashMap<String, String> map);
  }

  private static TestSuite wrappedHashMapTests(

                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());

        return new ConcurrentHashMap<>(map);
      }
    },
    ImmutableMapImpl {
      @Override
      public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
        return ImmutableMap.copyOf(map);
      }
    },
    MapMakerStrongKeysStrongValues {
      @Override
      public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {

        map.put("two", "2");
    }

    /**
     * @throws Exception
     */
    @After
    public void tearDown() throws Exception {
        map = null;
    }

    /**
     * @throws Exception
     */
    @Test
    public void testContainsKey() throws Exception {
        assertThat(map.containsKey("ONE"), is(true));
        assertThat(map.containsKey("one"), is(true));

  @Override
  protected final void assertMoreInvariants(Map<K, V> map) {
    // TODO: can these be moved to MapInterfaceTest?
    for (Entry<K, V> entry : map.entrySet()) {
      assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString());
    }

    assertEquals("{" + JOINER.join(map.entrySet()) + "}", map.toString());
    assertEquals("[" + JOINER.join(map.entrySet()) + "]", map.entrySet().toString());