content: |
      This fix changes the behavior of overlapping wildcard hosts in VirtualService. Previously, the oldest VirtualService would take precedence
      regardless of whether or not it was the most specific host match. Now, the most specific host match will take precedence. To persist the old behavior,

                    configure<my.MySettingsExtension> {
                        action()
                    }
                }
            """
        )

        val result = build("ok")

        // then:
        result.assertOutputContains("It's 42!")
        result.assertOutputContains("Plugin extension takes precedence!")
    }

    @Test

    @Rule SetSystemProperties systemProperties = new SetSystemProperties()

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "build property set on command line takes precedence over properties file"() {
        when:
        file('gradle.properties') << """
org.gradle.configureondemand=true
"""
        buildFile << """
task assertCodEnabled {
    doLast {

        expect:
        EmptySchema.INSTANCE.attributes.empty
        !EmptySchema.INSTANCE.hasAttribute(Attribute.of(String))
    }

    def "has no precedence"() {
        expect:
        EmptySchema.INSTANCE.attributeDisambiguationPrecedence.empty
    }

    def "cannot set precedence"() {
        when:
        EmptySchema.INSTANCE.attributeDisambiguationPrecedence(Attribute.of("attribute", String))
        then:

    File getGlobalSettingsFile();

    /**
     * Sets the global settings file. A non-existent settings file is equivalent to empty settings. If both user
     * settings and global settings are given, the user settings take precedence.
     *
     * @param globalSettingsFile The global settings file, may be {@code null} to disable global settings.
     * @return This request, never {@code null}.
     */

        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") << ''

    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.