*
 * @param <T> The target type for this Spec
 */
public class AndSpec<T> extends CompositeSpec<T> {
    public static final AndSpec<?> EMPTY = new AndSpec<>();

    public AndSpec() {
        super();
    }

    @SafeVarargs
    @SuppressWarnings("varargs")
    public AndSpec(Spec<? super T>... specs) {
        super(specs);
    }

    public AndSpec(Iterable<? extends Spec<? super T>> specs) {
        super(specs);

        assertTrue(new AndSpec<Object>(createAtomicElements(true, true, true)).isSatisfiedBy(new Object()));
    }

    @Test
    public void isSatisfiedByWithOneFalse() {
        assertFalse(new AndSpec<Object>(createAtomicElements(true, false, true)).isSatisfiedBy(new Object()));
    }

    @Test
    public void canAddSpecs() {
        AndSpec<Object> spec = new AndSpec<Object>(createAtomicElements(true));

 * limitations under the License.
 */

package org.gradle.api.tasks.util.internal

import org.gradle.api.file.FileTreeElement
import org.gradle.api.specs.AndSpec
import org.gradle.api.specs.NotSpec
import org.gradle.api.specs.Spec
import org.gradle.api.tasks.util.PatternSet
import spock.lang.Specification

class CachingPatternSpecFactoryTest extends Specification {

    private static final DescribingAndSpec<?> EMPTY = new DescribingAndSpec<>();
    private final AndSpec<T> specHolder;

    private DescribingAndSpec(AndSpec<T> specHolder) {
        super(specHolder.getSpecs().toArray(Cast.uncheckedCast(new Spec[0])));
        this.specHolder = specHolder;
    }

    public DescribingAndSpec() {
        this(AndSpec.empty());
    }

    public DescribingAndSpec(Spec<? super T> spec, String description) {

 */

package org.gradle.api.internal;

import org.gradle.api.NonNullApi;
import org.gradle.api.file.FileCollection;
import org.gradle.api.internal.tasks.execution.SelfDescribingSpec;
import org.gradle.api.specs.AndSpec;
import org.gradle.api.tasks.TaskOutputs;
import org.gradle.internal.properties.PropertyVisitor;

import java.io.File;
import java.util.List;
import java.util.Set;

@NonNullApi

        }
        if (filtered.size() == 1) {
            return Cast.uncheckedCast(filtered.get(0));
        }
        return new AndSpec<T>(filtered);
    }
}

class AndSpec<T> implements Spec<T> {

    private final List<Spec<? super T>> specs;

    public AndSpec(List<Spec<T>> specs) {
        this.specs = new ArrayList<Spec<? super T>>(specs);
    }

    @Override

    private final FileCollection allOutputFiles;
    private final PropertyWalker propertyWalker;
    private final FileCollectionFactory fileCollectionFactory;
    private AndSpec<TaskInternal> upToDateSpec = AndSpec.empty();
    private boolean storeInCache = true;
    private final List<SelfDescribingSpec<TaskInternal>> cacheIfSpecs = new LinkedList<>();

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.testing.logging;

import com.google.common.base.Strings;
import org.gradle.api.specs.AndSpec;
import org.gradle.api.specs.Spec;
import org.gradle.api.tasks.testing.TestDescriptor;
import org.gradle.api.tasks.testing.logging.TestLogging;
import org.gradle.api.tasks.testing.logging.TestStackTraceFilter;

import org.gradle.api.internal.project.taskfactory.IncrementalTaskAction;
import org.gradle.api.internal.tasks.InputChangesAwareTaskAction;
import org.gradle.api.internal.tasks.properties.TaskProperties;
import org.gradle.api.specs.AndSpec;

@NonNullApi
public class DefaultTaskExecutionModeResolver implements TaskExecutionModeResolver {

    private final StartParameter startParameter;

import org.gradle.api.internal.TaskOutputsInternal
import org.gradle.api.internal.project.taskfactory.IncrementalTaskAction
import org.gradle.api.internal.tasks.properties.TaskProperties
import org.gradle.api.specs.AndSpec
import spock.lang.Specification

class DefaultTaskExecutionModeResolverTest extends Specification {

    def startParameter = new StartParameter()
    def repository = new DefaultTaskExecutionModeResolver(startParameter)