Class<?> utilClass = SmbEnumerationUtil.class;

            // Act
            Object unwrapped = invokePrivate(utilClass, "unwrapDOSFilter", new Class<?>[] { ResourceFilter.class }, wrapper);

            // Assert
            assertNotNull(unwrapped);
            assertTrue(unwrapped instanceof DosFileFilter);

            // Verify fields preserved (via reflection since they are protected)

        // Act & Assert
        // unwrap to interface itself should return same instance
        CredentialsInternal unwrapped = creds.unwrap(CredentialsInternal.class);
        assertNotNull(unwrapped, "unwrap to CredentialsInternal returns instance");
        assertSame(creds, unwrapped, "unwrap returns the same object instance");

        // unwrap to unrelated type should return null (use another Credentials implementation)

        void testUnwrapToDfsReferralData() {
            DfsReferralData unwrapped = referralData.unwrap(DfsReferralData.class);
            assertSame(referralData, unwrapped);
        }

        @Test
        @DisplayName("Should unwrap to DfsReferralDataInternal interface")
        void testUnwrapToDfsReferralDataInternal() {
            DfsReferralDataInternal unwrapped = referralData.unwrap(DfsReferralDataInternal.class);

     */
    @Test
    void testUnwrap() throws SmbException {
        SID sid = new SID(adminSidString);
        SID unwrapped = sid.unwrap(SID.class);
        assertNotNull(unwrapped);
        assertEquals(sid, unwrapped);

        assertThrows(ClassCastException.class, () -> sid.unwrap(String.class));
    }

    /**
     * Test the resolve method.
     *

    @DisplayName("unwrap returns self for assignable type; throws for incompatible and null")
    void testUnwrap() {
        // Happy path: unwrap to concrete type
        SmbPipeHandleImpl unwrapped = target.unwrap(SmbPipeHandleImpl.class);
        assertSame(target, unwrapped);

        // Incompatible type: expect ClassCastException
        class OtherPipeHandle implements SmbPipeHandle {
            @Override

        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);
        NbtAddress unwrapped = nbtAddress.unwrap(NbtAddress.class);
        assertNotNull(unwrapped);
        assertSame(nbtAddress, unwrapped);

        // Test unwrap for incompatible type - NbtAddress implements NetbiosAddress so it should return itself

        // Happy path: unwrap to interface and concrete type
        SmbPipeHandle unwrapped1 = handle.unwrap(SmbPipeHandle.class);
        SmbPipeHandleImpl unwrapped2 = handle.unwrap(SmbPipeHandleImpl.class);
        assertSame(handle, unwrapped1);
        assertSame(handle, unwrapped2);

        // Invalid type
        class OtherPipeHandle implements SmbPipeHandle {
            @Override

        () -> new ClassSanityTester().doTestEquals(SetWrapper.class));
  }

  private abstract static class Wrapper {
    private final Object wrapped;

    Wrapper(Object wrapped) {
      this.wrapped = checkNotNull(wrapped);
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      // In general getClass().isInstance() is bad for equals.

        // Setup mock SearchLogHelper that throws wrapped checked exception
        SearchLogHelper mockSearchLogHelper = new SearchLogHelper() {
            @Override
            public void storeSearchLog() {
                try {
                    throw new Exception("Checked exception");
                } catch (Exception e) {
                    throw new RuntimeException("Wrapped: " + e.getMessage(), e);
                }

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.jspecify.annotations.Nullable;

/**
 * A builder of {@link ConcurrentMap} instances that can have keys or values automatically wrapped
 * in {@linkplain WeakReference weak} references.
 *
 * <p>Usage example:
 *
 * {@snippet :
 * ConcurrentMap<Request, Stopwatch> timers = new MapMaker()
 *     .concurrencyLevel(4)
 *     .weakKeys()