* aka OPEN_EXISTING
     */

    static final int FILE_OPEN = 0x1;

    /* Create the file or fail if it does not exist
     * aka CREATE_NEW
     */

    static final int FILE_CREATE = 0x2;

    /* Open the file or create it if it does not exist
     * aka OPEN_ALWAYS
     */

    static final int FILE_OPEN_IF = 0x3;

    /* Open the file and overwrite it's contents or fail if it does not exist

  const val INITIAL_MAX_FRAME_SIZE = 0x4000 // 16384

  const val TYPE_DATA = 0x0
  const val TYPE_HEADERS = 0x1
  const val TYPE_PRIORITY = 0x2
  const val TYPE_RST_STREAM = 0x3
  const val TYPE_SETTINGS = 0x4
  const val TYPE_PUSH_PROMISE = 0x5
  const val TYPE_PING = 0x6
  const val TYPE_GOAWAY = 0x7
  const val TYPE_WINDOW_UPDATE = 0x8

     */
    public static final int COMPRESSION_NONE = 0x0;
    public static final int COMPRESSION_LZ77 = 0x1;
    public static final int COMPRESSION_LZ77_HUFFMAN = 0x2;
    public static final int COMPRESSION_LZNT1 = 0x3;
    public static final int COMPRESSION_PATTERN_V1 = 0x4;

    /**
     * Compresses data using the specified algorithm.
     *

   * represent the length.
   */
  internal const val B1_MASK_LENGTH = 127

  internal const val OPCODE_CONTINUATION = 0x0
  internal const val OPCODE_TEXT = 0x1
  internal const val OPCODE_BINARY = 0x2

  internal const val OPCODE_CONTROL_CLOSE = 0x8
  internal const val OPCODE_CONTROL_PING = 0x9
  internal const val OPCODE_CONTROL_PONG = 0xa

  /**

    public static final int COMPRESSION_NONE = 0x0;
    /** LZ77 compression */
    public static final int COMPRESSION_LZ77 = 0x1;
    /** LZ77 + Huffman compression */
    public static final int COMPRESSION_LZ77_HUFFMAN = 0x2;
    /** LZNT1 compression (Windows standard) */
    public static final int COMPRESSION_LZNT1 = 0x3;
    /** Pattern V1 compression */
    public static final int COMPRESSION_PATTERN_V1 = 0x4;

    void testDefaultFlags() {
        assertEquals(0, msg.getFlags(), "Initial flags should be 0");
    }

    @ParameterizedTest(name = "setFlags({0}) ➜ getFlags() == {0}")
    @ValueSource(ints = { 0x0, 0x1, 0x2, 0xFFFFFFFF, -123456 })
    void testSetAndGetFlags(int value) {
        msg.setFlags(value);
        assertEquals(value, msg.getFlags(), "getFlags should return the value set");
    }

    @Test

        super(config, SMB_COM_OPEN_ANDX, fileName, andx);
        this.fileAttributes = fileAttributes;

        this.desiredAccess = access & 0x3;
        if (this.desiredAccess == 0x3) {
            this.desiredAccess = 0x2; /* Mmm, I thought 0x03 was RDWR */
        }

        // map shareAccess as far as we can
        if ((shareAccess & SmbConstants.FILE_SHARE_READ) != 0 && (shareAccess & SmbConstants.FILE_SHARE_WRITE) != 0) {

     * Channel type for RDMA version 1
     */
    public static int SMB2_CHANNEL_RDMA_V1 = 0x1;
    /**
     * Channel type for RDMA version 1 with invalidate
     */
    public static int SMB2_CHANNEL_RDMA_V1_INVALIDATE = 0x2;

    private byte[] fileId;
    private final byte[] outputBuffer;
    private final int outputBufferOffset;
    private byte padding;
    private byte readFlags;
    private int readLength;

        for (int i = 0; i < fileId.length; i++)
            fileId[i] = (byte) (i + 1);

        byte[] header = buildSmb2Header();
        byte[] body = buildCreateBodyNoContexts((byte) 0x7, (byte) 0x2, 0x11223344, 1111L, 2222L, 3333L, 4444L, 123456789L, 987654321L,
                0xA5A5A5A5, fileId);
        byte[] packet = buildPacket(header, body, null, null);

        int read = resp.decode(packet, 0, false);

      0x1ff9,
      0x15,
      0xf8,
      0x7fa,
      0x3fa,
      0x3fb,
      0xf9,
      0x7fb,
      0xfa,
      0x16,
      0x17,
      0x18,
      0x0,
      0x1,
      0x2,
      0x19,
      0x1a,
      0x1b,
      0x1c,
      0x1d,
      0x1e,
      0x1f,
      0x5c,
      0xfb,
      0x7ffc,
      0x20,
      0xffb,
      0x3fc,
      0x1ffa,