return Cast.uncheckedCast(serviceFactories.get(serviceType));
        }
        DefaultServiceLocator.ServiceFactory<T> factory = delegate.findFactory(serviceType);
        serviceFactories.put(serviceType, factory);
        return factory;
    }

    @Override
    public synchronized <T> T get(Class<T> serviceType) throws UnknownServiceException {
        if (services.containsKey(serviceType)) {

        return Subject.valueOf(subjectString.toLowerCase());
    }

    public static ExcludeFactory maybeLog(ExcludeFactory factory) {
        if (LOGGER.isDebugEnabled()) {
            return new LoggingExcludeFactory(factory);
        }
        return factory;
    }

    @Override
    public ExcludeSpec anyOf(ExcludeSpec one, ExcludeSpec two) {

    private final InstantiatorFactory factory;

    public ImplicitInputsCapturingInstantiator(ServiceRegistry serviceRegistry, InstantiatorFactory factory) {
        this.serviceRegistry = serviceRegistry;
        this.factory = factory;
    }

    @Override
    public <T> T newInstance(Class<? extends T> type, Object... parameters) throws ObjectInstantiationException {

    }

    void "configured target uses given script plugin factory for nested scripts"() {
        given:
        def otherScriptPluginFactory = Mock(ScriptPluginFactory)
        factory.setScriptPluginFactory(otherScriptPluginFactory)
        final Object target = new Object()

        when:
        def configurer = factory.create(scriptSource, scriptHandler, targetScope, baseScope, false)

            }
        }
    }

    @Nullable
    public static <T> T whileDisabled(Factory<T> factory) {
        disable();
        try {
            return factory.create();
        } finally {
            maybeEnable();
        }
    }

    public static void whileDisabled(Runnable action) {
        disable();

IMPORTPATH
	testdata/issue22856

FILENAMES
	testdata/issue22856.go

FUNCTIONS
	// NewPointerSliceOfSlice is not a factory function because slices ...
	func NewPointerSliceOfSlice() [][]*T

	// NewSlice3 is not a factory function because 3 nested slices of ...
	func NewSlice3() [][][]T

	// NewSliceOfSlice is not a factory function because slices of a ...
	func NewSliceOfSlice() [][]T


TYPES
	// 
	type T struct{}

	// 

import org.gradle.api.file.FileCollection
import org.gradle.api.plugins.antlr.AntlrTask
import spock.lang.Specification

class AntlrSpecFactoryTest extends Specification {

    private AntlrSpecFactory factory = new AntlrSpecFactory()
    private FileCollection sourceSetDirectories = Mock()

    def tracePropertiesAddedToArgumentList() {
        when:
        sourceSetDirectoriesAreEmptySet()
        AntlrTask task = Mock()

}

type group struct {
	factory          internalinterfaces.SharedInformerFactory
	namespace        string
	tweakListOptions internalinterfaces.TweakListOptionsFunc
}

// New returns a new Interface.
func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
	return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}

    private final TypeSafeProjectDependencyFactory factory;
    private final ProjectDependencyInternal delegate;

    public DelegatingProjectDependency(TypeSafeProjectDependencyFactory factory, ProjectDependencyInternal delegate) {
        this.factory = factory;
        this.delegate = delegate;
    }

    protected ProjectDependencyInternal create(String path) {
        return factory.create(path);
    }

        0 * _

        when:
        result = factory.newCache("cache", 12000, calculator, BaseSerializerFactory.INTEGER_SERIALIZER).get(file)

        then:
        result == 12

        and:
        0 * _
    }

    def "reuses calculated value for file across factory instances"() {
        def file = new File("thing.txt")