}
	return false
}

// Returns true if any of the given wildcard patterns match the matchStr.
func hasPattern(patterns []string, matchStr string) bool {
	for _, pattern := range patterns {
		if ok := wildcard.MatchSimple(pattern, matchStr); ok {
			return true
		}
	}
	return false
}

// Returns the part file name which matches the partNumber and etag.

				// is available and honored at this domain.
				//
				// All other `<bucket>.<namespace>.svc.<cluster_domain>`
				// makes sure that buckets are routed through this matcher
				// to match for `<bucket>`
				return host != minioReservedBucket+"."+domainName
			}).Host("{bucket:.+}."+domainName).Subrouter())
		} else {
			routers = append(routers, apiRouter.Host("{bucket:.+}."+domainName).Subrouter())

     * @return True if the status code indicates a redirect, false otherwise
     */
    protected boolean isRedirectHttpStatus(final int httpStatusCode) {
        return redirectHttpStatusPattern.matcher(Integer.toString(httpStatusCode)).matches();
    }

    /**
     * Executes the HTTP client request.
     *
     * @param httpRequest The HTTP request to execute
     * @return The HTTP response

        // Get rule after removal
        matched = ruleManager.getRule(responseData);
        assertNull(matched); // No matching rule now

        // Add rule4 which matches
        ruleManager.addRule(rule4);
        matched = ruleManager.getRule(responseData);
        assertEquals("rule4", matched.getRuleId());
    }

    /**
     * Test rule replacement scenario
     */

			// standard metadata headers
			// specified in the filter
			var match bool
			for k, v := range obj.UserDefined {
				if !stringsHasPrefixFold(k, "x-amz-meta-") && !isStandardHeader(k) {
					continue
				}
				// We only need to match x-amz-meta or standardHeaders
				if kv.Match(BatchJobKV{Key: k, Value: v}) {
					match = true
				}
			}
			if !match {
				return false

        assertFalse(auth.matches("ftp://hostname:111/"));
        assertFalse(auth.matches("ftp://hostname:xx/"));
        assertFalse(auth.matches("ftp://hoge/test/aaa.html"));
        assertFalse(auth.matches("ftp://hoge/test"));
        assertFalse(auth.matches("ftp://hoge/"));
        assertFalse(auth.matches("ftp://hoge"));
        assertFalse(auth.matches("ftp://"));
        assertFalse(auth.matches("http://hostname/"));

func (kv BatchJobKV) Empty() bool {
	return kv.Key == "" && kv.Value == ""
}

// Match matches input kv with kv, value will be wildcard matched depending on the user input
func (kv BatchJobKV) Match(ikv BatchJobKV) bool {
	if kv.Empty() {
		return true
	}
	if strings.EqualFold(kv.Key, ikv.Key) {
		return wildcard.Match(kv.Value, ikv.Value)
	}
	return false
}

     */
    @Nonnull
    List<Exception> getExceptions();

    /**
     * Gets the versions (in ascending order) that matched the requested range.
     *
     * @return The list of matching versions, never {@code null}. An empty list indicates
     *         no versions matched the requested range.
     */
    @Nonnull
    List<Version> getVersions();

    /**

        assertTrue(tree.matches("testShare", "testService"));
        assertTrue(tree.matches("TESTSHARE", "testService"));
        assertTrue(tree.matches("testshare", "TESTSERVICE"));

        // Test matching share with null service
        assertTrue(tree.matches("testShare", null));

        // Test matching share with service starting with "??"
        assertTrue(tree.matches("testShare", "??otherService"));

	if len(newID) != len(id) {
		log.Fatalf("%s: build ID length mismatch %q vs %q", file, id, newID)
	}

	if len(matches) == 0 {
		return
	}

	f, err = os.OpenFile(file, os.O_RDWR, 0)
	if err != nil {
		log.Fatal(err)
	}
	if err := buildid.Rewrite(f, matches, newID); err != nil {
		log.Fatal(err)
	}
	if err := f.Close(); err != nil {
		log.Fatal(err)
	}