} catch (Exception // sneaky checked exception
            | Error atomicReferenceFieldUpdaterFailure) {
          // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
          // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
          // For these users fallback to a suboptimal implementation, based on synchronized. This

        }
    }

    private boolean isExceptPrivateAccessible(Field field) {
        // to avoid warning of JDK-internal access at Java11
        // Lasta Di does not need private access to the classes
        final String fqcn = field.getDeclaringClass().getName();
        return fqcn.startsWith("java.") || fqcn.startsWith("jdk.") || fqcn.startsWith("com.sun.") || fqcn.startsWith("sun.");
    }

    /**

     * <p>
     * Note: This method no longer uses internal JDK APIs for safety and compatibility.
     * It now uses the standard String constructor.
     * </p>
     *
     * @param chars
     *            the char array
     * @return a new String, or null if the input is null
     * @deprecated This method originally used internal JDK APIs (sun.misc.SharedSecrets) for

        Class<?> optionalClass = Class.forName("java.util.Optional");
        /*
         * We don't *need* to use reflection to access Optional: It's available on all JDKs we
         * support, and Android code won't get this far, anyway, because ProcessHandle is
         * unavailable. But given how much other reflection we're using, we might as well use it

fun <reified T : ComponentMetadataRule> ComponentMetadataHandler.applyRule(module: String, vararg modulesToRemove: Any) {
    withModule<T>(module) {
        params(*modulesToRemove)
    }
}


/**
 * The JDK now provides these.
 */
abstract class RemoveXmlApisRule : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {

      assertThat(cache.asMap().values()).contains(value2);
      assertThat(cache.asMap().entrySet()).containsExactly(immutableEntry(key2, value2));
    }
  }

  // fails in Maven with 64-bit JDK: https://github.com/google/guava/issues/1568

  // A simple type whose .toString() will return the same value each time, but without maintaining
  // a strong reference to that value.
  static class Key {

   * properties, including:
   *
   * <ul>
   *   <li>{@code java.vendor.version} (added in Java 11, listed as optional as of Java 13)
   *   <li>{@code jdk.module.*} (added in Java 9, optional)
   * </ul>
   */
  public @Nullable String value() {
    return System.getProperty(key);
  }

  /** Returns a string representation of this system property. */

 * <p>This class is tailored toward use cases in common.graph. It is *NOT* a general purpose map.
 *
 * @author James Sexton
 */
class MapIteratorCache<K, V> {
  private final Map<K, V> backingMap;

  /*
   * Per JDK: "the behavior of a map entry is undefined if the backing map has been modified after
   * the entry was returned by the iterator, except through the setValue operation on the map entry"

  protected static String formatFeatureSet(Set<? extends Feature<?>> features) {
    List<String> temp = new ArrayList<>();
    for (Feature<?> feature : features) {
      Object featureAsObject = feature; // to work around bogus JDK warning
      if (featureAsObject instanceof Enum) {
        Enum<?> f = (Enum<?>) featureAsObject;
        temp.add(f.getDeclaringClass().getSimpleName() + "." + feature);
      } else {

   * even worse. For now, we just suppress and move on with our lives.
   *
   * - https://github.com/jspecify/jspecify/issues/65
   *
   * - https://github.com/jspecify/jdk/commit/71d826792b8c7ef95d492c50a274deab938f2552
   */
  /*
   * TODO(cpovirk): Is the unchecked cast avoidable? Would System.arraycopy be similarly fast (if