import assertk.assertions.contains
import assertk.assertions.containsExactly
import assertk.assertions.doesNotContain
import assertk.assertions.isEqualTo
import assertk.assertions.isIn
import assertk.assertions.isInstanceOf
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import assertk.assertions.isSameAs
import java.io.File
import java.io.IOException
import java.io.InterruptedIOException

  public void testPropagate_noneDeclared_checked() {
    RuntimeException expected =
        assertThrows(RuntimeException.class, () -> propagate(new SomeCheckedException()));
    assertThat(expected).hasCauseThat().isInstanceOf(SomeCheckedException.class);
  }

  @GwtIncompatible // throwIfInstanceOf
  public void testThrowIfInstanceOf_unchecked() throws SomeCheckedException {

      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertThat(expected).isInstanceOf(IOException.class);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertNull(c3);

    assertTrue(suppressor.suppressions.isEmpty());
  }

    latch.countDown();
    ExecutionException expected =
        assertThrows(ExecutionException.class, () -> first.get(10, SECONDS));
    assertThat(expected).hasCauseThat().isInstanceOf(RejectedExecutionException.class);
  }

  public void testToString() {
    final Runnable[] currentTask = new Runnable[1];
    final Executor delegate =
        new Executor() {
          @Override

 */
package okhttp3.internal.tls

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isInstanceOf
import assertk.assertions.isTrue
import java.io.ByteArrayInputStream
import java.security.cert.CertificateFactory
import java.security.cert.X509Certificate
import javax.net.ssl.SSLSession

      int mod = i % 3;
      if (mod == 0 || mod == 2) {
        assertThat(result.get(i)).isInstanceOf(ExecutionException.class);
        assertThat((ExecutionException) result.get(i)).hasCauseThat().isSameInstanceAs(e);
      } else {
        assertThat(result.get(i)).isInstanceOf(UncheckedExecutionException.class);
        assertThat((UncheckedExecutionException) result.get(i)).hasCauseThat().isSameInstanceAs(e);

import assertk.assertions.isBetween
import assertk.assertions.isCloseTo
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isInstanceOf
import assertk.assertions.isLessThan
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import java.io.EOFException
import java.io.IOException
import java.io.InterruptedIOException

   * the full set of method parameters.
   */
  private void assertFailureCause(
      Throwable throwable, Class<? extends Throwable> clazz, Object[] params) {
    assertThat(throwable).isInstanceOf(clazz);
    if (params.length == 1) {
      assertThat(throwable).hasMessageThat().isNull();
    } else if (params.length == 2) {
      assertThat(throwable).hasMessageThat().isEmpty();
    } else {

    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() {

      expected.put(key, -i);
    }
    ImmutableMap<ClassWithTerribleHashCode, Integer> map = builder.buildKeepingLast();
    assertThat(map).containsExactlyEntriesIn(expected).inOrder();
    assertThat(map).isInstanceOf(JdkBackedImmutableMap.class);
  }

  @GwtIncompatible // Pattern, Matcher
  public void testBuilder_keepingLast_thenOrThrow() {
    ImmutableMap.Builder<String, Integer> builder =