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);
            });
        }

}

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

        MavenSessionBuilderSupplier builder = new MavenSessionBuilderSupplier();
        session.setDependencyTraverser(builder.getDependencyTraverser());
        session.setDependencyManager(new ClassicDependencyManager()); // Maven 3 behavior
        session.setDependencySelector(builder.getDependencySelector());
        session.setDependencyGraphTransformer(builder.getDependencyGraphTransformer());

    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 {

    @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);
            });
        }

        infoLine('-');
        MessageBuilder buffer = builder();

        if (session.getResult().hasExceptions()) {
            buffer.failure("BUILD FAILURE");
        } else {
            buffer.success("BUILD SUCCESS");
        }
        logger.info(buffer.toString());
    }

    private MessageBuilder builder() {
        return messageBuilderFactory.builder();
    }

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

  /**
   * Returns a builder that creates immutable sorted sets whose elements are ordered by the reverse
   * of their natural ordering.
   */
  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
    return new Builder<>(Collections.reverseOrder());
  }

  /**

    headerValue = null,
  )
}

internal fun CacheControl.Builder.commonNoCache() =
  apply {
    this.noCache = true
  }

internal fun CacheControl.Builder.commonNoStore() =
  apply {
    this.noStore = true
  }

internal fun CacheControl.Builder.commonOnlyIfCached() =
  apply {
    this.onlyIfCached = true
  }

internal fun CacheControl.Builder.commonNoTransform() =
  apply {
    this.noTransform = true