*/
    RESOLVER_WINS,

    /**
     * NETBIOS broadcast
     */
    RESOLVER_BCAST,

    /**
     * DNS
     */
    RESOLVER_DNS,

    /**
     * LMHosts file lookup
     */
    RESOLVER_LMHOSTS

			return err
		}
	case config.IdentityLDAPSubSys:
		cfg, err := xldap.Lookup(s, globalRootCAs)
		if err != nil {
			return err
		}
		if cfg.Enabled() {
			conn, cerr := cfg.LDAP.Connect()
			if cerr != nil {
				return cerr
			}
			conn.Close()
		}
	case config.IdentityTLSSubSys:
		if _, err := xtls.Lookup(s[config.IdentityTLSSubSys][config.Default]); err != nil {
			return err
		}

        @Inject
        private PlexusContainer lookup;

        private final String name;

        BaseLifecycleProvider(String name) {
            this.name = name;
        }

        @Override
        public org.apache.maven.lifecycle.Lifecycle get() {
            try {
                LifecycleRegistry registry = lookup.lookup(LifecycleRegistry.class);

    shadowDns.responder = {
      throw IllegalArgumentException("Network.fromNetworkHandle refusing to instantiate NETID_UNSET Network.")
    }

    val dns = AsyncDns.toDns(asyncDns)

    assertFailure {
      dns.lookup("google.invalid")
    }.apply {
      hasMessage("Network.fromNetworkHandle refusing to instantiate NETID_UNSET Network.")
      isInstanceOf(UnknownHostException::class)
    }
  }

		if err != nil {
			return nil, err
		}
		return nil, errors.New("kms: no KMS configuration specified")
	}

	lookup := func(key string) bool {
		_, ok := os.LookupEnv(key)
		return ok
	}
	switch {
	case lookup(EnvKMSEndpoint):
		rawEndpoint := env.Get(EnvKMSEndpoint, "")
		if rawEndpoint == "" {
			return nil, errors.New("kms: no KMS server endpoint provided")
		}

        session.setSession(new DefaultSessionFactory(
                        getContainer().lookup(RepositorySystem.class),
                        getContainer().lookup(MavenRepositorySystem.class),
                        new DefaultLookup(getContainer()),
                        getContainer().lookup(RuntimeInformation.class))
                .newSession(session));

        legacySupport.setSession(session);
    }

     *
     * @param id the id of the type to retrieve
     * @return the type
     */
    @Nonnull
    @Override
    default Type require(@Nonnull String id) {
        return lookup(id).orElseThrow(() -> new IllegalArgumentException("Unknown extensible enum value '" + id + "'"));
    }

      <inheritedByDefault>true</inheritedByDefault>
      <phase>package</phase>
      <implementation>org.apache.maven.plugin.jar.JarMojo</implementation>
      <language>java</language>
      <instantiationStrategy>per-lookup</instantiationStrategy>
      <executionStrategy>once-per-session</executionStrategy>
      <deprecated>deprecated-mojo</deprecated>
      <since>2.2</since>
      <executePhase>generate-sources</executePhase>

  }

  @Throws(IOException::class)
  private fun Proxy.connectToInetAddress(
    url: HttpUrl,
    dns: Dns,
  ): InetAddress {
    return when (type()) {
      Proxy.Type.DIRECT -> dns.lookup(url.host).first()
      else -> (address() as InetSocketAddress).address
    }
  }

    @Test
    void testMng5459() throws Exception {
        // prepare
        DefaultArtifactDescriptorReader reader =
                (DefaultArtifactDescriptorReader) getContainer().lookup(ArtifactDescriptorReader.class);

        RepositoryEventDispatcher eventDispatcher = mock(RepositoryEventDispatcher.class);

        ArgumentCaptor<RepositoryEvent> event = ArgumentCaptor.forClass(RepositoryEvent.class);