*       res = (seqNum < other.seqNum ? -1 : 1);
 *     }
 *     return res;
 *   }
 * }
 * }</pre>
 *
 * @author Doug Lea
 * @author Justin T. Sampson
 * @param <E> the type of elements held in this collection
 */
@NullUnmarked
public class MonitorBasedPriorityBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E> {

  // Based on revision 1.55 of PriorityBlockingQueue by Doug Lea, from

    assertEquals(originalMap, map);

    for (int i = 1; i <= originalCount * 2; i *= 2) {
      if (i > 1) {
        // TODO(b/145386688): This access should be guarded by 'segment', which is not currently
        // held
        segment.expand();
      }
      assertEquals(i, segment.table.length());
      assertEquals(originalCount, countLiveEntries(map));
      assertEquals(originalCount, segment.count);

    assertEquals(originalMap, map);

    for (int i = 1; i <= originalCount * 2; i *= 2) {
      if (i > 1) {
        // TODO(b/145386688): This access should be guarded by 'segment', which is not currently
        // held
        segment.expand();
      }
      assertEquals(i, segment.table.length());
      assertEquals(originalCount, countLiveEntries(map));
      assertEquals(originalCount, segment.count);

 * @see TimestampConversionUtil
 */
public abstract class TimeConversionUtil {

    /**
     * Do not instantiate.
     */
    protected TimeConversionUtil() {
    }

    /** Array of styles held by {@link DateFormat} */
    protected static final int[] STYLES = new int[] { SHORT, MEDIUM, LONG, FULL };

    /**
     * Returns the pattern string for {@link DateFormat#SHORT} style in the default locale.
     *

 * @see TimeConversionUtil
 */
public abstract class TimestampConversionUtil {

    /**
     * Do not instantiate.
     */
    protected TimestampConversionUtil() {
    }

    /** Array of styles held by {@link DateFormat} */
    protected static final int[] STYLES = new int[] { SHORT, MEDIUM, LONG, FULL };

    /**
     * Returns the pattern string for {@link DateFormat#SHORT} style using the default locale.
     *

 *    * dns ([dnsStart], [dnsEnd])
 *    * connect ([connectStart], [connectEnd], [connectFailed])
 *      * secure connect ([secureConnectStart], [secureConnectEnd])
 *    * connection held ([connectionAcquired], [connectionReleased])
 *      * request ([requestFailed])
 *        * headers ([requestHeadersStart], [requestHeadersEnd])
 *        * body ([requestBodyStart], [requestBodyEnd])

 *
 * <ul>
 *   <li>Each lock adds (and removes) itself to/from a ThreadLocal Set of acquired locks when the
 *       Thread acquires its first hold (and releases its last remaining hold).
 *   <li>Before the lock is acquired, the lock is checked against the current set of acquired
 *       locks---to each of the acquired locks, an edge from the soon-to-be-acquired lock is either

  outFinished: Boolean,
  inFinished: Boolean,
  headers: Headers?,
) : Lockable,
  Socket {
  // Internal state is guarded by `this`. No long-running or potentially blocking operations are
  // performed while the lock is held.

  /** The bytes consumed and acknowledged by the stream. */
  val readBytes: WindowCounter = WindowCounter(id)

  /** The total number of bytes produced by the application. */
  var writeBytesTotal = 0L

     * for (Lock lock : locks) {
     *   lock.lock();
     * }
     * operation();
     * for (Lock lock : locks) {
     *   lock.unlock();
     * }
     *
     * If we only held the int[] stripes, translating it on the fly to L's, the original locks might
     * be garbage collected after locking them, ending up in a huge mess.
     */

    void dispatchListenerEvents() {
      checkState(
          !monitor.isOccupiedByCurrentThread(),
          "It is incorrect to execute listeners with the monitor held.");
      listeners.dispatch();
    }

    @GuardedBy("monitor")
    void checkHealthy() {
      if (states.count(RUNNING) != numberOfServices) {
        IllegalStateException exception =