@Test
  fun ecdsaSignedByRsa() {
    val root =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .rsa2048()
        .build()
    val leaf =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .ecdsa256()
        .signedBy(root)
        .build()
    assertThat(root.certificate.sigAlgName).isEqualTo("SHA256WITHRSA", ignoreCase = true)

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

  }

internal fun CacheControl.Companion.commonForceNetwork() =
  CacheControl
    .Builder()
    .noCache()
    .build()

internal fun CacheControl.Companion.commonForceCache() =
  CacheControl
    .Builder()
    .onlyIfCached()
    .maxStale(Int.MAX_VALUE.seconds)
    .build()

internal fun CacheControl.Builder.commonBuild(): CacheControl =
  CacheControl(
    noCache = noCache,
    noStore = noStore,

    val client =
      OkHttpClient
        .Builder()
        .sslSocketFactory(sslContext.socketFactory, trustManager)
        .build()

    // An example test URL that returns client certificate details.
    val request =
      Request
        .Builder()
        .url("https://prod.idrix.eu/secure/")
        .build()

    client.newCall(request).execute().use { response ->

  }

  boolean isPartialView() {
    return false;
  }

  /** GWT emulated version of {@link ImmutableCollection.Builder}. */
  public abstract static class Builder<E> {
    static final int DEFAULT_INITIAL_CAPACITY = 4;

    Builder() {}

    static int expandedCapacity(int oldCapacity, int minCapacity) {
      if (minCapacity < 0) {

    val request =
      Request
        .Builder()
        .url("https://server/robots.txt")
        .build()
    val response =
      Response
        .Builder()
        .request(request)
        .code(401)
        .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
        .protocol(HTTP_2)
        .message("Unauthorized")
        .build()

  public void run() throws Exception {
    final PipeBody pipeBody = new PipeBody();

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(pipeBody)
        .build();

    streamPrimesToSinkAsynchronously(pipeBody.sink());

    try (Response response = client.newCall(request).execute()) {

        return new JLineMessageBuilderFactory();
    }

    protected abstract Invoker createInvoker();

    protected abstract Parser createParser();

    protected abstract ParserRequest.Builder createParserRequestBuilder(String[] args);

    //                                                                               =====

    @Override
    public SearchRequestBuilder build(SearchRequestBuilder builder) {
        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();
            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }

            }
          }

        val headers =
          Headers
            .Builder()
            .addUnsafeNonAscii("Content-Disposition", disposition)
            .build()

        return create(headers, body)
      }
    }
  }

  class Builder
    @JvmOverloads
    constructor(
      boundary: String = UUID.randomUUID().toString(),
    ) {