private final Invokable<?, ?> declaration;
  private final int position;
  private final TypeToken<?> type;
  private final ImmutableList<Annotation> annotations;

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using
   * the Android flavor of Guava). The field is declared with a type of {@code Object} to avoid

#!/usr/bin/env bash

set -e

cleanup() {
	echo "Cleaning up instances of MinIO"
	pkill minio || true
	pkill -9 minio || true
	rm -rf /tmp/xl/ || true
	rm -rf /tmp/minio.configfile.{1,2,3,4} || true
}

cleanup

unset MINIO_KMS_KES_CERT_FILE
unset MINIO_KMS_KES_KEY_FILE
unset MINIO_KMS_KES_ENDPOINT
unset MINIO_KMS_KES_KEY_NAME

export MINIO_CI_CD=1

if [ ! -f ./mc ]; then
	os="$(uname -s)"
	arch="$(uname -m)"

      nullifyWriteOrder(e);

      return next != NullEntry.INSTANCE;
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean contains(Object o) {
      ReferenceEntry<K, V> e = (ReferenceEntry<K, V>) o;
      return e.getNextInWriteQueue() != NullEntry.INSTANCE;
    }

    @Override
    public boolean isEmpty() {

 */
public abstract class SessionServicePacket {

    /**
     * Default constructor for SessionServicePacket.
     * Creates a new session service packet instance.
     */
    public SessionServicePacket() {
        // Default constructor
    }

    // session service packet types
    static final int SESSION_MESSAGE = 0x00;
    static final int SESSION_REQUEST = 0x81;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * A mutable type-to-instance map. See also {@link ImmutableTypeToInstanceMap}.
 *
 * @author Ben Yu
 * @since 13.0
 */
public final class MutableTypeToInstanceMap<B extends @Nullable Object>

                    v3(),
                    (oldV, newV) -> {
                      throw new AssertionFailedError();
                    }));
  }

  /**
   * Returns the {@link Method} instance for {@link #testMergeNullValue()} so that tests of {@link
   * Hashtable} can suppress it with {@code FeatureSpecificTestSuiteBuilder.suppressing()}.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection

            assertEquals(command, msg.getCommand());
        }
    }

    @Nested
    @DisplayName("Command Constants Tests")
    class CommandConstantsTests {

        @Test
        @DisplayName("Should have correct command constants")
        void testCommandConstants() {
            assertEquals(0x00, ServerMessageBlock2.SMB2_NEGOTIATE);

  public void testAddNullReference() {
    assertThrows(NullPointerException.class, () -> equalsTester.addEqualityGroup((Object) null));
  }

  /** Test equalObjects after adding multiple instances at once with a null */
  public void testAddTwoEqualObjectsAtOnceWithNull() {
    assertThrows(
        NullPointerException.class,
        () -> equalsTester.addEqualityGroup(reference, equalObject1, null));
  }

import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link PairedStatsAccumulator}. This tests the stats methods for instances built with
 * {@link PairedStatsAccumulator#add}, and various error cases of that method. For tests of the
 * {@link PairedStatsAccumulator#snapshot} method which returns {@link PairedStats} instances, see
 * {@link PairedStatsTest}.
 *
 * @author Pete Gillin
 */
@NullUnmarked

 * the paths specified in a {@code --patch-module} Java option is effective only for a specified module.
 * This type is created by calls to {@link #patchModule(String)} and a new instance must be created for
 * every module to patch.</p>
 *
 * <p>Path types are often exclusive. For example, a dependency should not be both on the Java class path
 * and on the Java module path.</p>
 *