this.subject = subject;
            this.failOnRefresh = failOnRefresh;
        }

        @Override
        public TestCredentials clone() {
            // Return a shallow copy with the same field values
            return new TestCredentials(this.domain, this.anonymous, this.guest, this.subject, this.failOnRefresh);
        }

        @Override

Guava provides two different "flavors": one for use on a (Java 8+) JRE and one
for use on Android or by any library that wants to be compatible with Android.
These flavors are specified in the Maven version field as either `33.5.0-jre` or
`33.5.0-android`. For more about depending on Guava, see
[using Guava in your build].

To add a dependency on Guava using Maven, use the following:

```xml
<dependency>

     * purposes, the "count" field, tracking the number of elements, serves as that volatile
     * variable ensuring visibility. This is convenient because this field needs to be read in many
     * read operations anyway:
     *
     * - All (unsynchronized) read operations must first read the "count" field, and should not look
     * at table entries if it is 0.
     *

        }
        // Convert milliseconds to 100-nanosecond intervals
        // 1 ms = 10,000 * 100ns intervals
        long intervals = timeoutMs * 10000L;
        // MS-SMB2 timeout field is 4 bytes (uint32), so clamp to max value
        return Math.min(intervals, 0xFFFFFFFFL);
    }

    /**
     * Get the flags
     * @return the flags
     */
    public int getFlags() {

  /*
   * Per JDK: "the behavior of a map entry is undefined if the backing map has been modified after
   * the entry was returned by the iterator, except through the setValue operation on the map entry"
   * As such, this field must be cleared before every map mutation.
   *
   * Note about volatile: volatile doesn't make it safe to read from a mutable graph in one thread

    /**
     * Creates a NetBIOS session message header.
     * The header format is:
     * - Byte 0: Message type (0x00 for SESSION_MESSAGE)
     * - Byte 1: High bit of 17-bit length field
     * - Bytes 2-3: Lower 16 bits of length field
     */
    private static byte[] messageHeader(int length) {
        byte[] h = new byte[4];
        h[0] = (byte) SessionServicePacket.SESSION_MESSAGE;

    /** Version number for optimistic locking. */
    public String versionNo;

    /**
     * Clears all pagination state and filter parameters.
     * Resets pagination counters to default values and clears all filter fields.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;
        existNextPage = false;
        pageSize = getDefaultPageSize();

  @WeakOuter
  private final class ServiceDelegate extends AbstractService {

    // A handle to the running task so that we can stop it when a shutdown has been requested.
    // These two fields are volatile because their values will be accessed from multiple threads.
    private volatile @Nullable Cancellable runningTask;
    private volatile @Nullable ScheduledExecutorService executorService;

  var bodyLimit: Long by delegate::bodyLimit

  var serverSocketFactory: ServerSocketFactory? by delegate::serverSocketFactory

  var dispatcher: Dispatcher = QueueDispatcher()
    set(value) {
      field = value
      delegate.dispatcher = value.wrap()
    }

  val port: Int
    get() {
      before() // This implicitly starts the delegate.
      return delegate.port
    }

  val hostName: String

    }

    if (userRequest.header("Connection") == null) {
      requestBuilder.header("Connection", "Keep-Alive")
    }

    // If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
    // the transfer stream.
    var transparentGzip = false
    if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
      transparentGzip = true