// Should match with same values
        assertTrue(fileInfo.matches(1024L, 1000L, 0x20));

        // Should not match with different size
        assertFalse(fileInfo.matches(2048L, 1000L, 0x20));

        // Should not match with different last modified
        assertFalse(fileInfo.matches(1024L, 2000L, 0x20));

     * Supports concurrent multiplexing flag.
     */
    int DCERPC_CONC_MPX = 0x10; /* supports concurrent multiplexing */
    /**
     * Did not execute flag - indicates request was not executed
     */
    int DCERPC_DID_NOT_EXECUTE = 0x20;
    /**
     * Maybe flag - indicates 'maybe' call semantics requested
     */
    int DCERPC_MAYBE = 0x40; /* `maybe' call semantics requested */
    /**

	MOVF.NE	(g), F3                                   // 003a9a1d
	MOVD	(g), F3                                   // 003b9aed
	MOVF	0x20(R3), F9       // MOVF 32(R3), F9     // 089a93ed
	MOVD.EQ	0x20(R4), F9       // MOVD.EQ 32(R4), F9  // 089b940d
	MOVF.NE	-0x20(g), F3       // MOVF.NE -32(g), F3  // 083a1a1d
	MOVD	-0x20(g), F3       // MOVD -32(g), F3     // 083b1aed
	MOVF	F9, (R4)                                  // 009a84ed

  }

  @Test
  fun flagOverlapOn0x20() {
    assertThat(frameLog(true, 3, 10000, TYPE_HEADERS, 0x20))
      .isEqualTo("<< 0x00000003 10000 HEADERS       PRIORITY")
    assertThat(frameLog(true, 3, 10000, TYPE_DATA, 0x20))
      .isEqualTo("<< 0x00000003 10000 DATA          COMPRESSED")
  }

  /**

        // Given
        int testType = 0x20; // Server service
        when(mockNetbiosName.getNameType()).thenReturn(testType);

        // When
        int nameType = mockNetbiosName.getNameType();

        // Then
        assertEquals(testType, nameType);
        verify(mockNetbiosName).getNameType();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0x00, 0x03, 0x06, 0x1B, 0x1C, 0x1D, 0x1E, 0x20 })

     */
    public static final int SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY = 0x10;

    /**
     * Share capability indicating scale-out support.
     */
    public static final int SMB2_SHARE_CAP_SCALEOUT = 0x20;

    /**
     * Share capability indicating cluster support.
     */
    public static final int SMB2_SHARE_CAP_CLUSTER = 0x40;

    /**
     * Share capability indicating asymmetric support.
     */

  const val FLAG_END_HEADERS = 0x4 // Used for headers and continuation.
  const val FLAG_END_PUSH_PROMISE = 0x4
  const val FLAG_PADDED = 0x8 // Used for headers and data.
  const val FLAG_PRIORITY = 0x20 // Used for headers.
  const val FLAG_COMPRESSED = 0x20 // Used for data.

  /** Lookup table for valid frame types. */
  private val FRAME_NAMES =
    arrayOf(
      "DATA",
      "HEADERS",
      "PRIORITY",
      "RST_STREAM",

    void testEquals() {
        byte[] testBytes1 = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
        byte[] testBytes2 = Arrays.copyOf(testBytes1, 16);
        byte[] testBytes3 = new byte[] { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20 };

        Smb2LeaseKey key1 = new Smb2LeaseKey(testBytes1);

    @Test
    void testSetFid() {
        response.fid = 123;
        assertEquals(123, response.fid);
    }

    @Test
    void testSetFileAttributes() {
        response.fileAttributes = 0x20; // ATTR_ARCHIVE
        assertEquals(0x20, response.fileAttributes);
    }

    @Test
    void testSetLastWriteTime() {
        long time = System.currentTimeMillis();
        response.lastWriteTime = time;

            + "abcdefghijklmnopqrstuvwxyz"
            + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            + "1234567890";
    assertEquals(s, xmlEscaper.escape(s));

    // Test ASCII control characters.
    for (char ch = 0; ch < 0x20; ch++) {
      if (ch == '\t' || ch == '\n' || ch == '\r') {
        // Only these whitespace chars are permitted in XML,
        if (shouldEscapeWhitespaceChars) {