assertThat(cacheEvents()).containsExactly(CacheMiss::class)

    result = cachedDns.lookup("google.com")
    assertThat(server.takeRequest(1, TimeUnit.MILLISECONDS)).isNull()
    assertThat(result).isEqualTo(listOf(address("157.240.1.18")))

    assertThat(cacheEvents()).containsExactly(CacheHit::class)

    result = cachedDns.lookup("www.google.com")
    assertThat(result).containsExactly(address("157.240.1.18"))

        // Default constructor
    }

    private static final Logger logger = LogManager.getLogger(QueryProcessor.class);

    /**
     * Map of query commands indexed by query class simple names.
     * Used to lookup appropriate command handlers for different query types.
     */
    protected Map<String, QueryCommand> queryCommandMap = new HashMap<>();

    /**
     * List of filters that will be applied during query processing.

    private final Lookup lookup;

    public PlexusContainerCapsule(
            LookupContext context, ClassLoader previousClassLoader, DefaultPlexusContainer plexusContainer) {
        this.previousClassLoader = requireNonNull(previousClassLoader, "previousClassLoader");
        this.plexusContainer = requireNonNull(plexusContainer, "plexusContainer");
        this.lookup = new DefaultLookup(plexusContainer);

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final Lookup lookup;

    private final DefaultLifecycles defaultLifeCycles;

    @Inject
    public DefaultLifecyclePluginAnalyzer(Lookup lookup, DefaultLifecycles defaultLifeCycles) {
        this.lookup = requireNonNull(lookup);
        this.defaultLifeCycles = requireNonNull(defaultLifeCycles);
    }

            final Object bean = instantiateObject(implType);
            if (null == value) {
                processConfiguration(lookup, bean, loader, configuration, evaluator, listener);
            } else {
                // Use optimized helper for better performance
                new EnhancedCompositeBeanHelper(lookup, loader, evaluator, listener)
                        .setDefault(bean, value, configuration);
            }

import java.util.Optional;

import org.apache.maven.api.services.Lookup;
import org.apache.maven.api.services.LookupException;

public class SimpleLookup implements Lookup {
    private final List<Object> objects;

    public SimpleLookup(List<Object> objects) {
        this.objects = objects;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        return objects.stream()

        return new ScriptScoreQuery(new MatchAllDocsQuery(), null, leafFactory, lookup, null, "test", 0, Version.CURRENT);
    }

    private ScoreScript.Factory bareMetalScript() {
        return (params, lookup) -> {
            MappedFieldType type = fieldTypes.get("n");
            IndexNumericFieldData ifd = (IndexNumericFieldData) lookup.getForField(type);

            @Nonnull RepositorySystem repositorySystem,
            @Nullable List<RemoteRepository> remoteRepositories,
            @Nonnull MavenRepositorySystem mavenRepositorySystem,
            @Nonnull Lookup lookup,
            @Nonnull RuntimeInformation runtimeInformation) {
        super(
                requireNonNull(session).getRepositorySession(),
                repositorySystem,
                remoteRepositories,

    # Either the 'source' or 'remote' *must* be the "local" deployment
#    endpoint: "http://127.0.0.1:9000"
#    # path: "on|off|auto" # "on" enables path-style bucket lookup. "off" enables virtual host (DNS)-style bucket lookup. Defaults to "auto"
#    credentials:
#      accessKey: minioadmin # Required
#      secretKey: minioadmin # Required

    protected String[] searchFields;

    /** Set of fields that can be searched against for O(1) lookup */
    protected Set<String> searchFieldSet;

    /** Array of fields that can be used for faceted search */
    protected String[] facetFields;

    /** Set of fields that can be used for faceted search for O(1) lookup */
    protected Set<String> facetFieldSet;