} finally {
      if (t.getState() != Thread.State.TERMINATED) {
        t.interrupt();
        fail("Test timed out");
      }
    }
  }

  /**
   * Waits for LONG_DELAY_MS milliseconds for the thread to terminate (using {@link
   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
   * fails.
   */
  void awaitTermination(Thread t) {

   * ExecutorService#close}.
   *
   * @param service the {@code ExecutorService} to shut down
   * @param timeout the maximum time to wait for the {@code ExecutorService} to terminate
   * @return {@code true} if the {@code ExecutorService} was terminated successfully, {@code false}
   *     if the call timed out or was interrupted
   * @since 28.0 (but only since 33.4.0 in the Android flavor)
   */
  @CanIgnoreReturnValue

import jcifs.Configuration;
import jcifs.internal.smb1.AndXServerMessageBlock;
import jcifs.internal.smb1.ServerMessageBlock;

/**
 * SMB1 Logoff AndX request message.
 *
 * This command is used to terminate a user session that was
 * previously established with a Session Setup AndX command.
 */
public class SmbComLogoffAndX extends AndXServerMessageBlock {

    /**

        }
        return crawlerContext.sessionId;
    }

    /**
     * Waits for the crawling process to terminate indefinitely.
     */
    public void awaitTermination() {
        awaitTermination(0);
    }

    /**
     * Waits for the crawling process to terminate for a specified duration.
     * @param millis The maximum time to wait in milliseconds. A value of 0 means wait indefinitely.
     */

import jcifs.Configuration;
import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Logoff request message. This command is used to terminate an SMB2 session.
 *
 * @author mbechler
 *
 */
public class Smb2LogoffRequest extends ServerMessageBlock2Request<Smb2LogoffResponse> {

    /**

            }
        }
    }

    /**
     * Interrupts the thread and waits for it to terminate.
     *
     * @param timeoutMillis
     *            The time to wait (in milliseconds)
     * @return <code>true</code> if the thread has terminated
     * @throws InterruptedException
     *             If interrupted while waiting
     */

   * Such a sequence is referred to as "text." STX may be used to terminate a sequence of characters
   * started by SOH.
   *
   * @since 8.0
   */
  public static final byte STX = 2;

  /**
   * End of Text: A communication control character used to terminate a sequence of characters
   * started with STX and transmitted as an entity.
   *
   * @since 8.0
   */

         * @return true if the thread is actively executing
         */
        public boolean isRunning() {
            return running;
        }

        /**
         * Waits for the crawling thread to terminate.
         * This method blocks until the thread completes its execution.
         * Interrupted exceptions are caught and logged at debug level.
         */
        public void awaitTermination() {
            try {

        if (sneaky == null) {
          return sample;
        } else {
          /* Someone beat us to it! Trying again...
           *
           * Technically this loop not guaranteed to terminate, so theoretically (extremely
           * unlikely) this thread might starve, but even then, there is always going to be another
           * thread doing progress here.
           */
        }
      }
    }

      this.sink.trailers = trailers
    }
  }

  fun readTimeout(): Timeout = readTimeout

  fun writeTimeout(): Timeout = writeTimeout

  /**
   * Abnormally terminate this stream. This blocks until the `RST_STREAM` frame has been
   * transmitted.
   */
  @Throws(IOException::class)
  fun close(
    rstStatusCode: ErrorCode,
    errorException: IOException?,
  ) {