@DisplayName("Should reject offset+length exceeding buffer size in sign method")
        void testSignOffsetLengthExceedsBuffer() {
            byte[] data = new byte[100];
            assertThrows(IllegalArgumentException.class, () -> digest.sign(data, 50, 60, request, response),
                    "Should throw IllegalArgumentException when offset+length > buffer size");
        }

        @Test

    }

    /**
     * Constructs a buffer cache with specified parameters.
     *
     * @param maxBuffers the maximum number of buffers to cache
     * @param maxSize the size of each buffer in bytes
     *
     */
    public BufferCacheImpl(final int maxBuffers, final int maxSize) {
        this.cache = new Object[maxBuffers];
        this.bufferSize = maxSize;
    }

    /**

        if (len > this.outputBuffer.length) {
            throw new SMBProtocolDecodingException("Payload exceeds buffer size");
        }
        System.arraycopy(buffer, bufferIndex, this.outputBuffer, 0, len);
        return len;
    }

    @Override
    public String toString() {

  }

  public void testSize0() {
    Iterator<String> iterator = emptyIterator();
    assertEquals(0, Iterators.size(iterator));
  }

  public void testSize1() {
    Iterator<Integer> iterator = singleton(0).iterator();
    assertEquals(1, Iterators.size(iterator));
  }

  public void testSize_partiallyConsumed() {
    Iterator<Integer> iterator = asList(1, 2, 3, 4, 5).iterator();

    List<Range<C>> asRanges = ImmutableList.copyOf(rangeSet.asRanges());

    // test that connected ranges are coalesced
    for (int i = 0; i + 1 < asRanges.size(); i++) {
      Range<C> range1 = asRanges.get(i);
      Range<C> range2 = asRanges.get(i + 1);
      assertFalse(range1.isConnected(range2));
    }

    // test that there are no empty ranges

  }

  /**
   * Defer to {@link AbstractGraph#edges()} (based on {@link #successors(Object)}) for full edges()
   * implementation.
   */
  @Override
  protected long edgeCount() {
    return delegate().edges().size();
  }

  @Override
  public boolean isDirected() {
    return delegate().isDirected();
  }

  @Override
  public boolean allowsSelfLoops() {
    return delegate().allowsSelfLoops();
  }

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Generator for collection of a particular size.
 *
 * @author George van den Driessche
 */
@GwtCompatible
@NullMarked
public final class OneSizeGenerator<T, E extends @Nullable Object>
    implements OneSizeTestContainerGenerator<T, E> {

            if (info != null) {
                interfaces.add(info);
            }

            if (next == 0) {
                // Last entry - advance by the full structure size
                bufferIndex += 152;
                break;
            }

            // Move to next entry based on Next offset
            bufferIndex += next;
        }

        return bufferIndex - start;

    return q.comparator();
  }

  @CanIgnoreReturnValue // pushed down from class to method
  @Override
  public int size() {
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      return q.size();
    } finally {
      monitor.leave();
    }
  }

  /**

    return singletonIterator(element);
  }

  @Override
  public Spliterator<E> spliterator() {
    return singleton(element).spliterator();
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public ImmutableList<E> subList(int fromIndex, int toIndex) {
    Preconditions.checkPositionIndexes(fromIndex, toIndex, 1);