*/
  fun hasNext(failedConnection: RealConnection? = null): Boolean

  /**
   * Returns true if the host and port are unchanged from when this was created. This is used to
   * detect if followups need to do a full connection-finding process including DNS resolution, and
   * certificate pin checks.
   */
  fun sameHostAndPort(url: HttpUrl): Boolean

  /**

        return minor;
    }

    public int getRevision() {
        return revision;
    }

    public boolean hasQualifier() {
        return qualifier != null;
    }

    public Qualifier getQualifier() {
        return qualifier;
    }

    public boolean isSnapshot() {
        return this.qualifier != null && this.qualifier.level == QualifierLevel.SNAPSHOT;
    }

    private final Collection<String> blackListedProjects = Collections.synchronizedSet(new HashSet<>());

    private volatile boolean halted = false;

    public ReactorBuildStatus(ProjectDependencyGraph projectDependencyGraph) {
        this.projectDependencyGraph = projectDependencyGraph;
    }

    public boolean isBlackListed(MavenProject project) {
        return blackListedProjects.contains(BuilderCommon.getKey(project));
    }

 * directly.
 */
class ConscryptSocketAdapter : SocketAdapter {
  override fun matchesSocket(sslSocket: SSLSocket): Boolean = Conscrypt.isConscrypt(sslSocket)

  override fun isSupported(): Boolean = isSupported

  override fun getSelectedProtocol(sslSocket: SSLSocket): String? =
    when {
      matchesSocket(sslSocket) -> Conscrypt.getApplicationProtocol(sslSocket)

        Cut<C> fromKey, boolean fromInclusive, Cut<C> toKey, boolean toInclusive) {
      return subMap(
          Range.range(
              fromKey, BoundType.forBoolean(fromInclusive),
              toKey, BoundType.forBoolean(toInclusive)));
    }

    @Override
    public NavigableMap<Cut<C>, Range<C>> headMap(Cut<C> toKey, boolean inclusive) {

        doc.put("boolTrue", true);
        assertEquals(Boolean.TRUE, DocumentUtil.getValue(doc, "boolTrue", Boolean.class));

        doc.put("boolFalse", false);
        assertEquals(Boolean.FALSE, DocumentUtil.getValue(doc, "boolFalse", Boolean.class));

        doc.put("boolStr", "anything");
        assertEquals(Boolean.FALSE, DocumentUtil.getValue(doc, "boolStr", Boolean.class));
    }

    @Test

    }

    public static class LicenseInfo {
        private final String identifier;
        private final boolean spdxLicense;
        private final boolean sourceRedistributionRequired;

        public LicenseInfo(String identifier, boolean spdxLicense, boolean sourceRedistributionRequired) {
            this.identifier = identifier;
            this.spdxLicense = spdxLicense;

  private static class UnmovableFile extends File {

    private final boolean canRename;
    private final boolean canDelete;

    UnmovableFile(File file, boolean canRename, boolean canDelete) {
      super(file.getPath());
      this.canRename = canRename;
      this.canDelete = canDelete;
    }

    @Override
    public boolean renameTo(File to) {
      return canRename && super.renameTo(to);
    }

                @Override
                public boolean remove(Object o) {
                  return map.entrySet().remove(o);
                }

                @Override
                public boolean containsAll(Collection<?> c) {
                  return map.entrySet().containsAll(c);
                }

                @Override
                public boolean removeAll(Collection<?> c) {

        }

        public boolean add(final E e) {
            return parent.add(e);
        }

        public boolean remove(final Object o) {
            return parent.remove(o);
        }

        public boolean containsAll(final Collection<?> c) {
            return parent.containsAll(c);
        }

        public boolean addAll(final Collection<? extends E> c) {