}
    }

    if (hasLowBound && hasUpBound) {
      int cmp = comparator.compare(lowEnd, upEnd);
      if (cmp > 0 || (cmp == 0 && lowType == OPEN && upType == OPEN)) {
        // force allowed empty range
        lowEnd = upEnd;
        lowType = OPEN;
        upType = CLOSED;
      }
    }

    return new GeneralRange<>(comparator, hasLowBound, lowEnd, lowType, hasUpBound, upEnd, upType);

    @MethodSource("wrapExceptions")
    void connectWrapException_wrapsToSmbException(SmbResourceLocatorImpl loc, Exception thrown) throws Exception {
        // Arrange: spy on instance to force connect() failure with specific exception
        CIFSContext ctx = mock(CIFSContext.class);
        SmbTreeConnectionTrace trace = Mockito.spy(new SmbTreeConnectionTrace(ctx));
        doThrow(thrown).when(trace).connect(loc);

        if (creationTime == null) {
            return -1;
        }
        return System.currentTimeMillis() - creationTime;
    }

    /**
     * Force rotation of all active keys
     *
     * @return number of keys rotated
     */
    public int forceRotateAllKeys() {
        checkNotClosed();

        int rotated = 0;

        }
    }

    @Nested
    @DisplayName("Unicode Support Tests")
    class UnicodeSupportTests {

        @Test
        @DisplayName("Should always force unicode")
        void testIsForceUnicode() {
            assertTrue(response.isForceUnicode());
        }

        @Test
        @DisplayName("Should consistently return true for unicode")

    checkState(xSumOfSquaresOfDeltas > 0.0);
    checkState(ySumOfSquaresOfDeltas > 0.0);
    // The product of two positive numbers can be zero if the multiplication underflowed. We
    // force a positive value by effectively rounding up to MIN_VALUE.
    double productOfSumsOfSquaresOfDeltas =
        ensurePositive(xSumOfSquaresOfDeltas * ySumOfSquaresOfDeltas);

     *            initiated by the client (MSIE post requests after successful NTLM SSP
     *            authentication). If false and the user has not been authenticated yet
     *            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

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client: OkHttpClient = OkHttpClient.Builder()

    /**
     * Emergency cleanup method to prevent resource leaks during finalization
     */
    private void emergencyCloseHandle() {
        try {
            synchronized (this) {
                // Force close the handle
                this.open = false;
                this.usageCount.set(0);

                // Clear mutable references to free memory

      }
    }
  }

  private fun MockResponse.Builder.body(
    protocol: Protocol,
    body: String,
  ) = apply {
    when (protocol) {
      Protocol.HTTP_1_1 -> chunkedBody(body, 1024) // Force multiple chunks.
      else -> body(body)
    }
  }

  private fun enableProtocol(protocol: Protocol) {
    if (protocol == Protocol.HTTP_2) {
      enableTls()
      client =
        client

    void length_handlesNullInternalArray() throws Exception {
        // Arrange
        SecurityBlob blob = new SecurityBlob(new byte[] { 1, 2, 3 });

        // Force internal field to null via reflection to exercise defensive branch
        Field field = SecurityBlob.class.getDeclaredField("b");
        field.setAccessible(true);
        field.set(blob, null);

        // Act & Assert