-----BEGIN PGP PRIVATE KEY BLOCK-----

lQIGBGFWykABBAC5Ub/qYQwlbKRM7DZkZSX2kHlqKmZbR19lqAizbD74BxH7wi9N
2S12JcCDuuJ4il6oUOP2NGaWNyXJBiDsAfwivVpX+t48mEd5W4HHUVK/Qg6WsEQN
AHwetRhkr4d2E/FFiuBAaPqBT1TCqvHhkyHem2xCw1kQZ3cVUGY09S+WzwARAQAB
/gcDAqcenWy80U6X9g7ylfrcgrKIZa7PHO/56EUcplO5w9lVAuLQLTRW8N6CqusC
Ys//13zifu5V2zijr3K5fAFKRIRWMIC6mSTUXOq/T5SOlpiGQ/h0LqwSzO2tMz1k
ARuITw7UzU5Dnoj3hlN3GijauL5y9KS7UEnoBW2PL+1974w0pPuVDerROtPqyfQd

        [group: 'foo']               | "Required keys [name, version] are missing from map {group=foo}."
        [name: 'foo']                | "Required keys [group, version] are missing from map {name=foo}."
        [name: 'foo', version: 'v1'] | "Required keys [group] are missing from map {name=foo, version=v1}."
        [name: null]                 | "Required keys [group, name, version] are missing from map {name=null}."
    }

    void put(K key, V value) {
        map.put(new WeakKey<>(key), value);
    }

    @Nullable
    V get(K key) {
        return map.get(new WeakKey<>(key));
    }

    Set<WeakKey<K>> keySet() {
        return map.keySet();
    }

    V computeIfAbsent(K key, AbsentValueProvider<V> absentValueProvider) {
        WeakKey<K> weakKey = new WeakKey<>(key);
        V value = map.get(weakKey);

Louis Jacomet <******@****.***> 1672066652 +0100

Louis Jacomet <******@****.***> 1672066652 +0100

        configurationCache.assertStateLoaded()
        outputContains("configurationCache.requested=true")
        outputContains("configurationCache.active=true")
    }

    def "not active even if requested due to --export-keys flag"() {
        def configurationCache = newConfigurationCacheFixture()

        buildFile """
            import org.gradle.api.configuration.BuildFeatures

            <xs:element type="trusted-artifactsType" name="trusted-artifacts"/>
            <xs:element type="ignored-keysType" name="ignored-keys"/>
            <xs:element type="trusted-keysType" name="trusted-keys"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="md5Type" mixed="true">
        <xs:sequence>

    /**
     * Creates a new map instance whose keys are Class instances. Keys are referenced using strong or weak references, values by strong or other references depending on their usage.
     * This allows the classes to be collected.
     *
     * <p>A map differs from a cache in that entries are not discarded based on memory pressure, but are discarded only when the key is collected.

            <xs:element type="trusted-keysType" name="trusted-keys"/>
            <xs:element type="key-serversType" name="key-servers"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="md5Type" mixed="true">
        <xs:sequence>
            <xs:element type="also-trustType" name="also-trust" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute type="xs:string" name="value" use="required"/>

 * and for strong class references not to be held for the cache keys.
 * <p>
 * The use of {@link WeakClassSet} as the cache key, opposed to just {@link Class}, is because a type may be composed of types from different classloaders.
 * An example of this would be something like {@code ModelSet<SomeCustomUserType>}.
 * The class set abstraction effectively creates a key for all classes involved in a type.