.put(UnsupportedOperationException.class, e -> e instanceof UnsupportedOperationException)
          .put(VerifyException.class, e -> e instanceof VerifyException)
          .putAll(PlatformSpecificExceptionBatch.PLATFORM.exceptions())
          .buildOrThrow();

  private ReflectionFreeAssertThrows() {}

    Table<String, Integer, @NonNull C> other = HashBasedTable.create();
    other.put("foo", 1, cellValue('d'));
    other.put("bar", 2, cellValue('e'));
    other.put("cat", 2, cellValue('f'));
    table.putAll(other);
    assertEquals((Character) 'd', table.get("foo", 1));
    assertEquals((Character) 'b', table.get("bar", 1));
    assertEquals((Character) 'c', table.get("foo", 3));

     */
    @Test
    public void testPutAll() throws Exception {
        final Map<String, String> m = new HashMap<String, String>();
        m.put("three", "3");
        m.put("four", "4");
        map.putAll(m);
        assertThat(map.get("THREE"), is("3"));
        assertThat(map.get("FOUR"), is("4"));
        assertThat(map.size(), is(4));
    }

    /**
     * @throws Exception
     */
    @Test

    @Override
    public Object put(final Object key, final Object value) {
        return getProperties().put(key, value);
    }

    @Override
    public void putAll(final Map<? extends Object, ? extends Object> t) {
        getProperties().putAll(t);
    }

    @Override
    public Object remove(final Object key) {
        return getProperties().remove(key);
    }

    @Override

  public @Nullable V put(
      @ParametricNullness R rowKey, @ParametricNullness C columnKey, @ParametricNullness V value) {
    return row(rowKey).put(columnKey, value);
  }

  @Override
  public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
    for (Table.Cell<? extends R, ? extends C, ? extends V> cell : table.cellSet()) {
      put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
    }
  }

   *
   * @throws IllegalArgumentException if an attempt to {@code put} any entry fails. Note that some
   *     map entries may have been added to the bimap before the exception was thrown.
   */
  @Override
  void putAll(Map<? extends K, ? extends V> map);

  // Views

  /**
   * {@inheritDoc}
   *
   * <p>Because a bimap has unique values, this method returns a {@link Set}, instead of the {@link

          .put(UnsupportedOperationException.class, e -> e instanceof UnsupportedOperationException)
          .put(VerifyException.class, e -> e instanceof VerifyException)
          .putAll(PlatformSpecificExceptionBatch.PLATFORM.exceptions())
          .buildOrThrow();

  private ReflectionFreeAssertThrows() {}

   */
  public static <K extends Enum<K>, V extends Enum<V>> EnumBiMap<K, V> create(Map<K, V> map) {
    EnumBiMap<K, V> bimap =
        create(inferKeyTypeOrObjectUnderJ2cl(map), inferValueTypeOrObjectUnderJ2cl(map));
    bimap.putAll(map);
    return bimap;
  }

  private EnumBiMap(Class<K> keyTypeOrObjectUnderJ2cl, Class<V> valueTypeOrObjectUnderJ2cl) {
    super(

   * Changes to the returned map, such as element removal, will update the underlying multimap. The
   * map does not support {@code setValue()} on its entries, {@code put}, or {@code putAll}.
   *
   * <p>When passed a key that is present in the map, {@code asMap().get(Object)} has the same
   * behavior as {@link #get}, returning a live collection. When passed a key that is not present,

    this(
        multimap.keySet().size(),
        (multimap instanceof ArrayListMultimap)
            ? ((ArrayListMultimap<?, ?>) multimap).expectedValuesPerKey
            : DEFAULT_VALUES_PER_KEY);
    putAll(multimap);
  }

  /**
   * Creates a new, empty {@code ArrayList} to hold the collection of values for an arbitrary key.
   */
  @Override
  List<V> createCollection() {