"syscall"
)

// Returns true if no error and there is no object or prefix inside this directory
func isDirEmpty(dirname string, legacy bool) bool {
	if legacy {
		// On filesystems such as btrfs, nfs this is not true, so fallback
		// to performing readdir() instead.
		entries, err := readDirN(dirname, 1)
		if err != nil {
			return false
		}
		return len(entries) == 0
	}
	var stat syscall.Stat_t

   *     exception itself.
   * @param executor the executor that runs {@code fallback} if the input fails
   */
  public <X extends Throwable> ClosingFuture<V> catching(
      Class<X> exceptionType, ClosingFunction<? super X, ? extends V> fallback, Executor executor) {
    return catchingMoreGeneric(exceptionType, fallback, executor);
  }

        nestedMap.put("outer", Maps.map("inner", "value").$());
        assertEquals(183L, MemoryUtil.sizeOf(nestedMap));
    }

    public void test_sizeOf_customObjects() {
        // Test fallback case for custom objects (should return 16L)
        assertEquals(16L, MemoryUtil.sizeOf(new Object()));
        assertEquals(16L, MemoryUtil.sizeOf(new CustomTestObject()));

        assertEquals("share/", b.getName());

        // host when no path/share
        SmbResourceLocatorImpl c = locator("smb://server/");
        assertEquals("server/", c.getName());

        // root fallback
        SmbResourceLocatorImpl d = locator("smb:///");
        assertEquals("smb://", d.getName());
    }

    @Test
    @DisplayName("Parent URL is computed correctly")
    void testGetParent() {

        assertNotNull(firstName, "First called name should not be null");
    }

    @Test
    @DisplayName("nextCalledName should return valid name for fallback attempts")
    void testNextCalledNameContract() {
        // Given
        String expectedNextName = "SERVER15";
        when(mockAddress.nextCalledName(mockContext)).thenReturn(expectedNextName);

        // When

        // Test cleanup
        region.close();
        assertFalse(region.isValid(), "Region should be invalid after close");
    }

    @Test
    public void testGetProviderName() {
        assertEquals("TCP Fallback", provider.getProviderName());
    }

    @Test
    public void testGetMaxMessageSize() {
        assertEquals(65536, provider.getMaxMessageSize(), "TCP provider should have 64KB limit");
    }

    @Test

- [ ] Create RDMA negotiation context
- [ ] Implement RDMA transport layer
- [ ] Add RDMA buffer registration
- [ ] Create RDMA read/write operations
- [ ] Implement RDMA credits management
- [ ] Add fallback to TCP when RDMA unavailable

#### 5.3 Integration Points
- Create new transport type alongside TCP
- Modify negotiation to include RDMA contexts
- Update read/write operations for RDMA

---

    )

  println("TLS1.3+TLS1.2")
  testClient(urls, buildClient(ConnectionSpec.RESTRICTED_TLS))

  println("\nTLS1.3 only")
  testClient(urls, buildClient(TLS_13))

  println("\nTLS1.3 then fallback")
  testClient(urls, buildClient(TLS_13, TLS_12))

      } else {
        sslSocket.enabledProtocols
      }

    // In accordance with https://tools.ietf.org/html/draft-ietf-tls-downgrade-scsv-00 the SCSV
    // cipher is added to signal that a protocol fallback has taken place.
    val supportedCipherSuites = sslSocket.supportedCipherSuites
    val indexOfFallbackScsv =
      supportedCipherSuites.indexOf(
        "TLS_FALLBACK_SCSV",
        CipherSuite.ORDER_BY_NAME,

        // Try providers in order of preference
        List<RdmaProvider> providers = Arrays.asList(new DisniRdmaProvider(), // InfiniBand/RoCE - highest performance
                new TcpRdmaProvider() // TCP fallback - always available
        );

        for (RdmaProvider provider : providers) {
            if (provider.isAvailable()) {
                log.info("Selected RDMA provider: {}", provider.getProviderName());