* object). So it is important to not call {@link #dispatch} while holding any locks. This is why
 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision
 * to run a particular event is made during the state change, but the decision to actually invoke
 * the listeners can be delayed slightly so that locks can be dropped. Also, because {@link
 * #dispatch} is expected to be called concurrently, it is idempotent.
 */

 * sample of code points to detect Unicode control characters commonly used in binary file
 * signatures.
 *
 * @param codePointLimit the number of code points to read in order to make a decision.
 */
internal fun BufferedSource.isProbablyUtf8(codePointLimit: Long = Long.MAX_VALUE): Boolean {
  try {
    val peek = peek()
    for (i in 0 until codePointLimit) {
      if (peek.exhausted()) {
        break

 * object). So it is important to not call {@link #dispatch} while holding any locks. This is why
 * {@link #enqueue} and {@link #dispatch} are 2 different methods. It is expected that the decision
 * to run a particular event is made during the state change, but the decision to actually invoke
 * the listeners can be delayed slightly so that locks can be dropped. Also, because {@link
 * #dispatch} is expected to be called concurrently, it is idempotent.
 */

        verifyNoInteractions(mockDir);
    }

    /**
     * Interaction with dependency: implementation can use directory's methods to make decisions.
     * Tests a filter that uses directory path information.
     */
    @Test
    @DisplayName("filter can use SmbFile directory for decision logic")
    void filterCanUseSmbFileForDecision() throws Exception {
        // Stub the getPath method to return a specific value

After filing a report, a representative from the Square Code of Conduct committee will contact you
personally. The committee will then review the incident, follow up with any additional questions,
and make a decision as to how to respond.

Anyone asked to stop unacceptable behavior is expected to comply immediately. If an individual
engages in unacceptable behavior, the Square Code of Conduct committee may take any action they deem

        assertTrue(ex.getMessage().contains("Server does not support NTLM authentication"));

        // Verify the decision consulted the configuration
        // getConfig() is called twice: once in Kerb5Authenticator and once in NtlmPasswordAuthenticator
        verify(tc, times(2)).getConfig();

          }

          // We have a task to execute when we complete the loop.
          else -> {
            readyTask = candidate
          }
        }
      }

      // Implement the decision.
      when {
        // We have a task ready to go. Get ready.
        readyTask != null -> {
          beforeRun(readyTask)

          // Also start another thread if there's more work or scheduling to do.

   * href="https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html">mutually
   * comparable</a>. If you pass objects that are not mutually comparable, this method may throw an
   * exception. (The reason for this decision is lost to time, but the reason <i>might</i> be that
   * we wanted to support legacy classes that implement the raw type {@code Comparable} (instead of

 * and the last 7 bits from this byte.
 *
 * The end of the range is not encoded, but can be inferred by looking at the start of the range
 * that follows.
 *
 * b1
 * --
 *
 * This is either a mapping decision or the length of the mapped output, according to this table:
 *
 * ```
 *  0..63 : Length of the UTF-16 sequence that this range maps to. The offset is b2b3.

  //   is). If we wanted to be strict about it, we could store the unpark() time in the Waiter node
  //   and we could use that to make a decision about whether or not we timed out prior to being
  //   unparked.

  @SuppressWarnings({
    "LabelledBreakTarget", // TODO(b/345814817): Maybe fix?