forwarding.put("a", 1);
    assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
    forwarding.remove("c");
    assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
  }

  @SuppressWarnings({"rawtypes", "unchecked"})
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            NavigableMap.class,
            new Function<NavigableMap, NavigableMap>() {

     * @param responseType the class of the expected response type
     * @return decoded data
     * @throws SmbException if decoding fails or the response type is incompatible
     */
    @SuppressWarnings("unchecked")
    public <T extends Decodable> T getOutputData(final Class<T> responseType) throws SmbException {

        final Decodable out = getOutputData();

        if (out == null) {

/**
 * A future whose value is derived from a collection of input futures.
 *
 * @param <InputT> the type of the individual inputs
 * @param <OutputT> the type of the output (i.e. this) future
 */
@GwtCompatible
@SuppressWarnings(
    // Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||
    "ShortCircuitBoolean")
abstract class AggregateFuture<InputT extends @Nullable Object, OutputT extends @Nullable Object>

   * {@code <C extends Comparable<? super C>>}, to support legacy types from before Java 5.
   *
   * <p><b>Java 8+ users:</b> use {@link Comparator#naturalOrder} instead.
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  // TODO(kevinb): right way to explain this??
  // plus https://github.com/google/guava/issues/989
  public static <C extends Comparable> Ordering<C> natural() {

      assertThrows(
          NullPointerException.class, () -> builder.addAll((Iterable<String>) iterableWithNulls));
    }
  }

  // We need to test that asList() really does return the original list.
  @SuppressWarnings("InlineMeInliner")
  public void testAsList() {
    ImmutableList<String> list = ImmutableList.of("a", "b");
    assertThat(list.asList()).isSameInstanceAs(list);
  }

  @GwtIncompatible // builder internals

     * @param nonce The OpenID Connect nonce parameter.
     */
    protected void storeStateInSession(final HttpSession session, final String state, final String nonce) {
        @SuppressWarnings("unchecked")
        Map<String, StateData> stateMap = (Map<String, StateData>) session.getAttribute(STATES);
        if (stateMap == null) {
            stateMap = new HashMap<>();

 * <p>In contrast to {@link RangeSet}, no "coalescing" is done of {@linkplain
 * Range#isConnected(Range) connected} ranges, even if they are mapped to the same value.
 *
 * @author Louis Wasserman
 * @since 14.0
 */
@SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
@DoNotMock("Use ImmutableRangeMap or TreeRangeMap")
@GwtIncompatible
public interface RangeMap<K extends Comparable, V> {
  /*

            private final String classifier;
            private final String extension;
            private final String type;
            private final String coordinatesString;

            @SuppressWarnings("checkstyle:ParameterNumber")
            DefaultArtifactFactoryRequestArtifact(
                    @Nonnull Session session,
                    RequestTrace trace,
                    String groupId,

 * your own escapers extend this class and implement the {@link #escape(char)} method.
 *
 * @author Sven Mawson
 * @since 15.0
 */
@GwtCompatible
@SuppressWarnings("EscapedEntity") // We do mean for the user to see "<" etc.
public abstract class CharEscaper extends Escaper {
  /** Constructor for use by subclasses. */
  protected CharEscaper() {}

  /**

 */
@GwtCompatible
/*
 * The type parameter is <T> rather than <T extends @Nullable> so that we can use T in the
 * doEquivalent and doHash methods to indicate that the parameter cannot be null.
 */
@SuppressWarnings("UngroupedOverloads")
public abstract class Equivalence<T> {
  /** Constructor for use by subclasses. */
  protected Equivalence() {}

  /**
   * Returns {@code true} if the given objects are considered equivalent.