}
			for _, td := range spiffeConfig.GetTrustDomains() {
				builder := NewSecretItemBuilder()
				builder.Name(secret.Name).State(state)
				builder.TrustDomain(td.GetName())
				builder.Data(string(td.GetTrustBundle().GetInlineBytes()))
				secretItem, err := builder.Build()
				if err != nil {
					return []SecretItem{}, err
				}

            builder.field(STORE_NAME.getPreferredName(), storeName);
        }
        if (this.params != null && !this.params.isEmpty()) {
            builder.field(PARAMS.getPreferredName(), this.params);
        }
        if (activeFeatures != null && !activeFeatures.isEmpty()) {
            builder.field(ACTIVE_FEATURES.getPreferredName(), activeFeatures);
        }
        printBoostAndQueryName(builder);
        builder.endObject();
    }

    HandshakeCertificates clientCertificates = new HandshakeCertificates.Builder()
        .addTrustedCertificate(localhostCertificate.certificate())
        .build();
    OkHttpClient client = new OkHttpClient.Builder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager())
        .build();

    Call call = client.newCall(new Request.Builder()
        .url(server.url("/"))
        .build());

    path: String,
    vararg headers: String?,
  ): RecordedResponse {
    val builder = Request.Builder()
    builder.url(server.url(path))
    var i = 0
    val size = headers.size
    while (i < size) {
      builder.addHeader(headers[i]!!, headers[i + 1]!!)
      i += 2
    }
    return executeSynchronously(builder.build())
  }

  private fun executeSynchronously(request: Request): RecordedResponse {

}

internal fun Headers.commonIterator(): Iterator<Pair<String, String>> {
  return Array(size) { name(it) to value(it) }.iterator()
}

internal fun Headers.commonNewBuilder(): Headers.Builder {
  val result = Headers.Builder()
  result.namesAndValues += namesAndValues
  return result
}

internal fun Headers.commonEquals(other: Any?): Boolean {
  return other is Headers && namesAndValues.contentEquals(other.namesAndValues)

    // read in chunks to fixed array
    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {
      builder.append(buf, 0, read);
    }
    assertEquals(expected, builder.toString());
    assertFullyRead(reader);

    // read all to one CharBuffer

    void testCompleteWiring() throws Exception {
        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
        request.setProcessPlugins(true);
        request.setPomFile(getPom("simple"));

        ModelBuildingResult result = builder.build(request);
        assertNotNull(result);

        context.terminal
                .writer()
                .println(messageBuilderFactory
                        .builder()
                        .format(
                                response.isValid()
                                        ? messageBuilderFactory
                                                .builder()
                                                .success("%sConfiguration validation of %s: %s")

    @Override
    public SearchRequestBuilder build(SearchRequestBuilder builder) {
        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();
            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }

    @Override
    public SearchRequestBuilder build(SearchRequestBuilder builder) {
        if (_conditionQuery != null) {
            QueryBuilder queryBuilder = _conditionQuery.getQuery();
            if (queryBuilder != null) {
                builder.setQuery(queryBuilder);
            }
            _conditionQuery.getFieldSortBuilderList().forEach(sort -> {
                builder.addSort(sort);
            });
        }