}
			}
		}
	}
	return allErrs
}

// ValidateURLs validates the URLs given in the string slice, makes sure they are parsable. Optionally, it can enforces HTTPS usage.
func ValidateURLs(urls []string, requireHTTPS bool, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}
	for _, urlstr := range urls {
		u, err := url.Parse(urlstr)
		if err != nil {

	// certificate.”

	host := uri.Host
	if len(host) == 0 {
		return false, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
	}

	if strings.Contains(host, ":") && !strings.HasSuffix(host, "]") {
		var err error
		host, _, err = net.SplitHostPort(uri.Host)
		if err != nil {
			return false, err
		}
	}

  filesystem separated by space. You may also use a '...' convention
  to abbreviate the directory arguments. Remote directories in a
  distributed setup are encoded as HTTP(s) URIs.
{{if .VisibleFlags}}
FLAGS:
  {{range .VisibleFlags}}{{.}}
  {{end}}{{end}}
EXAMPLES:
  1. Start MinIO server on "/home/shared" directory.
     {{.Prompt}} {{.HelpName}} /home/shared

        repo instanceof MavenResolver
        repo.root == uri
    }

    def "creates repository with additional artifact URLs"() {
        given:
        def uri = new URI("https://localhost:9090/repo")
        def uri1 = new URI("https://localhost:9090/repo1")
        def uri2 = new URI("https://localhost:9090/repo2")
        _ * resolver.resolveUri('repo-dir') >> uri
        _ * resolver.resolveUri('repo1') >> uri1

        def mockSftpClient2 = Mock(LockableSftpClient)

        given:
        URI uri1 = new URI('http://localhost:22/repo1')
        URI uri2 = new URI('http://localhost:22/repo2')
        PasswordCredentials credentials1 = new DefaultPasswordCredentials('sftp1', 'sftp1')
        PasswordCredentials credentials2 = new DefaultPasswordCredentials('sftp2', 'sftp2')

        when:

	return rule, matchingRDigests, matchingNDigests, skippingRDigests, skippingNDigests
}

func cross(uis []user.Info, ris []*request.RequestInfo) []RequestDigest {
	ans := make([]RequestDigest, 0, len(uis)*len(ris))
	for _, ui := range uis {
		for _, ri := range ris {
			ans = append(ans, RequestDigest{RequestInfo: ri, User: ui})
		}
	}
	return ans
}

  }

  @Test
  fun fromUri() {
    val uri = URI("http://username:password@host/path?query#fragment")
    val httpUrl = uri.toHttpUrlOrNull()
    assertThat(httpUrl.toString())
      .isEqualTo("http://username:password@host/path?query#fragment")
  }

  @Test
  fun fromUriUnsupportedScheme() {
    val uri = URI("mailto:******@****.***")
    assertThat(uri.toHttpUrlOrNull()).isNull()
  }

  @Test

        this.updatedTime = value;
    }

    public String getUrls() {
        checkSpecifiedProperty("urls");
        return convertEmptyToNull(urls);
    }

    public void setUrls(String value) {
        registerModifiedProperty("urls");
        this.urls = value;
    }

    public String getUserAgent() {
        checkSpecifiedProperty("userAgent");

    - --experimental-watch-progress-notify-interval=5s
    - --initial-advertise-peer-urls=https://:2380
    - --initial-cluster==https://:2380
    - --key-file=etcd/server.key
    - --listen-client-urls=https://127.0.0.1:2379,https://:2379
    - --listen-metrics-urls=http://127.0.0.1:2381
    - --listen-peer-urls=https://:2380
    - --name=
    - --peer-cert-file=etcd/peer.crt
    - --peer-client-cert-auth=true

			Name:   resource,
			UID:    mustGetUUID(),
			Owner:  owners[i%len(owners)],
			Quorum: 2,
		}
		lris = append(lris, lri)
		locksHeld[resource] = append(locksHeld[resource], lri)
		// concurrent read lock, same resource different uid
		lri.UID = mustGetUUID()
		lris = append(lris, lri)
		locksHeld[resource] = append(locksHeld[resource], lri)
	}

	var peerLocks []*PeerLocks