// var oldValue = map.get(keyToRemove);
        map.remove(keyToRemove);
        // This line doesn't hold - see the Javadoc comments above.
        // assertEquals(expectedValue, oldValue);
        assertFalse(map.containsKey(keyToRemove));
        assertEquals(initialSize - 1, map.size());
      } else {
        assertThrows(UnsupportedOperationException.class, () -> map.remove(keyToRemove));
      }

          RateLimiter rateLimiter =
              RateLimiter.create(qps, warmupMillis, MILLISECONDS, coldFactor, stopwatch);
          assertEquals(warmupMillis, measureTotalTimeMillis(rateLimiter, warmupPermits, random));
        }
      }
    }
  }

  public void testNulls() {
    NullPointerTester tester =
        new NullPointerTester()

          RateLimiter rateLimiter =
              RateLimiter.create(qps, warmupMillis, MILLISECONDS, coldFactor, stopwatch);
          assertEquals(warmupMillis, measureTotalTimeMillis(rateLimiter, warmupPermits, random));
        }
      }
    }
  }

  public void testNulls() {
    NullPointerTester tester =
        new NullPointerTester()

    // TODO: move this to invariant checks once the appropriate hook exists?
    super.expectContents(expected);
    for (Entry<K, V> entry : expected) {
      assertEquals(
          "Wrong value for key " + entry.getKey(), entry.getValue(), getMap().get(entry.getKey()));
    }
  }

  protected final void expectReplacement(Entry<K, V> newEntry) {

import static com.google.common.collect.Maps.immutableEntry;
import static java.util.Collections.singleton;
import static java.util.Collections.unmodifiableList;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertTrue;
import static junit.framework.TestCase.fail;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.ArrayListMultimap;

import static java.lang.Math.max;
import static java.util.Arrays.asList;
import static java.util.Collections.sort;
import static junit.framework.Assert.assertEquals;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEquals(getOrderedElements(), entries);
  }

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();

            "CH", "ID", "DNT", "DNS", "DPR", "ECT", "GPC", "HTTP2", "IP", "MD5", "P3P", "RTT", "TE",
            "UA", "UID", "URL", "WWW", "XSS");

    for (Field field : httpHeadersFields()) {
      assertEquals(
          upperToHttpHeaderName(field.getName(), specialCases, uppercaseAcronyms), field.get(null));
    }
  }

  // Tests that there are no duplicate HTTP header names

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.codelibs.core.beans.converter.DateConverter;

    assertFalse(resultFuture.cancel(true));
    assertFalse(resultFuture.isCancelled());
    assertFalse(inputFuture.isCancelled());
    assertFalse(outputFuture.isCancelled());
    assertEquals(RESULT_DATA, resultFuture.get());
  }

  public void testFutureGetThrowsRuntimeException() throws Exception {
    BadFuture badInput = new BadFuture(immediateFuture(20));