verify {
                prop = ['key1': 'value1']
                prop.put('key2', 'value2')
                prop.put('key3', project.provider { 'value3' })
                prop.putAll(['key4': 'value4'])
                prop.putAll(project.provider { ['key5': 'value5'] })
                expected = ['key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5']
            }

        }
    }

    @Test
    fun `can handle Hashtable`() {
        val hashtable = Hashtable<String, Any>(100)
        hashtable.put("key1", "value1")
        hashtable.put("key2", true)
        hashtable.put("key3", 42)
        configurationCacheRoundtripOf(hashtable).run {
            assertThat(hashtable, equalTo(this))
        }
    }

        if (unrecognizedContributors.isNotEmpty()) {
            val contributorsToUpdate = contributorsInReleaseNotes + unrecognizedContributors.map { it to contributorsFromPullRequests[it]!! }
            val sortedContributors = contributorsToUpdate.entries.sortedBy { TextUtil.toLowerCaseLocaleSafe(it.value.name ?: it.key) }

    @Override
    public boolean containsKey(Object key) {
        return getAndReportAccess(key) != null;
    }

    @Override
    @Nullable
    public Object put(Object key, Object value) {
        Object oldValue;
        synchronized (delegate) {
            oldValue = delegate.put(key, value);
        }
        reportAccess(key, oldValue);
        reportChange(key, value);
        return oldValue;

    }

        }
    }

    /**
     * A key for merging document nodes.
     * The scope of this key is a particular object's configuring block.
     *
     * Keys from the configuring blocks of different objects should never get matched against each other.
     */
    sealed interface MergeKey {
        /**
         * Nodes having this key are unique and never get merged with any other nodes.

        server.expectGet("/redirect/cache/${key.hashCode}", srcFile)

        when:
        def receivedInput = null
        cache.load(key) { input ->
            receivedInput = input.text
        }

        then:
        receivedInput == "Data"
    }

    def "reports cache miss on 404"() {
        server.expectGetMissing("/cache/${key.hashCode}")

        cache.store(((BuildCacheKeyInternal) key).getHashCodeInternal(), result::writeTo);
    }

    @Override
    public void storeLocally(BuildCacheKey key, File file) {
        cache.storeLocally(((BuildCacheKeyInternal) key).getHashCodeInternal(), file);
    }

    @Override
    public void withTempFile(HashCode key, Consumer<? super File> action) {

            Map.class.getName(), valueType.getName(), key);

        K sanitizedKey = keySanitizer.sanitize(key);
        if (!keyType.isInstance(sanitizedKey)) {
            throw new IllegalArgumentException(String.format(
                "Cannot get the value of a property of type %s with key type %s as the source contains a key of type %s.",

    }

    @Override
    void createBuildCacheEntry(String key, File value, long timestamp) {
        File cacheFile = cacheDir.file(key)
        Files.copy(value.toPath(), cacheFile.toPath())
        writeLastFileAccessTimeToJournal(cacheFile, timestamp)
    }

    @Override
    boolean existsBuildCacheEntry(String key) {
        cacheDir.file(key).exists()
    }

    @Override

        }.groupBy({ (_, softwareTypeName) -> softwareTypeName }, valueTransform = { (access, _) -> access })

        val softwareTypeNames = assignments.keys + additions.keys + nestedObjectAccess.keys

        return softwareTypeNames.associateWith {
            SoftwareTypeConventionResolutionResults(it, assignments[it].orEmpty(), additions[it].orEmpty(), nestedObjectAccess[it].orEmpty())
        }