.sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .protocols(protocols.toList())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = client.protocols
  }

  private fun assertConnectionReused(vararg requests: Request?) {

            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolatorException e) {
            throw new ExtensionResolutionException(extension, e);
        }
    }

        }

        ClassMap classMap = getClassMap(value.getClass());
        String methodBase = Character.toTitleCase(property.charAt(0)) + property.substring(1);
        try {
            for (String prefix : Arrays.asList("get", "is", "to", "as")) {
                Method method = classMap.findMethod(prefix + methodBase);
                if (method != null) {
                    return method.invoke(value, OBJECT_ARGS);
                }

                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieves a specific synonym dictionary item by ID.
     *
     * @param dictId the dictionary ID

                                p.getLocation("version").getSource().getModelId()))
                .distinct()
                .map(Plugin::getArtifactId) // managed by us, groupId is always o.a.m.plugins
                .toList();

        if (!unversionedPlugins.isEmpty()) {
            logger.warn("Version not locked for default bindings plugins " + unversionedPlugins

import static com.google.common.collect.testing.Helpers.mapEntry;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyMap;
import static java.util.Collections.singleton;
import static java.util.Collections.singletonMap;

import com.google.common.annotations.GwtCompatible;

   */
  private int findSuffixOfType(Optional<PublicSuffixType> desiredType) {
    int partsSize = parts.size();

    for (int i = 0; i < partsSize; i++) {
      String ancestorName = DOT_JOINER.join(parts.subList(i, partsSize));

      if (i > 0
          && matchesType(
              desiredType, Optional.fromNullable(PublicSuffixPatterns.UNDER.get(ancestorName)))) {
        return i - 1;
      }

                    new Layout(
                            idx < reader.getCommentLines().size()
                                    ? new ArrayList<>(reader.getCommentLines()
                                            .subList(
                                                    idx,
                                                    reader.getCommentLines().size()))
                                    : null,

                    new Layout(
                            idx < reader.getCommentLines().size()
                                    ? new ArrayList<>(reader.getCommentLines()
                                            .subList(
                                                    idx,
                                                    reader.getCommentLines().size()))
                                    : null,

        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }
    return absentBehavior.resultIndex(lower);
  }