# Unlike standard Dockerfiles, Istio builds artifacts outside of docker and then copies them to a temp folder;
# This folder is then passed as the docker context. This avoids complex .dockerignore or large context loads.

# Example image config
example:
- name: helloworld # Name of the image. Will end up pushed to <HUB>/helloworld:<TAG>
  dockerfile: helloworld/Dockerfile.proxyv2
  files:
  # Include a static file

//go:noescape
func Load(ptr *uint32) uint32

//go:noescape
func Load8(ptr *uint8) uint8

// NO go:noescape annotation; *ptr escapes if result escapes (#31525)
func Loadp(ptr unsafe.Pointer) unsafe.Pointer

//go:noescape
func LoadAcq(ptr *uint32) uint32

//go:noescape
func LoadAcquintptr(ptr *uintptr) uintptr

//go:noescape
func And8(ptr *uint8, val uint8)

        when:
        journal.setLastAccessTime(file, 42)
        journal.deleteLastAccessTime(file)

        then:
        journal.getLastAccessTime(file) == inceptionTimestamp
    }

    def "loads and uses previously stored inception time unless file has a later modification time"() {
        given:
        def inceptionTimestamp = System.currentTimeMillis() - 30_000
        file.lastModified = inceptionTimestamp - 30_000

   * {@linkplain Thread#getContextClassLoader() context class loader}. In simple environments, the
   * context class loader will find resources from the class path. In environments where different
   * threads can have different class loaders, for example app servers, the context class loader
   * will typically have been set to an appropriate loader for the current thread.
   *

        public List<FilterableCallInterceptor> getCallInterceptors() {
            return interceptors.get();
        }
    }

    /**
     * Use {@link ClassLoaderSourceGroovyCallInterceptorsProvider} instead that loads classes via SPI.
     * Kept to support old case where we loaded a class directly.
     */
    @NonNullApi
    @Deprecated
    @SuppressWarnings("DeprecatedIsStillUsed")

        2 * gradleProperties.mergeProperties([:]) >> [prop: 'value']

        when:
        loader.load(settings, gradle)

        then:
        1 * rootProperties.set('prop', 'value')
    }

    def "loads project properties from gradle.properties file in project dir"() {
        given:
        GUtil.saveProperties(new Properties([prop: 'rootValue']), rootPropertiesFile())

        then:
        secondResult.assertTaskSkipped(":test")

        where:
        dsl << ['groovy', 'kotlin']
    }

    /**
     * Loads the JUnit XML test results file for the given, named test case. It
     * assumes the file path to that file and loads it using Groovy's XmlSlurper
     * which can then be used to extract information from the XML.
     */

Rel(scriptResolver, editorReportPanel, "Reports")
Rel(scriptResolver, editorHints, "Reports")
Rel(scriptResolver, tapiModels, "Requests", "TAPI")
Rel(gradleKotlinDslApi, kotlinc, "Uses", "Embedded")

Rel(ideKotlin, scriptResolver, "Loads", "Embedded")
Rel(ideKotlin, kotlinc, "Uses")

Rel_Neighbor(kgp, buildCache, "Uses")
Rel(providerExecution, buildCache, "Uses")

Lay_D(gradle, gradleKotlinDsl)
Lay_D(ide, gradleBuildTool)

In order to avoid hard-coding the included builds to load, the `settings.gradle` file in `multirepo-app` loads each of these builds dynamically:

====
include::sample[dir="kotlin",files="settings.gradle.kts[tags=include_builds]"]
include::sample[dir="groovy",files="settings.gradle[tags=include_builds]"]
====

import javax.inject.Inject;
import java.io.File;

/**
 * <p>A {@code GeneratorTask} generates a configuration file based on a domain object of type T.
 * When executed the task:
 * <ul>
 *
 * <li>loads the object from the input file, if it exists.</li>
 *
 * <li>Calls the beforeConfigured actions, passing the object to each action.</li>
 *
 * <li>Configures the object in some task-specific way.</li>
 *