DnsOverHttps
      .Builder()
      .client(bootstrapClient)
      .url("https://dns.google/dns-query".toHttpUrl())
      .bootstrapDnsHosts(getByIp("8.8.4.4"), getByIp("8.8.8.8"))
      .build()

  private fun buildGooglePost(bootstrapClient: OkHttpClient): DnsOverHttps =
    DnsOverHttps
      .Builder()
      .client(bootstrapClient)

    private TotalHits totalHits;
    private Aggregations aggregations;

    private SearchRequestBuilder builder;

    public EsPagingResultBean(final SearchRequestBuilder builder) {
        this.builder = builder;
    }

    public String getQueryDsl() {
        return builder.toString();
    }

    public long getTook() {
        return took;
    }

    public void setTook(long took) {

  static final Iterable<Double> ALL_DOUBLE_CANDIDATES;
  static final Iterable<Double> DOUBLE_CANDIDATES_EXCEPT_NAN;

  static {
    ImmutableSet.Builder<Double> integralBuilder = ImmutableSet.builder();
    ImmutableSet.Builder<Double> fractionalBuilder = ImmutableSet.builder();
    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL

        if (handle == null) {
            JavaExecHandleBuilder builder = getExecActionFactory().newJavaExec();
            builder.setExecutable(getJavaLauncher().get().getExecutablePath().getAsFile());
            builder.getMainModule().set("jdk.httpserver");
            builder.setStandardOutput(System.out);
            builder.setErrorOutput(System.err);

  }

  public static <E> Builder<E> orderedBy(Comparator<E> comparator) {
    return new Builder<E>(comparator);
  }

  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
    return new Builder<E>(Ordering.natural().reverse());
  }

  public static <E extends Comparable<?>> Builder<E> naturalOrder() {
    return new Builder<E>(Ordering.natural());
  }

  }

  @Test
  fun trailersHttp2() {
    trailers(Protocol.HTTP_2)
  }

  private fun trailers(protocol: Protocol) {
    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("h1", "v1")
        .trailers(headersOf("t1", "v2"))
        .body(protocol, "Hello")
        .build(),
    )

    val call = client.newCall(Request(server.url("/")))

  }

  /** Returns a new builder for an immutable range set. */
  public static <C extends Comparable<?>> Builder<C> builder() {
    return new Builder<>();
  }

  /**
   * A builder for immutable range sets.
   *
   * @since 14.0
   */
  public static class Builder<C extends Comparable<?>> {
    private final List<Range<C>> ranges;

    public Builder() {
      this.ranges = new ArrayList<>();

	return "RETURNING"
}

// Build build where clause
func (returning Returning) Build(builder Builder) {
	if len(returning.Columns) > 0 {
		for idx, column := range returning.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(column)
		}
	} else {
		builder.WriteByte('*')
	}
}

// MergeClause merge order by clauses

    }

    /**
     * Sets the query builder.
     * @param queryBuilder The query builder.
     */
    public void setQuery(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
    }

    /**
     * Adds a sort builder.
     * @param sortBuilder The sort builder.
     */
    public void addSort(final SortBuilder<?> sortBuilder) {

    var request =
      Request
        .Builder()
        .url(endpointUrl)
        .header("Content-Type", "application/xml")
        .put(ValidRequestBody())
        .build()
    client.newCall(request).execute().use {
      assertEquals(201, it.code)
    }

    request =
      Request
        .Builder()
        .url(endpointUrl)
        .head()
        .build()