expect:
        factory.sourceDirectorySet("name", "display") != null
    }

    def "list property has empty list as value"() {
        expect:
        def property = factory.listProperty(String)
        property.present
        property.get().empty
    }

    def "can create list property with primitive type"() {
        given:
        def property = factory.listProperty(type)

        expect:

public class DefaultUnscopedCacheBuilderFactory implements UnscopedCacheBuilderFactory {
    private final CacheFactory factory;

    public DefaultUnscopedCacheBuilderFactory(CacheFactory factory) {
        this.factory = factory;
    }

    @Override
    public CacheBuilder cache(File baseDir) {
        return new DefaultCacheBuilder(factory, baseDir);
    }

import org.gradle.internal.Factories;
import org.gradle.internal.Factory;

import java.io.IOException;

@ThreadSafe
public class SimpleModelRuleDescriptor extends AbstractModelRuleDescriptor {

    private final Factory<String> factory;

    public SimpleModelRuleDescriptor(final Factory<String> descriptor) {
        this.factory = new Factory<String>() {
            String cachedValue;
            @Override

        return track(new Factory<Iterable<? extends Completion>>() {
            @Override
            public Iterable<? extends Completion> create() {
                return TimeTrackingProcessor.super.getCompletions(element, annotation, member, userText);
            }
        });
    }

    private <T> T track(Factory<T> factory) {
        stopwatch.start();
        try {

        when:
        async {
            threadCount.times { i ->
                def nextValue = i.toString()
                start {
                    Factory<String> factory = new Factory<String>() {
                        @Override
                        String create() {
                            assert System.getProperty(presetPropertyName) == nextValue

    private static final BaseEncoding ENCODING = BaseEncoding.base32().lowerCase().omitPadding();
    private static final Pattern PATTERN = Pattern.compile("[a-z2-7]{26}");

    private static final Factory<UniqueId> FACTORY = new Factory<UniqueId>() {
        @Override
        public UniqueId create() {
            return generate();
        }
    };

    private final String value;

    public static UniqueId from(UUID uuid) {

  public CharSinkTester(
      CharSinkFactory factory, String string, String suiteName, String caseDesc, Method method) {
    super(factory, string, suiteName, caseDesc, method);
    this.lines = getLines(string);
    this.expectedLines = getLines(expected);
  }

  @Override
  protected void setUp() throws Exception {
    this.sink = factory.createSink();
  }

  public void testOpenStream() throws IOException {

  static TestSuite tests(String name, ByteSourceFactory factory, boolean testAsCharSource) {
    TestSuite suite = new TestSuite(name);
    for (Entry<String, String> entry : TEST_STRINGS.entrySet()) {
      if (testAsCharSource) {
        suite.addTest(suiteForString(factory, entry.getValue(), name, entry.getKey()));
      } else {
        suite.addTest(
            suiteForBytes(

            @Provides
            Integer createInteger(Factory<String> factory) {
                return factory.create().length()
            }

            @Provides
            Factory<String> createString(Callable<String> action) {
                return { action.call() } as Factory
            }

            @Provides
            Callable<String> createAction() {

        when:
        instantiator.registerFactory(String, {})

        then:
        IllegalArgumentException e = thrown()
        e.message == "Cannot register a factory for type String because it is not a subtype of container element type Base."
    }

    def "registering factory for the same type more than once results in an exception"() {
        given:
        instantiator.registerFactory(TestType, {})

        when: