@BeforeEach
    public void setUp() throws Exception {
        super.setUp();

        ArtifactResolver resolver = getContainer().lookup(ArtifactResolver.class, "classpath");
        DefaultArtifactDescriptorReader pomReader =
                (DefaultArtifactDescriptorReader) getContainer().lookup(ArtifactDescriptorReader.class);
        Field field = DefaultArtifactDescriptorReader.class.getDeclaredField("artifactResolver");

        if (getContainer().hasComponent(ProjectBuilder.class, "test")) {
            projectBuilder = getContainer().lookup(ProjectBuilder.class, "test");
        } else {
            // default over to the main project builder...
            projectBuilder = getContainer().lookup(ProjectBuilder.class);
        }
    }

    protected ProjectBuilder getProjectBuilder() {
        return projectBuilder;
    }

        try {
            return c.lookup(RepositorySystem.class);
        } catch (ComponentLookupException e) {
            throw new IllegalStateException(e);
        }
    }

    private static RepositorySystemSession rss(PlexusContainer c) {
        try {
            LegacySupport legacySupport = c.lookup(LegacySupport.class);

            return legacySupport.getRepositorySession();

import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;

import org.apache.maven.api.annotations.Nullable;
import org.apache.maven.api.cli.InvokerRequest;
import org.apache.maven.api.services.Lookup;
import org.apache.maven.cling.invoker.LookupContext;
import org.apache.maven.cling.invoker.LookupInvoker;
import org.apache.maven.cling.utils.CLIReportingUtils;
import org.jline.builtins.ConfigurationPath;

    hostAddresses.remove(hostname)
    return this
  }

  @Throws(UnknownHostException::class)
  fun lookup(
    hostname: String,
    index: Int,
  ): InetAddress = hostAddresses[hostname]!![index]

  @Throws(UnknownHostException::class)
  override fun lookup(hostname: String): List<InetAddress> {
    requestedHosts.add(hostname)
    return hostAddresses[hostname] ?: throw UnknownHostException()
  }

	if err != nil {
		return err
	}

	var ok bool
	claims.AccessKey, ok = claims.Lookup("accessKey")
	if !ok {
		claims.AccessKey, ok = claims.Lookup("sub")
		if !ok {
			return jwtgo.NewValidationError("accessKey/sub missing",
				jwtgo.ValidationErrorClaimsInvalid)
		}
	}

	// Lookup key from claims, claims may not be valid and may return

	return word == "JMP" || word == "CALL" || word == "Call" || word == "Br" || word == "BrIf"
}

func archX86(linkArch *obj.LinkArch) *Arch {
	register := make(map[string]int16)
	// Create maps for easy lookup of instruction names etc.
	for i, s := range x86.Register {
		register[s] = int16(i + x86.REG_AL)
	}
	// Pseudo-registers.
	register["SB"] = RSB
	register["FP"] = RFP
	register["PC"] = RPC

    this.replacementArray = replacementArray;
  }

  // Returns the non-null array of replacements for fast lookup.
  char[][] getReplacementArray() {
    return replacementArray;
  }

  // Creates a replacement array from the given map. The returned array is a
  // linear lookup table of replacement character sequences indexed by the
  // original character value.
  @VisibleForTesting

        ComponentLookupException e =
                assertThrows(ComponentLookupException.class, () -> container.lookup(MySingletonBean2.class));
        assertTrue(e.getMessage().matches("[\\s\\S]*: Can not set .* field .* to [\\s\\S]*"));

        MySingletonBean bean = container.lookup(MySingletonBean.class);
        assertNotNull(bean);
        assertNotNull(bean.anotherBean);

            RepositorySystem repositorySystem;
            try {
                repositorySystem = container.lookup(RepositorySystem.class);
            } catch (ComponentLookupException e) {
                throw new IllegalStateException("Unable to lookup " + RepositorySystem.class.getName());
            }

            if (mirrors) {