* limitations under the License.
 */

package org.gradle.api.internal.tasks.execution

import org.gradle.api.DefaultTask
import org.gradle.api.execution.TaskExecutionListener
import org.gradle.api.internal.TaskInternal
import org.gradle.api.internal.project.taskfactory.TaskIdentity
import org.gradle.api.internal.tasks.TaskExecuter
import org.gradle.api.internal.tasks.TaskExecuterResult

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

package org.gradle.tooling.internal.provider.runner

import org.gradle.api.internal.TaskInternal
import org.gradle.api.internal.tasks.execution.ExecuteTaskBuildOperationDetails
import org.gradle.api.internal.tasks.testing.TestDescriptorInternal

import org.gradle.api.DefaultTask;
import org.gradle.api.Incubating;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.internal.tasks.TaskContainerInternal;
import org.gradle.api.tasks.TaskContainer;
import org.gradle.language.base.plugins.LifecycleBasePlugin;
import org.gradle.model.Each;

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

package org.gradle.internal.enterprise.exceptions

import org.gradle.api.internal.TaskInternal
import org.gradle.api.tasks.TaskExecutionException
import org.gradle.api.tasks.VerificationException
import org.gradle.execution.MultipleBuildFailures
import org.gradle.groovy.scripts.ScriptCompilationException

        }
        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])

 * limitations under the License.
 */

package org.gradle.plugin.devel.tasks.internal;

import com.google.common.reflect.TypeToken;
import org.gradle.api.NonNullApi;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.internal.tasks.properties.TypeScheme;
import org.gradle.api.internal.tasks.properties.annotations.OutputPropertyRoleAnnotationHandler;
import org.gradle.api.tasks.Nested;

        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;