@Override
  AbstractFuture<@Nullable Integer> newDelegate() {
    AbstractFuture<@Nullable Integer> future = new AbstractFuture<@Nullable Integer>() {};
    assertFalse(future instanceof TrustedFuture); // sanity check
    return future;
  }

                return SearchResult.create().build();
            } catch (final ExecutionException e) {
                if (e.getCause() instanceof final InvalidQueryException iqe) {
                    throw iqe;
                }
                if (e.getCause() instanceof final ResultOffsetExceededException roee) {
                    throw roee;
                }

    }

    @Test
    @DisplayName("Should correctly inherit from ServerMessageBlock2Request")
    void testInheritance() {
        // Then
        assertTrue(request instanceof ServerMessageBlock2Request);
        assertTrue(request instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should handle different previous session IDs")
    void testDifferentPreviousSessionIds() throws Exception {

  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) {
      return s.equals(((BaseComparable) other).s);
    } else {
      return false;
    }
  }

  @Override
  public int compareTo(BaseComparable o) {
    return s.compareTo(o.s);
  }

  /** Constructor for use by subclasses. */
  public AbstractGraph() {}

  @Override
  public final boolean equals(@Nullable Object obj) {
    if (obj == this) {
      return true;
    }
    if (!(obj instanceof Graph)) {
      return false;
    }
    Graph<?> other = (Graph<?>) obj;

    return isDirected() == other.isDirected()
        && nodes().equals(other.nodes())
        && edges().equals(other.edges());
  }

        // Verify that RequestTimeoutException is a subclass of TransportException
        RequestTimeoutException exception = new RequestTimeoutException();
        assertTrue(exception instanceof TransportException, "RequestTimeoutException should be an instance of TransportException");
    }

    BinaryBreakingSuperclassChangeRule(Map<String, Object> params) {
        super(params)
    }

    @Override
    protected boolean changed(JApiCompatibility member) {
        return member instanceof JApiClass && !member.superclass.binaryCompatible && !member.superclass.compatibilityChanges.empty
    }

    @Override
    protected Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass) {

        this.config = cfg;
        this.name = name.getName();
        this.hexCode = name.getNameType();
        this.scope = name.getScope();
        if (name instanceof Name) {
            this.srcHashCode = ((Name) name).srcHashCode;
        }
    }

    /**
     * Checks if this represents an unknown address.
     *
     * @return whether this is the unknown address

            tmp.writeVInt(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(Integer.MAX_VALUE - i);
        }
        BytesReference pagedBytes = tmp.bytes();
        if (pagedBytes instanceof PagedBytesReference == false) {
            throw new AssertionError("expected PagedBytesReference but saw [" + pagedBytes.getClass() + "]");
        }
        this.streamInput = pagedBytes.streamInput();
    }

            tmp.writeVLong(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVLong(Long.MAX_VALUE - i);
        }
        BytesReference pagedBytes = tmp.bytes();
        if (pagedBytes instanceof PagedBytesReference == false) {
            throw new AssertionError("expected PagedBytesReference but saw [" + pagedBytes.getClass() + "]");
        }
        this.streamInput = pagedBytes.streamInput();
    }