}
    }

    private JarTestFixture transformJar(TransformFactoryType factory, File originalJar) {
        def outputJar = testDir.file("transformed.jar")
        return new JarTestFixture(transform(factory, originalJar, outputJar), 'UTF-8', null, /* checkManifest */ false)
    }

    private TestFile transformDirectory(TransformFactoryType factory, File originalDir) {
        def outputDir = testDir.file("transformed")

public class DependencyProjectNotationConverter implements NotationConverter<Project, ProjectDependency> {

    private final DefaultProjectDependencyFactory factory;

    public DependencyProjectNotationConverter(DefaultProjectDependencyFactory factory) {
        this.factory = factory;
    }

    @Override
    public void describe(DiagnosticsVisitor visitor) {
        visitor.candidate("Projects").example("project(':some:project:path')");

     *
     * @param factory
     *            {@link SAXParserFactory}。{@literal null}であってはいけません
     * @return {@link SAXParser}の新しいインスタンス
     */
    public static SAXParser newSAXParser(final SAXParserFactory factory) {
        assertArgumentNotNull("factory", factory);

        try {
            return factory.newSAXParser();
        } catch (final ParserConfigurationException e) {

    ImmutableModuleIdentifierFactory moduleIdentifierFactory = new DefaultImmutableModuleIdentifierFactory()
    AttributeDesugaring attributeDesugaring = Mock()

    def factory = new DefaultDependencyCoordinateResolverFactory(
        projectDependencyResolver, moduleIdentifierFactory, attributeDesugaring
    )

class DefaultArtifactFactoryTest {

    @Inject
    ArtifactFactory factory;

    @Test
    void testPropagationOfSystemScopeRegardlessOfInheritedScope() {
        Artifact artifact = factory.createDependencyArtifact(
                "test-grp", "test-artifact", VersionRange.createFromVersion("1.0"), "type", null, "system", "provided");
        Artifact artifact2 = factory.createDependencyArtifact(

            throw new GradleException(String.format("Cannot register a factory for type %s because a factory for this type is already registered.", type.getSimpleName()));
        }
        factories.put(type, factory);
    }

    @Override
    public Set<? extends Class<? extends T>> getCreatableTypes() {
        return ImmutableSet.copyOf(factories.keySet());
    }

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

        }
}

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

    }

    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