void testInstantiation() {
        TestLocking t = new TestLocking();
        assertNotNull(t, "TestLocking instance should not be null");
    }

    @Test
    @DisplayName("Field values are independent across instances")
    void testIndependentInstances() {
        TestLocking t1 = new TestLocking();
        TestLocking t2 = new TestLocking();

        // Set different values
        t1.numThreads = 2;

        Thread.sleep(500);

        // Now it should be expired
        assertTrue(auth.isExpired());
    }

    /**
     * Test password array independence after construction
     */
    @Test
    @DisplayName("Test password array is truly independent of input")
    public void testPasswordArrayIndependence() {
        char[] originalPassword = "IndependentPass123!".toCharArray();

        assertSame(originalKey, serverData.encryptionKey);
    }

    /**
     * Test multiple ServerData instances are independent
     */
    @Test
    @DisplayName("Test multiple instances are independent")
    public void testMultipleInstancesIndependence() {
        // Given
        ServerData serverData1 = new ServerData();
        ServerData serverData2 = new ServerData();

 *
 * <p>{@code CharSource} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a reader:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned reader is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

 *
 * <p>{@code CharSource} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a reader:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned reader is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

        assertEquals("16s", builder.timeoutSettings.clusterTimeout);
    }

    @Test
    public void testTimeoutSettingsIndependence() {
        // Test that timeout settings are independent for each builder instance
        SuggestSettingsBuilder builder1 = new SuggestSettingsBuilder();
        SuggestSettingsBuilder builder2 = new SuggestSettingsBuilder();

        builder1.scrollTimeout("10s");

permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from or

        // Then
        assertTrue(smbComTreeDisconnect instanceof ServerMessageBlock);
    }

    /**
     * Test multiple instances are independent
     */
    @Test
    @DisplayName("Test multiple instances are independent")
    public void testMultipleInstancesIndependence() {
        // Setup mock to return a valid PID
        when(mockConfig.getPid()).thenReturn(5678);

        // Given

 * immutable <i>supplier</i> of {@code InputStream} instances.
 *
 * <p>{@code ByteSource} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned stream is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

        // Second execution
        String result2 = aggregateLogJob.execute();
        assertNotNull(result2);
        assertTrue(result2.contains("Error 2"));

        // Results should be independent
        assertFalse(result1.equals(result2));
    }

    public void test_execute_withEmptyStringException() {
        // Setup mock SearchLogHelper that throws exception with empty message