TaskDetailsFactory factory

    def setup() {
        project.allprojects >> [project, subproject]
        factory = new TaskDetailsFactory(project)
    }

    def createsDetailsForTaskInMainProject() {
        task.project >> project
        task.path >> ':path'
        project.relativeProjectPath(':path') >> 'task'

        expect:
        def details = factory.create(task)

  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 {

  /** Factory for {@link ByteSink} instances. */
  public interface ByteSinkFactory extends SinkFactory<ByteSink, byte[]> {}

  /** Factory for {@link CharSource} instances. */
  public interface CharSourceFactory extends SourceFactory<CharSource, String> {}

  /** Factory for {@link CharSink} instances. */
  public interface CharSinkFactory extends SinkFactory<CharSink, String> {}

  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(

// NewSliceOfSlice is not a factory function because slices of a slice of
// type *T are not factory functions of type T.
func NewSliceOfSlice() [][]T { return []T{[]T{}} }

// NewPointerSliceOfSlice is not a factory function because slices of a
// slice of type *T are not factory functions of type T.
func NewPointerSliceOfSlice() [][]*T { return []*T{[]*T{}} }

// NewSlice3 is not a factory function because 3 nested slices of type T

            @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:

     */
    int getMaxWorkerCount();

    /**
     * Runs a given {@link Factory} while the specified locks are being held, releasing
     * the locks upon completion.  Blocks until the specified locks can be obtained.
     */
    <T> T withLocks(Collection<? extends ResourceLock> locks, Factory<T> factory);

    /**
     * Runs a given {@link Runnable} while the specified locks are being held, releasing

        private final Factory<WritableArtifactCacheLockingAccessCoordinator> factory;
        private volatile WritableArtifactCacheLockingAccessCoordinator delegate;

        private LateInitWritableArtifactCacheLockingAccessCoordinator(Factory<WritableArtifactCacheLockingAccessCoordinator> factory) {
            this.factory = factory;
        }

    /**
     * Locates a factory which can create services of the given type.
     *
     * @param type The service type that the factory should create.
     * @param <T>  The service type that the factory should create.
     * @return The factory. Never returns null.
     * @throws UnknownServiceException When there is no factory available for services of the given type.