assertEquals(2, dataMap.size());
        assertEquals("A0", dataMap.get("a"));
        assertEquals("B1", dataMap.get("b"));
    }

    /** Case 2: Key conflict (without .overwrite) → Overwrite with value from responseDataMap */
    public void test_mergeResponseData_keyConflict() {
        Map<String, Object> dataMap = new HashMap<>();
        dataMap.put("x", "X0");
        Map<String, Object> responseDataMap = new HashMap<>();

            docList.stream().forEach(doc -> {
                if (!thumbnailManager.offer(doc)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Removing {}={} from doc[{}]", thumbnailField, doc.get(thumbnailField),
                                doc.get(fessConfig.getIndexFieldUrl()));
                    }
                    doc.remove(thumbnailField);
                }

        assertTrue(UniAddress.isAllDigits(""), "isAllDigits should return true for empty string (no non-digits)");
    }

    /* ---------------------------------------------------------------------
     * 4. Exceptions from static methods that don't resolve without stubbing
     * --------------------------------------------------------------------- */
    @Test
    void getAllByNameRejectsNullOrEmptyHostname() {

        // Assert: the extended interface relationship holds
        assertTrue(impl instanceof CredentialsInternal, "Should be usable as CredentialsInternal");

        // Cast and check we can call clone() from CredentialsInternal contract
        CredentialsInternal ci = (CredentialsInternal) impl;
        CredentialsInternal cloned = ci.clone();
        assertNotNull(cloned, "clone() should return a non-null CredentialsInternal");

        verify(locator).handleDFSReferral(null, "");
        verifyNoMoreInteractions(locator);
    }

    // Invalid input: null reqPath leads to NPE from implementation
    @Test
    @DisplayName("handleDFSReferral throws NPE on null reqPath")
    void handleDfsReferralNullPathThrows() {

        IOException error = new IOException("Connection failed");
        failover.handleFailure(failedChannel, error);

        // Verify pending operations were cleared from failed channel
        assertEquals(0, failedChannel.getRequestsPending());

        // Verify alternative channel was selected and operation added
        verify(mockLoadBalancer).selectChannel(mockOperation);

        verify(mockHandle, times(1)).sendrecv(any(MsrpcSamrCloseHandle.class));
    }

    @Test
    void testClose_SmbExceptionOnClose() throws IOException {
        // Test case: close() with non-zero retval from MsrpcSamrCloseHandle, should throw SmbException
        String server = "testServer";
        int access = 123;
        int errorRetval = 12345; // Simulate an error code

        // Setup for successful constructor

            if (p.getType() == type) {
                return true;
            }
        }
        return false;
    }

    /**
     * Gets the first AV pair of the specified type from the list
     *
     * @param pairs the list of AV pairs to search
     * @param type the AV pair type to retrieve
     * @return first occurance of the given type
     */

		return errInvalidArgument
	}
	return nil
}

// BatchJobReplicateTarget describes target element of the replication job that receives
// the filtered data from source
type BatchJobReplicateTarget struct {
	Type     BatchJobReplicateResourceType `yaml:"type" json:"type"`
	Bucket   string                        `yaml:"bucket" json:"bucket"`

        assertNull(delegatingConfig.getMaximumVersion(), "Should return null when delegate returns null");
    }

    @Test
    @DisplayName("Delegation should handle exceptions from delegate")
    void testExceptionHandling() {
        // Given
        RuntimeException testException = new RuntimeException("Test exception");
        when(mockDelegate.getResponseTimeout()).thenThrow(testException);