limit += 2;
        } else if( spec.startsWith( "smb1://" ) == false &&
                    host != null && host.length() == 0 ) {
            spec = "//" + spec;
            limit += 2;
        }
        super.parseURL( u, spec, start, limit );
        path = u.getPath();
        ref = u.getRef();
        if (ref != null) {
            path += '#' + ref;
        }
        port = u.getPort();
        if( port == -1 ) {

        requireNonNull(dependency, "dependency cannot be null");
        String prop = dependency.getArtifact().getProperty(MavenArtifactProperties.INCLUDES_DEPENDENCIES, "");
        return !Boolean.parseBoolean(prop);
    }

    @Override
    public DependencyTraverser deriveChildTraverser(DependencyCollectionContext context) {
        requireNonNull(context, "context cannot be null");
        return this;
    }

    @Override

            StringBuilder sb = new StringBuilder();
            sb.append("The option ");
            if (option.getOpt() != null) {
                sb.append("-").append(option.getOpt());
            }
            if (option.getLongOpt() != null) {
                if (option.getOpt() != null) {
                    sb.append(",");
                }
                sb.append("--").append(option.getLongOpt());
            }

  fun duplexWithAuthChallenge() {
    enableProtocol(Protocol.HTTP_2)
    val credential = basic("jesse", "secret")
    client =
      client.newBuilder()
        .authenticator(RecordingOkAuthenticator(credential, null))
        .build()
    val body1 =
      MockStreamHandler()
        .sendResponse("please authenticate!\n")
        .requestIOException()
        .exhaustResponse()
    server.enqueue(

                messages.addErrorsBlankPassword("password");
            }, validationErrorLambda);
        }
        if (form.password != null && !form.password.equals(form.confirmPassword)) {
            form.confirmPassword = null;
            throwValidationError(messages -> {
                messages.addErrorsInvalidConfirmPassword("confirmPassword");
            }, validationErrorLambda);
        }

      return if (!fieldType.isInstance(value)) null else fieldType.cast(value)
    } catch (_: NoSuchFieldException) {
    }

    c = c.superclass
  }

  // Didn't find the field we wanted. As a last gasp attempt,
  // try to find the value on a delegate.
  if (fieldName != "delegate") {
    val delegate = readFieldOrNull(instance, Any::class.java, "delegate")

    public abstract SearchRequestType getType();

    public abstract String getSimilarDocHash();

    public String getTrackTotalHits() {
        return null;
    }

    public Float getMinScore() {
        return null;
    }

    public boolean hasConditionQuery() {
        final Map<String, String[]> conditions = getConditions();
        return !isEmptyArray(conditions.get(AS_Q))//

 */
class Route(
  @get:JvmName("address") val address: Address,
  /**
   * Returns the [Proxy] of this route.
   *
   * **Warning:** This may disagree with [Address.proxy] when it is null. When the address's proxy
   * is null, the proxy selector is used.
   */
  @get:JvmName("proxy") val proxy: Proxy,
  @get:JvmName("socketAddress") val socketAddress: InetSocketAddress,
) {
  @JvmName("-deprecated_address")
  @Deprecated(

  /**
   * The collection must not throw {@code NullPointerException} on calls such as {@code
   * contains(null)} or {@code remove(null)}, but instead must return a simple {@code false}.
   */
  ALLOWS_NULL_QUERIES,
  ALLOWS_NULL_VALUES(ALLOWS_NULL_QUERIES),

  /**
   * Indicates that a collection disallows certain elements (other than {@code null}, whose validity

       * since the Equivalence base type now implements this logic itself
       */
      assertTrue(item + " must be inequivalent to null", !equivalence.equivalent(item, null));
      assertTrue("null must be inequivalent to " + item, !equivalence.equivalent(null, item));
      assertTrue(item + " must be equivalent to itself", equivalence.equivalent(item, item));
      assertEquals(