} catch (NoSuchElementException success) {
      }
    } catch (InterruptedException ie) {
      threadUnexpectedException(ie);
    }
  }

  @SuppressWarnings("unchecked")
  <T> T serialClone(T o) {
    try {
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(bos);
      oos.writeObject(o);
      oos.flush();

    scheduling. In your debugger you will see new thread names and more use of daemon threads.

 *  Fix: Don't drop callbacks on unexpected exceptions. When an interceptor throws an unchecked
    exception the callback is now notified that the call was canceled. The exception is still sent
    to the uncaught exception handler for reporting and recovery.

            spec = new ArtifactSpec();
            spec.artifact = artifact;
            source.addArtifact(spec);
        }
        return spec;
    }

    @SuppressWarnings("unchecked")
    private static Set<Artifact> createSet(Object[] x) {
        return new LinkedHashSet(Arrays.asList(x));
    }

    private class ArtifactSpec {
        private Artifact artifact;

    Entry<Number, String> entry = entries.iterator().next();
    assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    @SuppressWarnings("unchecked")
    Entry<Integer, String> entry2 = (Entry<Integer, String>) entries.toArray()[0];
    assertThrows(UnsupportedOperationException.class, () -> entry2.setValue("four"));
  }

  public void testImmutableEntry() {

    assertThrows(InvalidCacheLoadException.class, () -> cache.getUnchecked("bar"));
    assertThat(callCount.get()).isEqualTo(2);
  }

  /**
   * On a concurrent computation that throws an unchecked exception, all threads should get the
   * (wrapped) exception, with the loader called only once. The result should not be cached (a later
   * request should call the loader again).
   */

  private transient int[] nextInInsertionOrder;

  private HashBiMap(int expectedSize) {
    init(expectedSize);
  }

  @SuppressWarnings("unchecked")
  void init(int expectedSize) {
    checkNonnegative(expectedSize, "expectedSize");
    int tableSize = Hashing.closedTableSize(expectedSize, 1.0);
    size = 0;

    keys = (K[]) new Object[expectedSize];

    @Override
    public ExtensionRealmCache.CacheRecord setupExtensionsRealm(
            MavenProject project, Plugin plugin, RepositorySystemSession session) throws PluginManagerException {
        @SuppressWarnings("unchecked")
        Map<String, ExtensionRealmCache.CacheRecord> pluginRealms =
                (Map<String, ExtensionRealmCache.CacheRecord>) project.getContextValue(KEY_EXTENSIONS_REALMS);
        if (pluginRealms == null) {

    @Keep
    public void checkArray(Converter<String, Integer> c, String s) {
      calledWith(c, s);
    }

    void check() {
      runTester();
      @SuppressWarnings("unchecked") // We are checking it anyway
      Converter<String, Integer> defaultConverter =
          (Converter<String, Integer>) getDefaultParameterValue(0);

  }

  // TODO: Re-enable this test after moving to new serialization format in ImmutableMap.
  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  @SuppressWarnings("unchecked")
  public void ignore_testSerializationNoDuplication_regularImmutableMap() throws Exception {
    // Tests that serializing a map, its keySet, and values only writes the underlying data once.

## Version 3.14.4

_2019-09-29_

 *  Fix: Cancel calls that fail due to unexpected exceptions. We had a bug where an enqueued call
    would never call back if it crashed with an unchecked throwable, such as a
    `NullPointerException` or `OutOfMemoryError`. We now call `Callback.onFailure()` with an
    `IOException` that reports the call as canceled. The triggering exception is still delivered to