entry := NewEntry(deploymentID)

	entry.RemoteHost = handlers.GetSourceIP(r)
	entry.UserAgent = r.UserAgent()
	entry.ReqClaims = reqClaims
	entry.ReqHost = r.Host
	entry.ReqPath = r.URL.Path

	q := r.URL.Query()
	reqQuery := make(map[string]string, len(q))
	for k, v := range q {
		reqQuery[k] = strings.Join(v, ",")
	}
	entry.ReqQuery = reqQuery

        @Override
        public boolean apply(Entry<String, String> entry) {
          return !Helpers.mapEntry("banana", "toast").equals(entry);
        }
      };

  static final Predicate<Entry<String, String>> FILTER_ENTRIES_2 =
      new Predicate<Entry<String, String>>() {
        @Override
        public boolean apply(Entry<String, String> entry) {

      // don't let the entries get GCed
      List<Entry<Object, Object>> warmed = warmUp(cache);
      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();
        assertSame(entry.getValue(), cache.asMap().put(entry.getKey(), newValue));
        // don't let the new entry get GCed
        warmed.add(entryOf(entry.getKey(), newValue));

          builder.add(mapEntry(entry.getKey(), v));
        }
        map.put(entry.getKey(), entry.getValue());
      }
      Iterable<Entry<K, V>> ordered = multimapGenerator.order(builder);
      LinkedHashMap<K, Collection<V>> orderedMap = new LinkedHashMap<>();
      for (Entry<K, V> entry : ordered) {
        orderedMap.put(entry.getKey(), map.get(entry.getKey()));
      }

        if (o instanceof Entry) {
          Entry<?, ?> entry = (Entry<?, ?>) o;
          return containsMapping(entry.getKey(), columnKey, entry.getValue());
        }
        return false;
      }

      @Override
      public boolean remove(@CheckForNull Object obj) {
        if (obj instanceof Entry) {
          Entry<?, ?> entry = (Entry<?, ?>) obj;

          reverse(samples.e3()),
          reverse(samples.e4()));
    }

    private Entry<V, K> reverse(Entry<K, V> entry) {
      return Helpers.mapEntry(entry.getValue(), entry.getKey());
    }

    @SuppressWarnings("unchecked")
    @Override
    public BiMap<V, K> create(Object... elements) {
      Entry<?, ?>[] entries = new Entry<?, ?>[elements.length];
      for (int i = 0; i < elements.length; i++) {

  }

  public void testToString() {
    assertEquals("foo=1", entry("foo", 1).toString());
  }

  public void testToStringNull() {
    assertEquals("null=1", entry(NK, 1).toString());
    assertEquals("foo=null", entry("foo", NV).toString());
    assertEquals("null=null", entry(NK, NV).toString());
  }

  public void testEquals() {
    Entry<String, Integer> foo1 = entry("foo", 1);

  static <K extends @Nullable Object, V extends @Nullable Object> Entry<V, K> reverseEntry(
      Entry<K, V> entry) {
    return Helpers.mapEntry(entry.getValue(), entry.getKey());
  }

  @Override
  protected void expectContents(Collection<Entry<K, V>> expected) {
    super.expectContents(expected);
    List<Entry<V, K>> reversedEntries = new ArrayList<>();
    for (Entry<K, V> entry : expected) {
      reversedEntries.add(reverseEntry(entry));

  static <K extends @Nullable Object, V extends @Nullable Object> Entry<V, K> reverseEntry(
      Entry<K, V> entry) {
    return Helpers.mapEntry(entry.getValue(), entry.getKey());
  }

  @Override
  protected void expectContents(Collection<Entry<K, V>> expected) {
    super.expectContents(expected);
    List<Entry<V, K>> reversedEntries = new ArrayList<>();
    for (Entry<K, V> entry : expected) {
      reversedEntries.add(reverseEntry(entry));

    @Override
    public Entry<String, Integer>[] createArray(int length) {
      return (Entry<String, Integer>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
      return new Ordering<Entry<String, Integer>>() {
        @Override
        public int compare(Entry<String, Integer> left, Entry<String, Integer> right) {