@DisplayName("hasCapability(cap): returns configured value and captures argument across edge caps")
    void hasCapability_variousCaps_returnsTrue_andCapturesArgument(int cap) throws Exception {
        // Arrange: stub to return true regardless of input
        when(handle.hasCapability(anyInt())).thenReturn(true);

        // Act
        boolean result = handle.hasCapability(cap);

* Шифрование соединения происходит на **уровне TCP**.
    * Это на один уровень **ниже HTTP**.
    * Поэтому **сертификаты и шифрование** обрабатываются **до HTTP**.
* **TCP не знает о «доменах»**. Только об IP-адресах.
    * Информация о **конкретном домене** передаётся в **данных HTTP**.

      app: {{ template "minio.name" . }}
      release: {{ .Release.Name }}
  ingress:
  - toPorts:
    - ports:
      - port: "{{ .Values.minioAPIPort }}"
        protocol: TCP
      - port: "{{ .Values.minioConsolePort }}"
        protocol: TCP
    {{- if not .Values.networkPolicy.allowExternal }}
    fromEndpoints:
    - matchLabels:
        {{ template "minio.name" . }}-client: "true"
    {{- end }}
  egress:

Após isso, o cliente e o servidor possuem uma conexão TCP encriptada, que é provida pelo TLS. E então eles podem usar essa conexão para começar a comunicação HTTP propriamente dita.

E isso resume o que é HTTPS, apenas HTTP simples dentro de uma conexão TLS segura em vez de uma conexão TCP pura (não encriptada).

/// tip | Dica

        props.setProperty("jcifs.smb.client.useRDMA", "true");
        props.setProperty("jcifs.smb.client.rdmaProvider", "tcp");

        PropertyConfiguration config = new PropertyConfiguration(props);

        assertTrue(config.isUseRDMA(), "RDMA should be enabled");
        assertEquals("tcp", config.getRdmaProvider(), "Provider should be tcp");
    }

    @Test
    public void testRdmaAutoProvider() throws CIFSException {

done
set -e

# Single handler for all cleanup actions, triggered on an EXIT trap.
# TODO(angerson) Making this use different scripts may be overkill.
cleanup() {
  if [[ "$TFCI_DOCKER_ENABLE" == 1 ]]; then
    ./ci/official/utilities/cleanup_docker.sh
  fi
  ./ci/official/utilities/cleanup_summary.sh
}

    @ValueSource(ints = { -1, 0, 1, 1024 })
    void hasCapability_variousCaps(int cap) throws SmbException {
        when(transport.hasCapability(anyInt())).thenAnswer(inv -> ((int) inv.getArgument(0)) >= 0);

        boolean result = transport.hasCapability(cap);

        assertEquals(cap >= 0, result);
        verify(transport, times(1)).hasCapability(cap);
    }

    @Test
    public void testRdmaProviderSelectionAlwaysReturnsProvider() {
        // This should always return at least the TCP fallback provider
        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();
        assertNotNull(provider, "Should always select an RDMA provider (at minimum TCP fallback)");
        assertNotNull(provider.getProviderName(), "Provider name should not be null");

// not be used after the arena is freed. Accessing the underlying storage of the
// slice after free may result in a fault, but this fault is also not guaranteed.
func MakeSlice[T any](a *Arena, len, cap int) []T {
	var sl []T
	runtime_arena_arena_Slice(a.a, &sl, cap)
	return sl[:len]
}

// Clone makes a shallow copy of the input value that is no longer bound to any
// arena it may have been allocated from, returning the copy. If it was not

import java.util.EnumSet;
import java.util.Set;

/**
 * Interface for RDMA provider implementations.
 *
 * This interface abstracts different RDMA implementations such as
 * InfiniBand, iWARP, RoCE, or TCP fallback providers.
 */
public interface RdmaProvider {

    /**
     * Check if RDMA is available on this system
     *
     * @return true if RDMA can be used, false otherwise
     */