/**
     * Gets the settings URL of this model source.
     *
     * @return The underlying settings URL, never {@code null}.
     * @deprecated instead use {@link #getUrl()}
     */
    @Deprecated
    public URL getSettingsUrl() {
        return getUrl();
    }

            assertEquals("application/octet-stream", responseData.getMimeType());
            assertNull(responseData.getResponseBody());
            assertNull(responseData.getMetaDataMap().get("label"));
        }
        try (final ResponseData responseData = storageClient.doHead("storage://fess/dir3/file4.txt")) {
            assertEquals("storage://fess/dir3/file4.txt", responseData.getUrl());

        buf.append("url:").append(getUrl(keyObj));
        buf.append('\t');
        buf.append("time:").append(FessFunctions.formatDate(new Date(time)));
        return buf;
    }

    protected String getUrl(final Object keyObj) {
        if (keyObj instanceof final UrlQueue<?> urlQueue) {
            return escapeValue(urlQueue.getUrl());
        }

        final String url = urlQueue.getUrl();
        if (StringUtil.isBlank(url)) {
            if (logger.isDebugEnabled()) {
                logger.debug("URL is a blank: {}", url);
            }
            return false;
        }

        // check it in queue
        for (final UrlQueue<Long> urlInQueue : urlQueueList) {
            if (url.equals(urlInQueue.getUrl())) {

    }

    private void handshake() throws IOException {
        if (handshakeComplete) return;
        doHandshake();
        handshakeComplete = true;
    }

    public URL getURL() {
        return connection.getURL();
    }

    public int getContentLength() {
        try {
            handshake();
        } catch (IOException ex) { }
        return connection.getContentLength();
    }

                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("smbUrl:{} roleType:{}", responseData.getUrl(), roleTypeList);
                }
            } else if (responseData.getUrl().startsWith("smb1:")) {
                final jcifs.smb1.smb1.SID[] allowedSids =

                    throw e;
                } catch (final Exception e) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Failed to access to {}", request.getUrl(), e);
                    }

                    if (listener != null) {
                        listener.onException(this, request, count, e);
                    }

                    if (exceptionList == null) {

        final ClRuntimeException ex = new ClRuntimeException("ECL0001", asArray("hoge"));
        assertThat(ex.getMessageCode(), is("ECL0001"));
        assertThat(ex.getArgs().length, is(1));
        assertThat(ex.getArgs()[0], is((Object) "hoge"));
        System.out.println(ex.getMessage());
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetCause() throws Exception {

    }

    @Override
    public String getKey() {
        return userLocalArtifactRepository.getKey();
    }

    @Override
    public String getUrl() {
        return userLocalArtifactRepository.getUrl();
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + (buildReactor == null ? 0 : buildReactor.hashCode());

        if (model == null) {
            return;
        }

        model.setUrl(normalize(model.getUrl()));

        Scm scm = model.getScm();
        if (scm != null) {
            scm.setUrl(normalize(scm.getUrl()));
            scm.setConnection(normalize(scm.getConnection()));
            scm.setDeveloperConnection(normalize(scm.getDeveloperConnection()));
        }