Queue<String> outer = Synchronized.queue(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestQueue<E> implements Queue<E> {
    private final Queue<E> delegate = new LinkedList<>();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public boolean offer(E o) {

import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

@NullUnmarked
public class SynchronizedTableTest extends AbstractTableTest<Character> {
  private static final class TestTable<R, C, V> implements Table<R, C, V>, Serializable {
    private final Table<R, C, V> delegate = HashBasedTable.create();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public String toString() {

 *
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingQueue<E extends @Nullable Object> extends ForwardingCollection<E>
    implements Queue<E> {

  /** Constructor for use by subclasses. */
  protected ForwardingQueue() {}

  @Override
  protected abstract Queue<E> delegate();

  @CanIgnoreReturnValue // TODO(cpovirk): Consider removing this?

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 {

  private final transient ImmutableList<List<E>> axes;
  private final transient int[] axesSizeProduct;

  static <E> List<List<E>> create(List<? extends List<? extends E>> lists) {

 * See {@link jcifs.Configuration#isDfsConvertToFQDN()} for a workaround.
 *
 * @author mbechler
 */
public class JAASAuthenticator extends Kerb5Authenticator implements CallbackHandler, SmbRenewableCredentials {

    private static final Logger log = LoggerFactory.getLogger(JAASAuthenticator.class);

    /**
     *
     */

        assertEquals(1, problems.messages.size());
        assertContains(problems.messages.get(0), "'proxies.proxy.host' for default is missing");
    }

    private static class SimpleProblemCollector implements SettingsProblemCollector {

        List<String> messages = new ArrayList<>();

        @Override
        public void add(Severity severity, String message, int line, int column, Exception cause) {

 *
 * @see DefaultArtifactDescriptorReader
 * @deprecated since 4.0.0, use {@code maven-api-impl} jar instead
 */
@Deprecated(since = "4.0.0")
class DefaultModelResolver implements ModelResolver {

    private final RepositorySystemSession session;

    private final RequestTrace trace;

    private final String context;

    private List<RemoteRepository> repositories;

/**
 * Base class for services that can implement {@link #startUp}, {@link #run} and {@link #shutDown}
 * methods. This class uses a single thread to execute the service; consider {@link AbstractService}
 * if you would like to manage any threading manually.
 *
 * @author Jesse Wilson
 * @since 1.0
 */
@GwtIncompatible
@J2ktIncompatible
public abstract class AbstractExecutionThreadService implements Service {

	}
}

// ErrNotImplemented when a functionality is not implemented
var ErrNotImplemented = errors.New("not implemented")

// ReadFrom implements support for calling internal io.ReaderFrom implementations
// returns an error if the underlying ResponseWriter does not implement io.ReaderFrom
func (lrw *ResponseRecorder) ReadFrom(r io.Reader) (int64, error) {
	if lrw.ReaderFrom != nil {
		n, err := lrw.ReaderFrom.ReadFrom(r)

 *
 * @author mbechler
 * @param <T>
 *            response type
 */
public abstract class ServerMessageBlock2Request<T extends ServerMessageBlock2Response> extends ServerMessageBlock2
        implements CommonServerMessageBlockRequest, Request<T> {

    private static final Logger log = LoggerFactory.getLogger(ServerMessageBlock2Request.class);

    private T response;
    private Integer overrideTimeout;

    /**