MinIO divides the drives you provide into erasure-coding sets of *2 to 16* drives.  Therefore, the number of drives you present must be a multiple of one of these numbers.  Each object is written to a single erasure-coding set.

        LEAST_CONNECTIONS,
        /** Random selection */
        RANDOM,
        /** Failover only (use primary until failure) */
        FAILOVER_ONLY
    }

    /**
     * Represents a group of channels for a single session.
     */
    public static class ChannelGroup {
        private final String sessionId;
        private final List<ChannelInfo> channels = new CopyOnWriteArrayList<>();

import java.util.NoSuchElementException;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * An immutable sorted set with one or more elements. TODO(jlevy): Consider separate class for a
 * single-element sorted set.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
@SuppressWarnings({"serial", "rawtypes"})
final class RegularImmutableSortedSet<E> extends ImmutableSortedSet<E> {

            }
        }

        @Override
        public void close() {
            this.executor.close();
        }

        /**
         * Processes a single build step, deciding whether to schedule it for execution or skip it.
         *
         * @param step The build step to process
         */
        private void processStep(BuildStep step) {

                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieve a single character mapping entry by ID for the specified dictionary.
     *
     * @param dictId identifier of the dictionary
     * @param id identifier of the mapping entry
     * @return JSON response containing the mapping entry

   * threadBuilder.name("rpc-pool-", 0)}.
   *
   * @param nameFormat a {@link String#format(String, Object...)}-compatible format String, to which
   *     a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will
   *     be unique to the built instance of the ThreadFactory and will be assigned sequentially. For
   *     example, {@code "rpc-pool-%d"} will generate thread names like {@code "rpc-pool-0"}, {@code

 * @author Charles Fry
 * @since 10.0
 */
@DoNotMock("Use CacheBuilder.newBuilder().build()")
@GwtCompatible
public interface Cache<K, V> {

  /**
   * Returns the value associated with {@code key} in this cache, or {@code null} if there is no
   * cached value for {@code key}.
   *
   * @since 11.0
   */
  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?

    List<E> containsNull = singletonList(null);
    assertTrue("addAll(containsNull) should return true", collection.addAll(containsNull));
    /*
     * We need (E) to force interpretation of null as the single element of a
     * varargs array, not the array itself
     */
    expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)

import java.util.Objects;
import java.util.function.UnaryOperator;

/**
 * An helper to manage a vagrant box.
 *
 * This is created alongside a {@link VagrantExtension} for a project to manage starting and
 * stopping a single vagrant box.
 */
public class VagrantMachine {

    private final VagrantExtension extension;
    private final Provider<ReaperService> reaperServiceProvider;
    private ReaperService reaper;

        assertNotNull(param.getValues());
        assertEquals(0, param.getValues().length);
    }

    @Test
    public void test_constructor_withSingleValue() {
        // Test with single value
        String name = "singleParam";
        String[] values = { "onlyValue" };
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());