assertThat(map.size(), is(5));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testEqaulas() throws Exception {
        @SuppressWarnings("unchecked")
        Map<String, String> copy = (ArrayMap<String, String>) map.clone();
        assertThat(map.equals(copy), is(true));
        assertThat(map.equals(null), is(not(true)));
        map.put("3", "test3");

     * @return the value represented by the {@code static} field
     * @throws IllegalAccessRuntimeException if the field cannot be accessed
     * @see Field#get(Object)
     */
    @SuppressWarnings("unchecked")
    public static <T> T get(final Field field) throws IllegalAccessRuntimeException {
        assertArgumentNotNull("field", field);

        return (T) get(field, null);
    }

    /**

     *
     * @param <T> The target type.
     * @param field The field value from OpenSearch.
     * @param clazz The target class.
     * @return The converted field value.
     */
    @SuppressWarnings("unchecked")
    private <T> T getFieldValue(final Object field, final Class<T> clazz) {
        if (field == null) {
            return null;
        }
        if (clazz.equals(Integer.class)) {

    arraycopy(array, 0, dst, dstOff, size);
    return dstOff + size;
  }

  // The fake cast to E is safe because the creation methods only allow E's
  @Override
  @SuppressWarnings("unchecked")
  public E get(int index) {
    checkElementIndex(index, size);
    // requireNonNull is safe because we guarantee that the first `size` elements are non-null.
    return (E) requireNonNull(array[index]);
  }

        s.writeInt(size);
        for (Entry e = header.next; e != header; e = e.next) {
            s.writeObject(e.element);
        }
    }

    @SuppressWarnings("unchecked")
    @Override
    public void readExternal(final ObjectInput s) throws IOException, ClassNotFoundException {
        final int size = s.readInt();
        header = new Entry(null, null, null);

              @Override
              public SortedMultiset<E> create(Object... entries) {
                @SuppressWarnings("unchecked")
                // we dangerously assume E is a string
                List<E> extremeValues = (List<E>) getExtremeValues();
                @SuppressWarnings("unchecked")
                // map generators must past entry objects
                List<E> normalValues = (List<E>) asList(entries);

     * @param queryString The query string to process.
     * @param isQuery Whether this is a search query (enables highlighting and logging).
     */
    @SuppressWarnings("unchecked")
    public QueryContext(final String queryString, final boolean isQuery) {
        if (queryString != null) {
            if (queryString.startsWith(ALLINURL_FIELD_PREFIX)) {

      return this;
    }

    private void add(@Nullable Object[] elements, int n) {
      ensureRoomFor(n);
      /*
       * The following call is not statically checked, since arraycopy accepts plain Object for its
       * parameters. If it were statically checked, the checker would still be OK with it, since
       * we're copying into a `contents` array whose type allows it to contain nulls. Still, it's

    this.forwardOrder = checkNotNull(forwardOrder);
  }

  @Override
  public int compare(@ParametricNullness T a, @ParametricNullness T b) {
    return forwardOrder.compare(b, a);
  }

  @SuppressWarnings("unchecked") // how to explain?
  @Override
  public <S extends T> Ordering<S> reverse() {
    return (Ordering<S>) forwardOrder;
  }

  // Override the min/max methods to "hoist" delegation outside loops

  @Override

    final Future<Object> future;

    Result(Future<Object> result) {
      this.future = result;
    }
  }

  private enum ExceptionType {
    CHECKED(IOException.class),
    UNCHECKED(RuntimeException.class);

    final Class<? extends Exception> exceptionType;

    ExceptionType(Class<? extends Exception> exceptionType) {
      this.exceptionType = exceptionType;
    }
  }