then:
        1 * target.jvmArgs(['argFromProvider'])
    }

    def "defaults are compatible"() {
        def other = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())

        expect:
        options.isCompatibleWith(other)
    }

    def "is compatible with identical options"() {

        this.compatible = new BitSet(candidates.size());
        compatible.set(0, candidates.size());
    }

    public int[] getMatches() {
        findCompatibleCandidates();
        if (compatible.cardinality() <= 1) {
            return getCandidates(compatible);
        }
        if (longestMatchIsSuperSetOfAllOthers()) {

            this.name = name;
            this.candidateAttributes = attributes.asImmutable();
            this.candidateCapabilities = candidateCapabilities;
            this.compatible = compatible;
            this.incompatible = incompatible;

            assertHasAccepted(
                "Method com.example.Task.getSourceCompatibility(): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method return type has changed", "Method is now abstract"),
                "Method com.example.Task.setSourceCompatibility(java.lang.String): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method has been removed")
            )
        }
    }

     *
     * <p>A compatibility rule can tell if two values are compatible.
     * Compatibility doesn't mean equality. Typically two different Java platforms can be
     * compatible, without being equal.</p>
     *
     * <p>A rule <i>can</i> express an opinion by calling the @{link {@link CompatibilityCheckDetails#compatible()}}
     * method to tell that two attributes are compatible, or it <i>can</i> call {@link CompatibilityCheckDetails#incompatible()}

1. Each candidate's attribute value is compared to the consumer's requested attribute value. A candidate is considered compatible if its value matches the consumer's value exactly, passes the attribute's compatibility rule or is not provided.
2. If only one candidate is considered compatible, that candidate wins.

                // consumer didn't express any preferences, everything fits
                details.compatible();
                return;
            }
            if (consumerValue.getName().equals(Usage.JAVA_API)) {
                if (COMPATIBLE_WITH_JAVA_API.contains(producerValue.getName())) {
                    details.compatible();
                }
                return;
            }

    def "check compatibility rules"() {
        CompatibilityCheckResult details = Mock(CompatibilityCheckResult)

        when:
        compatibilityRules.execute(details)

        then:
        1 * details.getConsumerValue() >> consumer
        1 * details.getProducerValue() >> producer

        if (compatible) {
            1 * details.compatible()

   > Could not resolve project :producer.
     Required by:
         project :consumer
      > Dependency resolution is looking for a library compatible with JVM runtime version $currentJava, but 'project :producer' is only compatible with JVM runtime version $tooHighJava or newer.""")
        failure.assertHasErrorOutput("Caused by: " + VariantSelectionException.class.getName())

// NewExpressions environment to be compatible with that version. The EnvSet also
// prepares StoredExpressions to be compatible with all known versions of Kubernetes.
type EnvSet struct {
	// compatibilityVersion is the version that all configuration in
	// the NewExpressions environment is compatible with.
	compatibilityVersion *version.Version