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

  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

        SmbShareInfo instance = new SmbShareInfo();
        long expResult = 0L;
        long result = instance.createTime();
        assertEquals(expResult, result);
    }

    /**
     * Test of lastModified method, of class SmbShareInfo.
     */
    @Test
    void testLastModified() {
        SmbShareInfo instance = new SmbShareInfo();
        long expResult = 0L;
        long result = instance.lastModified();

   *
   * @throws RejectedExecutionException if the queue is shut down and the task is not cancelable.
   */
  fun schedule(
    task: Task,
    delayNanos: Long = 0L,
  ) {
    taskRunner.withLock {
      if (shutdown) {
        if (task.cancelable) {
          taskRunner.logger.taskLog(task, this) { "schedule canceled (queue is shutdown)" }
          return
        }

        assertSame(handle, result, "Should return handle after retry");
        // Verify we removed READONLY on the path before retrying
        verify(dest).setPathInformation(currentAttrs & ~SmbConstants.ATTR_READONLY, 0L, 0L, 0L);
        verify(dest, times(2)).openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt());
    }

    @Test
    @DisplayName("openCopyTargetFile rethrows when not READONLY")

   * @return the sum
   */
  public long sumThenReset() {
    long sum = base;
    Cell[] as = cells;
    base = 0L;
    if (as != null) {
      int n = as.length;
      for (int i = 0; i < n; ++i) {
        Cell a = as[i];
        if (a != null) {
          sum += a.value;
          a.value = 0L;
        }
      }
    }
    return sum;
  }

  /**

    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());
    }

        // Setup
        String pipeName = "TestPipe";
        long timeout = 0L;
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName, timeout);
        byte[] buffer = new byte[100];

        // Execute
        int bytesEncoded = request.encode(buffer, 0);

        // Verify
        assertEquals(0L, SMBUtil.readInt8(buffer, 0));

    eventRecorder.takeEvent(ResponseHeadersEnd::class.java, 0L)
    eventRecorder.takeEvent(FollowUpDecision::class.java, 0L)
    eventRecorder.takeEvent(ResponseBodyStart::class.java, responseBodyStartDelay)
    eventRecorder.takeEvent(ResponseBodyEnd::class.java, responseBodyEndDelay)
    eventRecorder.takeEvent(ConnectionReleased::class.java, 0L)
    eventRecorder.takeEvent(CallEnd::class.java, 0L)
  }

  private fun enableTlsWithTunnel() {

            }
            if (name.length() > 0) {
                // if !files we don't need to create SmbFiles here
                final SmbFile f = new SmbFile(this, name, e.getType(), ATTR_READONLY | ATTR_DIRECTORY, 0L, 0L, 0L);
                if (ff != null && !ff.accept(f)) {
                    continue;
                }
                if (files) {
                    list.add(f);
                } else {