final URI uri = new URI(pos == -1 ? path : path.substring(0, pos));
            if (!"ftp".equals(uri.getScheme()) || (StringUtil.isNotBlank(server) && !server.equals(uri.getHost()))) {
                return false;
            }
            int p = uri.getPort();
            if (p == -1) {
                p = 21;
            }
            if (port > 0 && port != p) {
                return false;
            }

        // host/port/realm: only set if not blank (null means "any" - AuthScope.ANY equivalent)
        if (StringUtil.isNotBlank(getHostname())) {
            config.setHost(getHostname());
        }
        if (getPort() != null) {
            config.setPort(getPort());
        }
        if (StringUtil.isNotBlank(getAuthRealm())) {
            config.setRealm(getAuthRealm());
        }

        // AuthSchemeType の設定

                int hash = (proxy.getUserName() + proxy.getPassword()).hashCode();
                buffer.append(hash).append('@');
            }
            buffer.append(proxy.getHost()).append(':').append(proxy.getPort()).append('>');
        }

        // consider the username&password because a repo manager might block artifacts depending on authorization
        Authentication auth = repository.getAuthentication();

        }

        try {
            URL url = new URL(null, smbUrl, new jcifs.smb.Handler());

            // Validate host
            String host = url.getHost();
            if (host == null || host.isEmpty()) {
                throw new SmbException("SMB URL missing host");
            }

            // Validate host format
            if (!isValidHost(host)) {

            AuthenticationBuilder authBuilder = new AuthenticationBuilder();
            authBuilder.addUsername(proxy.getUserName()).addPassword(proxy.getPassword());
            result = new Proxy(proxy.getProtocol(), proxy.getHost(), proxy.getPort(), authBuilder.build());
        }
        return result;
    }

    public static ArtifactHandler newHandler(Artifact artifact) {

        "addAll(n, allPresent) should return true",
        getList().addAll(0, MinimalCollection.of(e0())));
    expectAdded(0, e0());
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAllAtIndex_unsupportedAllPresent() {
    assertThrows(
        UnsupportedOperationException.class, () -> getList().addAll(0, MinimalCollection.of(e0())));
    expectUnchanged();
  }

        lastModified = 0L;
        isExists = false;

        try {
            if (url.getHost().length() == 0) {} else if (share == null) {
                if (getType() == TYPE_WORKGROUP) {
                    UniAddress.getByName(url.getHost(), true);
                } else {
                    UniAddress.getByName(url.getHost()).getHostName();
                }

                credentialsProvider.setCredentials(authScope, authentication.getCredentials());
                if (authScope.getHost() != null && authScheme != null) {
                    final HttpHost targetHost = new HttpHost(authScope.getSchemeName(), authScope.getHost(), authScope.getPort());
                    authCache.put(targetHost, authScheme);
                }
            }
        }

   */
  public void testAddAtIndex_unsupportedPresent() {
    assertThrows(UnsupportedOperationException.class, () -> getList().add(0, e0()));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_supportedNotPresent() {
    getList().add(0, e3());
    expectAdded(0, e3());
  }

  @CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)

  public void testRemoveAtIndex_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getList().remove(0));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  public void testRemoveAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().remove(-1));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)