private static final class IsEither extends FastMatcher {

    private final char match1;
    private final char match2;

    IsEither(char match1, char match2) {
      this.match1 = match1;
      this.match2 = match2;
    }

    @Override
    public boolean matches(char c) {
      return c == match1 || c == match2;
    }

    @GwtIncompatible // used only from other GwtIncompatible code

  private static final class IsEither extends FastMatcher {

    private final char match1;
    private final char match2;

    IsEither(char match1, char match2) {
      this.match1 = match1;
      this.match2 = match2;
    }

    @Override
    public boolean matches(char c) {
      return c == match1 || c == match2;
    }

    @GwtIncompatible // used only from other GwtIncompatible code

    server.enqueue(MockResponse())
    dns["san.com"] = Dns.SYSTEM.lookup(server.hostName).subList(0, 1)
    val sanUrl = url.newBuilder().host("san.com").build()
    val latch1 = CountDownLatch(1)
    val latch2 = CountDownLatch(1)
    val latch3 = CountDownLatch(1)
    val latch4 = CountDownLatch(1)
    val listener1: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,

            // Verify escaped pattern matches
            assertTrue("Escaped pattern should match: " + mimeType, Pattern.compile(escapedPattern).matcher(mimeType).matches());

            // Verify unescaped pattern does NOT match
            assertFalse("Unescaped pattern should NOT match: " + mimeType, Pattern.compile(mimeType).matcher(mimeType).matches());
        }
    }

    @Test

// flags:
//   filter:
//     newerThan: "7d" # match objects newer than this value (e.g. 7d10h31s)
//     olderThan: "7d" # match objects older than this value (e.g. 7d10h31s)
//     createdAfter: "date" # match objects created after "date"
//     createdBefore: "date" # match objects created before "date"
//     tags:
//       - key: "name"
//         value: "pick*" # match objects with tag 'name', with all values starting with 'pick'

    checkArgument(
        !separatorPattern.matcher("").matches(),
        "The pattern may not match the empty string: %s",
        separatorPattern);

    return new Splitter(
        (splitter, toSplit) -> {
          CommonMatcher matcher = separatorPattern.matcher(toSplit);
          return new SplittingIterator(splitter, toSplit) {
            @Override

        }

        /**
         * Matches the given path.
         *
         * @param path The path to match.
         * @return True if the path matches, otherwise false.
         */
        public boolean match(final String path) {
            if (includedPaths == null) {
                if (excludedPaths != null && excludedPaths.matcher(path).matches()) {
                    if (logger.isDebugEnabled()) {

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
}

    void oidFormat() {
        assertAll(() -> assertTrue(OID_PATTERN.matcher(SpnegoConstants.SPNEGO_MECHANISM).matches(), "Invalid OID: SPNEGO_MECHANISM"),
                () -> assertTrue(OID_PATTERN.matcher(SpnegoConstants.KERBEROS_MECHANISM).matches(), "Invalid OID: KERBEROS_MECHANISM"),
                () -> assertTrue(OID_PATTERN.matcher(SpnegoConstants.LEGACY_KERBEROS_MECHANISM).matches(),
                        "Invalid OID: LEGACY_KERBEROS_MECHANISM"),

						continue
					}

					batch = append(batch, obj.Item)

					if len(batch) < *r.Source.Snowball.Batch {
						continue
					}
					writeFn(batch)
					batch = batch[:0]
				}
				writeFn(batch)
				xioutil.SafeClose(slowCh)
			}()
		} else {
			slowCh = walkCh
		}