'java.util.logging.ConsoleHandler.level = FINEST' + EOL +
                'hello.level = INFO' + EOL +
                'hello.world.level = FINER' + EOL))
        }
    }

    def setup() {
        savedJULConfigClassProperty = System.getProperty("java.util.logging.config.class")
    }

    def cleanup() {

                    assert logger.isLoggable(Level.INFO)
                    assert logger.isLoggable(Level.CONFIG)
                    assert logger.isLoggable(Level.FINE)
                    assert !logger.isLoggable(Level.FINER)
                    assert !logger.isLoggable(Level.FINEST)
                }
            }
        """

        when:
        executer.withArgument("--debug")

        then:
        succeeds('isLoggable')

    Method method;
    try {
      method = extractMethod(test);
    } catch (IllegalArgumentException e) {
      logger.finer(Platform.format("%s: including by default: %s", test, e.getMessage()));
      return true;
    }
    if (suppressedTests.contains(method)) {
      logger.finer(Platform.format("%s: excluding because it was explicitly suppressed.", test));
      return false;
    }
    TesterRequirements requirements;

    Method method;
    try {
      method = extractMethod(test);
    } catch (IllegalArgumentException e) {
      logger.finer(Platform.format("%s: including by default: %s", test, e.getMessage()));
      return true;
    }
    if (suppressedTests.contains(method)) {
      logger.finer(Platform.format("%s: excluding because it was explicitly suppressed.", test));
      return false;
    }
    TesterRequirements requirements;

apiVersion: install.istio.io/v1alpha1
kind: IstioOperator
metadata:
  name: install
spec:
  meshConfig:
    # Disable retries. This avoids confusing logs and errors, and allows finer grain control for tests
    defaultHttpRetryPolicy: {}
    accessLogFile: "/dev/stdout"
    defaultConfig:
      proxyMetadata:
        ISTIO_META_DNS_CAPTURE: "true"
  values:
    pilot:

     * will not be used and a network request will be made.
     *
     * @param maxAge a non-negative duration. This is stored and transmitted with [TimeUnit.SECONDS]
     *     precision; finer precision will be lost.
     */
    fun maxAge(maxAge: Duration) =
      apply {
        val maxAgeSeconds = maxAge.inWholeSeconds
        require(maxAgeSeconds >= 0) { "maxAge < 0: $maxAgeSeconds" }

        return scala2VersionsSupportedByJdk(javaVersion) + scala3VersionsSupportedByJdk(javaVersion)
    }

    private static Set<String> scala2VersionsSupportedByJdk(JavaVersion javaVersion) {
        // There are finer grained version requirements, but we don't need to worry about them here, as we use latest patch versions
        if (javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)) {
            // All latest patches of 2.13 work on Java 9+

A _consumer_ needs to be understood in the large sense:

- a project that depends on another project is a _consumer_
- a _task_ that depends on an artifact is a finer grained consumer

In dependency management, a lot of the decisions we make depend on the type of project we are building, that is to say, <<#sub:being-respectful-consumers,what kind of _consumer_ we are>>.

//    *different* variables
//  - they make the blanket assumption that any functions called cause or depend
//    on side effects (i.e., access resource variables.)
//
// By moving the logic to compile time, we will be able to do a finer-grained
// data flow analysis in the future, which will enable more optimizations.
// This could happen in two steps:
// (1) build multiple dependency chains (one per variable), still treating

Only comparing the build cache key on its own does not give much information, so we need to look at some finer grained data to be able to diagnose the cache miss.
A list of all inputs to the computed build cache key can be found in the <<build_cache.adoc#sec:task_output_caching_details,section on cacheable tasks>>.