// It returns the value, which will be the default if the variable is not present.
// To distinguish between an empty value and an unset value, use Lookup.
func (v StringVar) Get() string {
	result, _ := v.Lookup()
	return result
}

// Lookup retrieves the value of the environment variable. If the
// variable is present in the environment the
// value (which may be empty) is returned and the boolean is true.

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

        private Instant startTime = Instant.now();

        DefaultSession(RepositorySystemSession session, RepositorySystem repositorySystem, Lookup lookup) {
            this(session, repositorySystem, Collections.emptyList(), null, lookup);
        }

        protected DefaultSession(
                RepositorySystemSession session,
                RepositorySystem repositorySystem,

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 {

type disasmFunc func(code []byte, pc uint64, lookup lookupFunc, ord binary.ByteOrder, _ bool) (text string, size int)

func disasm_386(code []byte, pc uint64, lookup lookupFunc, _ binary.ByteOrder, gnuAsm bool) (string, int) {
	return disasm_x86(code, pc, lookup, 32, gnuAsm)
}

func disasm_amd64(code []byte, pc uint64, lookup lookupFunc, _ binary.ByteOrder, gnuAsm bool) (string, int) {

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

        writableCache.storeMissing(key);
    }

    @Nullable
    @Override
    public CachedExternalResource lookup(String key) {
        CachedExternalResource lookup = writableCache.lookup(key);
        if (lookup != null) {
            return lookup;
        }
        return readOnlyCache.lookup(key);
    }

    @Override
    public void clear(String key) {
        writableCache.clear(key);
    }

        expect:
        registry.lookup(fooFactory.id) == fooFactory
    }

    def "returns null for unknown type"() {
        def fooFactory = factory(Foo)
        def barFactory = factory(Bar)
        def buzzFactory = factory(Buzz)
        registry.withFactories(barFactory, fooFactory)

        expect:
        registry.lookup(buzzFactory.id) == null
    }