@CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    collection.clear();
    assertTrue("After clear(), a collection should be empty.", collection.isEmpty());
    assertEquals(0, collection.size());
    assertFalse(collection.iterator().hasNext());
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testClear_unsupported() {

  protected boolean standardRemoveAll(Collection<?> collection) {
    return Sets.removeAllImpl(this, checkNotNull(collection)); // for GWT
  }

  /**
   * A sensible definition of {@link #equals} in terms of {@link #size} and {@link #containsAll}. If
   * you override either of those methods, you may wish to override {@link #equals} to forward to
   * this implementation.
   *
   * @since 7.0
   */

    }
    return successors;
  }

  @Override
  public Set<E> edgesConnecting(N node) {
    return new MultiEdgesConnecting<E>(outEdgeMap, node) {
      @Override
      public int size() {
        return successorsMultiset().count(node);
      }
    };
  }

  @Override
  public N removeInEdge(E edge, boolean isSelfLoop) {
    N node = super.removeInEdge(edge, isSelfLoop);

/// note | Not

`PATCH`, `PUT`'a göre daha az yaygın kullanılır ve daha az bilinir.

Hatta birçok ekip, kısmi güncellemeler için bile yalnızca `PUT` kullanır.

Bunları nasıl isterseniz öyle kullanmakta **özgürsünüz**; **FastAPI** herhangi bir kısıtlama dayatmaz.

Ancak bu kılavuz, aşağı yukarı, bunların nasıl kullanılması amaçlandığını gösterir.

///

}

// WidthCap returns the cap width of the byte arrays in this pool.
func (bp *BytePoolCap) WidthCap() (n int) {
	if bp == nil {
		return 0
	}
	return bp.wcap
}

// CurrentSize returns current size of buffer pool
func (bp *BytePoolCap) CurrentSize() int {
	if bp == nil {
		return 0
	}
	return len(bp.c) * bp.w

        });
    }

    @Test
    @DisplayName("Test writeParametersWireFormat with exact buffer size")
    void testWriteParametersWireFormatExactBuffer() throws Exception {
        netShareEnum = new NetShareEnum(realConfig);

        // Exact size needed (19 bytes)
        byte[] dst = new byte[19];

        assertDoesNotThrow(() -> {

again:
	nextOut, ok := w.buffer[w.nextOffset]
	if ok {
		n, err = w.w.Write(nextOut)
		delete(w.buffer, w.nextOffset)
		w.nextOffset += int64(n)
		if n != len(nextOut) {
			return 0, fmt.Errorf("expected write size %d but wrote %d bytes", len(nextOut), n)
		}
		if err != nil {
			return 0, err
		}
		goto again
	}

	return len(b), nil
}

    public boolean retainAll(Collection<?> c) {
      synchronized (mutex) {
        return delegate().retainAll(c);
      }
    }

    @Override
    public int size() {
      synchronized (mutex) {
        return delegate().size();
      }
    }

    @Override
    public @Nullable Object[] toArray() {
      synchronized (mutex) {
        return delegate().toArray();
      }
    }

    public boolean removeIf(Predicate<? super E> filter) {
      synchronized (mutex) {
        return delegate().removeIf(filter);
      }
    }

    @Override
    public int size() {
      synchronized (mutex) {
        return delegate().size();
      }
    }

    @Override
    public @Nullable Object[] toArray() {
      synchronized (mutex) {
        return delegate().toArray();
      }
    }

      TrustManagerFactory.getInstance(
        TrustManagerFactory.getDefaultAlgorithm(),
        provider,
      )
    factory.init(null as KeyStore?)
    val trustManagers = factory.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {
      "Unexpected default trust managers: ${trustManagers.contentToString()}"
    }
    return trustManagers[0] as X509TrustManager
  }