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
	}

		{`"\" rest`, "", `"\" rest`},
		{`"C:\dev\go\robots.txt"`, `C:\dev\go\robots.txt`, ""},
		{`"C:\新建文件夹\中文第二次测试.mp4"`, `C:\新建文件夹\中文第二次测试.mp4`, ""},
	}
	for _, test := range tests {
		value, rest := consumeValue(test[0])
		expectedValue := test[1]
		expectedRest := test[2]
		if value != expectedValue {
			t.Errorf("expected to consume value [%s], not [%s] from [%s]",
				expectedValue, value, test[0])

        @Override
        public void execute(MultipleCandidatesDetails<TargetJvmEnvironment> details) {
            TargetJvmEnvironment consumerValue = details.getConsumerValue();
            if (consumerValue != null && details.getCandidateValues().contains(consumerValue)) {
                details.closestMatch(consumerValue); // exact match
            } else {

    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)) {

    }

    @Override
    @Nullable
    public String describeMissingAttribute(Attribute<?> attribute, Object consumerValue) {
        StringBuilder sb = new StringBuilder();
        if (haveSameName(Usage.USAGE_ATTRIBUTE, attribute)) {
            sb.append("its usage (required ");
            describeUsage(consumerValue, sb);
            sb.append(")");

                } else {
                    incompatible.add(new AssessedAttribute<>(attribute, Cast.uncheckedCast(consumerValue.get()), Cast.uncheckedCast(producerValue.get())));
                }
            } else if (consumerValue.isPresent()) {
                onlyOnConsumer.add(new AssessedAttribute<>(attribute, Cast.uncheckedCast(consumerValue.get()), null));

        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) {