}

        this.oplockLevel = buffer[bufferIndex + 2];
        this.openFlags = buffer[bufferIndex + 3];
        bufferIndex += 4;

        this.createAction = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.creationTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);

) : Interceptor.Chain {
  private var calls: Int = 0

  internal fun copy(
    index: Int = this.index,
    exchange: Exchange? = this.exchange,
    request: Request = this.request,
    connectTimeoutMillis: Int = this.connectTimeoutMillis,
    readTimeoutMillis: Int = this.readTimeoutMillis,
    writeTimeoutMillis: Int = this.writeTimeoutMillis,
  ) = RealInterceptorChain(
    call,
    interceptors,
    index,
    exchange,

    Trans2FindFirst2(final String filename, final String wildcard, final int searchAttributes) {
        if (filename.equals("\\")) {
            this.path = filename;
        } else {
            this.path = filename + "\\";
        }
        this.wildcard = wildcard;
        this.searchAttributes = searchAttributes & 0x37; /* generally ignored tho */
        command = SMB_COM_TRANSACTION2;
        subCommand = TRANS2_FIND_FIRST2;

        return FS_SIZE_INFO;
    }

    @Override
    public long getCapacity() {
        return this.alloc * this.sectPerAlloc * this.bytesPerSect;
    }

    @Override
    public long getFree() {
        return this.free * this.sectPerAlloc * this.bytesPerSect;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */

    return network.isDirected() ? ordered(nodeU, nodeV) : unordered(nodeU, nodeV);
  }

  /**
   * If this {@link EndpointPair} {@link #isOrdered()}, returns the node which is the source.
   *
   * @throws UnsupportedOperationException if this {@link EndpointPair} is not ordered
   */
  public abstract N source();

  /**
   * If this {@link EndpointPair} {@link #isOrdered()}, returns the node which is the target.
   *

@NullMarked
public interface TestContainerGenerator<T, E extends @Nullable Object> {
  /** Returns the sample elements that this generate populates its container with. */
  SampleElements<E> samples();

  /**
   * Creates a new container containing the given elements. TODO: would be nice to figure out how to
   * use E... or E[] as a parameter type, but this doesn't seem to work because Java creates an
   * array of the erased type.
   */

 * pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingQueue}.
 *
 * @author Raimundo Mirisola
 * @param <E> the type of elements held in this collection
 * @since 4.0
 */
@J2ktIncompatible
@GwtIncompatible

        this.contentSize += contentSize;
    }

    /**
     * Gets the total processing time for all documents in this list.
     *
     * @return the total processing time in milliseconds
     */
    public long getProcessingTime() {
        return processingTime;
    }

    /**
     * Adds to the total processing time of this document list.
     *

    public NetShareEnum(final Configuration config) {
        super(config, SMB_COM_TRANSACTION, NET_SHARE_ENUM);
        this.name = "\\PIPE\\LANMAN";
        this.maxParameterCount = 8;

        // maxDataCount = 4096; why was this set?
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 0;
        this.timeout = 5000;
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, final int dstIndex) {

/*
 * Copyright 2012-2025 CodeLibs Project and the Others.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,