/** Deflates [buffer] in place as described in RFC 7692 section 7.2.1. */
  @Throws(IOException::class)
  fun deflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {

    void testServerInfo1TimeMethods() throws Exception {
        NetServerEnum2Response.ServerInfo1 server = response.new ServerInfo1();
        assertEquals(0L, server.createTime());
        assertEquals(0L, server.lastModified());
        assertEquals(0L, server.lastAccess());
        assertEquals(0L, server.length());
    }

    @Test
    @DisplayName("Test ServerInfo1 toString")
    void testServerInfo1ToString() throws Exception {

    }

    /**
     * Parameterised test of capacity values, including edge cases such as
     * zero and negative capacities.
     */
    @ParameterizedTest
    @ValueSource(longs = { 0L, -1L, Long.MAX_VALUE })
    @DisplayName("capacity may be any long value")
    void testCapacityEdgeValues(long capacity) {
        when(mockAllocInfo.getCapacity()).thenReturn(capacity);

internal inline fun Lockable.notifyAll() = (this as Object).notifyAll()

internal inline fun Lockable.awaitNanos(nanos: Long) {
  val ms = nanos / 1_000_000L
  val ns = nanos - (ms * 1_000_000L)
  if (ms > 0L || nanos > 0) {
    (this as Object).wait(ms, ns.toInt())
  }
}

internal inline fun Lockable.assertLockNotHeld() {
  if (assertionsEnabled && Thread.holdsLock(this)) {

        return (T) Short.valueOf((short) 0);
      } else if (type == int.class) {
        return (T) Integer.valueOf(0);
      } else if (type == long.class) {
        return (T) Long.valueOf(0L);
      } else if (type == float.class) {
        return (T) FLOAT_DEFAULT;
      } else if (type == double.class) {
        return (T) DOUBLE_DEFAULT;
      }
    }
    return null;
  }

  fun mockWebServer() {
    val mockWebServer = MockWebServer()
    var port: Int = mockWebServer.getPort()
    mockWebServer.setServerSocketFactory(ServerSocketFactory.getDefault())
    mockWebServer.setBodyLimit(0L)
    mockWebServer.setProtocolNegotiationEnabled(false)
    mockWebServer.setProtocols(listOf(Protocol.HTTP_1_1))
    var requestCount: Int = mockWebServer.getRequestCount()
  }

  @Test @Disabled

    val ns = nanos - (ms * 1_000_000L)

    while (ms > 100) {
      Thread.sleep(100)
      if (javaNetSocket.isClosed) throw InterruptedIOException("socket closed")
      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())
    }
  }

  override fun cancel() {
    delegate.cancel()
  }

  override fun close() {
    javaNetSocket.close()
  }

 * for the requested file or directory.
 */
public class SmbComQueryInformationResponse extends ServerMessageBlock implements SmbBasicFileInfo {

    private int fileAttributes = 0x0000;
    private long lastWriteTime = 0L;
    private final long serverTimeZoneOffset;
    private int fileSize = 0;

    /**
     * Constructs a query information response.
     *
     * @param config the configuration

    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {
        return@map InetAddress.getByAddress(
          Buffer().writeLong(0L).writeLong(it).readByteArray(),
        )
      }
  }

    const val TAG_CLASS_APPLICATION = 0b0100_0000
    const val TAG_CLASS_CONTEXT_SPECIFIC = 0b1000_0000
    const val TAG_CLASS_PRIVATE = 0b1100_0000

    const val TAG_END_OF_CONTENTS = 0L
  }