@AndroidIncompatible // depends on details of GC
  public void testFreesNextReference() {
    Iterator<Object> itr =
        new AbstractIterator<Object>() {
          @Override
          public Object computeNext() {
            return new Object();
          }
        };
    WeakReference<Object> ref = new WeakReference<>(itr.next());
    GcFinalization.awaitClear(ref);
  }

    assertEquals(1, Iterators.size(registry.getSubscribers(new Object())));
    assertEquals(1, Iterators.size(registry.getSubscribers(1)));

    registry.register(new IntegerSubscriber());
    assertEquals(3, Iterators.size(registry.getSubscribers("")));
    assertEquals(1, Iterators.size(registry.getSubscribers(new Object())));
    assertEquals(2, Iterators.size(registry.getSubscribers(1)));
  }

      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a

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...

                        # TODO: remove when deprecating Pydantic v1
                        ["name", "price"],
                    ),
                    "type": "object",
                    "properties": {
                        "name": {"title": "Name", "type": "string"},
                        "price": {"title": "Price", "type": "number"},
                        "description": IsDict(

    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        fail(); // Unreachable
        return null;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        fail(); // Unreachable
        return null;
    }

    @Override
    protected void testRead() {
        final Map<String, Object> searchBody = new HashMap<>();

 *
 * @author Jesse Wilson
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class TestMapEntrySetGenerator<
        K extends @Nullable Object, V extends @Nullable Object>
    implements TestSetGenerator<Map.Entry<K, V>> {
  private final SampleElements<K> keys;
  private final SampleElements<V> values;

 */
@ElementTypesAreNonnullByDefault
abstract class MultiEdgesConnecting<E> extends AbstractSet<E> {

  private final Map<E, ?> outEdgeToNode;
  private final Object targetNode;

  MultiEdgesConnecting(Map<E, ?> outEdgeToNode, Object targetNode) {
    this.outEdgeToNode = checkNotNull(outEdgeToNode);
    this.targetNode = checkNotNull(targetNode);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {

    private final Map<String, Object> params = new HashMap<>();

    public CrawlerClientFactoryWrapper(final CrawlerClientFactory factory) {
        this.factory = factory;
    }

    public CrawlerClientFactory getParent() {
        return factory;
    }

    @Override
    public void setInitParameterMap(final Map<String, Object> params) {
        this.params.putAll(params);
    }

    // it still should only have executed twice due to memoization
    assertEquals(2, countingSupplier.calls);
  }

  public void testOfInstanceSuppliesSameInstance() {
    Object toBeSupplied = new Object();
    Supplier<Object> objectSupplier = Suppliers.ofInstance(toBeSupplied);
    assertSame(toBeSupplied, objectSupplier.get());
    assertSame(toBeSupplied, objectSupplier.get()); // idempotent
  }