assertThat(map, is(notNullValue()));
        assertThat(map.isEmpty(), is(false));
        assertThat(map.get(Foo.class.getTypeParameters()[0]), is(sameClass(Object.class)));
    }

    /**
     * @throws Exception
     */
    public void testGenericMethod() throws Exception {
        final Map<TypeVariable<?>, Type> map = GenericsUtil.getTypeVariableMap(Fuga.class);

    /**
     * Transform Graph into a Collection of metadata objects that
     * could serve as a classpath for a particular scope
     *
     * @param dirtyGraph - dependency graph
     * @param scope - which classpath to extract
     * @param resolve - whether to resolve artifacts.
     * @return Collection of metadata objects in the linked subgraph of the graph which
     *             contains the graph.getEntry() vertice

public class ScriptExecutor extends JobExecutor {

    /**
     * Constructor.
     */
    public ScriptExecutor() {
        super();
    }

    @Override
    public Object execute(final String scriptType, final String script) {
        final Map<String, Object> params = new HashMap<>();
        params.put("executor", this);

        return ComponentUtil.getScriptEngineFactory().getScriptEngine(scriptType).evaluate(script, params);
    }

/**
 * A generator for {@code ListMultimap} implementations based on test data.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestListMultimapGenerator<K extends @Nullable Object, V extends @Nullable Object>

import org.jspecify.annotations.Nullable;

/**
 * An interface for all filtered multimap types.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
interface FilteredMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends Multimap<K, V> {
  Multimap<K, V> unfiltered();

  Predicate<? super Entry<K, V>> entryPredicate();

    /** Counter for generating unique IDs */
    protected static volatile long idCount = 0L;

    /** Lock object for synchronizing access to idCount */
    private static Object idCountLock = new Object();

    /** Helper for managing access result data in memory */
    @Resource
    protected MemoryDataHelper dataHelper;

    /**
     * Constructs a new DataServiceImpl.

  operator fun set(
    requested: InetAddress,
    real: InetSocketAddress,
  ) {
    hostMapping[requested] = real
  }

  override fun createSocket(): Socket =
    object : Socket() {
      override fun connect(
        endpoint: SocketAddress?,
        timeout: Int,
      ) {
        val requested = (endpoint as InetSocketAddress)

    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + toInvert.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj instanceof InversionArtifactFilter other) {
            return toInvert.equals(other.toInvert);
        } else {

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The {@code Immutable} annotation indicates that the object is immutable, i.e.
 * none of its field can be changed.  This also ensures that the type is
 * {@link ThreadSafe}.
 *
 * @see ThreadSafe
 * @since 4.0.0
 */
@Experimental
@Documented

// Copyright (c) 2015-2021 MinIO, Inc.
//
// This file is part of MinIO Object Storage stack
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful