/**
     * Returns a {@link Logger}.
     *
     * @param clazz
     *            Class to be used as the logger category. Must not be {@literal null}.
     * @return {@link Logger}
     */
    public static synchronized Logger getLogger(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (!initialized) {
            initialize();
        }
        Logger logger = loggers.get(clazz);

 *   // do other things since the monitor was not available
 * }
 * }
 *
 * <h2>Comparison with {@code synchronized} and {@code ReentrantLock}</h2>
 *
 * <p>The following examples show a simple threadsafe holder expressed using {@code synchronized},
 * {@link ReentrantLock}, and {@code Monitor}.
 *
 * <h3>{@code synchronized}</h3>
 *
 * <p>This version is the fewest lines of code, largely because the synchronization mechanism used

    }

    @Override
    public void setFile(File file) {
        throw new UnsupportedOperationException("transformed artifact file cannot be set");
    }

    @Override
    public synchronized File getFile() {
        try {
            String state = mayUpdate();
            if (state == null) {
                return null;
            }
            return target.toFile();

   *
   * @param bimap the bimap to be wrapped in a synchronized view
   * @return a synchronized view of the specified bimap
   */
  @J2ktIncompatible // Synchronized
  public static <K extends @Nullable Object, V extends @Nullable Object>
      BiMap<K, V> synchronizedBiMap(BiMap<K, V> bimap) {
    return Synchronized.biMap(bimap, null);
  }

  /**

     * @param path the path to resolve
     * @param auth the authentication credentials
     * @return a DFS referral for the resolved path
     * @throws SmbAuthException if authentication fails
     */
    public synchronized DfsReferral resolve(String domain, String root, final String path, final NtlmPasswordAuthentication auth)
            throws SmbAuthException {
        DfsReferral dr = null;
        final long now = System.currentTimeMillis();

  private TearDownStack buildTearDownStack() {
    TearDownStack result = new TearDownStack();
    tearDownStack.addTearDown(
        () -> {
          synchronized (result.lock) {
            assertEquals(
                "The test should have cleared the stack (say, by virtue of running runTearDown)",
                0,
                result.stack.size());
          }

        writeUtf8("\r\n")
        write(source, byteCount)
        writeUtf8("\r\n")
      }
    }

    @Synchronized
    override fun flush() {
      if (closed) return // Don't throw; this stream might have been closed on the caller's behalf.
      socket.sink.flush()
    }

    @Synchronized
    override fun close() {
      if (closed) return
      closed = true
      socket.sink.writeUtf8("0\r\n\r\n")

    Subscriber s1 = Subscriber.create(bus, this, getTestSubscriberMethod("recordingMethod"));
    assertThat(s1).isInstanceOf(Subscriber.SynchronizedSubscriber.class);

    // a thread-safe method should not create a synchronized subscriber
    Subscriber s2 = Subscriber.create(bus, this, getTestSubscriberMethod("threadSafeMethod"));
    assertThat(s2).isNotInstanceOf(Subscriber.SynchronizedSubscriber.class);
  }

  static class Key {
    private final int value;
    private WeakReference<String> toString;

    Key(int value) {
      this.value = value;
    }

    @Override
    public synchronized String toString() {
      String s;
      if (toString != null) {
        s = toString.get();
        if (s != null) {
          return s;
        }
      }
      s = Integer.toString(value);

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link Synchronized#deque} and {@link Queues#synchronizedDeque}.
 *
 * @author Kurt Alfred Kluever
 */
@NullUnmarked
public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);