public void testAddAll_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(nothing) should return false or throw", collection.addAll(emptyCollection()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_supportedNonePresent() {
    assertTrue(

 * and access mask are considered. If the ACE is a "deny"
 * ACE and <i>any</i> of the desired access bits match bits in the access
 * mask of the ACE, the whole access check fails. If the ACE is an "allow"
 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)

    void resetSingleton() {
        try {
            Field instance = SingletonContext.class.getDeclaredField("INSTANCE");
            instance.setAccessible(true);
            instance.set(null, null);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            log.error("Failed to reset SingletonContext instance", e);
            fail("Failed to reset SingletonContext instance: " + e.getMessage());
        }

        try {
            Field f = target.getClass().getDeclaredField(name);
            f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {
            fail("Failed to set field '" + name + "'", e);
        }
    }

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

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          val socket =
            try {
              checkUpgradeSuccess(response)
            } catch (e: IOException) {
              failWebSocket(e, response)
              response.closeQuietly()
              response.socket?.sink?.closeQuietly()
              response.socket?.source?.closeQuietly()

          if (nextPlan != null) {
            routePlanner.deferredPlans.addFirst(nextPlan)
            continue
          }
        }
        return plan.handleSuccess()
      } catch (e: IOException) {
        if (firstException == null) {
          firstException = e
        } else {
          firstException.addSuppressed(e)
        }
        if (!routePlanner.hasNext()) {

        PreauthIntegrityNegotiateContext ctx = new PreauthIntegrityNegotiateContext();
        try {
            setPrivateField(ctx, "hashAlgos", new int[] { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 });
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return ctx;
    }

    private NegotiateContextRequest createMockEncryptionContext() {

   */
  @JvmOverloads
  fun charset(defaultValue: Charset? = null): Charset? {
    val charset = parameter("charset") ?: return defaultValue
    return try {
      Charset.forName(charset)
    } catch (_: IllegalArgumentException) {
      defaultValue // This charset is invalid or unsupported. Give up.
    }
  }

  /**
   * Returns the parameter [name] of this media type, or null if this media type does not define

    }

    @Test
    void testActivityTracking() {
        long initialTime = channelInfo.getLastActivityTime();

        // Wait a bit and update activity
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        channelInfo.updateActivity();
        assertTrue(channelInfo.getLastActivityTime() > initialTime);

	strict bool   // Versions must match exactly, including all metadata.

	// Reusable slice for resolution
	candidates [][]xlMetaV2ShallowVersion
}

// resolve multiple entries.
// entries are resolved by majority, then if tied by mod-time and versions.
// Names must match on all entries in m.