'existing' | 'existingValue'    | 'existingValue' | 'other'       | 'otherValue'       | 'otherValue'   | true
        'existing' | 'nonexistingValue' | 'existingValue' | 'other'       | 'otherValue'       | 'otherValue'   | false
        'existing' | 'nonexistingValue' | 'existingValue' | 'missing'     | 'missingValue'     | null           | false

			}
		})
	}
}

func TestGet_Slice(t *testing.T) {
	exp := []*resource.FakeResource{
		{
			IDValue:    "child-resource",
			OtherValue: "child",
		},
		{
			IDValue:    "parent-resource",
			OtherValue: "parent",
		},
	}

	g := NewWithT(t)
	parent := newScope("parent", nil)
	parent.add(exp[1], &resourceID{id: exp[1].IDValue})
	child := newScope("child", parent)

    val propertyName = pair.first
    val value = pair.second
    if (hasProperty(propertyName)) {
        val otherValue = property(propertyName)
        if (value.toString() != otherValue.toString()) {
            throw RuntimeException("Attempting to set global property $propertyName to two different values ($value vs $otherValue)")
        }
    }
    extra.set(propertyName, value)
}

// FakeResource used for testing.
type FakeResource struct {
	IDValue    string
	OtherValue string
}

func (f *FakeResource) ID() ID {
	return FakeID(f.IDValue)
}

// GetOtherValue is an additional method used to distinguish this resource API from others.
func (f *FakeResource) GetOtherValue() string {
	return f.OtherValue

        where:
        key        | oldValue        | expectedValue   | expectedResult
        'existing' | 'existingValue' | 'newValue'      | true
        'existing' | 'otherValue'    | 'existingValue' | false
        'missing'  | 'otherValue'    | null            | false

    }

    def "method replace(#key, #oldValue, newValue) reports change"() {
        when:

            dummyModel("otherValue"),
            [
                { it.value }
            ]
        )

        then:
        def error = thrown(AssertionError)
        error.message.contains("assert getter(actual) == getter(expected)")
        error.message.contains("       |      |       |  |")
        error.message.contains("       |      |       |  'otherValue'")

        when:
        def properties = loadAndMergePropertiesWith(emptyMap())

        then:
        "value" == properties["prop1"]
        "value" == properties["prop2"]

        when:
        properties = loadPropertiesFrom(otherSettingsDir).getProperties()

        then:
        "otherValue" == properties["prop1"]

                    verify.prop.putAll(['key': 'newValue', 'otherKey': 'otherValue'])
                    verify.expected = ['key': 'newValue', 'otherKey': 'otherValue']
                }
            }

            task replacingPutAllWithProvider {
                doLast {
                    verify.prop.putAll(provider { ['key': 'newValue', 'otherKey': 'otherValue'] })

        def attr = Attribute.of(Flavor)

        given:
        schema.attribute(attr).compatibilityRules.add(CustomCompatibilityRule)

        def value1 = flavor('value')
        def value2 = flavor('otherValue')

        expect:
        schema.matcher().selectionSchema.matchValue(attr, value1, value2)
        !schema.matcher().selectionSchema.matchValue(attr, value2, value1)

    }

    def "write property"() {
        when:
        writeableProperty(JavaTestSubject, "myProperty", String.class).setValue(myProperties, "otherValue")

        then:
        readableProperty(JavaTestSubject, String, "myProperty").getValue(myProperties) == "otherValue"
    }

    def "write property with multiple setters"() {
        when: