buffer.rpos(pos)

            def matched = expectations.find { it.matches(buffer, type, id) }
            if (matched) {
                if (matched.failing) {
                    sendStatus(prepareReply(new ByteArrayBuffer()), id, SftpConstants.SSH_FX_FAILURE, "Failure")
                    buffer.rpos(originalBufferPosition + length)
                } else if (matched.missing) {

		matches, matchGVR, matchGVK, err := d.matcher.DefinitionMatches(a, o, policyAccessor)
		if err != nil {
			// There was an error evaluating if this policy matches anything.
			utilruntime.HandleError(err)
			relevantHooks = append(relevantHooks, PolicyInvocation[P, B, E]{
				Policy: hook.Policy,
				Error:  err,
			})
			continue
		} else if !matches {
			continue

  public abstract boolean matches(char c);

  // Non-static factories

  /** Returns a matcher that matches any character not matched by this matcher. */
  // @Override under Java 8 but not under Java 7
  public CharMatcher negate() {
    return new Negated(this);
  }

  /**
   * Returns a matcher that matches any character matched by both this matcher and {@code other}.
   */

// locale-specific data for your supported languages.
// Match and MatchString both return the index of the matched supported tag
// to simplify associating such data with the matched tag.
//
// # Canonicalization
//
// If one uses the Matcher to compare languages one does not need to
// worry about canonicalization.
//
// The meaning of a Tag varies per application. The language package

  public abstract boolean matches(char c);

  // Non-static factories

  /** Returns a matcher that matches any character not matched by this matcher. */
  // @Override under Java 8 but not under Java 7
  @Override
  public CharMatcher negate() {
    return new Negated(this);
  }

  /**
   * Returns a matcher that matches any character matched by both this matcher and {@code other}.
   */

					matched = false
					break
				} else if l != v {
					matched = false
					break
				}
			}

			// Empty selector matches everything
			if len(paramRef.Selector.MatchExpressions) == 0 && len(paramRef.Selector.MatchLabels) == 0 {
				matched = true
			}

			if !matched {
				continue
			}
		}

        RequirementMatcher matcher;
        matcher = RequirementMatcherFactory.createVersionMatcher("1.5.2");
        assertFalse(matcher.matches("1.5"));
        assertTrue(matcher.matches("1.5.2"));
        assertFalse(matcher.matches("[1.4,1.5)"));
        assertFalse(matcher.matches("[1.5,1.5.2)"));
        assertFalse(matcher.matches("(1.5.2,1.6)"));
        assertTrue(matcher.matches("(1.4,1.5.2]"));

// Any doesn't filter out any echos.
var Any Matcher = func(_ echo.Instance) bool {
	return true
}

// And is an aggregate Matcher that requires all matches return true.
func And(ms ...Matcher) Matcher {
	return func(i echo.Instance) bool {
		for _, m := range ms {
			if m != nil && !m(i) {
				return false
			}
		}
		return true
	}
}

// Or is an aggregate Matcher that requires at least one matches return true.

        matches("NA", "name")
        matches("somena", "someName")
        matches("somena", "SomeName")
        matches("somena", "SomeName")
        matches("some na", "Some Name")
    }

    def "selects item with matching camel case prefix"() {
        expect:
        matches("sN", "someName")
        matches("soN", "someName")
        matches("SN", "someName")
        matches("SN", "SomeName")

        expect:
        matcher.matches([candidate1, candidate2], requested, explanationBuilder) == [candidate1, candidate2]

        matcher.matches([candidate1], requested, explanationBuilder) == [candidate1]
        matcher.isMatching(candidate1, requested)

        matcher.matches([candidate2], requested, explanationBuilder) == [candidate2]
        matcher.isMatching(candidate2, requested)
    }