if strings.HasSuffix(file, ".zip") {
			var sz int64
			f, err := os.Open(file)
			if err != nil {
				return err
			}
			if st, err := f.Stat(); err == nil {
				sz = st.Size()
			}
			defer f.Close()
			zr, err := zip.NewReader(f, sz)
			if err != nil {
				return err
			}
			for _, file := range zr.File {
				if !file.FileInfo().IsDir() && strings.HasSuffix(file.Name, ".healing.bin") {
					r, err := file.Open()

  private val routeB1 = factory.newRoute(addressB)
  private val addressC = factory.newAddress("c")
  private val routeC1 = factory.newRoute(addressC)

  @AfterEach fun tearDown() {
    factory.close()
    peer.close()
  }

  @Test fun connectionsEvictedWhenIdleLongEnough() {
    val pool = factory.newConnectionPool()
    val c1 = factory.newConnection(pool, routeA1, 50L)

        } finally {
            super.finalize();
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    public void close() {
        release();
    }

    /**
     *
     */
    public void release() {
        long usage = this.usageCount.decrementAndGet();

     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public void close() throws IOException {
        try {
            final SmbFileHandleImpl h = this.handle;
            if (h != null) {
                h.close();
            }
        } catch (final SmbException se) {
            throw seToIoe(se);
        } finally {
            this.tmp = null;

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
        this.opened = true;
    }

    @Override
    public synchronized void close() throws IOException {
        if (this.opened) {
            this.opened = false;
            final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
            this.handle.sendrecv(rpc);

    assertThat(response.body.string()).isEqualTo("Hello")
  }

  private fun gzip(data: String): Buffer {
    val result = Buffer()
    val sink = GzipSink(result).buffer()
    sink.writeUtf8(data)
    sink.close()
    return result
  }

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

    synchronized (lock) {
      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  public void clear() {
    synchronized (lock) {
      list.clear();
    }
  }

  /** Returns a snapshot of the logged records. */
  /*

 * address in IPv4 or IPv6 notation, or a domain name.
 *
 * <p>Because this class is intended to represent host specifiers which can reasonably be used in a
 * URI, the domain name case is further restricted to include only those domain names which end in a
 * recognized public suffix; see {@link InternetDomainName#isPublicSuffix()} for details.
 *
 * <p>Note that no network lookups are performed by any {@code HostSpecifier} methods. No attempt is

If you don't want to have those optional dependencies, you can instead install `pip install fastapi`.

If you want to install the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.