fail();
    } catch (TwoArgConstructorException expected) {
      assertThat(expected).hasCauseThat().isInstanceOf(InterruptedException.class);
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetCheckedUntimed_cancelled() throws TwoArgConstructorException {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);

    while (!source.exhausted()) {
      out.write(source.buffer, source.buffer.size)
      out.flush()
    }

    response.body.close()
  } catch (e: IOException) {
    e.printStackTrace()
  } finally {
    close()
  }

    dnsProviders =
      providers(
        client = bootstrapClient,
        http2Only = true,
        workingOnly = true,
        getOnly = true,
      )
    runBatch(dnsProviders, names)
  } finally {
    bootstrapClient.connectionPool.evictAll()
    bootstrapClient.dispatcher.executorService.shutdownNow()
    bootstrapClient.cache?.close()
  }

                    System.err.println(ioe.getMessage());
//ioe.printStackTrace(System.err);
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            numComplete++;
        }
    }

    public static void main(String[] args) throws Exception
    {
        if (args.length < 1) {

    }
  }

  /** Updates the sink with the given number of bytes from the buffer. */
  @CanIgnoreReturnValue
  private Hasher update(int bytes) {
    try {
      update(scratch.array(), 0, bytes);
    } finally {
      Java8Compatibility.clear(scratch);
    }
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putByte(byte b) {
    update(b);
    return this;
  }

  @Override

  public void testGetUnchecked_interrupted() {
    Thread.currentThread().interrupt();
    try {
      assertEquals("foo", getUnchecked(immediateFuture("foo")));
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetUnchecked_cancelled() {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);

  public void testGetUnchecked_interrupted() {
    Thread.currentThread().interrupt();
    try {
      assertEquals("foo", getUnchecked(immediateFuture("foo")));
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetUnchecked_cancelled() {
    SettableFuture<String> future = SettableFuture.create();
    future.cancel(true);

        org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback()
}


private
inline fun <T : Any?> Disposable.use(action: Disposable.() -> T) =
    try {
        action(this)
    } finally {
        Disposer.dispose(this)

  private static class BadLengthFile extends File {

    private final long badLength;

    public BadLengthFile(File delegate, long badLength) {
      super(delegate.getPath());
      this.badLength = badLength;
    }

    @Override
    public long length() {
      return badLength;
    }

    private static final long serialVersionUID = 0;
  }

  }

  public void testMultipleTearDownsHappenInOrder() throws Exception {
    final TearDownStack stack = buildTearDownStack();

    final SimpleTearDown tearDownOne = new SimpleTearDown();
    stack.addTearDown(tearDownOne);

    final Callback callback =
        new Callback() {
          @Override
          public void run() {
            assertEquals(