}

        @Test
        @DisplayName("release should decrement usage count")
        void shouldDecrementUsageCount() {
            transport.acquire();
            long beforeRelease = transport.getUsageCount();
            transport.release();
            assertEquals(beforeRelease - 1, transport.getUsageCount());
        }

        @Test

	target.httpClient = &http.Client{Transport: transport}

	yes, err := target.isActive()
	if err != nil {
		return err
	}
	if !yes {
		return store.ErrNotConnected
	}

	return nil
}

// NewWebhookTarget - creates new Webhook target.
func NewWebhookTarget(ctx context.Context, id string, args WebhookArgs, loggerOnce logger.LogOnce, transport *http.Transport) (*WebhookTarget, error) {

 */
package jcifs;

/**
 * Opaque reference to a SMB transport
 *
 * @author mbechler
 *
 * <p>This interface is intended for internal use.</p>
 */
public interface SmbTransport extends AutoCloseable {

    /**
     * Gets the CIFS context associated with this transport.
     *
     * @return the context this transport is attached to
     */
    CIFSContext getContext();

    /**

 * <p>
 * This implementation is backed by Maven Resolver API, supported protocols and transport selection depends on it. If
 * resolver preference regarding transport is altered, it will affect this service as well.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface TransportProvider extends Service {
    /**
     * Provides new {@link Transport} instance for given {@link RemoteRepository}, if possible.
     *

	if err != nil {
		return err
	}

	req.Header.Set("Content-Type", "application/json")
	if a.AuthToken != "" {
		req.Header.Set("Authorization", a.AuthToken)
	}

	client := &http.Client{Transport: a.Transport}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer a.CloseRespFn(resp.Body)

	return nil
}

// UnmarshalJSON - decodes JSON data.

        // Transport and context delegation
        assertSame(cifsContext, session.getContext());
        clearInvocations(transport);
        assertSame(transport, session.getTransport());
        verify(transport, times(1)).acquire();
    }

    @Test
    @DisplayName("close/release manage usage and transport lifecycle")
    void testReleaseLifecycle() {

    }

    /**
     * Get channel for specific transport
     *
     * @param transport transport instance
     * @return corresponding channel or null
     */
    public ChannelInfo getChannelForTransport(SmbTransport transport) {
        return channels.values().stream().filter(c -> c.getTransport() == transport).findFirst().orElse(null);
    }

    /**
     * Remove a channel
     *

        assertNull(session.transport, "transport not created yet");
        SmbTransport tr = session.transport();
        assertNotNull(tr, "transport should now exist");
        // subsequent calls return the same instance
        assertSame(tr, session.transport());
    }

    @Test
    void sendResetsResponseAndForwards() throws Exception {

    private RdmaConnection rdmaConnection;
    private final Object connectionLock = new Object();

    /**
     * Creates a new RDMA transport wrapping the given delegate transport.
     *
     * @param delegate the underlying SMB transport to wrap
     * @param context the CIFS context for configuration
     */
    public RdmaTransport(SmbTransportInternal delegate, CIFSContext context) {

package jcifs.smb1.util.transport;

/**
 * Marker interface for transport layer request objects.
 * Represents a request that can be sent through the SMB1 transport layer.
 */
public interface Request {