return "", v
	}
	return v[0:notPos], v[notPos:]
}

// consumeValue consumes a "value" per RFC 2045, where a value is
// either a 'token' or a 'quoted-string'.  On success, consumeValue
// returns the value consumed (and de-quoted/escaped, if a
// quoted-string) and the rest of the string. On failure, returns
// ("", v).
func consumeValue(v string) (value, rest string) {
	if v == "" {
		return
	}

    private final T consumerValue;
    private final T producerValue;
    private boolean compatible;
    private boolean done;

    public DefaultCompatibilityCheckResult(@Nullable T consumerValue, T producerValue) {
        assert producerValue != null : "Internal contract of the current implementation, can be changed with a motivation";
        assert !Objects.equals(consumerValue, producerValue);

    static class CompatibilityRule implements AttributeCompatibilityRule<String> {
        @Override
        void execute(CompatibilityCheckDetails<String> details) {
            assert details.consumerValue == "value1"
            assert details.producerValue == "value2"
            details.compatible()
        }
    }

    static class CompatibilityRuleWithParams implements AttributeCompatibilityRule<String> {

    private final Set<T> candidateValues;
    private final T consumerValue;

    // Match recording is optimized for the general case of a single match
    private T singleMatch;
    private Set<T> multipleMatches;

    public DefaultMultipleCandidateResult(@Nullable T consumerValue, Set<T> candidateValues) {
        if (candidateValues.isEmpty() || (consumerValue != null && candidateValues.size() == 1)) {

        this.reverse = reverse;
    }

    @Override
    public void execute(CompatibilityCheckDetails<T> details) {
        T consumerValue = details.getConsumerValue();
        T producerValue = details.getProducerValue();
        int cmp = comparator.compare(consumerValue, producerValue);
        if (reverse) {
            cmp = -cmp;
        }
        if (cmp >= 0) {
            details.compatible();

    }

    @Override
    public String describeMissingAttribute(Attribute<?> attribute, Object consumerValue) {
        return StyledException.style(StyledTextOutput.Style.Info, delegate.describeMissingAttribute(attribute, consumerValue));
    }

    @Override
    public String describeExtraAttribute(Attribute<?> attribute, Object producerValue) {

    static class CompatibilityRule implements AttributeCompatibilityRule<String> {
        @Override
        void execute(CompatibilityCheckDetails<String> details) {
            if (details.consumerValue == null) {
                details.compatible()
            } else {
                if (details.producerValue in ["best", "compatible"]) {
                    details.compatible()
                }
            }

        @Override
        public void execute(MultipleCandidatesDetails<GradlePluginApiVersion> details) {
            GradlePluginApiVersion consumerValue = details.getConsumerValue();
            GradleVersion consumer = consumerValue == null ? GradleVersion.current() : GradleVersion.version(consumerValue.getName());
            GradleVersion bestMatchVersion = GradleVersion.version("0.0");
            GradlePluginApiVersion bestMatchAttribute = null;

        candidates.getConsumerValue() >> consumerValue
        candidates.getCandidateValues() >> candidateValues.collect { usage(it) }

        when:
        rule.execute(candidates)

        then:
        count * candidates.closestMatch({ it.name == Usage.JAVA_RUNTIME })

        where:
        consumerValue      | candidateValues                                 | choosesRuntime

                });
            return sb.toString();
        }

        @Override
        public String describeMissingAttribute(Attribute<?> attribute, Object consumerValue) {
            return attribute.getName() + " (required '" + consumerValue + "')";
        }

        @Override
        public String describeExtraAttribute(Attribute<?> attribute, Object producerValue) {