private final Lookup lookup;
    private final RuntimeInformation runtimeInformation;

    @Inject
    @SuppressWarnings("checkstyle:ParameterNumber")
    public DefaultSessionFactory(
            RepositorySystem repositorySystem,
            MavenRepositorySystem mavenRepositorySystem,
            Lookup lookup,
            RuntimeInformation runtimeInformation) {

        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._

    dns[PROXY_A_HOST] = dns.allocate(2)
    val selection = routeSelector.next()
    assertRoute(selection.next(), address, proxyA, dns.lookup(PROXY_A_HOST, 0), PROXY_A_PORT)
    assertRoute(selection.next(), address, proxyA, dns.lookup(PROXY_A_HOST, 1), PROXY_A_PORT)
    assertThat(selection.hasNext()).isFalse()
    assertThat(routeSelector.hasNext()).isFalse()
    dns.assertRequests(PROXY_A_HOST)

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

        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,