import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tester for typical subclass of {@link ForwardingObject} by using Mockito.
 *
 * @author Ben Yu
 */
@NullUnmarked
final class ForwardingObjectTester {

  private static final Method DELEGATE_METHOD;

  static {
    try {

    }

    value = getWithoutCaching(key);
    if (value != null) {
      addToCache((K) key, value);
    }
    return value;
  }

  // Internal methods (package-visible, but treat as only subclass-visible)

  @Override
  @Nullable V getIfCached(@Nullable Object key) {
    V value = super.getIfCached(key);
    if (value != null) {
      return value;
    }

        assertEquals(cause, exception.getCause(), "Cause should match the provided throwable");
    }

    @Test
    void testIsInstanceOfTransportException() {
        // Verify that RequestTimeoutException is a subclass of TransportException
        RequestTimeoutException exception = new RequestTimeoutException();
        assertTrue(exception instanceof TransportException, "RequestTimeoutException should be an instance of TransportException");

              public void remove() {
                throw new IllegalStateException() {
                  /* subclass */
                };
              }

              @Override
              public Integer next() {
                throw new NoSuchElementException() {
                  /* subclass */
                };
              }

              @Override
              public boolean hasNext() {

   * {@link SortedMultiset#entrySet}, and {@link SortedMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link SortedMultiset#elementSet} to forward to this
   * implementation or a subclass thereof.
   */
  protected class StandardElementSet extends SortedMultisets.ElementSet<E> {
    /** Constructor for use by subclasses. */
    public StandardElementSet() {
      super(ForwardingSortedMultiset.this);

 * result extraction, header encoding/decoding, and the round-trip of an
 * encode/decode operation.
 */
public class DcerpcMessageTest {

    /**
     * A trivial concrete subclass used for testing. It simply writes a
     * single small value in {@code encode_in} and reads it in
     * {@code decode_out}.
     */
    private static class TestMessage extends DcerpcMessage {

   * ForwardingMultiset#entrySet}, and {@link ForwardingMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link ForwardingMultiset#elementSet} to forward to this
   * implementation or a subclass thereof.
   *
   * @since 10.0
   */
  protected class StandardElementSet extends Multisets.ElementSet<E> {
    /** Constructor for use by subclasses. */
    public StandardElementSet() {}

    @Override

 * single row key may or may not be ordered, depending on the implementation. When rows and columns
 * are both sorted, it's easier to use the {@link TreeBasedTable} subclass.
 *
 * <p>The {@link #rowKeySet} method returns a {@link SortedSet} and the {@link #rowMap} method
 * returns a {@link SortedMap}, instead of the {@link Set} and {@link Map} specified by the {@link
 * Table} interface.
 *

 * <i>chaining</i>, and <i>using</i>.
 *
 * <h4>Acquiring</h4>
 *
 * <p>The common ways to get an instance of {@code Ordering} are:
 *
 * <ul>
 *   <li>Subclass it and implement {@link #compare} instead of implementing {@link Comparator}
 *       directly
 *   <li>Pass a <i>pre-existing</i> {@link Comparator} instance to {@link #from(Comparator)}

 * thought of as overkill; however, it's difficult to determine which proper subset of this massive
 * set would be sufficient to expose any possible bug. Brute force is simpler.
 *
 * <p>To use this class the concrete subclass must implement the {@link
 * IteratorTester#newTargetIterator()} method. This is because it's impossible to test an Iterator
 * without changing its state, so the tester needs a steady supply of fresh Iterators.
 *