@SuppressWarnings("ThrowIfUncheckedKnownUnchecked")
  public void testThrowIfUnchecked_unchecked() {
    assertThrows(
        SomeUncheckedException.class, () -> throwIfUnchecked(new SomeUncheckedException()));
  }

  // We're testing that the method is in fact equivalent to throwing the exception directly.
  @SuppressWarnings("ThrowIfUncheckedKnownUnchecked")

  @SuppressWarnings("ThrowIfUncheckedKnownUnchecked")
  public void testThrowIfUnchecked_unchecked() {
    assertThrows(
        SomeUncheckedException.class, () -> throwIfUnchecked(new SomeUncheckedException()));
  }

  // We're testing that the method is in fact equivalent to throwing the exception directly.
  @SuppressWarnings("ThrowIfUncheckedKnownUnchecked")

    assertThrows(
        SomeUncheckedException.class,
        () ->
            getMap()
                .compute(
                    k0(),
                    (k, v) -> {
                      assertEquals(k0(), k);
                      assertEquals(v0(), v);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }

  public void testComputeIfAbsent_functionThrows() {
    assertThrows(
        SomeUncheckedException.class,
        () ->
            getMap()
                .computeIfAbsent(
                    k3(),
                    k -> {
                      assertEquals(k3(), k);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }

  }

  public void testException() {
    SomeUncheckedException exception = new SomeUncheckedException();
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          @Override
          public Integer computeNext() {
            throw exception;
          }
        };

    // It should pass through untouched
    SomeUncheckedException e = assertThrows(SomeUncheckedException.class, iter::hasNext);

    assertThrows(
        SomeUncheckedException.class,
        () ->
            getMap()
                .merge(
                    k0(),
                    v3(),
                    (oldV, newV) -> {
                      assertEquals(v0(), oldV);
                      assertEquals(v3(), newV);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();

    Iterator<Object> broken = new BrokenAbstractSequentialIterator();
    assertTrue(broken.hasNext());
    // We can't retrieve even the known first element:
    assertThrows(SomeUncheckedException.class, broken::next);
    assertThrows(SomeUncheckedException.class, broken::next);
  }

  private static Iterator<Integer> newDoubler(int first, int last) {
    return new AbstractSequentialIterator<Integer>(first) {
      @Override

    assertThrows(
        SomeUncheckedException.class,
        () ->
            getMap()
                .computeIfPresent(
                    k0(),
                    (k, v) -> {
                      assertEquals(k0(), k);
                      assertEquals(v0(), v);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }

  public void testComputeIfAbsent_functionThrows() {
    assertThrows(
        SomeUncheckedException.class,
        () ->
            getMap()
                .computeIfAbsent(
                    k3(),
                    k -> {
                      assertEquals(k3(), k);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }

    assertThrows(
        SomeUncheckedException.class,
        () ->
            getMap()
                .computeIfPresent(
                    k0(),
                    (k, v) -> {
                      assertEquals(k0(), k);
                      assertEquals(v0(), v);
                      throw new SomeUncheckedException();
                    }));
    expectUnchanged();
  }