work.visitImplementations(implementationsBuilder);
        ImplementationSnapshot implementation = implementationsBuilder.getImplementation();
        ImmutableList<ImplementationSnapshot> additionalImplementations = implementationsBuilder.getAdditionalImplementations();

        if (LOGGER.isDebugEnabled()) {

    def classloaderHierarchyHasher = Mock(ClassLoaderHierarchyHasher)
    def inputFingerprinter = Mock(InputFingerprinter)
    def implementationSnapshot = ImplementationSnapshot.of("MyWorkClass", TestHashCodes.hashCodeFrom(1234))

    abstract AbstractCaptureStateBeforeExecutionStep<PreviousExecutionContext, CachingResult> getStep()

    def setup() {
        _ * work.inputFingerprinter >> inputFingerprinter
    }

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedMap;
import org.gradle.api.Describable;
import org.gradle.internal.snapshot.ValueSnapshot;
import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

import java.util.Map;

class InputValueChanges implements ChangeContainer {
    private final Describable executable;
    private final ImmutableMap<String, String> changed;

import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

public class ImplementationChanges implements ChangeContainer {
    private final ClassImplementationSnapshot previousImplementation;
    private final ImmutableList<ImplementationSnapshot> previousAdditionalImplementations;
    private final ClassImplementationSnapshot currentImplementation;
    private final ImmutableList<ImplementationSnapshot> currentAdditionalImplementations;

            if (valueSnapshot instanceof ImplementationSnapshot) {
                ImplementationSnapshot implementationSnapshot = (ImplementationSnapshot) valueSnapshot;
                validateNestedInput(workValidationContext, propertyName, implementationSnapshot);
            }
        });
    }

        original == written
    }

    def "serializes implementation properties with unknown classloader"() {
        def original = ImplementationSnapshot.of("someClassName", null)
        write(original)

        expect:
        ImplementationSnapshot copy = written as ImplementationSnapshot
        copy.classIdentifier == original.classIdentifier
        copy.classLoaderHash == null

    private Map<String, ? extends File> outputFiles
    private Map<String, ? extends File> outputDirs
    private Collection<? extends TestFile> create
    private ImplementationSnapshot implementation = ImplementationSnapshot.of(UnitOfWork.name, TestHashCodes.hashCodeFrom(1234))
    private Consumer<WorkValidationContext> validator

    private final InputFingerprinter inputFingerprinter

    private final HashCode cacheKey;

    public DefaultPreviousExecutionState(
        OriginMetadata originMetadata,
        HashCode cacheKey,
        ImplementationSnapshot implementation,
        ImmutableList<ImplementationSnapshot> additionalImplementations,
        ImmutableSortedMap<String, ValueSnapshot> inputProperties,
        ImmutableSortedMap<String, FileCollectionFingerprint> inputFileProperties,

import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

public interface ImplementationAwareTaskAction extends Action<Task> {

    /**
     * Returns the implementation snapshot for the action.
     *
     * This can be the implementation of the implementing class, or of some delegate action.
     */
    ImplementationSnapshot getActionImplementation(ClassLoaderHierarchyHasher hasher);

import org.gradle.internal.snapshot.FileSystemSnapshot;
import org.gradle.internal.snapshot.impl.ClassImplementationSnapshot;
import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

import static org.gradle.internal.execution.history.impl.OutputSnapshotUtil.findOutputsStillPresentSincePreviousExecution;

public class DefaultExecutionStateChangeDetector implements ExecutionStateChangeDetector {