}

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

      0x1ff8,
      0x7fffd8,
      0xfffffe2,
      0xfffffe3,
      0xfffffe4,
      0xfffffe5,
      0xfffffe6,
      0xfffffe7,
      0xfffffe8,
      0xffffea,
      0x3ffffffc,
      0xfffffe9,
      0xfffffea,
      0x3ffffffd,
      0xfffffeb,
      0xfffffec,
      0xfffffed,
      0xfffffee,
      0xfffffef,
      0xffffff0,
      0xffffff1,
      0xffffff2,
      0x3ffffffe,

            this.largeReadX = true;
            this.readSizeFile =
                    Math.min(th.getConfig().getReceiveBufferSize() - 70, th.areSignaturesActive() ? 0xFFFF - 70 : 0xFFFFFF - 70);
            log.debug("Enabling LARGE_READX with " + this.readSizeFile);
        } else {
            log.debug("LARGE_READX disabled");
            this.readSizeFile = this.readSize;
        }

            }

            // there seems to be a bug with some servers that causes corruption if using signatures + CAP_LARGE_WRITE
            if (th.hasCapability(SmbConstants.CAP_LARGE_WRITEX) && !th.areSignaturesActive()) {
                this.writeSize = Math.min(th.getConfig().getSendBufferSize() - 70, 0xFFFF - 70);
            }

            this.fp = 0L;

	MOVW	R1, R0<<0(F1)      // ERROR "illegal base register"
	MOVB	R2, R0<<0(F1)      // ERROR "illegal base register"
	MOVF	0x00ffffff(F2), F1 // ERROR "illegal base register"
	MOVD	0x00ffffff(F2), F1 // ERROR "illegal base register"
	MOVF	F2, 0x00ffffff(F2) // ERROR "illegal base register"
	MOVD	F2, 0x00ffffff(F2) // ERROR "illegal base register"
	MULS.S	R1, R2, R3, R4     // ERROR "invalid .S suffix"

        return Stream.of(Arguments.of(0), Arguments.of(1), Arguments.of(255), Arguments.of(256), Arguments.of(65535), Arguments.of(65536),
                Arguments.of(0x7FFFFFFF), Arguments.of(0xFFFFFFFF));
    }

    @Test
    @DisplayName("readInt2 should correctly read 16-bit integer")
    void testReadInt2() {
        byte[] src = { (byte) 0x12, (byte) 0x34, (byte) 0x56 };

      throw IOException("FRAME_SIZE_ERROR: $length")
    }
    val type = source.readByte() and 0xff
    val flags = source.readByte() and 0xff
    val streamId = source.readInt() and 0x7fffffff // Ignore reserved bit.
    if (type != TYPE_WINDOW_UPDATE && logger.isLoggable(FINE)) {
      logger.fine(frameLog(true, streamId, length, type, flags))
    }

    if (requireSettings && type != TYPE_SETTINGS) {

				t.Fatal(err)
			}
		}
	}
	t.Run("uint32max-2_NoZip64", func(t *testing.T) {
		t.Parallel()
		if generatesZip64(t, gen(0xfffffffe)) {
			t.Error("unexpected zip64")
		}
	})
	t.Run("uint32max-1_Zip64", func(t *testing.T) {
		t.Parallel()
		if !generatesZip64(t, gen(0xffffffff)) {
			t.Error("expected zip64")
		}
	})
}

// At 16k records, we need to generate a zip64 file.

        streamId = streamId,
        length = length + 4,
        type = TYPE_PUSH_PROMISE,
        flags = if (byteCount == length.toLong()) FLAG_END_HEADERS else 0,
      )
      sink.writeInt(promisedStreamId and 0x7fffffff)
      sink.write(hpackBuffer, length.toLong())

      if (byteCount > length) writeContinuationFrames(streamId, byteCount - length)
    }
  }

  @Throws(IOException::class)
  fun flush() {

        transaction.setTotalParameterCount(0xFFFFFFFF);
        transaction.setTotalDataCount(0xFFFFFFFF);
        transaction.setMaxParameterCount(0xFFFFFFFF);
        transaction.setMaxDataCountForTest(0xFFFFFFFF);
        transaction.setParameterCount(0xFFFFFFFF);
        transaction.setParameterOffset(0xFFFFFFFF);
        transaction.setDataCount(0xFFFFFFFF);
        transaction.setDataOffset(0xFFFFFFFF);