public void testAsMapGet() {
    for (K key : sampleKeys()) {
      List<V> expectedValues = new ArrayList<>();
      for (Entry<K, V> entry : getSampleElements()) {
        if (entry.getKey().equals(key)) {
          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {
        assertNull(collection);

    super(expectedSize, loadFactor);
  }

  ObjectCountLinkedHashMap(ObjectCountHashMap<K> map) {
    init(map.size(), DEFAULT_LOAD_FACTOR);
    for (int i = map.firstIndex(); i != -1; i = map.nextIndex(i)) {
      put(map.getKey(i), map.getValue(i));
    }
  }

  @Override
  void init(int expectedSize, float loadFactor) {
    super.init(expectedSize, loadFactor);
    firstEntry = ENDPOINT;
    lastEntry = ENDPOINT;

            throw new UncheckedExecutionException(e);
          }
        });

    CacheTesting.checkEmpty(cache);
    for (RemovalNotification<String, String> entry : notifications) {
      assertThat(entry.getKey()).isNotNull();
      assertThat(entry.getValue()).isNotNull();
    }
  }

  public void testComputeExceptionally() {
    assertThrows(
        RuntimeException.class,
        () ->

            log.trace("Domain " + entry.getKey());
            for (final Entry<String, CacheEntry<DfsReferralDataInternal>> entry2 : entry.getValue().entrySet()) {
                log.trace("  Root " + entry2.getKey());
                if (entry2.getValue().map != null) {

                        ImmutableTypeToInstanceMap.builder();
                    for (Object object : elements) {
                      Entry<?, ?> entry = (Entry<?, ?>) object;
                      builder.put((TypeToken) entry.getKey(), entry.getValue());
                    }
                    return (Map) builder.build();
                  }
                })
            .named("ImmutableTypeToInstanceMap")
            .withFeatures(

        // Given
        byte[] key = "testkey1".getBytes(); // 8 bytes for DES
        byte[] plaintext = "12345678".getBytes(); // 8 bytes (DES block size)

        // When
        Cipher desCipher = Crypto.getDES(key);
        desCipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "DES"));
        byte[] encrypted = desCipher.doFinal(plaintext);

        // Then
        assertNotNull(encrypted);

        if (from != null) {
            for (Map.Entry<K, ? extends Artifact> entry : from.entrySet()) {
                to.put(entry.getKey(), ArtifactUtils.copyArtifact(entry.getValue()));
            }
        }

        return to;
    }

    private static <T> List<T> copyList(List<T> original) {
        List<T> copy = null;

                            .entrySet()
                            .stream()
                            .filter(p -> p.getValue() > 1)
                            .map(Map.Entry::getKey)
                            .collect(Collectors.toSet());
                }
            }
        }
        return duplicateIds;
    }

    public List<BuildStep> sortedNodes() {

    assertNull("put(null, null) should return null", put(nullKeyValueEntry));
    expectAdded(nullKeyValueEntry);
  }

  @CanIgnoreReturnValue
  private V put(Entry<K, V> entry) {
    return getMap().put(entry.getKey(), entry.getValue());
  }

  /**
   * Returns the {@link Method} instance for {@link #testPut_nullKeyUnsupported()} so that tests of
   * {@link java.util.TreeMap} can suppress it with {@code

                                                                logger.debug("Skipping interpolation of field: " + field
                                                                        + " (key: " + entry.getKey() + ") in: "
                                                                        + cls.getName()
                                                                        + "; it is an unmodifiable collection.");