/**
    * Share flag indicating that level 2 oplocks are forced on this share.
    */
    public static final int SMB2_SHAREFLAG_FORCE_LEVEL2_OPLOCK = 0x1000;
    /**
     * Share flag indicating that hash generation V1 is enabled for this share.
     */
    public static final int SMB2_SHAREFLAG_ENABLE_HASH_V1 = 0x2000;
    /**

        assertEquals(0x0001, SmbConstants.FLAGS2_LONG_FILENAMES);
        assertEquals(0x0002, SmbConstants.FLAGS2_EXTENDED_ATTRIBUTES);
        assertEquals(0x0800, SmbConstants.FLAGS2_EXTENDED_SECURITY_NEGOTIATION);
        assertEquals(0x0004, SmbConstants.FLAGS2_SECURITY_SIGNATURES);
        assertEquals(0x4000, SmbConstants.FLAGS2_STATUS32);
        assertEquals(0x8000, SmbConstants.FLAGS2_UNICODE);
    }

    /**

    @Test
    void testSetFileType() {
        response.fileType = 1;
        assertEquals(1, response.fileType);
    }

    @Test
    void testSetDeviceState() {
        response.deviceState = 0x8000;
        assertEquals(0x8000, response.deviceState);
    }

    @Test
    void testSetAction() {
        response.action = 2;
        assertEquals(2, response.action);
    }

    @Test
    void testSetServerFid() {

            throw new PACDecodingException("Empty kerberos token");
        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {
            content = ASN1Util.readUnparsedTagged(0, 0x8000, stream);
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }

        try (ASN1InputStream stream = new ASN1InputStream(content)) {

    private static final int SHARING_COMPATIBILITY = 0x00;
    private static final int SHARING_DENY_READ_WRITE_EXECUTE = 0x10;
    private static final int SHARING_DENY_WRITE = 0x20;
    private static final int SHARING_DENY_READ_EXECUTE = 0x30;
    private static final int SHARING_DENY_NONE = 0x40;

    private static final int DO_NOT_CACHE = 0x1000; // bit 12
    private static final int WRITE_THROUGH = 0x4000; // bit 14

    static final int SHARING_COMPATIBILITY = 0x00;
    static final int SHARING_DENY_READ_WRITE_EXECUTE = 0x10;
    static final int SHARING_DENY_WRITE = 0x20;
    static final int SHARING_DENY_READ_EXECUTE = 0x30;
    static final int SHARING_DENY_NONE = 0x40;

    static final int DO_NOT_CACHE = 0x1000; // bit 12
    static final int WRITE_THROUGH = 0x4000; // bit 14

    static final int OPEN_FN_CREATE = 0x10;

    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putBytes(new byte[] {0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00});
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putLong(0x0000000001000101L);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher

      mergeAdjacentRanges(
        listOf(
          Mapping(0x0000, 0x002c, TYPE_DISALLOWED_STD3_VALID, ByteString.EMPTY),
        ),
      ),
    ).containsExactly(
      Mapping(0x0000, 0x002c, TYPE_VALID, ByteString.EMPTY),
    )
  }

  @Test fun simplifyCombinesCanonicalEquivalent() {
    assertThat(
      mergeAdjacentRanges(
        listOf(
          Mapping(0x0000, 0x002c, TYPE_DISALLOWED_STD3_VALID, ByteString.EMPTY),

    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putBytes(new byte[] {0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00});
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putLong(0x0000000001000101L);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher

    int i = 0;

    // This loop optimizes for pure ASCII.
    while (i < utf16Length && sequence.charAt(i) < 0x80) {
      i++;
    }

    // This loop optimizes for chars less than 0x800.
    for (; i < utf16Length; i++) {
      char c = sequence.charAt(i);
      if (c < 0x800) {
        utf8Length += (0x7f - c) >>> 31; // branch free!
      } else {
        utf8Length += encodedLengthGeneral(sequence, i);