// Parse only URL
            String[] args = { "smb://server/share/test.txt" };
            for (int ai = 0; ai < args.length; ai++) {
                if (!args[ai].startsWith("-")) {
                    t.url = args[ai];
                }
            }

            assertEquals("smb://server/share/test.txt", t.url, "URL should be parsed");

    /**
     * Retrieves the content of a repository URL.
     *
     * @param url the URL to retrieve content from
     * @return the content as a string
     * @throws IORuntimeException if I/O error occurs
     */
    protected String getRepositoryContent(final String url) {
        if (logger.isDebugEnabled()) {
            logger.debug("Loading: url={}", url);
        }

         *
         * @param url the URL to crawl
         * @param depth the depth of this URL in the crawling hierarchy
         */
        CrawlRequest(final String url, final int depth) {
            this.url = url;
            this.depth = depth;
        }

        /**
         * Gets the URL of this crawl request.
         *
         * @return the URL to be crawled
         */
        public String getUrl() {

    }

    /**
     * Creates a URL object from the current URL and a relative or absolute URL string.
     *
     * @param currentUrl the current URL as base
     * @param url the URL string to process
     * @return the URL object
     * @throws MalformedURLException if the URL is malformed
     */
    protected URL getURL(final String currentUrl, final String url) throws MalformedURLException {

            "image": {"url": "not a valid url", "name": "example image"},
        },
    )
    assert response.status_code == 422, response.text
    assert response.json() == {
        "detail": [
            {
                "loc": ["body", "image", "url"],
                "input": "not a valid url",
                "msg": "Input should be a valid URL, relative URL without a base",

    server.enqueue(MockResponse())
    assert200Http2Response(execute(url), server.hostName)
    val sanUrl = url.newBuilder().host("san.com").build()
    assert200Http2Response(execute(sanUrl), "san.com")
    assertThat(client.connectionPool.connectionCount()).isEqualTo(2)
  }

  private fun execute(url: HttpUrl) = client.newCall(Request(url = url)).execute()

  private fun assert200Http2Response(
    response: Response,

            return 0;
        }

        @Override
        public URL getURL() {
            try {
                // Create URL with custom protocol handler for SMB
                return new URL(null, urlStr, new jcifs.smb.Handler());
            } catch (Exception e) {
                // Return null if URL creation fails
                return null;
            }
        }

        @Override

    }

    /**
     * Validates if the URL is safe for redirection.
     *
     * @param url the URL to validate
     * @return true if the URL is valid for redirection, false otherwise
     */
    protected boolean isValidRedirectUrl(final String url) {
        if (StringUtil.isBlank(url)) {
            return false;
        }
        final String lowerUrl = url.toLowerCase();

    /**
     * Get the host on file.
     * @param url The URL.
     * @return The host on file.
     */
    protected String getHostOnFile(final String url) {
        if (StringUtil.isBlank(url)) {
            return StringUtil.EMPTY; // empty
        }

        if (url.startsWith("file:////")) {
            final String value = decodeUrlAsName(url.substring(9), true);
            final int pos = value.indexOf('/');

      override fun encodedValue(url: HttpUrl): String = url.encodedUsername

      override operator fun set(
        builder: HttpUrl.Builder,
        value: String,
      ) {
        builder.username(value)
      }

      override operator fun get(url: HttpUrl): String = url.username
    },

    PASSWORD {