*
 * @author mbechler
 */
public class SmbComLockingAndX extends AndXServerMessageBlock {

    private int fid;
    private byte typeOfLock;
    private byte newOpLockLevel;
    private long timeout;
    private LockingAndXRange[] locks;
    private LockingAndXRange[] unlocks;
    private boolean largeFile;

    /**
     * Creates a new SMB1 locking request for file byte-range locking operations.
     *

  private fun readHeader() {
    if (closed) throw IOException("closed")

    // Disable the timeout to read the first byte of a new frame.
    val b0: Int
    val timeoutBefore = source.timeout().timeoutNanos()
    source.timeout().clearTimeout()
    try {
      b0 = source.readByte() and 0xff
    } finally {
      source.timeout().timeout(timeoutBefore, TimeUnit.NANOSECONDS)
    }

    opcode = b0 and B0_MASK_OPCODE

  })
  @ParametricNullness
  final V blockingGet(long timeout, TimeUnit unit)
      throws InterruptedException, TimeoutException, ExecutionException {
    // NOTE: if timeout < 0, remainingNanos will be < 0 and we will fall into the while(true) loop
    // at the bottom and throw a timeoutexception.
    long timeoutNanos = unit.toNanos(timeout); // we rely on the implicit null check on unit.

        }

        // Test with config parameters
        configParameters = "config.timeout=30\nconfig.retry=3";
        result = ParameterUtil.createConfigParameterMap(configParameters);
        assertEquals(2, result.get(ConfigName.CONFIG).size());
        assertEquals("30", result.get(ConfigName.CONFIG).get("timeout"));
        assertEquals("3", result.get(ConfigName.CONFIG).get("retry"));

    boolean isUseLeases();

    /**
     * @return timeout for persistent handles in milliseconds
     */
    long getPersistentHandleTimeout();

    /**
     * Gets the witness heartbeat timeout in milliseconds.
     *
     * @return the heartbeat timeout
     */
    long getWitnessHeartbeatTimeout();

    /**
     * Gets the witness registration timeout in milliseconds.
     *

import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource

@Flaky // STDOUT logging enabled for test
@Timeout(30)
@Tag("Slow")
open class ConnectionListenerTest {
  @RegisterExtension
  val platform = PlatformRule()

  @Override
  public final void awaitRunning(long timeout, TimeUnit unit) throws TimeoutException {
    delegate.awaitRunning(timeout, unit);
  }

  /**
   * @since 15.0
   */
  @Override
  public final void awaitTerminated() {
    delegate.awaitTerminated();
  }

  /**
   * @since 15.0
   */
  @Override
  public final void awaitTerminated(long timeout, TimeUnit unit) throws TimeoutException {

        }
        return this.nextNameTrnId;
    }

    void ensureOpen(final int timeout) throws IOException {
        this.closeTimeout = 0;
        if (this.transportContext.getConfig().getNetbiosSoTimeout() != 0) {
            this.closeTimeout = Math.max(this.transportContext.getConfig().getNetbiosSoTimeout(), timeout);
        }
        // If socket is still good, the new closeTimeout will

    super.connect(new UnixSocketAddress(path), 0);
  }

  @Override public void connect(SocketAddress endpoint, int timeout) throws IOException {
    this.inetSocketAddress = (InetSocketAddress) endpoint;
    super.connect(new UnixSocketAddress(path), timeout);
  }

  @Override public InetAddress getInetAddress() {
    return inetSocketAddress.getAddress();
  }

    return future.blockingGet();
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future, long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    return future.blockingGet(timeout, unit);
  }

  private Platform() {}