When configured, MinIO sends request and credential details for every API call to an external HTTP(S) endpoint and expects an allow/deny response. MinIO is thus able to delegate access management to an external system, and users are able to use a custom solution instead of S3 standard IAM policies.

  StandardMutableGraph(AbstractGraphBuilder<? super N> builder) {
    this.backingValueGraph = new StandardMutableValueGraph<>(builder);
  }

  @Override
  BaseGraph<N> delegate() {
    return backingValueGraph;
  }

  @Override
  public boolean addNode(N node) {
    return backingValueGraph.addNode(node);
  }

  @Override
  public boolean putEdge(N nodeU, N nodeV) {

        UniAddress ua = new UniAddress(nbtMock);
        // Act
        String next = ua.nextCalledName();
        // Assert
        assertEquals("NEXT", next, "nextCalledName should delegate to NbtAddress when called");
    }

    @Test
    void nextCalledNameWithInetAddressReturnsSMBSERVERFirstIfNotDefault() {
        // Arrange
        InetAddress addr = mock(InetAddress.class);

              @Override
              public SortedSet<String> create(String[] elements) {
                NavigableSet<String> delegate = new TreeSet<>(MinimalCollection.of(elements));
                return Collections.synchronizedNavigableSet(delegate);
              }
            })
        .named("synchronizedNavigableSet/TreeSet, natural")
        .withFeatures(
            SetFeature.GENERAL_PURPOSE,

        handle = new SmbTreeHandleImpl(resourceLoc, treeConnection);
    }

    @Test
    @DisplayName("Constructor acquires tree connection; getConfig/isConnected delegate")
    void constructorAndSimpleDelegations() {
        // Ensures constructor acquires tree connection and simple delegate methods forward correctly
        // Verify constructor invoked acquire once
        verify(treeConnection, times(1)).acquire();

        // getConfig delegates

    out.write(b);
    count++;
  }

  // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:
  // it silently ignores any exception thrown by flush(). Instead, just close the delegate stream.
  // It should flush itself if necessary.
  @Override
  public void close() throws IOException {
    out.close();
  }

   - If unable to complete the review, tag another reviewer (e.g., `@username please take over`).

4. **Shared Responsibility**:
   - All MinIO contributors are reviewers. The first commenter on a PR owns the review unless they delegate.
   - Multiple reviewers are encouraged for complex PRs.

5. **No Self-Edits**:
   - Don’t modify the PR directly (e.g., fixing bugs). Request changes from the submitter or create a follow-up PR.

@GwtCompatible
public class BaseComparable implements Comparable<BaseComparable>, Serializable {
  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {

@GwtCompatible
@NullUnmarked
class Base implements Comparable<Base>, Serializable {
  private final String s;

  public Base(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof Base) {

  companion object {
    /**
     * A DNS that uses [InetAddress.getAllByName] to ask the underlying operating system to
     * lookup IP addresses. Most custom [Dns] implementations should delegate to this instance.
     */
    @JvmField
    val SYSTEM: Dns = DnsSystem()

    private class DnsSystem : Dns {
      override fun lookup(hostname: String): List<InetAddress> {
        try {