}

    /**
     * Gets a nested Map from the map.
     *
     * @param map The source map
     * @param key The key to look up
     * @return The nested Map, or null if the key doesn't exist or value is not a Map
     */
    @SuppressWarnings("unchecked")
    public static Map<String, Object> getMap(final Map<String, Object> map, final String key) {
        final Object value = map.get(key);
        if (value instanceof Map) {

        .testForwarding(
            Map.class,
            new Function<Map, Map>() {
              @Override
              public Map apply(Map delegate) {
                return wrap(delegate);
              }
            });
  }

  public void testEquals() {
    Map<Integer, String> map1 = ImmutableMap.of(1, "one");
    Map<Integer, String> map2 = ImmutableMap.of(2, "two");

var isMultipartTests = []struct {
	Metadata  map[string]string
	Multipart bool
}{
	{Multipart: true, Metadata: map[string]string{MetaMultipart: ""}},                          // 0
	{Multipart: true, Metadata: map[string]string{"X-Minio-Internal-Encrypted-Multipart": ""}}, // 1
	{Multipart: true, Metadata: map[string]string{MetaMultipart: "some-value"}},                // 2

    assertTrue(map.equals(map));
    assertTrue(makeEmptyMap().equals(map));
    assertEquals(emptyMap(), map);
    assertFalse(map.equals(emptySet()));
    // noinspection ObjectEqualsNull
    assertFalse(map.equals(null));
  }

  public void testGet() {
    Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {

  }

  @LazyInit private transient @Nullable Map<R, Map<C, V>> rowMap;

  @Override
  public Map<R, Map<C, V>> rowMap() {
    Map<R, Map<C, V>> result = rowMap;
    return (result == null) ? rowMap = createRowMap() : result;
  }

  Map<R, Map<C, V>> createRowMap() {
    return new RowMap();
  }

  @WeakOuter
  class RowMap extends ViewCachingAbstractMap<R, Map<C, V>> {
    @Override

    Map<String, Long> in = ImmutableMap.of("1", 1L, "2", 2L, "3", 3L);
    AtomicLongMap<String> map = AtomicLongMap.create();
    assertTrue(map.isEmpty());
    assertEquals(0, map.size());
    assertFalse(map.containsKey("1"));
    assertFalse(map.containsKey("2"));
    assertFalse(map.containsKey("3"));
    assertEquals(0L, map.get("1"));
    assertEquals(0L, map.get("2"));
    assertEquals(0L, map.get("3"));

    map.putAll(in);

            return Map.of();
        }
    }

    /**
     * Gets a nested map value from the given map.
     *
     * @param map the source map.
     * @param key the key to look up.
     * @return the map value, or {@code null} if not found or not a map.
     */
    @SuppressWarnings("unchecked")
    protected Map<String, Object> getMapValue(final Map<String, Object> map, final String key) {

  }

  public void testTransformSingletonMapEquality() {
    Map<String, String> map =
        transformValues(ImmutableMap.of("a", 1), Functions.toStringFunction());
    Map<String, String> expected = ImmutableMap.of("a", "1");
    assertMapsEqual(expected, map);
    assertThat(map.get("a")).isEqualTo(expected.get("a"));
  }

  public void testTransformIdentityFunctionEquality() {

        Map<String, Object> parentMap = new LinkedHashMap<>();
        DocMap docMap = new DocMap(parentMap);

        docMap.put("lang", "fr");

        Set<Map.Entry<String, Object>> entrySet = docMap.entrySet();
        assertEquals(1, entrySet.size());

        String[] keys = entrySet.stream().map(Map.Entry::getKey).toArray(String[]::new);
        assertEquals("lang", keys[0]);
    }

    @Test

        }
    }

    /**
     * Copies from a {@literal Map} to another {@literal Map}.
     *
     * @param src The source {@literal Map}. Must not be {@literal null}.
     * @param dest The destination {@literal Map}. Must not be {@literal null}.
     */
    public static void copyMapToMap(final Map<String, ? extends Object> src, final Map<String, Object> dest) {
        copyMapToMap(src, dest, DEFAULT_OPTIONS);
    }