}
    return headerEntries(*nameValues)
  }

  private fun writeMedium(
    sink: BufferedSink,
    i: Int,
  ) {
    sink.writeByte(i ushr 16 and 0xff)
    sink.writeByte(i ushr 8 and 0xff)
    sink.writeByte(i and 0xff)
  }

        final char[] arr = new char[length];
        int ai = arr.length;
        while (ai-- > 0) {
            arr[ai] = HEXCHARS[value & 0xF];
            value >>>= 4;
        }
        return new String(arr);
    }

    private static byte B(final int i) {
        return (byte) (i & 0xFF);
    }

    private static short S(final int i) {
        return (short) (i & 0xFFFF);
    }

    /**

        this.path = path;
        this.service = service;
        command = SMB_COM_TREE_CONNECT_ANDX;
    }

    @Override
    int getBatchLimit(final byte command) {
        final int c = command & 0xFF;
        // why isn't this just return batchLimits[c]?
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return batchLimits[0];
        case SMB_COM_CREATE_DIRECTORY:
            return batchLimits[2];

        bufferIndex += 2;
        this.dataDisplacement = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.setupCount = buffer[bufferIndex] & 0xFF;
        bufferIndex += 2;

        return bufferIndex - start;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {

                Arguments.of(new byte[] { (byte) 0x0F }, "0f"), Arguments.of(new byte[] { (byte) 0x10 }, "10"),
                Arguments.of(new byte[] { (byte) 0xAB }, "ab"),
                Arguments.of(new byte[] { (byte) 0x7F, (byte) 0x80, (byte) 0xFF }, "7f80ff"));
    }

    // Verifies that toString() formats bytes as lower-case hex with zero-padding

        bufferIndex += 2;
        this.deviceState = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.directory = (buffer[bufferIndex++] & 0xFF) > 0;
        return bufferIndex - start;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override

        this.server = server;
        this.path = path;
        this.service = service;
    }

    @Override
    protected int getBatchLimit(final Configuration cfg, final byte cmd) {
        final int c = cmd & 0xFF;
        switch (c) {
        case SMB_COM_CHECK_DIRECTORY:
            return cfg.getBatchLimit("TreeConnectAndX.CheckDirectory");
        case SMB_COM_CREATE_DIRECTORY:

                log.println("session established ok with " + address);
            }
            return;
        case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
            final int errorCode = in.read() & 0xFF;
            close();
            throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
        case -1:
            throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);

                    break;
                case ServerMessageBlock.SMB_COM_TRANSACTION:
                case ServerMessageBlock.SMB_COM_TRANSACTION2:
                    switch (((SmbComTransaction) request).subCommand & 0xFF) {
                    case SmbComTransaction.NET_SHARE_ENUM:
                    case SmbComTransaction.NET_SERVER_ENUM2:
                    case SmbComTransaction.NET_SERVER_ENUM3:

        assertEquals(0x123, buf.dec_ndr_long()); // call_id
    }

    @Test
    void testEncodeWithDifferentFlags() throws Exception {
        for (int flag : new int[] { 0, 0xFF, 0x01, 0x80 }) {
            TestMessage m = new TestMessage();
            m.ptype = 0;
            m.flags = flag;

            NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
            m.encode(buf);