Events
======

Events allow you to capture metrics on your application’s HTTP calls. Use events to monitor:

 * The size and frequency of the HTTP calls your application makes. If you’re making too many calls, or your calls are too large, you should know about it!
 * The performance of these calls on the underlying network. If the network’s performance isn’t sufficient, you need to either improve the network or use less of it.

### EventListener

  // Use fewer steps in the ListIteratorTester in ListListIteratorTester because it's slow in prod
  // mode.
  static int listListIteratorTesterNumIterations() {
    // TODO(hhchan): It's 4 in java.  Figure out why even 3 is too slow in prod mode.
    return 2;
  }

  // Use fewer steps in the IteratorTester in CollectionIteratorTester because it's slow in prod
  // mode.
  static int collectionIteratorTesterNumIterations() {
    return 3;

    }

    @Test
    @DisplayName("Should throw exception when buffer too small")
    void testWriteBytesWireFormatBufferTooSmall() {
        // Given
        Configuration mockConfig = mock(Configuration.class);
        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);
        byte[] buffer = new byte[3]; // Too small for 4 bytes

        // When & Then

        // Then
        assertEquals(4, bytesRead);
    }

    @Test
    @DisplayName("Should throw exception when buffer too small for reading")
    void testReadBytesWireFormatBufferTooSmall() {
        // Given
        byte[] buffer = new byte[1]; // Too small to read structure size

        // When & Then
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {

        // Length is 10 bytes, so expected string length is 5 characters
        PacUnicodeString pacString = new PacUnicodeString((short) 10, (short) 20, 100);
        String testString = "too-long"; // Length is 8

        // Expect a PACDecodingException to be thrown
        PACDecodingException exception = assertThrows(PACDecodingException.class, () -> {
            pacString.check(testString);

    listener.shouldClose = true
    // Large headers are a likely reason the servers would cut off the connection before it completes sending
    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =
      Headers
        .Builder()
        .apply {
          repeat(32) {
            add("name-$it", "value-$it-" + "0".repeat(1024))
          }
        }.build()
    val call2 =

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        if (dst.length - dstIndex < pipeDataLen) {
            if (LogStream.level >= 3) {
                log.println("TransTransactNamedPipe data too long for buffer");
            }
            return 0;
        }
        System.arraycopy(pipeData, pipeDataOff, dst, dstIndex, pipeDataLen);
        return pipeDataLen;
    }

    @Override

                + expected
                + ", actual = "
                + actual);
      }
    }

    if (expectedIter.hasNext() || actualIter.hasNext()) {
      // actual either had too few or too many elements
      fail(
          "contents were not equal and in the same order: "
              + "expected = "
              + expected
              + ", actual = "
              + actual);
    }

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        if (dst.length - dstIndex < pipeDataLen) {
            if (LogStream.level >= 3) {
                log.println("TransCallNamedPipe data too long for buffer");
            }
            return 0;
        }
        System.arraycopy(pipeData, pipeDataOff, dst, dstIndex, pipeDataLen);
        return pipeDataLen;
    }

    @Override

import org.jspecify.annotations.Nullable;

/** Tests for {@link AbstractSequentialIterator}. */
@GwtCompatible
@NullMarked
public class AbstractSequentialIteratorTest extends TestCase {
  @GwtIncompatible // Too slow
  public void testDoublerExhaustive() {
    new IteratorTester<Integer>(
        3, UNMODIFIABLE, ImmutableList.of(1, 2), IteratorTester.KnownOrder.KNOWN_ORDER) {
      @Override