assertEquals(Strength.WEAK, internerImpl.map.keyStrength());
    assertEquals(concurrencyLevel, internerImpl.map.concurrencyLevel);
  }


  public void testWeak_afterGC() throws InterruptedException {
    Integer canonical = new Integer(5);
    Integer not = new Integer(5);

    Interner<Integer> pool = Interners.newWeakInterner();
    assertSame(canonical, pool.intern(canonical));

  public void addListener(Runnable listener, Executor exec) {
    executionList.add(listener, exec);
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {

    long timeoutNanos = unit.toNanos(timeout);
    if (timeoutNanos <= OverflowAvoidingLockSupport.MAX_NANOSECONDS_THRESHOLD) {

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int nalgos = SMBUtil.readInt2(buffer, bufferIndex);
        final int nsalt = SMBUtil.readInt2(buffer, bufferIndex + 2);

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, final int bufferIndex, final int len) throws SMBProtocolDecodingException {
        if (this.largeFile) {
            this.pid = SMBUtil.readInt2(buffer, bufferIndex);
            final int boHigh = SMBUtil.readInt4(buffer, bufferIndex + 4);

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

class DefaultToolchainTest {
    private final Logger logger = mock(Logger.class);

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
    }

    private DefaultToolchain newDefaultToolchain(ToolchainModel model) {
        return new DefaultToolchain(model, logger) {
            @Override

   * available. It may also not be provided when an authenticator is re-used manually in an
   * application interceptor, such as when implementing client-specific retries.
   */
  @Throws(IOException::class)
  fun authenticate(
    route: Route?,
    response: Response,
  ): Request?

  companion object {
    /** An authenticator that knows no credentials and makes no attempt to authenticate. */

    }

    /**
     * Test the writeBytesWireFormat method.
     * It should write the dialect string to the destination array.
     */
    @Test
    void testWriteBytesWireFormat() throws UnsupportedEncodingException {
        byte[] expectedBytes = DIALECTS.getBytes("ASCII");
        byte[] dst = new byte[expectedBytes.length];
        int dstIndex = 0;

        // Execute the method to write bytes

    //
    // p1 ---> p0 --> super model
    //
    // ----------------------------------------------------------------------

    @Test
    void testDependencyManagementOverridesTransitiveDependencyVersion() throws Exception {
        File localRepo = getLocalRepositoryPath();

        File pom0 = new File(localRepo, "p0/pom.xml");
        File pom0Basedir = pom0.getParentFile();
        File pom1 = new File(pom0Basedir, "p1/pom.xml");

    private static final Logger logger = LogManager.getLogger(HtmlXpathExtractorTest.class);

    public HtmlXpathExtractor htmlXpathExtractor;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("htmlXpathExtractor", HtmlXpathExtractor.class);

  public void testForSupplierSerializable() {
    checkCanReserialize(Functions.forSupplier(new CountingSupplier()));
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testNulls() throws Exception {
    new ClassSanityTester().forAllPublicStaticMethods(Functions.class).testNulls();
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection