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

    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

public final class okhttp3/sse/EventSources {
	public static final field INSTANCE Lokhttp3/sse/EventSources;
	public static final fun createFactory (Lokhttp3/Call$Factory;)Lokhttp3/sse/EventSource$Factory;
	public static final synthetic fun createFactory (Lokhttp3/OkHttpClient;)Lokhttp3/sse/EventSource$Factory;
	public static final fun processResponse (Lokhttp3/Response;Lokhttp3/sse/EventSourceListener;)V

        e.message == "boom"

        where:
        factory            | factoryName
        Lazy.unsafe()::of  | "unsafe"
        Lazy.locking()::of | "locking"
        Lazy.atomic()::of  | "atomic"
    }

    def "#factoryName supplier code is executed once with apply"() {
        def supplier = Mock(Supplier)

        when:
        def lazy = factory(supplier)

        then:
        0 * supplier._

        }
        if (value instanceof Factory) {
            return ((Factory<?>) value).create();
        }
        return value;
    }

    public static boolean isDeferred(Object value) {
        return value instanceof Provider
            || value instanceof Factory
            || isNestableDeferred(value);
    }

import org.gradle.internal.Factory;

/**
 * A specialized version of multi cause exception that is cheaper to create
 * because we avoid to fill a stack trace, and the message MUST be generated lazily.
 */
@Contextual
public class DefaultMultiCauseExceptionNoStackTrace extends DefaultMultiCauseException {
    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory) {
        super(messageFactory);

func TestSimpleMetaFactoryInterpret(t *testing.T) {
	factory := SimpleMetaFactory{}
	gvk, err := factory.Interpret([]byte(`{"apiVersion":"1","kind":"object"}`))
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if gvk.Version != "1" || gvk.Kind != "object" {
		t.Errorf("unexpected interpret: %#v", gvk)
	}

	// no kind or version
	gvk, err = factory.Interpret([]byte(`{}`))
	if err != nil {

public class TaskDependencyMatchers {
    @Factory
    public static Matcher<Task> dependsOn(final String... tasks) {
        return dependsOn(equalTo(new HashSet<String>(Arrays.asList(tasks))));
    }

    @Factory
    public static Matcher<Task> dependsOn(Matcher<? extends Iterable<String>> matcher) {
        return dependsOn(matcher, false);
    }

    @Factory

        then:
        1 * action.execute("original")

        and:
        result == null
    }

    def "factory as transformer"() {
        def factory = Mock(Factory)

        when:
        def result = toTransformer(factory).transform("original")

        then:
        1 * factory.create() >> "transformed"
        result == "transformed"
    }

    def constants() {
        def foo = "foo"

    def storeFile = Mock(File)
    def storeFactory = Mock(PersistentScopeIdStoreFactory)
    def idFactory = Mock(Factory) as Factory<UniqueId>
    def store = Mock(ObjectHolder)

    def loader = new DefaultPersistentScopeIdLoader(globalScopedCacheBuilderFactory, buildTreeScopedCacheBuilderFactory, storeFactory, idFactory)

    def "generates user ID in expected location"() {
        given:
        def newId = UniqueId.generate()