extends SimpleImmutableEntry<@Nullable K, @Nullable V> {
  private final RemovalCause cause;

  /**
   * Creates a new {@code RemovalNotification} for the given {@code key}/{@code value} pair, with
   * the given {@code cause} for the removal. The {@code key} and/or {@code value} may be {@code
   * null} if they were already garbage collected.
   *
   * @since 19.0
   */
  public static <K, V> RemovalNotification<K, V> create(

  /**
   * The map does not throw {@code NullPointerException} on calls such as {@code
   * containsValue(null)}, {@code values().contains(null)} or {@code values().remove(null)}.
   */
  ALLOWS_NULL_VALUE_QUERIES,
  ALLOWS_NULL_VALUES(ALLOWS_NULL_VALUE_QUERIES),
  /**
   * The map does not throw {@code NullPointerException} on calls such as {@code
   * entrySet().contains(null)} or {@code entrySet().remove(null)}
   */

   * }
   *
   * <p>For <i>small</i> immutable maps, the {@code ImmutableMap.of()} methods are even more
   * convenient.
   *
   * <p>By default, a {@code Builder} will generate maps that iterate over entries in the order they
   * were inserted into the builder, equivalently to {@code LinkedHashMap}. For example, in the
   * above example, {@code WORD_TO_INT.entrySet()} is guaranteed to iterate over the entries in the

 * maven-compiler-plugin and maven-clean-plugin.
 * <p>
 * Pattern syntax supports:
 * <ul>
 *   <li>Standard glob patterns with {@code *}, {@code ?}, and {@code **} wildcards</li>
 *   <li>Explicit syntax prefixes like {@code "glob:"} or {@code "regex:"}</li>
 *   <li>Maven 3 compatible behavior for patterns without explicit syntax</li>
 *   <li>Default exclusion patterns for SCM files when requested</li>
 * </ul>

Or in other way, no need for them, import and use the code you need.

Any integration is designed to be so simple to use (with dependencies) that you can create a "plug-in" for your application in 2 lines of code using the same structure and syntax used for your *path operations*.

### Tested { #tested }

* 100% <abbr title="The amount of code that is automatically tested">test coverage</abbr>.

 *
 * <p>As this interface extends {@code java.util.function.Function}, an instance of this type can be
 * used as a {@code java.util.function.Function} directly. To use a {@code
 * java.util.function.Function} in a context where a {@code com.google.common.base.Function} is
 * needed, use {@code function::apply}.
 *
 * <p>This interface is now a legacy type. Use {@code java.util.function.Function} (or the

    }
    return this;
  }

  /**
   * Adds each member of {@code elements} as a candidate for the top {@code k} elements. This
   * operation takes amortized linear time in the length of {@code elements}.
   *
   * <p>If all input data to this {@code TopKSelector} is in a single {@code Iterable}, prefer
   * {@link Ordering#leastOf(Iterable, int)}, which provides a simpler API for that use case.
   */

    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Code must be in range [1000,5000): 5000")
    }
  }

  @Test fun closeReservedSetThrows() {
    data.write("880203ec".decodeHex()) // Close with code 1004
    data.write("880203ed".decodeHex()) // Close with code 1005
    data.write("880203ee".decodeHex()) // Close with code 1006
    for (i in 1015..2999) {

/**
 * Utilities necessary for working with libraries that supply plain {@link Future} instances. Note
 * that, whenever possible, it is strongly preferred to modify those libraries to return {@code
 * ListenableFuture} directly.
 *
 * <p>For interoperability between {@code ListenableFuture} and <b>{@code CompletableFuture}</b>,
 * consider <a href="https://github.com/lukas-krecan/future-converter">Future Converter</a>.
 *

    }

    @ParameterizedTest(name = "Known code {0} maps to message")
    @MethodSource("knownCodeMessagePairs")
    void lookup_returns_expected_message_for_known_codes(int code, String expectedMessage) {
        // Valid inputs: each known code must map to its documented message
        assertEquals(expectedMessage, lookupMessage(code).orElse(null));
    }

    @ParameterizedTest