* the License.
 */

package com.google.common.cache;

import static com.google.common.cache.LocalCache.Strength.STRONG;
import static com.google.common.collect.Maps.immutableEntry;
import static com.google.common.truth.Truth.assertThat;

import com.google.common.cache.LocalCache.Strength;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;

import static com.google.common.collect.Maps.immutableEntry;
import static java.lang.Math.log;

import com.google.common.annotations.GwtIncompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.EnumSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Stream;

    return Maps.immutableEntry(key, value);
  }

  private void assertMapSize(Map<?, ?> map, int size) {
    assertThat(map).hasSize(size);
    if (size > 0) {
      assertThat(map.isEmpty()).isFalse();
    } else {
      assertThat(map.isEmpty()).isTrue();
    }
    assertCollectionSize(map.keySet(), size);
    assertCollectionSize(map.entrySet(), size);

      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return CompactHashMap.createWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {

   * RowSortedTable subinterface with the revised methods?
   */

  StandardRowSortedTable(
      SortedMap<R, Map<C, V>> backingMap, Supplier<? extends Map<C, V>> factory) {
    super(backingMap, factory);
  }

  private SortedMap<R, Map<C, V>> sortedBackingMap() {
    return (SortedMap<R, Map<C, V>>) backingMap;
  }

  /**
   * {@inheritDoc}
   *

    LinkedHashMap<K, V> map = new LinkedHashMap<>();
    map.put(key, value);
    return map;
  }

  @Generates
  static <K, V> ImmutableMap<K, V> generateImmutableMap(K key, V value) {
    return ImmutableMap.of(key, value);
  }

  @Empty
  static <K, V> ConcurrentMap<K, V> generateConcurrentMap() {
    return Maps.newConcurrentMap();
  }

  @Generates

    assertThat(map.putInstance(Integer.class, 1)).isNull();
    assertEquals(2, map.size());

    assertEquals(0, (int) map.getInstance(int.class));
    assertEquals(1, (int) map.getInstance(Integer.class));

    assertEquals(0, (int) map.putInstance(int.class, null));
    assertEquals(1, (int) map.putInstance(Integer.class, null));

    assertThat(map.getInstance(int.class)).isNull();

import java.util.NoSuchElementException;
import java.util.SortedMap;
import org.jspecify.annotations.Nullable;

/**
 * A sorted map which forwards all its method calls to another sorted map. Subclasses should
 * override one or more methods to modify the behavior of the backing sorted map as desired per the
 * <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

    assertThat(map.putInstance(Integer.class, 1)).isNull();
    assertEquals(2, map.size());

    assertEquals(0, (int) map.getInstance(int.class));
    assertEquals(1, (int) map.getInstance(Integer.class));

    assertEquals(0, (int) map.putInstance(int.class, null));
    assertEquals(1, (int) map.putInstance(Integer.class, null));

    assertThat(map.getInstance(int.class)).isNull();

  }

  /**
   * Implements {@code Multimap.put()} -- and no other methods -- for a {@code Map} by ignoring all
   * but the latest value for each key. This class exists only so that we can use {@link
   * MultimapsCollectionTest#populateMultimapForGet(Multimap, String[])} and similar methods to
   * populate a map to be passed to {@link Multimaps#forMap(Map)}. All tests should run against the
   * result of {@link #build()}.
   */