// Not specifying KNOWN_ORDER for PriorityQueue and PriorityBlockingQueue
  // even though they do have it, because our tests interpret KNOWN_ORDER to
  // also mean that the iterator returns the head element first, which those
  // don't.

  public Test testsForPriorityBlockingQueue() {
    return QueueTestSuiteBuilder.using(
            new TestStringQueueGenerator() {
              @Override

import okhttp3.tls.internal.TlsUtil.newKeyManager
import okhttp3.tls.internal.TlsUtil.newTrustManager

/**
 * Certificates to identify which peers to trust and also to earn the trust of those peers in kind.
 * Client and server exchange these certificates during the handshake phase of a TLS connection.
 *
 * ### Server Authentication
 *
 * This is the most common form of TLS authentication: clients verify that servers are trusted and

all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places:...

 *
 * <p><b>Warning:</b> Chunks of data that are put into the {@link Hasher} are not delimited. The
 * resulting {@link HashCode} is dependent only on the bytes inserted, and the order in which they
 * were inserted, not how those bytes were chunked into discrete put() operations. For example, the
 * following three expressions all generate colliding hash codes:
 *
 * {@snippet :
 * newHasher().putByte(b1).putByte(b2).putByte(b3).hash()

          }
        });

    // Run those tasks together.
    fakePool.runAll();

    // Check that the interruption of a SequentialExecutor's task is restored to the thread once
    // it is yielded. Clear the bit while checking so that the test doesn't hose JUnit or some other
    // test case.
    assertThat(Thread.interrupted()).isTrue();
  }

/**
 * Tests for {@link SmbComLockingAndX}.  The source class exposes
 * its wire-format helpers as protected methods and its internal state
 * is stored in private fields; tests make use of the same package to
 * access those members directly.
 */
@ExtendWith(MockitoExtension.class)
class SmbComLockingAndXTest {

    /**
     * Helper for setting a field via reflection.
     */

 */
package jcifs;

/**
 * An Access Control Entry (ACE) is an element in a security descriptor
 * such as those associated with files and directories. The Windows OS
 * determines which users have the necessary permissions to access objects
 * based on these entries.
 * <p>
 * To fully understand the information exposed by this class a description

import java.util.Iterator;
import java.util.List;
import org.junit.Ignore;

/**
 * Common superclass for {@link MultisetSetCountUnconditionallyTester} and {@link
 * MultisetSetCountConditionallyTester}. It is used by those testers to test calls to the
 * unconditional {@code setCount()} method and calls to the conditional {@code setCount()} method
 * when the expected present count is correct.
 *
 * @author Chris Povirk
 */
@GwtCompatible

 */
@J2ktIncompatible
@GwtIncompatible
public final class PairedStatsAccumulator {
  /** Creates a new accumulator. */
  public PairedStatsAccumulator() {}

  // These fields must satisfy the requirements of PairedStats' constructor as well as those of the
  // stat methods of this class.
  private final StatsAccumulator xStats = new StatsAccumulator();
  private final StatsAccumulator yStats = new StatsAccumulator();

          // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
          // For these users fallback to a suboptimal implementation, based on synchronized. This
          // will be a definite performance hit to those users.
          thrownAtomicReferenceFieldUpdaterFailure = atomicReferenceFieldUpdaterFailure;
          helper = new SynchronizedHelper();
        }