import org.gradle.api.tasks.util.PatternSet
import spock.lang.Specification


class PatternSpecFactoryTest extends Specification {
    def factory = new PatternSpecFactory()

    def "creates spec for empty patterns"() {
        def source = new PatternSet()

        expect:
        def spec = factory.createSpec(source)
        spec.isSatisfiedBy(element("a.java"))
        spec.isSatisfiedBy(element("/a/b/c.java"))

    @Override
    CrossBuildInMemoryCache<String, Object> newCache() {
        return factory.newCache()
    }

    def "retains strong references to values from the previous session"() {
        def function = Mock(Function)

        when:
        def cache = factory.newCache()
        cache.get("a", function)
        cache.get("b", function)

        then:

                    TikaExtractor tikaExtractor = container.getComponent("tikaExtractor");
                    ZipExtractor zipExtractor = container.getComponent("zipExtractor");
                    factory.addExtractor("text/plain", tikaExtractor);
                    factory.addExtractor("text/html", tikaExtractor);
                    factory.addExtractor("application/zip", zipExtractor);

    /**
     * Returns the root directory of this cache builder factory. You should avoid using this method and instead use one of the other methods.
     */
    File getRootDir();

    /**
     * Returns the base directory that would be used for a Gradle-version specific cache builder created by this factory.
     */
    File baseDirForCache(String key);

    /**

        DefaultSerializerRegistry registry = new DefaultSerializerRegistry(false);

        BaseSerializerFactory factory = new BaseSerializerFactory();
        Serializer<LogLevel> logLevelSerializer = factory.getSerializerFor(LogLevel.class);
        Serializer<Throwable> throwableSerializer = factory.getSerializerFor(Throwable.class);

        // Log events

class DependencyManagementProjectScopeServices implements ServiceRegistrationProvider {
    void configure(ServiceRegistration registration) {
        registration.add(DefaultExternalResourceFileStore.Factory.class);
        registration.add(DefaultArtifactIdentifierFileStore.Factory.class);
        registration.add(TransformStepNodeDependencyResolver.class);
    }

    /** This is needed in order to get the {@code taskDependencyFactory} from the current project. */

package org.gradle.internal.classloader


import org.gradle.internal.classpath.DefaultClassPath
import spock.lang.Specification

class DefaultClassLoaderFactoryTest extends Specification {
    final DefaultClassLoaderFactory factory = new DefaultClassLoaderFactory()
    ClassLoader original

    def setup() {
        original = Thread.currentThread().contextClassLoader
    }

    def cleanup() {

    public static void write(Writer writer, XmlNode dom) throws XMLStreamException {
        XMLOutputFactory factory = new com.ctc.wstx.stax.WstxOutputFactory();
        factory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
        factory.setProperty(com.ctc.wstx.api.WstxOutputProperties.P_USE_DOUBLE_QUOTES_IN_XML_DECL, true);
        factory.setProperty(com.ctc.wstx.api.WstxOutputProperties.P_ADD_SPACE_AFTER_EMPTY_ELEM, true);

    DefaultBuildOperationLoggerFactory factory = new DefaultBuildOperationLoggerFactory(logger)

    def "enabling debug causes all failures to be logged"() {
        given:
        logger.isDebugEnabled() >> debugEnabled
        def outputFile = outputDir.file("test.out")
        when:
        def config = factory.createLogInfo("testTask", outputFile, 10)
        then:

            ImplementationFactory<S, ?> factory = findFactory(implementationClass);
            if (factory == null) {
                throw new IllegalArgumentException(String.format("No factory registered to create an instance of implementation class '%s'.", implementationType));
            }
            this.implementationRegistration = new ImplementationRegistration<S>(source, implementationType, factory);
        }