then:
        converter.convert(properties, layout).properties.get(DaemonBuildOptions.JvmArgsOption.GRADLE_PROPERTY) == '-Xmx128m'
    }

    def "root dir properties take precedence over gradle installation home properties"() {
        when:
        def properties = properties()
        def layout = layout(properties)
        rootDir.file("settings.gradle") << ''

// license that can be found in the LICENSE file.

//go:build lldb

// Used by gcc_signal_darwin_arm64.c when doing the test build during cgo.
// We hope that for real binaries the definition provided by Go will take precedence
// and the linker will drop this .o file altogether, which is why this definition
// is all by itself in its own file.

    def highest = Attribute.of("highest", String)
    def middle = Attribute.of("middle", String)
    def lowest = Attribute.of("lowest", String)
    // This has no precedence
    def additional = Attribute.of("usage", String)

    static class CompatibilityRule implements AttributeCompatibilityRule<String> {
        @Override
        void execute(CompatibilityCheckDetails<String> details) {

/**
 * Read property value for compiler options.
 *
 * Kotlin compiler options for scripts can be set either via a System property or a Gradle property.
 * System properties have precedence, same as in `LayoutToPropertiesConverter`.
 */
private
fun getCompilerOptionBoolean(gradleProperties: GradlePropertiesController, propertyName: String, defaultValue: Boolean, whenUnset: (() -> Unit)? = null): Boolean {

     */
    Source getGlobalToolchainsSource();

    /**
     * Sets the global toolchains source. If both user toolchains and a global toolchains are given, the user toolchains
     * take precedence.
     *
     * @param globalToolchainsSource The global toolchains source, may be {@code null} to disable global toolchains.
     * @return This request, never {@code null}.
     */

//   `calibration_options`. In that case, the explicit configs take precedence
//   and the preset's configs are ignored.
//   - For `QuantizationSpecs`, the expanded `QuantizationSpec`s will be
//   populated first and user-provided `QuantizationSpec`s, if any, will be
//   appended. This expresses the fact that user-provided specs take precedence.
// * Preset unspecified
//   - No-op.

// mesh config, but takes precedence.
func (w *internalWatcher) HandleMeshConfigData(yaml string) {
	w.mutex.Lock()
	defer w.mutex.Unlock()
	w.revMeshConfig = yaml
	merged := w.merged()
	w.handleMeshConfigInternal(merged)
}

// HandleUserMeshConfig keeps track of user mesh config overrides. These are merged with the standard
// mesh config, which takes precedence.

    a. If the attribute has a known precedence, Gradle will stop as soon as there is a single candidate remaining.
    b. After all extra attributes with precedence are considered, the remaining candidates can be chosen if they are compatible with all of the non-ordered disambiguation rules.

					},
				},
				{
					"global takes precedence over default config",
					"",
					"",
					[]proxyConfigInstance{
						newProxyConfig("global", "istio-system", nil, map[string]string{
							"A": "3",
						}),
					},
					map[string]string{
						"A": "3",
						"B": "2",
					},
				},
				{
					"pod annotation takes precedence over namespace",
					"{ \"proxyMetadata\": {\"A\": \"5\"} }",

        // We need to take the existing requested attributes and sort them in "precedence" order
        // This returns a structure that tells us the order of requestedAttributes by their index in
        // requestedAttributes.
        //
        // If the requested attributes are [ A, B, C ]
        // If the attribute precedence is [ C, A ]
        // The indices are [ A: 0, B: 1, C: 2 ]