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

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

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:

        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+

 *  - Potentially only apply the end-of-build timestamp for input files only, as often some or all of the output files of a build will have the end-of-build timestamp.
 *  - Use finer grained timestamps, where available. Currently we still use the `File.lastModified()` timestamp on some platforms.
 */
public abstract class FileTimeStampInspector {
    private final File workDir;

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