}

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static void closeAll(BaseStream<?, ?>[] toClose) {
    // If one of the streams throws an exception, continue closing the others, then throw the
    // exception later. If more than one stream throws an exception, the later ones are added to the
    // first as suppressed exceptions. We don't catch Error on the grounds that it should be allowed

    }

    private String encodeUrl(final String url) {
        try {
            return URLEncoder.encode(url, Constants.UTF_8);
        } catch (final UnsupportedEncodingException e) {
            throw new FessSystemException("Unsupported encoding.", e);
        }
    }

    public void test_decodeUrl_ok() throws Exception {
        String url, exp;
        final FessFileTransformer transformer = createInstance();

        logger.log(
          buildString {
            append("<-- HTTP FAILED: $e.")
            append(" ${redactUrl(request.url)} (${tookMs}ms)")
          },
        )
        throw e
      }

      val tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

      val responseBody = response.body!!
      val contentLength = responseBody.contentLength()

    protected FilterChain createDefaultFilterChain() {
        return query -> {
            try {
                return createQueryParser().parse(query);
            } catch (final ParseException e) {
                throw new QueryParseException(e);
            }
        };
    }

    /**
     * Interface for query filters that can modify or transform queries.
     * Filters are applied in the order they are added to the parser.

            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    protected <RESULT extends User> RESULT updateEntity(Map<String, Object> source, RESULT result) {
        return result;
    }

        .matches("boiler <.*> plate");
  }

  private static class ThrowsOnToString {
    @Override
    public String toString() {
      throw new UnsupportedOperationException();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {
    NullPointerTester tester = new NullPointerTester();

    void testRunWithNullUrl() {
        TestLocking t = new TestLocking();
        t.url = null; // Null URL
        t.numIter = 0; // No iterations to avoid NPE

        // Should not throw exception
        assertDoesNotThrow(() -> t.run(), "run() should handle null URL gracefully");
        assertEquals(1, t.numComplete, "numComplete should still be incremented");
    }

    @Test

        if (errorCode != 0 || andxCommand == (byte) 0xFF) {
            andxCommand = (byte) 0xFF;
            andx = null;
        } else if (andx == null) {
            andxCommand = (byte) 0xFF;
            throw new RuntimeException("no andx command supplied with response");
        } else {

            /*
             * Set bufferIndex according to andxOffset
             */

        }

        value = props.getProperty("jcifs.smb.client.nativeLanMan");
        if (value != null) {
            this.nativeLanMan = value;
        }

        // Dialect version properties - these should throw exceptions for invalid values
        String minVersion = props.getProperty("jcifs.smb.client.minVersion");
        String maxVersion = props.getProperty("jcifs.smb.client.maxVersion");

    assertFailsWith<IOException> {
      anotherClient.newCall(request).execute()
    }.also { expected ->
      when (expected) {
        is SSLException, is TlsFatalAlert -> {}
        else -> throw expected
      }
    }
  }

  @Test
  fun connectionsAreNotReusedIfHostnameVerifierChanges() {
    enableHttps()
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())