Exception e =
        assertThrows(
            Exception.class, () -> new RecursiveTypeBoundBugExample<>().testAllDeclarations());
    assertThat(e).hasCauseThat().isInstanceOf(AssertionError.class);
  }

  @SuppressWarnings("RestrictedApiChecker") // crashes under JDK8, which EP no longer supports
  public void testSubtypeOfInnerClass_nonStaticAnonymousClass() {

    CacheLoader<Object, Object> loader =
        new CacheLoader<Object, Object>() {
          @Override
          public Object load(Object key) throws Exception {
            throw new AssertionError();
          }

          @Override
          public Map<Object, Object> loadAll(Iterable<?> keys) throws Exception {
            Map<Object, Object> result = Maps.newHashMap();

    switch (boundType) {
      case OPEN:
        return lessThan(endpoint);
      case CLOSED:
        return atMost(endpoint);
    }
    throw new AssertionError();
  }

  /**
   * Returns a range that contains all values strictly greater than {@code endpoint}.
   *
   * @since 14.0
   */

        case OPEN:
          return aggr.nodeAggregate(node) + aggr.treeAggregate(node.left);
        case CLOSED:
          return aggr.treeAggregate(node.left);
      }
      throw new AssertionError();
    } else {
      return aggr.treeAggregate(node.left)
          + aggr.nodeAggregate(node)
          + aggregateBelowRange(aggr, node.right);
    }
  }

   * appear in this multimap.
   */
  @Override
  public ImmutableSet<K> keySet() {
    return map.keySet();
  }

  @Override
  Set<K> createKeySet() {
    throw new AssertionError("unreachable");
  }

  /**
   * Returns an immutable map that associates each key with its corresponding values in the
   * multimap. Keys and values appear in the same order as in this multimap.
   */

          return null
        }

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) {
          throw AssertionError()
        }
      }

    val address =
      factory.newAddress(
        proxySelector = nullProxySelector,
      )
    val routeSelector = newRouteSelector(address)

   */
  private static char[] growBuffer(char[] dest, int index, int size) {
    if (size < 0) { // overflow - should be OutOfMemoryError but GWT/j2cl don't support it
      throw new AssertionError("Cannot increase internal buffer any further");
    }
    char[] copy = new char[size];
    if (index > 0) {
      System.arraycopy(dest, 0, copy, 0, index);
    }
    return copy;
  }

            // and resetting the stream.
            duplexResponseSent.await()
          } catch (e: InterruptedException) {
            throw AssertionError()
          }
          super.responseHeadersEnd(call, response)
        }
      }
    client =
      client.newBuilder()
        .eventListener(listener)
        .build()
    val body =

    try {
      in.copyTo(out);
      fail();
    } catch (IOException expected) {
      return expected.getSuppressed().length;
    }
    throw new AssertionError(); // can't happen
  }

  private static ByteSource newNormalByteSource() {
    return ByteSource.wrap(new byte[10]);
  }

  private static ByteSink newNormalByteSink() {
    return new ByteSink() {

      byteCount: Int,
      last: Boolean,
    ): Boolean {
      events.add(AssertionError("onData"))
      notifyAll()
      return false
    }

    @Synchronized override fun onReset(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      events.add(AssertionError("onReset"))
      notifyAll()
    }
  }

  companion object {
    fun roundUp(