# Signing key for Gradle artifacts

Below is the public PGP key used to sign all Gradle artifacts.

The key ID is `E2F38302C8075E3D` and its fingerprint is `1BD97A6A154E7810EE0BC832E2F38302C8075E3D`.
You can also find the key in the [Gradle website](https://gradle.org/keys/) and on [public key servers](https://keys.openpgp.org/search?q=maven-publishing%40gradle.com).

## Verification instructions

### Importing the key

    for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertThat(cache.getUnchecked(key1)).isSameInstanceAs(value1);
      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key1, key2));

    for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertThat(cache.getUnchecked(key1)).isSameInstanceAs(value1);
      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key1, key2));

                        keys ->
                            path.create(transform(keys, key -> immutableEntry(key, new Object()))),
                        keys ->
                            path.create(transform(keys, key -> immutableEntry(new Object(), key))),
                        keys -> path.create(transform(keys, key -> immutableEntry(key, key)))))
            .collect(toImmutableList()),

   *
   * @param keys the unique, non-null keys whose values should be loaded
   * @return a map from each key in {@code keys} to the value associated with that key; <b>may not
   *     contain null values</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is

 * according to the value ordering.
 *
 * <p>The multimap does not store duplicate key-value pairs. Adding a new key-value pair equal to an
 * existing key-value pair has no effect.
 *
 * <p>Null keys and values are permitted (provided, of course, that the respective comparators
 * support them). All optional multimap methods are supported, and all returned views are
 * modifiable.
 *

  /** Discards any cached value for key {@code key}. */
  void invalidate(@CompatibleWith("K") Object key);

  /**
   * Discards any cached values for keys {@code keys}.
   *
   * @since 11.0
   */
  // For discussion of <? extends Object>, see getAllPresent.
  void invalidateAll(Iterable<? extends Object> keys);

  /** Discards all entries in the cache. */
  void invalidateAll();

  SortedMap<K, V> create(Object... elements);

  /**
   * Returns an entry with a key less than the keys of the {@link #samples()} and less than the key
   * of {@link #belowSamplesGreater()}.
   */
  Entry<K, V> belowSamplesLesser();

  /**
   * Returns an entry with a key less than the keys of the {@link #samples()} but greater than the
   * key of {@link #belowSamplesLesser()}.
   */
  Entry<K, V> belowSamplesGreater();

  /**

     *
     * @param key the key whose presence in this map is to be tested
     * @return true if this map contains a mapping for the specified key
     */
    @Override
    public boolean containsKey(final Object key) {
        return parent.containsKey(key);
    }

    /**
     * Returns true if this map maps one or more keys to the specified value.
     *

  }

  @Override
  public void invalidate(Object key) {
    delegate().invalidate(key);
  }

  /**
   * @since 11.0
   */
  @Override
  // For discussion of <? extends Object>, see getAllPresent.
  public void invalidateAll(Iterable<? extends Object> keys) {
    delegate().invalidateAll(keys);
  }

  @Override
  public void invalidateAll() {
    delegate().invalidateAll();
  }