failureDescriptionContains(implementationUnknown {
            implementationOfTask(':customTask')
            unknownClassloader('CustomTask_Decorated')
        })
        failureDescriptionContains(implementationUnknown {
            additionalTaskAction(':customTask')
            unknownClassloader('CustomTask_Decorated')
        })
        def result = operations.first(SnapshotTaskInputsBuildOperationType).result

        failureDescriptionContains(implementationUnknown {
            implementationOfTask(':customTask')
            unknownClassloader('CustomTask_Decorated')
        })
        failureDescriptionContains(implementationUnknown {
            additionalTaskAction(':customTask')
            unknownClassloader('CustomTask_Decorated')
        })
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

    }

    def "tests output of unknown implementation with unknown classloader"() {
        when:
        render implementationUnknown(true) {
            implementationOfTask(':myTask')
            unknownClassloader('Unknown')
            includeLink()
        }

        then:
        outputEquals """
Implementation of task ':myTask' was loaded with an unknown classloader (class 'Unknown').

        failureDescriptionContains(implementationUnknown {
            nestedProperty('bean')
            unknownClassloader('NestedBean')
        })
    }

    def "changes to nested domain object container are tracked"() {
        buildFile << taskWithNestedInput()
        buildFile << """

        }

        UnknownImplementation additionalTaskAction(String taskPath) {
            prefix = "Additional action of task '${taskPath}'"
            this
        }

        UnknownImplementation unknownClassloader(String className) {
            postfix = "was loaded with an unknown classloader (class '${className}')."
            reason = "Gradle cannot track the implementation for classes loaded with an unknown classloader."

        boolean isLambda,
        @Nullable Object value
    ) {
        if (classLoaderHash == null) {
            return new UnknownImplementationSnapshot(classIdentifier, UnknownReason.UNKNOWN_CLASSLOADER);
        }

        if (isLambda) {
            return serializedLambdaFor(value)
                .<ImplementationSnapshot>map(it -> new LambdaImplementationSnapshot(classLoaderHash, it))

import javax.annotation.Nullable;
import java.util.Objects;

public class UnknownImplementationSnapshot extends ImplementationSnapshot {

    public enum UnknownReason {
        UNKNOWN_CLASSLOADER(
            "was loaded with an unknown classloader (class '%s').",
            "Gradle cannot track the implementation for classes loaded with an unknown classloader.",

        copy.classIdentifier == original.classIdentifier
        copy.classLoaderHash == null
        copy.unknownReason == UnknownImplementationSnapshot.UnknownReason.UNKNOWN_CLASSLOADER
    }

    def "serializes implementation properties with untracked lambda"() {
        def original = ImplementationSnapshot.of('someClassName$$Lambda/312454364', TestHashCodes.hashCodeFrom(1234))