return spec;
    }

    public static <T> Action<T> action(SerializableAction<T> action) {
        return action;
    }

    public static <T> Factory<T> factory(SerializableFactory<T> factory) {
        return factory;
    }

    public static <OUT, IN> Transformer<OUT, IN> transformer(SerializableTransformer<OUT, IN> transformer) {
        return transformer;
    }

}

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 != "" {

        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() >> {

    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

    @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.
     *

        registry.onTaskCompletion(provider)

        then:
        registry.subscriptions.size() == 1
        0 * listener._

        when:
        async {
            factory.fire(success)
            factory.fire(failure)
            factory.fire(skipped)
            signalBuildFinished()
        }

        then:
        1 * listener.onFinish({ it instanceof TaskFinishEvent && it.result instanceof TaskSuccessResult })

    private final Instantiator instantiator;
    private final DefaultProjectDependencyFactory factory;

    public DependencyConstraintProjectNotationConverter(Instantiator instantiator, DefaultProjectDependencyFactory factory) {
        this.instantiator = instantiator;
        this.factory = factory;
    }

    @Override
    public void describe(DiagnosticsVisitor visitor) {

            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)) {

    private LockOptions lockOptions = mode(FileLockManager.LockMode.Shared);
    private String displayName;

    public DefaultCacheBuilder(CacheFactory factory, File baseDir) {
        this.factory = factory;
        this.baseDir = baseDir;
    }

    @Override
    public CacheBuilder withProperties(Map<String, ?> properties) {
        this.properties = properties;
        return this;
    }

    @Override

        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")