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);
        message.setFlag(0b0001, true);
        assertEquals(0b0001, message.getFlags(), "Flag 0b0001 should be set.");

        assertNotNull(connection1, "First connection should not be null.");
        assertNotNull(connection2, "Second connection should not be null.");
        assertTrue(connection1 instanceof NtlmHttpURLConnection, "First connection should be wrapped.");
        assertTrue(connection2 instanceof NtlmHttpURLConnection, "Second connection should be wrapped.");
    }

    /** Array of fields to be included in standard search response */
    protected String[] responseFields;

    /** Array of fields to be included in scroll search response */
    protected String[] scrollResponseFields;

    /** Array of fields to be included in cache search response */
    protected String[] cacheResponseFields;

    /** Array of fields that can be highlighted in search results */

     * <p>
     * When a prefix is specified, only properties whose names start with the prefix will be included in the copy operation.
     * Additionally, the prefix will be removed from the source property name to form the destination property name.
     * </p>
     *
     * @param prefix
     *            The prefix. Must not be {@literal null} or an empty string.
     * @return This instance itself
     */

        assertTrue(config.isUseUnicode(), "Unicode should be enabled");
        assertTrue(config.isUseBatching(), "Batching should be enabled");

        // When both are enabled, batch limits should be available
        int limit = config.getBatchLimit("TreeConnectAndX.QueryInformation");
        assertTrue(limit >= 0, "Batch limit should be non-negative when Unicode and batching enabled");
    }

    /**

            // Then
            assertNotNull(os1, "Default output stream should not be null");
            assertNotNull(os2, "Output stream with append should not be null");
            assertNotNull(os3, "Output stream with sharing should not be null");
            assertNotNull(os4, "Output stream with full params should not be null");
            assertSame(mockOutputStream, os1, "Should return expected output stream");

# Lifespan Events { #lifespan-events }

You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.

        assertNotNull("Second instance should not be null", target2);
        assertNotSame("Instances should be different objects", target1, target2);
    }

    public void test_class_has_proper_annotations() {
        // Verify the class doesn't have any inappropriate annotations
        assertFalse("Class should not be deprecated", SystemMonitorTarget.class.isAnnotationPresent(Deprecated.class));
    }

        try {
            ThreadDumpUtil.printThreadDump();
        } catch (Exception e) {
            fail("printThreadDump() should not throw exceptions: " + e.getMessage());
        }
    }

    public void test_printThreadDumpAsWarn() {
        // This test verifies that printThreadDumpAsWarn() method exists and can be called without exceptions
        try {

     *
     * @param session the {@link Session}, must not be {@code null}
     * @param root the Maven Dependency, must not be {@code null}
     * @param scope the {link PathScope} to collect dependencies, must not be {@code null}
     * @return the collection result, never {@code null}
     * @throws DependencyResolverException if the dependency tree could not be built
     * @throws IllegalArgumentException if an argument is null or invalid