@Override
    @SuppressWarnings("EqualsHashCode") // same semantics
    public boolean equals(@Nullable Object object) {
      if (object == this) {
        return true;
      }
      if (!(object instanceof Set)) {
        return false;
      }
      Set<?> that = (Set<?>) object;

      int thatMaxSize = maxSize(that);
      if (minSize() > thatMaxSize) {

	obj, err := newObjectLayer(ctx, mustGetPoolEndpoints(0, disks...))
	if err != nil {
		t.Fatal("Unexpected object layer initialization error", err)
	}

	_, ok := obj.(*erasureServerPools)
	if !ok {
		t.Fatal("Unexpected object layer detected", reflect.TypeOf(obj))
	}

	// Tests for Erasure object layer initialization.

	// Create temporary backend for the test server.
	nDisks = 16

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

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

  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = new ArrayList<>();

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

        this.funnel,
        that.funnel);
    this.bits.putAll(that.bits);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof BloomFilter) {
      BloomFilter<?> that = (BloomFilter<?>) object;
      return this.numHashFunctions == that.numHashFunctions
          && this.funnel.equals(that.funnel)

  }

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

  @Override
  public final boolean addAll(int index, Collection<? extends E> newElements) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final E set(int index, E element) {

     *
     * @return JSON response containing system statistics
     */
    // GET /api/admin/stats
    @Execute
    public JsonResponse<ApiResult> index() {
        final HashMap<String, Object> stats = new HashMap<>();
        stats.put("jvm", getJvmObj());
        stats.put("os", getOsObj());
        stats.put("process", getProcessObj());
        stats.put("engine", getEngineObj());

	}

	object := "object"
	data := bytes.Repeat([]byte("a"), smallFileThreshold*32)
	z := obj.(*erasureServerPools)

	erasureDisks, err := z.GetDisks(0, 0)
	if err != nil {
		t.Fatal(err)
	}

	for i, test := range testCases {
		t.Run(fmt.Sprintf("case-%d", i), func(t *testing.T) {

     * 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

 */
@NullUnmarked
public class SegmentBenchmark {

  @Param({"16", "32", "64", "128", "256", "512", "1024", "2048", "4096", "8192"})
  int capacity;

  private Segment<Object, Object> segment;

  @BeforeExperiment
  void setUp() {
    LocalCache<Object, Object> cache =
        new LocalCache<>(
            CacheBuilder.newBuilder().concurrencyLevel(1).initialCapacity(capacity), null);
    checkState(cache.segments.length == 1);