super(tc, DcerpcHandle.parseBinding(url));
        this.pipe = new SmbNamedPipe(makePipeUrl(), pipeFlags, unshared, tc);
        this.handle = this.pipe.openPipe().unwrap(SmbPipeHandleInternal.class);
    }

    private String makePipeUrl() {
        final DcerpcBinding binding = getBinding();
        StringBuilder url =

    public SmbTreeImpl acquire() {
        return acquire(true);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTree#unwrap(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T extends SmbTree> T unwrap(final Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {
            return (T) this;
        }
        throw new ClassCastException();

else:  # pragma: no cover
    from asyncio import iscoroutinefunction


def _unwrapped_call(call: Optional[Callable[..., Any]]) -> Any:
    if call is None:
        return call  # pragma: no cover
    unwrapped = inspect.unwrap(_impartial(call))
    return unwrapped


def _impartial(func: Callable[..., Any]) -> Callable[..., Any]:
    while isinstance(func, partial):
        func = func.func
    return func


@dataclass

        Mockito.when(mockContext.getConfig()).thenReturn(mockConfig);
        Mockito.when(mockContext.getCredentials()).thenReturn(mockCredentials);
        Mockito.when(mockCredentials.unwrap(Mockito.any())).thenReturn(mockCredentialsInternal);
        Mockito.when(mockCredentialsInternal.clone()).thenReturn(mockCredentialsInternal);
        Mockito.when(mockTransport.acquire()).thenReturn(mockTransport);
    }

        // Given
        InetAddress realInetAddress = InetAddress.getByName("127.0.0.1");
        when(mockNetbiosAddress.toInetAddress()).thenReturn(realInetAddress);
        when(mockNetbiosAddress.unwrap(NbtAddress.class)).thenReturn(null);

        // When/Then - This will throw UnknownHostException quickly
        assertThrows(UnknownHostException.class, () -> {

                this.type = SmbConstants.TYPE_WORKGROUP;
            } else {
                try {
                    final NetbiosAddress nbaddr = getAddress().unwrap(NetbiosAddress.class);
                    if (nbaddr != null) {
                        final int code = nbaddr.getNameType();
                        if (code == 0x1d || code == 0x1b) {

type NetworkError struct {
	Err error
}

func (n *NetworkError) Error() string {
	return n.Err.Error()
}

// Unwrap returns the error wrapped in NetworkError.
func (n *NetworkError) Unwrap() error {
	return n.Err
}

// Client - http based RPC client.
type Client struct {
	connected int32 // ref: https://golang.org/pkg/sync/atomic/#pkg-note-BUG

   * method wraps the elements in the input sets (which may contain null) as Optionals, calls
   * Sets.cartesianProduct with those, then transforms the result to unwrap the Optionals.
   */
  private Iterable<List<Object>> buildCartesianProduct(Set<?>... sets) {
    List<Set<Optional<?>>> optionalSets = Lists.newArrayListWithExpectedSize(sets.length);
    for (Set<?> set : sets) {

pkg math/rand/v2, func Uint() uint #61716
pkg math/rand/v2, method (*ChaCha8) Read([]uint8) (int, error) #67059
pkg math/rand/v2, method (*Rand) Uint() uint #61716
pkg net, method (*DNSError) Unwrap() error #63116
pkg net, method (*TCPConn) SetKeepAliveConfig(KeepAliveConfig) error #62254
pkg net, type DNSError struct, UnwrapErr error #63116
pkg net, type Dialer struct, KeepAliveConfig KeepAliveConfig #62254

    }

    @Nested
    @DisplayName("DosFileFilter integration tests")
    class DosFileFilterTests {

        @Test
        @DisplayName("DosFileFilter wildcard and attributes are preserved through unwrap")
        void dosFileFilter_preservesFieldsThroughUnwrap() throws Exception {
            // Test with various wildcard patterns and attribute masks
            String[] wildcards = { "*.txt", "test*", null };