}

  private void putAll(Iterable<Entry<K, V>> entries) {
    Map<K, V> map = new LinkedHashMap<>();
    for (Entry<K, V> entry : entries) {
      map.put(entry.getKey(), entry.getValue());
    }
    getMap().putAll(map);
  }

  /**
   * Returns the {@link Method} instance for {@link #testPutAll_nullKeyUnsupported()} so that tests

        final Set<String> doubleFieldSet = getIndexAdminDoubleFieldSet();

        return source.entrySet().stream().filter(e -> isNonEmptyValue(e.getValue())).map(e -> {
            final String key = e.getKey();
            Object value = e.getValue();
            if (arrayFieldSet.contains(key)) {
                if (value instanceof String[]) {
                    value = Arrays.stream((String[]) value).toList();

                getAliasesResponse.getAliases()
                        .entrySet()
                        .forEach(x -> x.getValue()
                                .stream()
                                .filter(y -> updateAlias.equals(y.alias()))
                                .forEach(y -> updateIndices.add(x.getKey())));
            }

            return;
        }

        lock.writeLock().lock();
        try {
            // Clean up expired handles
            handles.entrySet().removeIf(entry -> {
                HandleInfo info = entry.getValue();
                if (info.isExpired() && !info.isReconnecting()) {
                    guidToHandle.remove(info.getCreateGuid());
                    removePersistedHandle(info);

        ArgumentCaptor<SmbComFindClose2> captor = ArgumentCaptor.forClass(SmbComFindClose2.class);
        verify(tree, times(1)).send(captor.capture(), any());
        assertNotNull(captor.getValue());

        // Tree handle is released after close
        verify(tree, atLeastOnce()).release();
    }

    @Test

        ArgumentCaptor<Integer> accessCaptor = ArgumentCaptor.forClass(Integer.class);
        verify(dest, times(1)).openUnshared(anyInt(), accessCaptor.capture(), anyInt(), eq(attrs), anyInt());
        int access = accessCaptor.getValue();
        boolean hasReadData = (access & SmbConstants.FILE_READ_DATA) != 0;
        assertEquals(alsoRead, hasReadData, "FILE_READ_DATA flag presence should match alsoRead");
    }

    @Test

            final Map<String, List<String>> map = new HashMap<>();
            headers.entrySet().stream().filter(e -> e.getKey() != null)
                    .forEach(e -> map.put(e.getKey().toLowerCase(Locale.ROOT), e.getValue()));
            this.headers = map;
        }
    }

    /**
     * Gets the headers of the response.
     *
     * @return the headers.
     */

      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = copyToList(collection);

      multimap().put(key, v3());

      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = copyToList(collection);

      multimap().put(key, v3());

  }

  private static <K, V> void putEntryWithChecks(
      SortedMap<K, V> map, Entry<? extends K, ? extends V> entry) {
    K key = checkNotNull(entry.getKey());
    V value = checkNotNull(entry.getValue());
    if (map.containsKey(key)) {
      // When a collision happens, the colliding entry is the first entry
      // of the tail map.
      Entry<K, V> previousEntry = map.tailMap(key).entrySet().iterator().next();