0 * readIndex._
    }

    def "lookup searches the write index then delegates to the read index"() {
        when:
        twoStageIndex.lookup("key")

        then:
        1 * writeIndex.lookup("key") >> null
        1 * readIndex.lookup("key")

        when:
        twoStageIndex.lookup("other")

        then:
        1 * writeIndex.lookup("other") >> Stub(CachedExternalResource)
        0 * readIndex._

	lookup := func() {
		for _, name := range names {
			typ := scope.Lookup(name).Type()
			LookupFieldOrMethod(typ, true, pkg, "m")
		}
	}

	// Perform a lookup once, to ensure that any lazily-evaluated state is
	// complete.
	lookup()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		lookup()
	}

    private final Lookup lookup;

    private final TypeRegistry typeRegistry;

    @Inject
    public DefaultPackagingRegistry(Lookup lookup, TypeRegistry typeRegistry, List<PackagingProvider> providers) {
        super(providers);
        this.lookup = lookup;
        this.typeRegistry = typeRegistry;
    }

    @Override
    public Optional<Packaging> lookup(String id) {

        this.lookup = lookup;
    }

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public void extend(MavenExecutionRequest mavenExecutionRequest) {
        Map<String, PropertyContributor> effectivePropertyContributors = lookup.lookupMap(PropertyContributor.class);
        if (!effectivePropertyContributors.isEmpty()) {

        this.customLifecycles = lifecycles;
        this.lookup = null;
        this.registry = null;
    }

    @Inject
    public DefaultLifecycles(LifecycleRegistry registry, Lookup lookup) {
        this.lookup = lookup;
        this.registry = registry;
    }

    /**
     * Get lifecycle based on phase
     *
     * @param phase
     * @return

        0 * readCache._
    }

    def "lookup searches the write index then delegates to the read index"() {
        when:
        twoStageCache.lookup(key)

        then:
        1 * writeCache.lookup(key) >> null
        1 * readCache.lookup(key)

        when:
        twoStageCache.lookup(key)

        then:
        1 * writeCache.lookup(key) >> Stub(CachedArtifact)
        0 * readCache._
    }

	ev := RegisterStringVar(testVar, "123", "")
	v, present := ev.Lookup()
	if v != "123" {
		t.Errorf("Expected 123, got %s", v)
	}
	if present {
		t.Errorf("Expected not present")
	}

	v = ev.Get()
	if v != "123" {
		t.Errorf("Expected 123, got %s", v)
	}

	_ = os.Setenv(testVar, "ABC")

	ev = RegisterStringVar(testVar, "123", "")
	v, present = ev.Lookup()
	if v != "ABC" {
		t.Errorf("Expected ABC, got %s", v)

    }

    @Override
    public <T> T lookup(Class<T> type) {
        try {
            return container.lookup(type);
        } catch (ComponentLookupException e) {
            throw new LookupException(e);
        }
    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        try {
            return container.lookup(type, name);
        } catch (ComponentLookupException e) {

import java.util.Set;

public abstract class AbstractCallInterceptor implements CallInterceptor {
    private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();

    private static final MethodHandle INTERCEPTOR;

    static {
        try {

	lookup := func() {
		for _, name := range names {
			typ := scope.Lookup(name).Type()
			LookupFieldOrMethod(typ, true, pkg, "m")
		}
	}

	// Perform a lookup once, to ensure that any lazily-evaluated state is
	// complete.
	lookup()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		lookup()
	}