}

  /**
   * Indicates that the load and store operations will be very efficient because of use of VarHandle
   * or Unsafe. May be useful for calling code to fall back on an alternative implementation that is
   * slower than those implementations but faster than the pure-Java mask-and-shift.
   */
  static boolean usingFastPath() {
    return byteArray.usesFastPath();
  }

  /**

        }
      }
    }
    return -1;
  }

  /** Returns an implementation of {@link List#listIterator(int)}. */
  static <E extends @Nullable Object> ListIterator<E> listIteratorImpl(List<E> list, int index) {
    return new AbstractListWrapper<>(list).listIterator(index);
  }

  /** An implementation of {@link List#subList(int, int)}. */
  static <E extends @Nullable Object> List<E> subListImpl(

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import org.jspecify.annotations.Nullable;

/**
 * Skeletal, implementation-agnostic implementation of the {@link Table} interface.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
abstract class AbstractTable<
        R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>

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

/** Implementation of an {@link Optional} not containing a reference. */
@GwtCompatible
final class Absent<T> extends Optional<T> {
  static final Absent<Object> INSTANCE = new Absent<>();

  @SuppressWarnings("unchecked") // implementation is "fully variant"
  static <T> Optional<T> withType() {
    return (Optional<T>) INSTANCE;
  }

                Map<String, String> scriptMap, Map<String, Object> defaultDataMap) {
            // Test implementation
        }
    }

    // Second Test DataStore implementation for testing multiple stores
    private static class TestDataStore2 extends AbstractDataStore {
        private String name;

        public TestDataStore2(String name) {

 */
package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;

/**
 * A dummy superclass of {@link ImmutableMultimap} that can be instanceof'd without ProGuard
 * retaining additional implementation details of {@link ImmutableMultimap}.
 */
@GwtCompatible

import java.io.Serializable;
import java.util.Collection;
import java.util.Set;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * {@link Set} implementation that asserts that a given lock is held whenever one of its methods is
 * called.
 */
@NullUnmarked
class LockHeldAssertingSet<E> extends ForwardingSet<E> implements Serializable {
  final Set<E> delegate;

     * Test getMessageByDcerpcError() with an error code larger than any known.
     * The binary search implementation has a bug where it accesses array out of bounds.
     */
    @Test
    void testGetMessageByDcerpcError_largerThanAny() {
        int unknownCode = 0x7FFFFFFF; // Max int value

        // The current implementation has a bug in the binary search that causes ArrayIndexOutOfBoundsException

            a.url = url;
            a.sae = sae;
            return a.getNtlmPasswordAuthentication();
        }
    }

    /**
     * An application extending this class must provide an implementation for this method that returns new user
     * credentials try try when accessing SMB resources described by the <code>getRequestingURL</code> and
     * <code>getRequestingException</code> methods.

import java.util.Objects;
import java.util.Properties;

import org.apache.maven.toolchain.model.ToolchainModel;
import org.slf4j.Logger;

/**
 * Default abstract toolchain implementation, to be used as base class for any toolchain implementation
 * to avoid rewriting usual code.
 *
 * @since 2.0.9
 * @deprecated Use {@link org.apache.maven.api.Toolchain} instead.
 */
@Deprecated(since = "4.0.0")