public static final field Companion Lokhttp3/dnsoverhttps/DnsOverHttps$Companion;
	public static final field MAX_RESPONSE_SIZE I
	public final fun client ()Lokhttp3/OkHttpClient;
	public final fun includeIPv6 ()Z
	public fun lookup (Ljava/lang/String;)Ljava/util/List;
	public final fun post ()Z
	public final fun resolvePrivateAddresses ()Z
	public final fun resolvePublicAddresses ()Z
	public final fun url ()Lokhttp3/HttpUrl;
}

        // Retrieve direct groups synchronously (parent group lookup is deferred)
        processDirectMemberOf(user, groupList, roleList, groupIdsForParentLookup, "https://graph.microsoft.com/v1.0/me/memberOf");

        if (logger.isDebugEnabled()) {
            logger.debug("[updateMemberOf] Direct groups retrieved. Total groups: {}, Total roles: {}, Group IDs for parent lookup: {}",

     */
    RESOLVER_WINS,

    /**
     * NETBIOS broadcast
     */
    RESOLVER_BCAST,

    /**
     * DNS
     */
    RESOLVER_DNS,

    /**
     * LMHosts file lookup
     */
    RESOLVER_LMHOSTS

import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class WinErrorTest {

    // Helper to lookup a message by code using the production arrays
    private static Optional<String> lookupMessage(int code) {
        int[] codes = WinError.WINERR_CODES;
        String[] msgs = WinError.WINERR_MESSAGES;

 */
package org.codelibs.fess.exception;

/**
 * Exception thrown when a user is not found in the Fess system.
 * This exception is typically thrown during authentication or user lookup operations
 * when the specified user does not exist in the system.
 */
public class FessUserNotFoundException extends FessSystemException {

    /** Serial version UID for serialization compatibility */

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * Factory for managing CORS handlers based on origin.
 * Maintains a registry of CORS handlers for different origins and provides lookup functionality.
 */
public class CorsHandlerFactory {

    /**
     * Creates a new instance of CorsHandlerFactory.
     */
    public CorsHandlerFactory() {
        // Default constructor
    }

                 * for the addresses hostname or failed lookups for one type will
                 * be cached and cause other types to fail even though they may
                 * not be the authority for the name. For example, if a WINS lookup
                 * for FOO fails and caches unknownAddress for FOO, a subsequent
                 * lookup for FOO using BCAST should not fail because of that

        /** Array of SIDs to lookup. */
        public LsarSidArray sids;
        /** Referenced domain list returned from lookup. */
        public LsarRefDomainList domains;
        /** Array of translated names. */
        public LsarTransNameArray names;
        /** Lookup level. */
        public short level;
        /** Count of SIDs to lookup. */
        public int count;

        /**

    platform.assumeNotConscrypt()

    val handshakeCertificates = localhost()
    server.useHttps(handshakeCertificates.sslSocketFactory())

    val dns =
      Dns {
        Dns.SYSTEM.lookup(server.hostName)
      }

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),

[gradle_verification]: https://docs.gradle.org/current/userguide/dependency_verification.html#sec:signature-verification