}

func (target *PostgreSQLTarget) init() error {
	return target.initOnce.Do(target.initPostgreSQL)
}

func (target *PostgreSQLTarget) initPostgreSQL() error {
	args := target.args

	db, err := sql.Open("postgres", target.connString)
	if err != nil {
		return err
	}
	target.db = db

	if args.MaxOpenConnections > 0 {
		// Set the maximum connections limit
		target.db.SetMaxOpenConns(args.MaxOpenConnections)

   *
   * <p>Note that this method will return ranges with unbounded endpoints if {@link BoundType#OPEN}
   * is requested for a domain minimum or maximum. For example, if {@code set} was created from the
   * range {@code [1..Integer.MAX_VALUE]} then {@code set.range(CLOSED, OPEN)} must return {@code
   * [1..∞)}.
   *
   * @throws NoSuchElementException if this set is empty
   */

    val cachedCall = client.newCall(request)

    cachedCall.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNotNull()
    }
  }

  @Test
  open fun testPublicSuffixDb() {
    val httpUrl = "https://www.google.co.uk".toHttpUrl()
    assertThat(httpUrl.topPrivateDomain()).isEqualTo("google.co.uk")
  }

  private fun assumeNetwork() {
    try {

                            long opStart = System.nanoTime();
                            session.getSmbTree(shareName, null);
                            long opEnd = System.nanoTime();

                            totalTime.addAndGet(opEnd - opStart);
                            treeOperations.incrementAndGet();
                        } catch (Exception e) {
                            synchronized (exceptions) {

                  multiset = multiset.tailMultiset(firstExclusive, BoundType.OPEN);
                }

                if (to == Bound.INCLUSIVE) {
                  multiset = multiset.headMultiset(lastInclusive, BoundType.CLOSED);
                } else if (to == Bound.EXCLUSIVE) {
                  multiset = multiset.headMultiset(lastExclusive, BoundType.OPEN);
                }

                return multiset;
              }

	PutMultiple(item []I) (Key, error)
	Get(key Key) (I, error)
	GetMultiple(key Key) ([]I, error)
	GetRaw(key Key) ([]byte, error)
	PutRaw(b []byte) (Key, error)
	Len() int
	List() []Key
	Del(key Key) error
	Open() error
	Delete() error
}

// Key denotes the key present in the store.
type Key struct {
	Name      string
	Compress  bool
	Extension string
	ItemCount int
}

// String returns the filepath name

          <type>DOM</type>
          <description>
            Toolchain identification information, which will be matched against project requirements.
            &lt;p>Actual content structure is completely open: each toolchain type will define its own format and
            semantics.
            &lt;p>This is generally a properties format: {@code &lt;name&gt;value&lt;/name&gt;} with predefined
            properties names.

  }

  @SuppressWarnings({"removal", "Finalize"}) // b/260137033
  @Override
  protected void finalize() {
    if (state.get().equals(OPEN)) {
      logger.get().log(SEVERE, "Uh oh! An open ClosingFuture has leaked and will close: {0}", this);
      FluentFuture<V> unused = finishToFuture();
    }
  }

 * a specific "Accept-Encoding: identity" or similar.
 *
 * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding
 */
open class CompressionInterceptor(
  vararg val algorithms: DecompressionAlgorithm,
) : Interceptor {
  internal val acceptEncoding =
    algorithms
      .map {
        it.encoding
      }.joinToString(separator = ", ")

            return
        }

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

    protected open fun shouldInclude(taskPath: String): Boolean = parameters.monitoredTaskPaths.get().contains(taskPath)

    abstract fun action(taskPath: String, taskResult: TaskOperationResult)