// When
            copy.encode(buffer, startIndex);

            // Then
            // The implementation skips 4 reserved bytes without writing zeros
            // This is consistent with the actual implementation behavior
            // The reserved bytes remain as they were in the buffer
            for (int i = 0; i < 4; i++) {

 * override {@code offer} as well, either providing your own implementation, or delegating to the
 * provided {@code standardOffer} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingDeque}.
 *

     *
     * @return the configuration used by this session
     */
    Configuration getConfig();

    /**
     * Unwraps this session to the specified type, allowing access to implementation-specific functionality.
     *
     * @param <T> the type to unwrap to
     * @param type the class of the type to unwrap to
     * @return session instance with the given type
     */

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.dcerpc.msrpc;

/**
 * MSRPC implementation for retrieving members of an alias.
 * This class provides functionality to get the list of security identifiers (SIDs)
 * that are members of a specific alias using the SAMR RPC interface.
 */

/**
 * Meta-annotation that marks other annotations as qualifier annotations.
 * <p>
 * Qualifiers are used to distinguish between multiple beans of the same type,
 * allowing for more precise control over which implementation should be injected.
 * Custom qualifier annotations should be annotated with {@code @Qualifier}.
 * <p>
 * Example of creating a custom qualifier:
 * <pre>
 * {@literal @}Qualifier
 * {@literal @}Retention(RUNTIME)

      TestByteSink okSink = new TestByteSink();
      assertThrows(IOException.class, () -> failSource.copyTo(okSink));
      // ensure stream was closed IF it was opened (depends on implementation whether or not it's
      // opened at all if source.newInputStream() throws).
      assertTrue(
          "stream not closed when copying from source with option: " + option,

      TestByteSink okSink = new TestByteSink();
      assertThrows(IOException.class, () -> failSource.copyTo(okSink));
      // ensure stream was closed IF it was opened (depends on implementation whether or not it's
      // opened at all if source.newInputStream() throws).
      assertTrue(
          "stream not closed when copying from source with option: " + option,

  }

  /**
   * Serialized type for all ImmutableMap instances. It captures the logical contents and they are
   * reconstructed using public factory methods. This ensures that the implementation types remain
   * as implementation details.
   */
  @J2ktIncompatible // serialization
  static class SerializedForm<K, V> implements Serializable {

import java.util.AbstractList;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link Lists#cartesianProduct(List)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class CartesianList<E> extends AbstractList<List<E>> implements RandomAccess {

import java.util.Set;
import junit.framework.TestSuite;
import org.jspecify.annotations.Nullable;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedMap
 * implementation.
 */
@GwtIncompatible
public class SortedMapTestSuiteBuilder<K, V> extends MapTestSuiteBuilder<K, V> {
  public static <K, V> SortedMapTestSuiteBuilder<K, V> using(
      TestSortedMapGenerator<K, V> generator) {