*/
public class RemappingScriptSource extends DelegatingScriptSource {
    public final static String MAPPED_SCRIPT = "_BuildScript_";

    public RemappingScriptSource(ScriptSource source) {
        super(source);
    }

    @Override
    public String getClassName() {
        return MAPPED_SCRIPT;
    }

)

// Store provides the interface for storing keyed data.
// Store must be thread-safe
type Store interface {
	// key must contain one or more characters in [A-Za-z0-9]
	// Write writes data with key.
	Write(key string, data []byte) error
	// Read retrieves data with key
	// Read must return ErrKeyNotFound if key is not found.
	Read(key string) ([]byte, error)
	// Delete deletes data by key

            }
        """
        fails "t"

        then:
        if (GradleContextualExecuter.configCache) {
            // Configuration caching resolves the outputs when storing to the configuration cache
            // This fails already, so we don't even get to resolving the mutations.
            failureDescriptionStartsWith("BOOM!")
        } else {

 * the License.
 */

/**
 * Static utilities for the eight primitive types and {@code void}, and value types for treating
 * them as unsigned or storing them in immutable arrays.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>
 * library.
 *
 * <p>See the Guava User Guide article on <a

    private static final String CLEAN_CONFIGURATION_CACHE_OUTPUT = "org.gradle.integtest.samples.cleanConfigurationCacheOutput";
    private static final Pattern CONFIGURATION_CACHE_OUTPUT = Pattern.compile(
        "((Configuration cache entry[^\\n]+\\.)|" +
            "(See the complete report at [^\\n]+\\n)|" +
            "(0 problems were found storing the configuration cache.\\n))(\\n)?"
    );

    @Override

    def readCache = Mock(ModuleArtifactCache)
    def writeCache = Mock(ModuleArtifactCache)

    @Subject
    def twoStageCache = new TwoStageModuleArtifactCache(readOnlyPath, readCache, writeCache)

    def "storing delegates to the write index"() {
        when:
        twoStageCache.store(key, artifact, hashCode)

        then:
        1 * writeCache.store(key, artifact, hashCode)
        0 * readCache._
    }

 * limitations under the License.
 */

package org.gradle.internal.reflect;

import java.util.WeakHashMap;

/**
 * A generic purpose, thread-safe cache which is aimed at storing information
 * about a class. The cache is a hierarchical cache, which key is a composite
 * of a receiver, and argument types. All those, key or arguments, are kept

internal
fun BuildOperationRunner.withStoreOperation(@Suppress("UNUSED_PARAMETER") cacheKey: String, block: () -> StoreResult) =
    run(object : RunnableBuildOperation {
        override fun description(): BuildOperationDescriptor.Builder = BuildOperationDescriptor
            .displayName("Store configuration cache state")
            .progressDisplayName("Storing configuration cache state")
            .details(StoreDetails)

 *
 * @since 3.5
 */
public class MapBasedBuildCacheService implements BuildCacheService {
    private final ConcurrentMap<String, byte[]> delegate;

    public MapBasedBuildCacheService(ConcurrentMap<String, byte[]> delegate) {
        this.delegate = delegate;
    }

    @Override
    public boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException {

    def metadata = Stub(ModuleMetadataCache.CachedMetadata)

    @Subject
    def twoStageCache = new TwoStageModuleMetadataCache(timeProvider, readCache, writeCache)

    def "storing delegates to write cache"() {
        when:
        twoStageCache.store(key, entry, metadata)

        then:
        1 * writeCache.store(key, entry, metadata)
        0 * readCache._
    }