const val LOOM_PROPERTY = "loom"

      /**
       * For whatever reason our BouncyCastle provider doesn't work with ECDSA keys. Just configure it
       * to use RSA-2048 instead.
       *
       * (We otherwise prefer ECDSA because it's faster.)
       */
      private val localhostHandshakeCertificatesWithRsa2048: HandshakeCertificates by lazy {
        val heldCertificate =
          HeldCertificate
            .Builder()

 * instances.
 *
 * <p><b>Warning:</b> The comparators or comparables used must be <i>consistent with equals</i> as
 * explained by the {@link Comparable} class specification. Otherwise, the resulting multiset will
 * violate the general contract of {@link SetMultimap}, which is specified in terms of {@link
 * Object#equals}.
 *

     */
    int getMaxDirectoryCacheEntries();

    /**
     * Get whether RDMA (SMB Direct) should be used
     *
     * @return true if RDMA should be used, false otherwise
     */
    boolean isUseRDMA();

    /**
     * Get RDMA provider preference
     *
     * @return RDMA provider name ("auto", "disni", "tcp", etc.)
     */
    String getRdmaProvider();

        System.exit(0);
    }

    /**
     * Checks if the lasta.env system property is not set.
     *
     * @return true if lasta.env is not set, false otherwise
     */
    private static boolean isNoneEnv() {
        return System.getProperty("lasta.env") == null;
    }

    /**
     * Gets the port number for the Tomcat server from system properties.
     *

     * the client will be forced to send an authentication (server sends
     * HttpServletResponse.SC_UNAUTHORIZED).
     * @return True if the negotiation is complete, otherwise false
     * @throws IOException if an I/O error occurs
     * @throws ServletException if a servlet error occurs
     */

        assertTrue(ex.getMessage().contains("Pipe handle already closed"));
    }

    @Test
    @DisplayName("close() calls handle.close when open and handle.release otherwise; releases tree")
    void testCloseBehavior() throws CIFSException {
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(true);

 */
@Timeout(30)
class FastFallbackTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  // Don't use JUnit 5 test rules for these; otherwise we can't bind them to a single local IP.
  private lateinit var localhostIpv4: InetAddress
  private lateinit var localhostIpv6: InetAddress
  private lateinit var serverIpv4: MockWebServer

   * associated with that range is returned.
   */
  @Nullable V get(K key);

  /**
   * Returns the range containing this key and its associated value, if such a range is present in
   * the range map, or {@code null} otherwise.
   */
  @Nullable Entry<Range<K>, V> getEntry(K key);

  /**
   * Returns the minimal range {@linkplain Range#encloses(Range) enclosing} the ranges in this
   * {@code RangeMap}.
   *

   * interpreted as a normal bit, and all other bits are treated as usual.
   *
   * <p>If the argument is nonnegative, the returned result will be equal to {@code bits},
   * otherwise, the result will be equal to {@code 2^64 + bits}.
   *
   * <p>To represent decimal constants less than {@code 2^63}, consider {@link #valueOf(long)}
   * instead.
   *
   * @since 14.0
   */

    ReentrantLock lockD = otherFactory.newReentrantLock("LockD");

    // lockD -> lockA
    lockD.lock();
    lockA.lock();
    lockA.unlock();
    lockD.unlock();

    // lockA -> lockD should warn but otherwise succeed because lockD was
    // created by a factory with the WARN policy.
    lockA.lock();
    lockD.lock();
  }

  public void testReentrantLock_tryLock() throws Exception {