* Converts to {@link Short}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@link Short}
     */
    public static Short toShort(final Object o) {
        return toShort(o, null);
    }

    /**
     * Converts to {@link Short}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string

        return ITEM_ENDPOINT_SUFFIX;
    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        final Map<String, Object> requestBody = new HashMap<>();
        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        return updateMap;
    }

    @AfterEach

    }

    return false;
  }

  @Override
  public boolean containsEntry(@Nullable Object key, @Nullable Object value) {
    Collection<V> collection = asMap().get(key);
    return collection != null && collection.contains(value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@Nullable Object key, @Nullable Object value) {
    Collection<V> collection = asMap().get(key);

    @Override
    public boolean containsKey(Object key) {
      return standardContainsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
      return standardContainsValue(value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {
      standardPutAll(map);
    }

    @Override
    public @Nullable V remove(Object object) {
      return standardRemove(object);

  abstract Type getGenericReturnType();

  static class MethodInvokable<T> extends Invokable<T, Object> {

    final Method method;

    MethodInvokable(Method method) {
      super(method);
      this.method = method;
    }

    @Override
    final @Nullable Object invokeInternal(@Nullable Object receiver, @Nullable Object[] args)
        throws InvocationTargetException, IllegalAccessException {

                        },
                        "type": "object",
                        "required": ["subname", "sub_description", "tags"],
                        "title": "SubItem",
                    },
                    "WithComputedField-Input": {
                        "properties": {"name": {"type": "string", "title": "Name"}},
                        "type": "object",
                        "required": ["name"],

 * java.lang.ref.Cleaner Cleaner}; see example <a href="#cleaner">below</a>.
 *
 * <p>Keep a strong reference to this object until all of the associated referents have been
 * finalized. If this object is garbage collected earlier, the backing thread will not invoke {@code
 * finalizeReferent()} on the remaining references.
 *

  private static final RangeMap<Comparable<?>, Object> EMPTY_SUB_RANGE_MAP =
      new RangeMap<Comparable<?>, Object>() {
        @Override
        public @Nullable Object get(Comparable<?> key) {
          return null;
        }

        @Override
        public @Nullable Entry<Range<Comparable<?>>, Object> getEntry(Comparable<?> key) {
          return null;
        }

    }

    /** Case 1: Normal merge (no duplicates) */
    @Test
    public void test_mergeResponseData_noOverwrite() {
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("a", "A0");
        Map<String, Object> responseDataMap = new HashMap<>();
        responseDataMap.put("b", "B1");

        indexUpdateCallback.mergeResponseData(dataMap, responseDataMap);

 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
public final class ArrayListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractListMultimap<K, V> {
  // Default from ArrayList
  private static final int DEFAULT_VALUES_PER_KEY = 3;

  @VisibleForTesting transient int expectedValuesPerKey;

  /**