* forwards the calls to the underlying {@code Map}.
   */
  private static class CheckSetUpInvocationHandler implements InvocationHandler, Serializable {
    private final Map<String, String> map;
    private final AtomicBoolean setUpRan;

    CheckSetUpInvocationHandler(Map<String, String> map, AtomicBoolean setUpRan) {
      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override

   */
  protected final void validateEndpoints(EndpointPair<?> endpoints) {
    checkNotNull(endpoints);
    checkArgument(isOrderingCompatible(endpoints), ENDPOINTS_MISMATCH);
  }

  protected final boolean isOrderingCompatible(EndpointPair<?> endpoints) {
    return endpoints.isOrdered() == this.isDirected();
  }

  @Override
  public final boolean equals(@CheckForNull Object obj) {

/**
 * Maven GA level metadata.
 *
 * @deprecated since 4.0.0, use {@code maven-api-impl} jar instead
 */
@Deprecated(since = "4.0.0")
final class VersionsMetadata extends MavenMetadata {

    private final Artifact artifact;

    VersionsMetadata(Artifact artifact, Date timestamp) {
        super(createRepositoryMetadata(artifact), (Path) null, timestamp);
        this.artifact = artifact;

import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ClassDocMethodsBuilder extends ModelBuilderSupport {
    private final JavadocConverter javadocConverter;
    private final GenerationListener listener;

    public ClassDocMethodsBuilder(JavadocConverter converter, GenerationListener listener) {
        this.javadocConverter = converter;
        this.listener = listener;

 * Clients may request multiple sessions.
 */
public final class OAuthSessionFactory extends Dispatcher implements Closeable {
  private final SecureRandom secureRandom = new SecureRandom();

  private final SlackApi slackApi;
  private MockWebServer mockWebServer;

  /** Guarded by this. */
  private final Map<ByteString, Listener> listeners = new LinkedHashMap<>();

    // Slide new entry into first cache position. Drop previous entry in second cache position.
    cacheEntry2 = cacheEntry1;
    cacheEntry1 = entry;
  }

  private static final class CacheEntry<K, V> {
    final K key;
    final V value;

    CacheEntry(K key, V value) {
      this.key = key;
      this.value = value;
    }
  }

@Named
@Singleton
public class DefaultTypeRegistry extends AbstractEventSpy implements TypeRegistry {
    private final Map<String, Type> types;

    private final LanguageRegistry languageRegistry;

    private final ConcurrentHashMap<String, Type> usedTypes;

    private final LegacyArtifactHandlerManager manager;

    @Inject
    public DefaultTypeRegistry(

    assertEquals(Service.State.RUNNING, service.state());
    assertThat(service.transitionStates).containsExactly(Service.State.STARTING);
  }

  public void testStart_failed() {
    final Exception exception = new Exception("deliberate");
    TestService service =
        new TestService() {
          @Override
          protected void startUp() throws Exception {
            super.startUp();

    assertEquals(1, factory1.newThread(monitoredRunnable).getPriority());
  }

  public void testThreadFactory() throws InterruptedException {
    final String THREAD_NAME = "ludicrous speed";
    final int THREAD_PRIORITY = 1;
    final boolean THREAD_DAEMON = false;
    ThreadFactory backingThreadFactory =
        new ThreadFactory() {
          @Override
          public Thread newThread(Runnable r) {

public class IngestFactory {
    private static final Logger logger = LogManager.getLogger(IngestFactory.class);

    private Ingester[] ingesters = {};

    public synchronized void add(final Ingester ingester) {
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded {}", ingester.getClass().getSimpleName());
        }
        final Ingester[] newIngesters = Arrays.copyOf(ingesters, ingesters.length + 1);