address.toInetAddress();
            address.unwrap(Address.class);
        }, "All Address interface methods should be callable");
    }

    @Test
    @DisplayName("unwrap method should return correct type when supported")
    void testUnwrapMethodContract() throws Exception {
        // Given
        when(mockAddress.unwrap(Address.class)).thenReturn(mockAddress);

        // When & Then

 * @author mbechler
 *
 */
public interface Credentials {

    /**
     * Unwrap credentials to a specific type.
     *
     * @param <T> the credential type to unwrap to
     * @param type the class of the credential type to unwrap to
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Credentials> T unwrap(Class<T> type);

    /**
     * Get the domain of the user account.

        SID mockSid1 = mock(SID.class);
        SID mockSid2 = mock(SID.class);

        // Mock the unwrap method to return a sid_t instance
        sid_t sidT1 = new sid_t();
        sid_t sidT2 = new sid_t();
        when(mockSid1.unwrap(sid_t.class)).thenReturn(sidT1);
        when(mockSid2.unwrap(sid_t.class)).thenReturn(sidT2);

        jcifs.SID[] sids = { mockSid1, mockSid2 };

public interface DfsReferralData {

    /**
     * Unwrap the referral data to a specific implementation type
     *
     * @param <T> the target type to unwrap to
     * @param type the class of the target type
     * @return the referral adapted to type
     * @throws ClassCastException
     *             if the type is not valid for this object
     */
    <T extends DfsReferralData> T unwrap(Class<T> type);

    /**

        }
    }

    @Nested
    @DisplayName("unwrap method tests")
    class UnwrapTests {

        private Address mockAddress;

        @BeforeEach
        void setup() {
            mockAddress = mock(Address.class);
        }

        @Test
        void shouldReturnUnwrappedAddressWhenWrappedIsAddress() {
            when(mockAddress.unwrap(Address.class)).thenReturn(mockAddress);

     * </table>
     *
     * @return type code
     */
    int getType();

    /**
     * Unwraps this SID to the specified type.
     *
     * @param <T> the type to unwrap to
     * @param type the class of the type to unwrap to
     * @return unwrapped instance
     */
    <T> T unwrap(Class<T> type);

            assertSame(data, data.next());
        }
    }

    @Nested
    @DisplayName("Unwrap Tests")
    class UnwrapTests {

        @Test
        @DisplayName("Should unwrap to DfsReferralData interface")
        void testUnwrapToDfsReferralData() {
            DfsReferralData unwrapped = referralData.unwrap(DfsReferralData.class);
            assertSame(referralData, unwrapped);
        }

        @Test

     * @throws DcerpcException if the wrapping operation fails
     */
    void wrap(NdrBuffer outgoing) throws DcerpcException;

    /**
     * Unwraps incoming DCERPC message data after security processing
     * @param incoming the buffer containing data to be unwrapped
     * @throws DcerpcException if the unwrapping operation fails
     */
    void unwrap(NdrBuffer incoming) throws DcerpcException;

import okio.Buffer
import okio.ByteString

internal fun Dispatcher.wrap(): mockwebserver3.Dispatcher {
  if (this is QueueDispatcher) return this.delegate

  val delegate = this
  return object : mockwebserver3.Dispatcher() {
    override fun dispatch(request: mockwebserver3.RecordedRequest): mockwebserver3.MockResponse = delegate.dispatch(request.unwrap()).wrap()

    override fun peek(): mockwebserver3.MockResponse = delegate.peek().wrap()

    }

    @Test
    @DisplayName("unwrap returns this for compatible types and throws otherwise")
    void unwrap_success_and_failure() {
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\z");

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