}

    /**
     * Gets the flags field which contains flags in SMB 3.1.1 or encryption algorithm ID in SMB 3.0/3.0.2
     *
     * @return the flags (SMB 3.1.1) or encryption algorithm (SMB 3.0/3.0.2)
     */
    public int getFlags() {
        return this.flags;
    }

    /**
     * Sets the flags field which contains flags in SMB 3.1.1 or encryption algorithm ID in SMB 3.0/3.0.2
     *

    }

    @DisplayName("Should handle various share flag combinations")
    @ParameterizedTest
    @MethodSource("provideFlagCombinations")
    void testShareFlagCombinations(int flags, boolean expectedDfs) throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = createValidResponseBuffer(0, flags, 0, 0);

        // When
        response.readBytesWireFormat(buffer, 0);

        offset += 8;

        // Directory flags (4 bytes)
        int flags = 0;
        if (cacheScope == DirectoryCacheScope.RECURSIVE_TREE) {
            flags |= DIRECTORY_LEASE_FLAG_RECURSIVE;
        }
        if (notificationEnabled) {
            flags |= DIRECTORY_LEASE_FLAG_NOTIFICATIONS;
        }
        SMBUtil.writeInt4(flags, buffer, offset);
        offset += 4;

     *
     * @param flags The flags to apply to this message.
     * @param suppliedDomain The supplied authentication domain.
     * @param suppliedWorkstation The supplied workstation name.
     */
    public Type1Message(final int flags, final String suppliedDomain, String suppliedWorkstation) {
        setFlags(getDefaultFlags() | flags);
        setSuppliedDomain(suppliedDomain);

        assertFalse(message.getFlag(0b0100), "Flag 0b0100 should not be set.");
        assertFalse(message.getFlag(0b0001), "Flag 0b0001 should not be set.");

        message.setFlags(0); // No flags set
        assertFalse(message.getFlag(0b1000), "No flags should be set.");
    }

    @Test
    void testSetFlag() {
        // Test setting a flag
        message.setFlags(0);

    @Test
    @DisplayName("Test flag checking with bitwise AND")
    void testFlagChecking() {
        int flags = SecurityInfo.OWNER_SECURITY_INFO | SecurityInfo.DACL_SECURITY_INFO;

        // Test presence of flags
        assertTrue((flags & SecurityInfo.OWNER_SECURITY_INFO) != 0);
        assertTrue((flags & SecurityInfo.DACL_SECURITY_INFO) != 0);

        // Test absence of flags

    // These XLA flags are needed to trigger XLA properly from C (more generally
    // non-Python) clients. If this API is called again with `enable` set to
    // false, it is safe to keep these flag values as is.
    tensorflow::MarkForCompilationPassFlags* flags =
        tensorflow::GetMarkForCompilationPassFlags();
    flags->tf_xla_cpu_global_jit = true;
    flags->tf_xla_min_cluster_size = 1;
  } else {

    private static final int BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.OpenAndX.ReadAndX", 1);

    int flags, desiredAccess, searchAttributes, fileAttributes, creationTime, openFunction, allocationSize;

    // flags is NOT the same as flags member

    SmbComOpenAndX(final String fileName, final int access, final int flags, final ServerMessageBlock andx) {
        super(andx);
        this.path = fileName;

     */
    @Test
    void testConstructor_CreateAndOpen() {
        int flags = SmbFile.O_CREAT;
        smbComOpenAndX = new SmbComOpenAndX(fileName, access, flags, andx);
        assertEquals(0x11, smbComOpenAndX.openFunction); // OPEN_FN_CREATE | OPEN_FN_OPEN
    }

    /**
     * Test constructor with no special flags.
     */
    @Test
    void testConstructor_OpenOnly() {
        int flags = 0;

            // Check that no two flags overlap (except combined flags)
            for (int i = 0; i < flags.length; i++) {
                for (int j = i + 1; j < flags.length; j++) {
                    assertEquals(0, flags[i] & flags[j], String.format("Flags at index %d and %d should not overlap", i, j));
                }
            }
        }
    }