All source code in Gradle is written to target one or more of these runtimes.
Most source code targets the daemon and the remaining code either targets a single runtime, for example the Gradle client, or is shared across multiple runtimes.

## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the runtimes.
Not every module contributes to every runtime.

import gradlebuild.buildutils.runtimes.CheckTargetRuntimes
import gradlebuild.configureAsRuntimeJarClasspath

plugins {
    id("gradlebuild.repositories")
}

val runtimeAware: NamedDomainObjectProvider<DependencyScopeConfiguration> = configurations.dependencyScope("runtimeAware") {
    description = "All dependencies which should run in a Gradle context, and therefore must declare or inherit target runtime compatibility"
}

    .url("https://www.nytimes.com/")
    .build();
client.newCall(newYorkTimesRequest).enqueue(new Callback() {
  ...
});
```

Running this race over home WiFi shows the Times (`0002`) completes just slightly sooner than the Post (`0001`):

```
0001 https://www.washingtonpost.com/
0001 0.000 callStart
0002 https://www.nytimes.com/
0002 0.000 callStart
0002 0.010 dnsStart

	}
	if types.Contains(madmin.MetricsCPU) {
		m.Aggregated.CPU = &madmin.CPUMetrics{
			CollectedAt: UTCNow(),
		}
		cm, err := c.Times(false)
		if err != nil {
			m.Errors = append(m.Errors, fmt.Sprintf("%s: %v (cpuTimes)", byHostName, err.Error()))
		} else {
			// not collecting per-cpu stats, so there will be only one element
			if len(cm) == 1 {
				m.Aggregated.CPU.TimesStat = &cm[0]

 * runtimes. All projects that these two projects depend on will inherit these runtimes
 * as part of their computed target runtimes.
 *
 * This task verifies that the computed target runtimes for each project properly reflect
 * the required target runtimes of all other projects. Optionally, it can write the correct
 * target runtimes back to the build files.
 *

    fun requiredRuntimes(action: ModuleTargetRuntimes.() -> Unit) {
        action(requiredRuntimes)
    }

    /**
     * The set of runtimes for this module, computed based on the required target
     * runtimes of this module and the required target runtimes of all modules
     * that depend on this module. This set contains a runtime if it is required

This platform does not provide special support for a particular kind of automation. This is the responsibility of other platforms.

It is made up of 3 architecture modules:

- **core-runtime**: Provides the runtimes or "containers" in which code runs. These runtimes include the Gradle client, the daemon and the worker processes. This is the base module on which all other architecture modules depend.

When working on some source code it is important to be aware of the runtimes in which it will run, so that you don't break these constraints.
There is some assistance in the IDE for this plus a lot of validation that is applied at build time and on CI, but it is useful to keep these constraints in mind as well.

See [Gradle runtimes](runtimes.md) for a list of these runtimes and more details.

### Build execution model

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.InetAddress;
import java.net.UnknownHostException;

import org.junit.jupiter.api.BeforeEach;

        verify(smbFileHandle, times(1)).getTree();
    }

    /**
     * Test isValid() when the handle is valid.
     */
    @Test
    void testIsValid_whenValid() {
        when(smbFileHandle.isValid()).thenReturn(true);
        assertTrue(smbFileHandle.isValid(), "isValid should return true when the handle is valid.");
        verify(smbFileHandle, times(1)).isValid();
    }

    /**