when(mockCtx.getConfig()).thenReturn(mock(Configuration.class));
        Smb2SessionSetupRequest nextReq = new Smb2SessionSetupRequest(mockCtx, 0, 0, 0L, null);
        assertEquals(0L, nextReq.getSessionId());

        resp.prepare(nextReq);
        assertEquals(0L, nextReq.getSessionId(), "SessionId should not be propagated before response is received");
    }

    @Test

        @Override
        public int getAttributes() {
            return 0;
        }

        @Override
        public long getCreateTime() {
            return 0L;
        }

        @Override
        public long getLastWriteTime() {
            return 0L;
        }

        @Override
        public long getSize() {
            return endOfFile;
        }

        @Override
        public String toString() {

        void shouldHandleZeroValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(0L, 0L);

            // When & Then
            assertEquals(0L, allocInfo.getCapacity());
            assertEquals(0L, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle maximum long values")
        void shouldHandleMaximumLongValues() {

  private val delegate: Sink,
  private val triggerByteCount: Long,
  private val trigger: () -> Unit,
) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount == 0L) return // Avoid double-triggering.

    if (bytesWritten == triggerByteCount) {
      source.skip(byteCount)
      return
    }

        assertEquals(1000L, configHelper.reloadInterval);

        configHelper.setReloadInterval(5000L);
        assertEquals(5000L, configHelper.reloadInterval);

        configHelper.setReloadInterval(0L);
        assertEquals(0L, configHelper.reloadInterval);

        configHelper.setReloadInterval(-1L);
        assertEquals(-1L, configHelper.reloadInterval);
    }

    val pool = factory.newConnectionPool()
    val poolApi = ConnectionPool(pool)
    val c1 = factory.newConnection(pool, routeA1, 0L)
    allocateAndLeakAllocation(poolApi, c1)
    awaitGarbageCollection()
    assertThat(pool.closeConnections(100L)).isEqualTo(0L)
    assertThat(c1.calls).isEmpty()

    // Can't allocate once a leak has been detected.
    assertThat(c1.noNewExchanges).isTrue()
  }

  private val noContextTakeover: Boolean,
) : Closeable {
  private var closed = false

  // Stateful data about the current frame.
  private var opcode = 0
  private var frameLength = 0L
  private var isFinalFrame = false
  private var isControlFrame = false
  private var readingCompressedMessage = false

  private val controlFrameBuffer = Buffer()
  private val messageFrameBuffer = Buffer()

package okhttp3.internal.http2.flowcontrol

class WindowCounter(
  val streamId: Int,
) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged

  @Synchronized
  fun update(
    total: Long = 0,

  private var intervalPingsSent = 0L
  private var intervalPongsReceived = 0L
  private var degradedPingsSent = 0L
  private var degradedPongsReceived = 0L
  private var awaitPingsSent = 0L
  private var awaitPongsReceived = 0L

  /** Consider this connection to be unhealthy if a degraded pong isn't received by this time. */
  private var degradedPongDeadlineNs = 0L

    void testGetCreateTime() {
        assertEquals(0L, fileStandardInfo.getCreateTime());
    }

    @Test
    @DisplayName("Test getLastWriteTime returns 0")
    void testGetLastWriteTime() {
        assertEquals(0L, fileStandardInfo.getLastWriteTime());
    }

    @Test
    @DisplayName("Test getLastAccessTime returns 0")
    void testGetLastAccessTime() {
        assertEquals(0L, fileStandardInfo.getLastAccessTime());
    }