}
    }

    private
    suspend fun ReadContext.readUpToDateSpec(task: TaskInternal) {
        if (readBoolean()) {
            task.outputs.upToDateWhen(readNonNull<Spec<Task>>())
        }
    }

    private
    fun WriteContext.writeReasonNotToTrackState(task: TaskInternal) {
        writeNullableString(task.reasonNotToTrackState.orElse(null))
    }

    private

    private static class PreviousOutputFileCollection extends LazilyInitializedFileCollection {
        private final TaskInternal task;
        private final FileCollectionFactory fileCollectionFactory;
        private final ImmutableSortedMap<String, FileSystemSnapshot> previousOutputs;

        }
        return new BuildServices(services, identifier, gradle)
    }

    TaskInternal task(BuildServices services, Node dependsOn) {
        def projectState = Stub(ProjectState)
        def project = Stub(ProjectInternal)
        def task = Stub(TaskInternal)
        def dependencies = Stub(TaskDependency)
        _ * dependencies.getDependencies(_) >> [dependsOn].toSet()

    }

    def "finalizer groups that finalize each other do not form a cycle"() {
        given:
        TaskInternal finalizerA = createTask("finalizerA")
        TaskInternal finalizerB = createTask("finalizerB")
        TaskInternal finalizerDepA = task("finalizerDepA", finalizedBy: [finalizerB])
        TaskInternal finalizerDepB = task("finalizerDepB", finalizedBy: [finalizerA])
        relationships(finalizerA, dependsOn: [finalizerDepA])

        assert createdTask.is(task)
        return task
    }

    private static void validateException(TaskInternal task, WorkValidationException exception, String... causes) {
        validateException(task, true, exception, causes)
    }

    private static void validateException(TaskInternal task, boolean ignoreType, WorkValidationException exception, String... causes) {

        failureHasCause("Cannot create task ':thing' of type 'AbstractTask' as this type is not supported for task registration.")
    }

    def "creating a task of type TaskInternal is not supported"() {
        buildFile << """
            task thing(type: ${TaskInternal.name}) { t ->
                assert t instanceof DefaultTask
                doFirst { println("thing") }
            }
        """

        expect:

 * limitations under the License.
 */
package org.gradle.composite.internal;

import com.google.common.annotations.VisibleForTesting;
import org.gradle.api.Task;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.specs.Spec;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.PlanExecutor;
import org.gradle.execution.plan.QueryableExecutionPlan;

 * limitations under the License.
 */

package org.gradle.execution.plan;

import org.gradle.api.file.FileTreeElement;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.internal.file.FileCollectionInternal;
import org.gradle.api.internal.file.FileCollectionStructureVisitor;
import org.gradle.api.internal.file.FileTreeInternal;

            throw new InvalidUserDataException("The task name must be provided.");
        }

        final Class<? extends TaskInternal> type = Objects.requireNonNull(Cast.uncheckedCast(actualArgs.get(Task.TASK_TYPE)), "Task type must not be null");

        final TaskIdentity<? extends TaskInternal> identity = taskIdentityFactory.create(name, type, project);
        return buildOperationRunner.call(new CallableBuildOperation<Task>() {

import org.gradle.api.DefaultTask
import org.gradle.api.Named
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.FileCollection
import org.gradle.api.internal.TaskInternal
import org.gradle.api.internal.file.TestFiles
import org.gradle.api.internal.tasks.properties.bean.TestImplementationResolver
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Destroys