@Override
  public int indexOf(@CheckForNull Object object) {
    return (object == null) ? -1 : Lists.indexOfImpl(this, object);
  }

  @Override
  public int lastIndexOf(@CheckForNull Object object) {
    return (object == null) ? -1 : Lists.lastIndexOfImpl(this, object);
  }

  @Override
  public boolean contains(@CheckForNull Object object) {
    return indexOf(object) >= 0;
  }

     * 
     * @return configuration to run
     */
    @Parameters ( name = "{0}" )
    public static Collection<Object> configs () {
        return getConfigs();
    }


    /**
     * @param mutations
     * @return
     */
    static Collection<Object> getConfigs ( String... mutations ) {
        List<Object> configs = new ArrayList<>();

                for (final SearchHit hit : hits) {
                    final Map<String, Object> source = hit.getSourceAsMap();
                    if (limitOfDocumentSize > 0) {
                        long size = 0;
                        for (final String field : supportedFields) {
                            final Object value = source.get(field);
                            if (value != null) {

        return Objects.equals(modelName, other.modelName) && Objects.equals(featureSetName, other.featureSetName)
                && Objects.equals(storeName, other.storeName) && Objects.equals(params, other.params)
                && Objects.equals(activeFeatures, other.activeFeatures);
    }

    @Override
    protected int doHashCode() {

        Map<String, Object> doc = new HashMap<>();

        int expected3 = 999;
        doc.put("key3", expected3);
        assertEquals(expected3, DocumentUtil.getValue(doc, "key3", Integer.class));

        doc.put("key9", new ArrayList<Integer>(Arrays.asList(777, 888, 999)));
        assertEquals(777, DocumentUtil.getValue(doc, "key9", Integer.class));
    }

    public void test_date() {
        Map<String, Object> doc = new HashMap<>();

    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (crawlingInfoId != null) {
            addFieldToSource(sourceMap, "crawlingInfoId", crawlingInfoId);
        }
        if (createdTime != null) {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@ElementTypesAreNonnullByDefault
public class MultimapEqualsTester<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testEqualsTrue() {
    new EqualsTester()
        .addEqualityGroup(multimap(), getSubjectGenerator().create(getSampleElements().toArray()))

 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public final class MinimalIterable<E extends @Nullable Object> implements Iterable<E> {
  /** Returns an iterable whose iterator returns the given elements in order. */
  public static <E extends @Nullable Object> MinimalIterable<E> of(E... elements) {
    // Make sure to get an unmodifiable iterator
    return new MinimalIterable<>(asList(elements).iterator());

failure whereas in MinIO erasure code you can lose as many as half of drives and still the data remains safe. Further, MinIO's erasure code is at the object level and can heal one object at a time. For RAID, healing can be done only at the volume level which translates into high downtime. As MinIO encodes each object individually, it can heal objects incrementally. Storage servers once deployed should not require drive replacement or healing for the lifetime of the server. MinIO's erasure coded backend...

  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = Lists.newArrayList();
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = Lists.newArrayList();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = Lists.newArrayList();

    public void neitherOverriddenNorAnnotated(Object o) {
      neitherOverriddenNorAnnotatedEvents.add(o);
    }