result.duration == delegateDuration
        result.afterExecutionOutputState.get().originMetadata.buildInvocationId == buildInvocationScopeId.asString()
        result.afterExecutionOutputState.get().originMetadata.buildCacheKey == buildCacheKey
        result.afterExecutionOutputState.get().originMetadata.executionTime >= result.duration
        !result.afterExecutionOutputState.get().reused
        assertOperation()

        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->
            def buildCacheKey = context.cachingState.cacheKeyCalculatedState.get().key
            buildCacheKey.hashCode == cacheKey.toString()
        }) >> delegateResult

        where:
        buildCacheEnabled << [true, false]
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.caching.impl;

import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.BuildCacheKeyInternal;
import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.internal.hash.HashCode;

 */

package org.gradle.api.internal.tasks

import com.google.common.collect.ImmutableSortedMap
import org.gradle.api.internal.tasks.properties.InputFilePropertySpec
import org.gradle.caching.BuildCacheKey
import org.gradle.internal.execution.caching.CachingState
import org.gradle.internal.execution.history.BeforeExecutionState
import org.gradle.internal.execution.model.InputNormalizer
import org.gradle.internal.file.FileType

    private static final String TYPE_KEY = "type";
    private static final String IDENTITY_KEY = "identity";
    private static final String CACHE_KEY = "buildCacheKey";
    private static final String CREATION_TIME_KEY = "creationTime";
    private static final String EXECUTION_TIME_KEY = "executionTime";

    private final String currentBuildInvocationId;

 * limitations under the License.
 */

package org.gradle.caching.internal;

import org.gradle.caching.BuildCacheKey;
import org.gradle.internal.hash.HashCode;

public interface BuildCacheKeyInternal extends BuildCacheKey {
    HashCode getHashCodeInternal();

        String buildInvocationId = decoder.readString();
        HashCode buildCacheKey = hashCodeSerializer.read(decoder);
        Duration executionTime = Duration.ofMillis(decoder.readSmallLong());
        return new OriginMetadata(
            buildInvocationId,
            buildCacheKey,
            executionTime
        );
    }

    @Override

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

    @Override
    public boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException {
        final byte[] bytes = delegate.get(key.getHashCode());
        if (bytes == null) {
            return false;
        }
        try {

     * @return {@code true} if an entry was found, {@code false} otherwise.
     * @throws BuildCacheException if the cache fails to load a cache entry for the given key
     */
    boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException;

    /**
     * Store the cache entry with the given cache key. The {@code writer} will be called to actually write the data.
     *

                }
                
                @Override
                boolean load(BuildCacheKey key, BuildCacheEntryReader reader) throws BuildCacheException {
                    return false
                }
    
                @Override
                void store(BuildCacheKey key, BuildCacheEntryWriter writer) throws BuildCacheException {
                }
    
                @Override