import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;

public class PatternSets {
    private static final Factory<PatternSet> PATTERN_SET_FACTORY = new PatternSetFactory(PatternSpecFactory.INSTANCE);

    /**
     * Should use as an injected service instead.
     * @deprecated
     */
    @Deprecated
    public static Factory<PatternSet> getNonCachingPatternSetFactory() {
        return PATTERN_SET_FACTORY;

class CachedStoreFactoryTest extends Specification {

    def "stores results"() {
        def factory = new CachedStoreFactory("some cache")

        def results1 = new Object()
        def results2 = new Object()

        def store1 = factory.createCachedStore("conf1")
        def store1b = factory.createCachedStore("conf1")
        def store2 = factory.createCachedStore("conf2")

        expect:
        store1.load(() -> results1) == results1

    }

    def "getting a worker daemon does not assume client use"() {
        when:
        factory.getWorker(requirement);

        then:
        0 * clientsManager._
    }

    def "new client is created when daemon is executed and no idle clients found"() {
        when:
        factory.getWorker(requirement).execute(spec)

        then:
        1 * clientsManager.reserveIdleClient(options) >> null

    private static URLStreamHandlerFactory factory;

    private CIFSContext transportContext;


    /**
     * Sets the URL stream handler factory for the environment. This
     * allows specification of the factory used in creating underlying
     * stream handlers. This can be called once per JVM instance.
     *
     * @param factory
     *            The URL stream handler factory.
     */

        return textResourceFactory;
    }

    public interface Factory {
        ResourceHandler create(FileOperations fileOperations);

        static Factory from(FileResolver fileResolver, TaskDependencyFactory taskDependencyFactory, FileSystem fileSystem, TemporaryFileProvider tempFileProvider, ApiTextResourceAdapter.Factory textResourceAdapterFactory) {

        }
}

internal class JavaElementDelegatingVariableReturnTypeSourceWithSmartPointer<TYPE : PsiType>(
    override val psiPointer: SmartPsiElementPointer<out PsiVariable>,
    override val factory: JavaElementSourceFactory,
) : JavaElementDelegatingTypeSourceWithSmartPointer<PsiVariable, TYPE>() {

    override fun getType(psi: PsiVariable): TYPE {
        @Suppress("UNCHECKED_CAST")
        return psi.type as TYPE

    private final ComponentSelector selector;

    public ModuleVersionResolveException(ComponentSelector selector, Factory<String> message, Throwable cause) {
        super(message, cause);
        this.selector = selector;
    }

    public ModuleVersionResolveException(ComponentSelector selector, Factory<String> message) {
        super(message);
        this.selector = selector;
    }

        }
    }

    ModuleExclude nextModule() {
        FACTORY.module(randomModuleName())
    }

    GroupExclude nextGroup() {
        FACTORY.group(randomGroupName())
    }

    ModuleIdExclude nextModuleId() {
        FACTORY.moduleId(randomModuleId())
    }

    ModuleSetExclude nextModuleSet() {
        FACTORY.moduleSet((0..(1 + random.nextInt(5))).collect { randomModuleName() } as Set<String>)

        private final ChecksumAlgorithmFactory factory;

        DefaultChecksumAlgorithm(ChecksumAlgorithmFactory factory) {
            this.factory = factory;
        }

        @Override
        public String getName() {
            return factory.getName();
        }

        @Override
        public String getFileExtension() {
            return factory.getFileExtension();
        }

import org.hamcrest.Description;
import org.hamcrest.Factory;
import org.hamcrest.Matcher;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.StringReader;
import java.util.regex.Pattern;

import static org.hamcrest.CoreMatchers.equalTo;

public class Matchers {

    @Factory