import org.gradle.api.specs.Spec;

/**
 * A {@code TaskCollection} contains a set of {@link Task} instances, and provides a number of query methods.
 *
 * @param <T> The type of tasks which this collection contains.
 */
public interface TaskCollection<T extends Task> extends NamedDomainObjectSet<T> {

    /**
     * {@inheritDoc}
     */
    @Override
    TaskCollection<T> named(Spec<String> nameFilter);

    /**

Laura Kassovic <******@****.***> 1701107622 -0800

        }
        for (T t : this) {
            context.add(t);
        }
    }

    @Override
    protected TaskCollection<T> getDelegate() {
        return (TaskCollection<T>) super.getDelegate();
    }

    private <S extends T> TaskCollection<S> realizable(Class<S> type, TaskCollection<S> collection) {

 *
 * @param S The type of objects to find.
 * @return The matching objects. Returns an empty collection if there are no such objects
 * in this collection.
 * @see [TaskCollection.withType]
 */
inline fun <reified S : Task> TaskCollection<in S>.withType(): TaskCollection<S> =

fun <T : Task> TaskCollection<out Task>.named(name: String, type: KClass<T>): TaskProvider<T> =
    (this as TaskCollection<T>).named(name, type.java)


/**
 * Configures a task by name and type, without triggering its creation or configuration, failing if there is no such task.
 *
 * @see [TaskCollection.named]
 * @see [TaskProvider.configure]
 */
@Suppress("unchecked_cast")

    }

    @Override
    public <S extends T> TaskCollection<S> withType(Class<S> type) {
        return filtered(createFilter(type));
    }

    @Override
    public TaskCollection<T> named(Spec<String> nameFilter) {
        Spec<T> spec = convertNameToElementFilter(nameFilter);
        return filtered(nameFilter, createFilter(spec));
    }

    @Override
    public TaskCollection<T> matching(Spec<? super T> spec) {

| link:{javadocPath}/org/gradle/api/tasks/TaskCollection.html#withType-java.lang.Class-[TaskCollection.withType().getByName()]
| Use `named()` instead.

| link:{javadocPath}/org/gradle/api/tasks/TaskCollection.html#getByName-java.lang.String-[TaskCollection.getByName()]
| Use `named()` instead.

| link:{javadocPath}/org/gradle/api/tasks/TaskCollection.html#whenTaskAdded-org.gradle.api.Action-[TaskCollection.whenTaskAdded()]

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

package org.gradle.api.internal.tasks

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskCollection
import org.gradle.model.internal.core.ModelNode
import org.gradle.model.internal.core.ModelPath
import org.gradle.model.internal.fixture.ModelRegistryHelper
import org.gradle.util.TestUtil
import spock.lang.Specification

        delegate.addAll(elements)

    override fun named(predicate: Spec<String>): TaskCollection<Task> =
        delegate.named(predicate)

    override fun matching(spec: Spec<in Task>): TaskCollection<Task> =
        delegate.matching(spec)

    override fun matching(closure: Closure<Any>): TaskCollection<Task> =
        delegate.matching(closure)

    override fun clear() =
        delegate.clear()

                ${DomainObjectCollection::class.qualifiedName}<Build_gradle.A>
                ${DomainObjectCollection::class.qualifiedName}<Build_gradle.B>
                ${TaskCollection::class.qualifiedName}<${Task::class.qualifiedName}>
                ${TaskCollection::class.qualifiedName}<${Delete::class.qualifiedName}>
                """
            )
        )
    }

    @Test