.collect(Collectors.toMap(AssessedAttribute::getAttribute, AssessedAttribute::getRequested, (a, b) -> a));
        @SuppressWarnings("DataFlowIssue") List<String> otherValues = assessedCandidate.getOnlyOnRequestAttributes().stream()
            .map(assessedAttribute -> "Doesn't say anything about " + describer.describeMissingAttribute(assessedAttribute.getAttribute(), assessedAttribute.getRequested()))

		return r.matches[i]
	}
	return r.otherValues[name]
}

// SetPathValue sets name to value, so that subsequent calls to r.PathValue(name)
// return value.
func (r *Request) SetPathValue(name, value string) {
	if i := r.patIndex(name); i >= 0 {
		r.matches[i] = value
	} else {
		if r.otherValues == nil {
			r.otherValues = map[string]string{}
		}
		r.otherValues[name] = value
	}
}

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

        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:

// 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

            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'] })