guard.condition.signalAll();
    }
  }

  /** Records that the current thread is about to wait on the specified guard. */
  @GuardedBy("lock")
  private void beginWaitingFor(Guard guard) {
    int waiters = guard.waiterCount++;
    if (waiters == 0) {
      // push guard onto activeGuards
      guard.next = activeGuards;
      activeGuards = guard;

  public final void testEnterWhen_initiallyTrue() throws Exception {
    TestGuard guard = new TestGuard(true);
    thread1.callAndAssertReturns(enterWhen(), guard);
  }

  public final void testEnterWhen_initiallyFalse() throws Exception {
    TestGuard guard = new TestGuard(false);
    thread1.callAndAssertWaits(enterWhen(), guard);
    monitor.enter();
    guard.setSatisfied(true);
    monitor.leave();

    TestGuard guard = new TestGuard(true);
    thread1.callAndAssertReturns(true, enterIf(), guard);
    thread2.callAndAssertBlocks(enter());
  }

  public final void testEnterIf_initiallyFalse() throws Exception {
    TestGuard guard = new TestGuard(false);
    thread1.callAndAssertReturns(false, enterIf(), guard);
    thread2.callAndAssertReturns(enter());
  }

    // (b) Waiting for the single guard to become satisfied.
    // (c) Occupying the monitor and awaiting the tearDownLatch.
    //
    // Except for (c), every thread should occupy the monitor very briefly, and every thread leaves
    // the monitor with the guard satisfied. Therefore as soon as tearDownLatch is triggered, we
    // should be able to enter the monitor, and then we set the guard to satisfied for the benefit

    // (b) Waiting for the single guard to become satisfied.
    // (c) Occupying the monitor and awaiting the tearDownLatch.
    //
    // Except for (c), every thread should occupy the monitor very briefly, and every thread leaves
    // the monitor with the guard satisfied. Therefore as soon as tearDownLatch is triggered, we
    // should be able to enter the monitor, and then we set the guard to satisfied for the benefit

    Monitor monitor2 = new Monitor();
    FlagGuard guard = new FlagGuard(monitor2);
    assertThrows(IllegalMonitorStateException.class, () -> monitor1.getWaitQueueLength(guard));
  }

  public void testHasWaitersWithWrongMonitorThrowsIMSE() {
    Monitor monitor1 = new Monitor();
    Monitor monitor2 = new Monitor();
    FlagGuard guard = new FlagGuard(monitor2);

    Monitor monitor2 = new Monitor();
    FlagGuard guard = new FlagGuard(monitor2);
    assertThrows(IllegalMonitorStateException.class, () -> monitor1.getWaitQueueLength(guard));
  }

  public void testHasWaitersWithWrongMonitorThrowsIMSE() {
    Monitor monitor1 = new Monitor();
    Monitor monitor2 = new Monitor();
    FlagGuard guard = new FlagGuard(monitor2);

        assertEquals(WinError.WINERR_CODES.length, WinError.WINERR_MESSAGES.length, "Codes/messages length mismatch");

        // Exact content check to guard against accidental reordering or drift
        assertArrayEquals(
                new int[] { WinError.ERROR_SUCCESS, WinError.ERROR_ACCESS_DENIED, WinError.ERROR_REQ_NOT_ACCEP, WinError.ERROR_BAD_PIPE,

   * found in any textbook.
   */

  /** Monitor guarding all access */
  final Monitor monitor;

  /** Guard for waiting takes */
  private final Monitor.Guard notEmpty;

  /** Guard for waiting puts */
  private final Monitor.Guard notFull;

  // Internal helper methods

  /** Circularly increment i. */
  final int inc(int i) {
    return (++i == items.length) ? 0 : i;
  }

  public final boolean equals(@Nullable Object obj) {
    if (obj instanceof Subscriber) {
      Subscriber that = (Subscriber) obj;
      // Use == so that different equal instances will still receive events.
      // We only guard against the case that the same object is registered
      // multiple times
      return target == that.target && method.equals(that.method);
    }
    return false;
  }

  /**