expect:
        compatible
    }

    def "contexts with different quantity of opts are not compatible"() {
        clientWants(Jvm.forHome(javaHome), ["-Xmx256m", "-Dfoo=foo"])
        candidate.javaHome >> javaHome
        candidate.daemonOpts >> ["-Xmx256m"]

        expect:
        !compatible
        unsatisfiedReason.contains "At least one daemon option is different"

            // they should not even be called in this case
            0 * details._()
        } else if (compatible) {
            1 * details.compatible()
        } else {
            0 * details._()
        }

        where:
        consumer                     | producer                                             | compatible

            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")
            )
        }
    }

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;
            }

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

executable::
A daemon is considered compatible only if it uses the same Java executable.

classpath::
A daemon is considered compatible if its classpath contains all the classpath entries requested. +
Note that a daemon is considered compatible only if the classpath exactly matches the requested classpath.

heap settings::
A daemon is considered compatible if it has at least the same heap size settings as requested. +

   > Could not resolve project :producer.
     Required by:
         project :
      > Dependency resolution is looking for a library compatible with JVM runtime version 6, but 'project :producer' is only compatible with JVM runtime version 7 or newer.""")
        failure.assertHasResolution("Change the dependency on 'project :producer' to an earlier version that supports JVM runtime version 7.")
    }

## List of metrics exposed by MinIO

- MinIO exports Prometheus compatible data by default as an authorized endpoint at `/minio/v2/metrics/cluster`. 
- MinIO exports Prometheus compatible data by default which is bucket centric as an authorized endpoint at `/minio/v2/metrics/bucket`.
- MinIO exports Prometheus compatible data by default which is node centric as an authorized endpoint at `/minio/v2/metrics/node`.