}

func InferPodsFromTypedResource(name, defaultNS string, factory cmdutil.Factory) ([]string, string, error) {
	resname, ns := inferNsInfo(name, defaultNS)
	if !strings.Contains(resname, "/") {
		return []string{resname}, ns, nil
	}
	client, podName, namespace, selector, err := getClientForResource(resname, ns, factory)
	if err != nil {
		return []string{}, "", err
	}
	if podName != "" {

    private final ProjectStateRegistry projectStateRegistry;
    private final LocalComponentGraphResolveStateFactory localResolveStateFactory;
    private final DefaultRootComponentMetadataBuilder.Factory factory;

    /**
     * Use {@link Factory#create} to create instances.
     */
    private DefaultRootComponentMetadataBuilder(
        DependencyMetaDataProvider metadataProvider,
        ComponentIdentifierFactory componentIdentifierFactory,

    DocumentationRegistry documentationRegistry = Mock()
    TemplateOperationFactory.TemplateOperationBuilder builder
    TemplateOperationFactory factory

    def setup() {
        factory = new TemplateOperationFactory("/some/template/package", documentationRegistry)
        builder = factory.newTemplateOperation()
        builder.withTemplate(GroovyMock(URL))
        _ * fileResolver.resolve(_) >> { String fileName ->

    @Nullable
    public ExcludeSpec intersect(ExcludeSpec left, ExcludeSpec right, ExcludeFactory factory) {
        if (leftType.isInstance(left) && rightType.isInstance(right)) {
            return doIntersect(leftType.cast(left), rightType.cast(right), factory);
        } else {
            return doIntersect(leftType.cast(right), rightType.cast(left), factory);
        }
    }

    /**
     * Intersects the given exclude specs.
     *

import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;
import org.gradle.internal.nativeintegration.filesystem.FileSystem;
import org.gradle.internal.nativeintegration.services.FileSystems;

import java.io.File;

public class DefaultDirectoryFileTreeFactory implements DirectoryFileTreeFactory {
    private final Factory<PatternSet> patternSetFactory;
    private final FileSystem fileSystem;

    private final BuildEventListenerFactory factory;

    public SubscribableBuildActionExecutor(ListenerManager listenerManager,
                                           BuildOperationListenerManager buildOperationListenerManager,
                                           BuildEventListenerFactory factory,
                                           BuildEventConsumer eventConsumer,

    private final Function<E, E> factory;

    public AccessTrackingSet(Set<? extends E> delegate, Listener listener) {
        this(delegate, listener, Function.identity());
    }

    public AccessTrackingSet(Set<? extends E> delegate, Listener listener, Function<E, E> factory) {
        this.delegate = delegate;
        this.listener = listener;
        this.factory = factory;
    }

    @Override

        events[1].message.startsWith('nag')
    }

    def "does not log warning while disabled with factory"() {
        given:
        Factory<String> factory = Mock(Factory)

        when:
        def result = DeprecationLogger.whileDisabled(factory)

        then:
        result == 'result'

        and:
        1 * factory.create() >> {

    def "generates from template within sourceSet"() {
        setup:
        def targetAsFile = new File(target)
        def settings = createInitSettings("")
        def factory = new TemplateFactory(settings, language, templateOperationFactory)

        when:
        factory.fromSourceTemplate("someTemplate/SomeClazz.somelang.template", sourceSet)

        then:
        1 * targetDir.file(target) >> targetFile

    gradlePluginPortal()
}

// tag::object-factory[]
tasks.register("myObjectFactoryTask") {
    doLast {
        val objectFactory = project.objects
        val myProperty = objectFactory.property(String::class)
        myProperty.set("Hello, Gradle!")
        println(myProperty.get())
    }
}
// end::object-factory[]

// tag::object-factory-inject[]
abstract class MyObjectFactoryTask