@Nullable
    <T> T computeIfAbsent(@Nonnull Key<T> key, @Nonnull Supplier<T> supplier);

    /**
     * Create a key using the given class as an identifier and as the type of the object.
     */
    static <T> Key<T> key(Class<T> clazz) {
        return new Key<>(clazz, clazz);
    }

    /**
     * Create a key using the given class and id.
     */
    static <T> Key<T> key(Class<T> clazz, Object id) {

    private byte[] testData;
    private byte[] largeTestData;

    @BeforeEach
    public void setUp() {
        compressionService = new DefaultCompressionService();

        // Create test data with patterns that should compress well
        testData = generateTestData(1024);
        largeTestData = generateTestData(8192);
    }

    @Test
    @DisplayName("Test supported algorithms")

import com.google.common.collect.testing.TestContainerGenerator;
import java.util.Map.Entry;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Creates bimaps, containing sample entries, to be tested.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public interface TestBiMapGenerator<K extends @Nullable Object, V extends @Nullable Object>

    /** The serial version ID. */
    private static final long serialVersionUID = 3372412184339653914L;

    // constructors -----------------------------------------------------------

    /**
     * Creates a new <code>ConflictResolverNotFoundException</code> with the specified message.
     *
     * @param message the message
     */
    public ConflictResolverNotFoundException(String message) {
        super(message);

    routePlanner.autoGeneratePlans = true
    routePlanner.defaultConnectionIdleAtNanos = expireTime
    val address = routePlanner.address
    val pool = routePlanner.pool

    // Connections are created as soon as a policy is set
    setPolicy(pool, address, AddressPolicy(2))
    assertThat(pool.connectionCount()).isEqualTo(2)

    // Connections are replaced if they idle out or are evicted from the pool

    private Method valueOfMethod;

    private boolean readable = false;

    private boolean writable = false;

    private ParameterizedClassDesc parameterizedClassDesc;

    /**
     * Creates an instance of {@link PropertyDescImpl}.
     *
     * @param propertyName
     *            The property name. Must not be {@literal null} or an empty string.
     * @param propertyType

            Mockito.when(mock.getServerSignature()).thenReturn(mockServerSig);
            Mockito.when(mock.getKdcSignature()).thenReturn(mockKdcSig);
        })) {

            // Create minimal PAC data
            byte[] pacData = createMinimalPacData();

            // Test constructor
            KerberosPacAuthData authData = new KerberosPacAuthData(pacData, keys);

            @Nullable String val,
            @Nullable UnaryOperator<String> callback,
            @Nullable BinaryOperator<String> postprocessor,
            boolean defaultsToEmpty);

    /**
     * Creates a composite function from a collection of functions.
     *
     * @param functions A collection of functions, each taking a String as input and returning a String.

      "index" : {
        "creation_date" : "1509021056731",
        "number_of_shards" : "5",
        "number_of_replicas" : "1",
        "uuid" : "MnnT8tsrT5GqpB8pYafyWg",
        "version" : {
          "created" : "6000051"
        },
        "provided_name" : "fess_config.role_type"
      }
    }
  }

import java.util.Enumeration;

/**
 * An empty {@link Enumeration}.
 *
 * @author higa
 * @param <T> the type of elements
 */
public class EmptyEnumeration<T> extends IteratorEnumeration<T> {

    /**
     * Creates an {@link EmptyEnumeration}.
     */
    public EmptyEnumeration() {
        super(new EmptyIterator<T>());
    }