},
			},
			mergedEnv: []v1.EnvVar{
				{Name: "Foo1", Value: "Bar1"},
				{Name: "Foo2", Value: "Bar2"},
				{Name: "Foo3", Value: "Bar3"},
			},
		},
		{
			name: "extraEnv env take precedence over the proxyEnv",
			proxyEnv: []kubeadmapi.EnvVar{
				{
					EnvVar: v1.EnvVar{Name: "Foo1", Value: "Bar1"},
				},
				{
					EnvVar: v1.EnvVar{Name: "Foo2", Value: "Bar2"},
				},
			},

}

// DetermineEffectiveSecurityContext returns a synthesized SecurityContext for reading effective configurations
// from the provided pod's and container's security context. Container's fields take precedence in cases where both
// are set
func DetermineEffectiveSecurityContext(pod *v1.Pod, container *v1.Container) *v1.SecurityContext {
	effectiveSc := securityContextFromPodSecurityContext(pod)

func (ps *printState) endScope(b byte) {
	ps.scopes--
	ps.writeByte(b)
}

// precedence is used for operator precedence. This is used to avoid
// unnecessary parentheses when printing expressions in the LLVM style.
type precedence int

// The precedence values, in order from high to low.
const (
	precPrimary precedence = iota
	precPostfix
	precUnary
	precCast
	precPtrMem
	precMul
	precAdd

        where:
        toStringReturns     | expected
        null                | "null"
        "toString() called" | "toString() called"
    }

    def "toString() declared in super-class takes precedence over Named"() {
        def value = new NamedExtendingHasToString(name: "name", superToString: "super-to-string")

        expect:
        RendererUtils.displayValueOf(value) == "super-to-string"
    }

        classpath('b').project('a').assertHasAttribute(EclipsePluginConstants.WITHOUT_TEST_CODE_ATTRIBUTE_KEY, 'false')
    }

    @ToBeFixedForConfigurationCache
    def "eclipse.classpath.containsTestFixtures configuration has precedence over the applied java-test-fixtures plugin"() {
        file('a/build.gradle') << """
            plugins {
                id 'java-test-fixtures'
            }

            eclipse {
                classpath {

 *
 * <p>Caching for individual task instances can be enabled and disabled via {@link TaskOutputs#cacheIf(String, Spec)} or disabled via {@link TaskOutputs#doNotCacheIf(String, Spec)}.
 * Using these APIs takes precedence over the presence (or absence) of {@code @DisableCachingByDefault}.</p>
 *
 * @see org.gradle.api.tasks.CacheableTask
 * @see org.gradle.api.artifacts.transform.CacheableTransform
 *
 * @since 7.0
 */
@Documented

If you enable auto-detection in your build, custom toolchains extend the set of toolchain locations.
Gradle picks a toolchain according to the <<sec:precedence,precedence rules>>.
====

[[sec:precedence]]
== Toolchain installations precedence

Gradle will sort all the JDK/JRE installations matching the toolchain specification of the build and will pick the first one.
Sorting is done based on the following rules:

				require.NoError(t, err, "failed to merge kubelet drop-in configs")
			}

			// Use kubelet config flag precedence
			err := kubeletConfigFlagPrecedence(kubeletConfig, test.cliArgs)
			require.NoError(t, err, "failed to set the kubelet config flag precedence")

			// Verify the merged configuration fields
			for fieldName, expectedValue := range test.overwrittenConfigFields {

        cleanup:
        env.removeEnvironmentVariable(GradleUserHomeLookup.GRADLE_USER_HOME_ENV_KEY)
    }

    def "Gradle user home set by system property takes precedence over environment variable"() {
        when:
        String sysPropDirName = 'some/dir'
        String envVarDirName = 'other/dir'
        System.setProperty(GradleUserHomeLookup.GRADLE_USER_HOME_PROPERTY_KEY, sysPropDirName)

  // `config.calibration_options.representative_datasets` and
  // `config.static_range_ptq_preset.representative_datasets` are both
  // specified. In this case, the one set to the `calibration_options` takes
  // precedence.
  QuantizationConfig config{};
  RepresentativeDatasetConfig& top_level_dataset_config =
      *config.mutable_calibration_options()->add_representative_datasets();